No OneTemporary
Actions

Authored By

Unknown

Size

322 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/src/Functions.cpp b/src/Functions.cpp
	index 210acf2..b9f453a 100644
	--- a/src/Functions.cpp
	+++ b/src/Functions.cpp
	@@ -1,1671 +1,1859 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include <stdio.h>
	#include <math.h>
	#include <algorithm>
	#include <SDL/SDL.h>
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_gfx/SDL_gfxPrimitives.h>
	#include <SDL_gfx/SDL_rotozoom.h>
	#else
	#include <SDL/SDL_mixer.h>
	#include <SDL/SDL_gfxPrimitives.h>
	#include <SDL/SDL_rotozoom.h>
	#endif
	#include <SDL/SDL_syswm.h>
	#include <string>
	#include "Globals.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Objects.h"
	#include "Player.h"
	#include "GameObjects.h"
	#include "LevelPack.h"
	#include "TitleMenu.h"
	#include "LevelEditSelect.h"
	#include "LevelEditor.h"
	#include "Game.h"
	#include "LevelPlaySelect.h"
	#include "Addons.h"
	#include "InputManager.h"
	#include "ImageManager.h"
	#include "MusicManager.h"
	#include "LevelPackManager.h"
	#include "ThemeManager.h"
	#include "GUIListBox.h"
	#include "GUIOverlay.h"
	#include "StatisticsManager.h"
	#include "StatisticsScreen.h"
	-#include "Cursors.h"

	#include "libs/tinyformat/tinyformat.h"
	#include "libs/tinygettext/tinygettext.hpp"
	#include "libs/tinygettext/log.hpp"
	extern "C" {
	#include "libs/findlocale/findlocale.h"
	}

	#ifdef HARDWARE_ACCELERATION
	#include <GL/gl.h>
	#include <GL/glu.h>

	//fix some Windows header bug
	#ifndef GL_BGR
	#define GL_BGR GL_BGR_EXT
	#endif
	#ifndef GL_BGRA
	#define GL_BGRA GL_BGRA_EXT
	#endif

	#endif
	using namespace std;

	#ifdef WIN32
	#include <windows.h>
	#include <shlobj.h>
	#else
	#include <strings.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include <dirent.h>
	#endif

	//Workaround for the resizing below 800x600 for X systems.
	#ifdef __linux__
	#include<X11/Xlib.h>
	#include<X11/Xutil.h>
	#endif

	//Initialise the imagemanager.
	//The ImageManager is used to prevent loading images multiple times.
	ImageManager imageManager;

	//Initialise the musicManager.
	//The MusicManager is used to prevent loading music files multiple times and for playing/fading music.
	MusicManager musicManager;

	//Initialise the levelPackManager.
	//The LevelPackManager is used to prevent loading levelpacks multiple times and for the game to know which levelpacks there are.
	LevelPackManager levelPackManager;

	//The scriptExecutor used for executing scripts.
	ScriptExecutor scriptExecutor;

	//Map containing changed settings using command line arguments.
	map<string,string> tmpSettings;
	//Pointer to the settings object.
	//It is used to load and save the settings file and change the settings.
	Settings* settings=0;

	#ifdef HARDWARE_ACCELERATION
	GLuint screenTexture;
	#endif

	SDL_Surface* loadImage(string file){
	//We use the imageManager to load the file.
	return imageManager.loadImage(file);
	}

	void applySurface(int x,int y,SDL_Surface* source,SDL_Surface* dest,SDL_Rect* clip){
	//The offset is needed to draw at the right location.
	SDL_Rect offset;
	offset.x=x;
	offset.y=y;

	//Let SDL do the drawing of the surface.
	SDL_BlitSurface(source,clip,dest,&offset);
	}

	void drawRect(int x,int y,int w,int h,SDL_Surface* dest,Uint32 color){
	//NOTE: We let SDL_gfx render it.
	rectangleRGBA(dest,x,y,x+w,y+h,color >> 24,color >> 16,color >> 8,255);
	}

	//Draw a box with anti-aliased borders using SDL_gfx.
	void drawGUIBox(int x,int y,int w,int h,SDL_Surface* dest,Uint32 color){
	//Fill content's background color from function parameter
	boxRGBA(dest,x+1,y+1,x+w-2,y+h-2,color >> 24,color >> 16,color >> 8,color >> 0);

	//Draw first black borders around content and leave 1 pixel in every corner
	lineRGBA(dest,x+1,y,x+w-2,y,0,0,0,255);
	lineRGBA(dest,x+1,y+h-1,x+w-2,y+h-1,0,0,0,255);
	lineRGBA(dest,x,y+1,x,y+h-2,0,0,0,255);
	lineRGBA(dest,x+w-1,y+1,x+w-1,y+h-2,0,0,0,255);

	//Fill the corners with transperent color to create anti-aliased borders
	pixelRGBA(dest,x,y,0,0,0,160);
	pixelRGBA(dest,x,y+h-1,0,0,0,160);
	pixelRGBA(dest,x+w-1,y,0,0,0,160);
	pixelRGBA(dest,x+w-1,y+h-1,0,0,0,160);

	//Draw second lighter border around content
	rectangleRGBA(dest,x+1,y+1,x+w-2,y+h-2,0,0,0,64);

	//Create anti-aliasing in corners of second border
	pixelRGBA(dest,x+1,y+1,0,0,0,50);
	pixelRGBA(dest,x+1,y+h-2,0,0,0,50);
	pixelRGBA(dest,x+w-2,y+1,0,0,0,50);
	pixelRGBA(dest,x+w-2,y+h-2,0,0,0,50);
	}

	void drawLine(int x1,int y1,int x2,int y2,SDL_Surface* dest,Uint32 color){
	//NOTE: We let SDL_gfx render it.
	lineRGBA(dest,x1,y1,x2,y2,color >> 24,color >> 16,color >> 8,255);
	}

	void drawLineWithArrow(int x1,int y1,int x2,int y2,SDL_Surface* dest,Uint32 color,int spacing,int offset,int xsize,int ysize){
	//Draw line first
	drawLine(x1,y1,x2,y2,dest,color);

	//calc delta and length
	double dx=x2-x1;
	double dy=y2-y1;
	double length=sqrt(dxdx+dydy);
	if(length<0.001) return;

	//calc the unit vector
	dx/=length; dy/=length;

	//Now draw arrows on it
	for(double p=offset;p<length;p+=spacing){
	drawLine(int(x1+pdx+0.5),int(y1+pdy+0.5),
	int(x1+(p-xsize)dx-ysizedy+0.5),int(y1+(p-xsize)dy+ysizedx+0.5),dest,color);
	drawLine(int(x1+pdx+0.5),int(y1+pdy+0.5),
	int(x1+(p-xsize)dx+ysizedy+0.5),int(y1+(p-xsize)dy-ysizedx+0.5),dest,color);
	}
	}

	bool createScreen(){
	//Check if we are going fullscreen.
	if(settings->getBoolValue("fullscreen"))
	pickFullscreenResolution();

	//Set the screen_width and height.
	SCREEN_WIDTH=atoi(settings->getValue("width").c_str());
	SCREEN_HEIGHT=atoi(settings->getValue("height").c_str());

	//Update the camera.
	camera.w=SCREEN_WIDTH;
	camera.h=SCREEN_HEIGHT;

	//Boolean if this is the first screen creation.
	bool initial=true;

	//Check if we should use gl or software rendering.
	if(settings->getBoolValue("gl")){
	#ifdef HARDWARE_ACCELERATION
	SDL_GL_SetAttribute(SDL_GL_RED_SIZE,8);
	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,8);
	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,8);
	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,8);

	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE,16);
	SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE,32);

	SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE,8);
	SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE,8);
	SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE,8);
	SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE,8);

	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,0);
	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,0);
	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1);

	//Set the video mode.
	Uint32 flags=SDL_HWSURFACE \| SDL_OPENGL;
	if(settings->getBoolValue("fullscreen"))
	flags\|=SDL_FULLSCREEN;
	else if(settings->getBoolValue("resizable"))
	flags\|=SDL_RESIZABLE;
	if(SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,flags)==NULL){
	fprintf(stderr,"FATAL ERROR: SDL_SetVideoMode failed\n");
	return false;
	}

	//Delete the old screen.
	//Warning: only if previous mode is OpenGL mode.
	//NOTE: The previous mode can't switch during runtime.
	if(screen){
	SDL_FreeSurface(screen);
	screen=NULL;

	//There was a screen so this isn't the initial screen creation.
	initial=false;
	}

	//Create a screen
	screen=SDL_CreateRGBSurface(SDL_HWSURFACE,SCREEN_WIDTH,SCREEN_HEIGHT,32,0x00FF0000,0x0000FF00,0x000000FF,0);

	//Create a texture.
	glDeleteTextures(1,&screenTexture);
	glGenTextures(1,&screenTexture);

	//And set up gl correctly.
	glClearColor(0, 0, 0, 0);
	glClearDepth(1.0f);
	glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, -1);
	glMatrixMode(GL_MODELVIEW);
	glEnable(GL_TEXTURE_2D);
	glLoadIdentity();
	#else
	//NOTE: Hardware accelerated rendering requested but compiled without.
	cerr<<"FATAL ERROR: Unable to use hardware acceleration (compiled without)."<<endl;
	return false;
	#endif
	}else{
	//Set the flags.
	Uint32 flags=SDL_HWSURFACE \| SDL_DOUBLEBUF;
	if(settings->getBoolValue("fullscreen"))
	flags\|=SDL_FULLSCREEN;
	else if(settings->getBoolValue("resizable"))
	flags\|=SDL_RESIZABLE;

	//Check if there already was a screen.
	if(screen)
	initial=false;

	//Create the screen and check if there weren't any errors.
	screen=SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,flags);
	if(screen==NULL){
	fprintf(stderr,"FATAL ERROR: SDL_SetVideoMode failed\n");
	return false;
	}
	}

	//Now configure the newly created window (if windowed).
	if(settings->getBoolValue("fullscreen")==false)
	configureWindow(initial);

	//Create the temp surface, just a replica of the screen surface, free the previous one if any.
	if(tempSurface)
	SDL_FreeSurface(tempSurface);
	tempSurface=SDL_CreateRGBSurface(SDL_HWSURFACE\|SDL_SRCALPHA,
	screen->w,screen->h,screen->format->BitsPerPixel,
	screen->format->Rmask,screen->format->Gmask,screen->format->Bmask,0);

	//Set the the window caption.
	SDL_WM_SetCaption(("Me and My Shadow "+version).c_str(),NULL);
	SDL_EnableUNICODE(1);

	//Nothing went wrong so return true.
	return true;
	}

	#ifdef WIN32

	static WNDPROC m_OldWindowProc=NULL;

	static LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam){
	if(msg==WM_GETMINMAXINFO){
	if(m_OldWindowProc){
	CallWindowProc(m_OldWindowProc,hwnd,msg,wParam,lParam);
	}else{
	DefWindowProc(hwnd,msg,wParam,lParam);
	}

	RECT r={0,0,800,600};
	AdjustWindowRect(&r,GetWindowLong(hwnd,GWL_STYLE),FALSE);

	MINMAXINFO info=(MINMAXINFO)lParam;
	info->ptMinTrackSize.x=r.right-r.left;
	info->ptMinTrackSize.y=r.bottom-r.top;

	return 0;
	}else{
	if(m_OldWindowProc){
	return CallWindowProc(m_OldWindowProc,hwnd,msg,wParam,lParam);
	}else{
	return DefWindowProc(hwnd,msg,wParam,lParam);
	}
	}
	}

	#endif

	void pickFullscreenResolution(){
	//Vector that will hold the resolutions to choose from.
	vector<_res> resolutionList;

	//Enumerate avaliable resolutions using SDL_ListModes()
	//Note: we enumerate fullscreen resolutions because
	// windowed resolutions always can be arbitrary
	if(resolutionList.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 predefinedResolutionList[] = {
	{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}
	};

	//Fill the resolutionList.
	for(unsigned int i=0;i<sizeof(predefinedResolutionList)/sizeof(_res);i++){
	resolutionList.push_back(predefinedResolutionList[i]);
	}
	}else{
	//Fill the resolutionList.
	for(unsigned int i=0;modes[i]!=NULL;i++){
	//Check if the resolution is higher than the minimum (800x600).
	if(modes[i]->w>=800 && modes[i]->h>=600){
	_res res={modes[i]->w, modes[i]->h};
	resolutionList.push_back(res);
	}
	}
	//Reverse it so that we begin with the lowest resolution.
	reverse(resolutionList.begin(),resolutionList.end());
	}
	}

	//The resolution that will hold the final result, we start with the minimum (800x600).
	_res closestMatch={800,600};
	int width=atoi(getSettings()->getValue("width").c_str());
	//int height=atoi(getSettings()->getValue("height").c_str());

	//Now loop through the resolutionList.
	for(int i=0;i<(int)resolutionList.size();i++){
	//The delta between the closestMatch and the resolution from the list.
	int dM=(closestMatch.w-resolutionList[i].w);
	//The delta between the target width and the resolution from the list.
	int dT=(width-resolutionList[i].w);

	//Since the resolutions are getting higher the lower (more negative) the further away it is.
	//That's why we check if the deltaMatch is lower than the the deltaTarget.
	if((dM)<(dT)){
	closestMatch.w=resolutionList[i].w;
	closestMatch.h=resolutionList[i].h;
	}
	}

	//Now set the resolution to the closest match.
	char s[64];
	sprintf(s,"%d",closestMatch.w);
	getSettings()->setValue("width",s);
	sprintf(s,"%d",closestMatch.h);
	getSettings()->setValue("height",s);
	}

	void configureWindow(bool initial){
	//We only need to configure the window if it's resizable.
	if(!getSettings()->getBoolValue("resizable"))
	return;

	//Retrieve the WM info from SDL containing the window handle.
	struct SDL_SysWMinfo wmInfo;
	SDL_VERSION(&wmInfo.version);
	SDL_GetWMInfo(&wmInfo);

	#ifdef __linux__
	//We assume that a linux system running meandmyshadow is also running an Xorg server.
	if(wmInfo.subsystem==SDL_SYSWM_X11){
	//Create the size hints to give to the window.
	XSizeHints* sizeHints;
	if(!(sizeHints=XAllocSizeHints())){
	cerr<<"ERROR: Unable to allocate memory for XSizeHings."<<endl;
	return;
	}

	//Configure the size hint.
	sizeHints->flags=PMinSize;
	sizeHints->min_width=800;
	sizeHints->min_height=600;

	//Set the normal hints of the window.
	(void)wmInfo.info.x11.lock_func;
	XSetNormalHints(wmInfo.info.x11.display,wmInfo.info.x11.wmwindow,sizeHints);
	(void)wmInfo.info.x11.unlock_func;

	//Free size hint structure
	XFree(sizeHints);
	}else{
	//No X11 so an unsupported window manager.
	cerr<<"WARNING: Unsupported window manager."<<endl;
	}
	#elif defined(WIN32)
	//We overwrite the window proc of SDL
	WNDPROC wndproc=(WNDPROC)GetWindowLong(wmInfo.window,GWL_WNDPROC);
	if(wndproc!=NULL && wndproc!=(WNDPROC)WindowProc){
	m_OldWindowProc=wndproc;
	SetWindowLong(wmInfo.window,GWL_WNDPROC,(LONG)(WNDPROC)WindowProc);
	}
	#endif
	}

	void onVideoResize(){
	//Check if the resize event isn't malformed.
	if(event.resize.w<=0 \|\| event.resize.h<=0)
	return;

	//Check the size limit.
	if(event.resize.w<800)
	event.resize.w=800;
	if(event.resize.h<600)
	event.resize.h=600;

	//Check if it really resizes.
	if(SCREEN_WIDTH==event.resize.w && SCREEN_HEIGHT==event.resize.h)
	return;

	char s[32];

	//Set the new width and height.
	sprintf(s,"%d",event.resize.w);
	getSettings()->setValue("width",s);
	sprintf(s,"%d",event.resize.h);
	getSettings()->setValue("height",s);

	//Do resizing.
	if(!createScreen())
	return;

	//Tell the theme to resize.
	if(!loadTheme(""))
	return;

	//The new resolution is valid.
	//Now we can save the settings. (TODO: should we save?)
	//saveSettings();

	//And let the currentState update it's GUI to the new resolution.
	currentState->resize();
	}

	//Include the scripting API.
	#include "ScriptAPI.h"

	bool init(){
	//Initialze SDL.
	if(SDL_Init(SDL_INIT_EVERYTHING)==-1) {
	fprintf(stderr,"FATAL ERROR: SDL_Init failed\n");
	return false;
	}

	//Initialze SDL_mixer (audio).
	if(Mix_OpenAudio(22050,MIX_DEFAULT_FORMAT,2,512)==-1){
	fprintf(stderr,"FATAL ERROR: Mix_OpenAudio failed\n");
	return false;
	}
	//Set the volume.
	Mix_Volume(-1,atoi(settings->getValue("sound").c_str()));

	//Initialze SDL_ttf (fonts).
	if(TTF_Init()==-1){
	fprintf(stderr,"FATAL ERROR: TTF_Init failed\n");
	return false;
	}

	//Create the screen.
	if(!createScreen())
	return false;

	//Load key config. Then initalize joystick support.
	inputMgr.loadConfig();
	inputMgr.openAllJoysitcks();

	//Init tinygettext for translations for the right language
	dictionaryManager = new tinygettext::DictionaryManager();
	dictionaryManager->add_directory(getDataPath()+"locale");
	dictionaryManager->set_charset("UTF-8");

	//Check if user have defined own language. If not, find it out for the player using findlocale
	string lang=getSettings()->getValue("lang");
	if(lang.length()>0){
	printf("Locale set by user to %s\n",lang.c_str());
	language=lang;
	}else{
	FL_Locale *locale;
	FL_FindLocale(&locale,FL_MESSAGES);
	printf("Locale isn't set by user: %s\n",locale->lang);

	language=locale->lang;
	if(locale->country!=NULL){
	language+=string("_")+string(locale->country);
	}
	if(locale->variant!=NULL){
	language+=string("@")+string(locale->variant);
	}

	FL_FreeLocale(&locale);
	}
	//Now set the language in the dictionaryManager.
	dictionaryManager->set_language(tinygettext::Language::from_name(language));

	//Disable annoying 'Couldn't translate: blah blah blah'
	tinygettext::Log::set_log_info_callback(NULL);

	//Create the types of blocks.
	for(int i=0;i<TYPE_MAX;i++){
	Game::blockNameMap[Game::blockName[i]]=i;
	}

	//Register the ScriptAPI's functions in the scriptExecutor.
	registerFunctions(getScriptExecutor());

	//Nothing went wrong so we return true.
	return true;
	}

	static TTF_Font* loadFont(const char* name,int size){
	TTF_Font* tmpFont=TTF_OpenFont((getDataPath()+"font/"+name+".ttf").c_str(),size);
	if(tmpFont){
	return tmpFont;
	}else{
	return TTF_OpenFont((getDataPath()+"font/DroidSansFallback.ttf").c_str(),size);
	}
	}

	bool loadFonts(){
	//Load the fonts.
	//NOTE: This is a separate method because it will be called separately when re-initing in case of language change.

	//First close the fonts if needed.
	if(fontTitle)
	TTF_CloseFont(fontTitle);
	if(fontGUI)
	TTF_CloseFont(fontGUI);
	if(fontGUISmall)
	TTF_CloseFont(fontGUISmall);
	if(fontText)
	TTF_CloseFont(fontText);

	/// TRANSLATORS: Font used in GUI:
	/// - Use "knewave" for languages using Latin and Latin-derived alphabets
	/// - "DroidSansFallback" can be used for non-Latin writing systems
	fontTitle=loadFont(_("knewave"),55);
	fontGUI=loadFont(_("knewave"),32);
	fontGUISmall=loadFont(_("knewave"),24);
	/// TRANSLATORS: Font used for normal text:
	/// - Use "Blokletters-Viltstift" for languages using Latin and Latin-derived alphabets
	/// - "DroidSansFallback" can be used for non-Latin writing systems
	fontText=loadFont(_("Blokletters-Viltstift"),16);
	if(fontTitle==NULL \|\| fontGUI==NULL \|\| fontGUISmall==NULL \|\| fontText==NULL){
	printf("ERROR: Unable to load fonts! \n");
	return false;
	}

	//Nothing went wrong so return true.
	return true;
	}

	//Generate small arrows used for some GUI widgets.
	static void generateArrows(){
	TTF_Font* fontArrow=loadFont(_("knewave"),18);

	if(arrowLeft1){
	SDL_FreeSurface(arrowLeft1);
	SDL_FreeSurface(arrowRight1);
	SDL_FreeSurface(arrowLeft2);
	SDL_FreeSurface(arrowRight2);
	}

	arrowLeft1=TTF_RenderUTF8_Blended(fontArrow,"<",themeTextColor);
	arrowRight1=TTF_RenderUTF8_Blended(fontArrow,">",themeTextColor);
	arrowLeft2=TTF_RenderUTF8_Blended(fontArrow,"<",themeTextColorDialog);
	arrowRight2=TTF_RenderUTF8_Blended(fontArrow,">",themeTextColorDialog);

	TTF_CloseFont(fontArrow);
	}

	bool loadTheme(string name){
	//Load default fallback theme if it isn't loaded yet
	if(objThemes.themeCount()==0){
	if(objThemes.appendThemeFromFile(getDataPath()+"themes/Cloudscape/theme.mnmstheme")==NULL){
	printf("ERROR: Can't load default theme file\n");
	return false;
	}
	}

	//Resize background or load specific theme
	if(name==""\|\|name.empty()){
	objThemes.scaleToScreen();
	}else{
	string theme=processFileName(name);
	if(objThemes.appendThemeFromFile(theme+"/theme.mnmstheme")==NULL){
	printf("ERROR: Can't load theme %s\n",theme.c_str());
	return false;
	}
	}

	generateArrows();

	//Everything went fine so return true.
	return true;
	}

	static Mix_Chunk* loadWAV(const char* s){
	Mix_Chunk* c=Mix_LoadWAV(s);
	if(c!=NULL) return c;
	printf("ERROR: Can't load sound file %s: %s\n",s,SDL_GetError());
	return NULL;
	}

	-static SDL_Cursor* loadCursor(const char* image[]){
	- int i,row,col;
	- //The array that holds the data (0=white 1=black)
	- Uint8 data[4*32];
	- //The array that holds the alpha mask (0=transparent 1=visible)
	- Uint8 mask[4*32];
	- //The coordinates of the hotspot of the cursor.
	- int hotspotX, hotspotY;
	-
	- i=-1;
	- //Loop through the rows and columns.
	- //NOTE: We assume a cursor size of 32x32.
	- for(row=0;row<32;++row){
	- for(col=0; col<32;++col){
	- if(col % 8) {
	- data[i]<<=1;
	- mask[i]<<=1;
	- }else{
	+//create_cursor
	+//
	+//This function is copied from SDL docs
	+//http://www.libsdl.org/docs/html/sdlcreatecursor.html
	+//
	+//image: image in XPM format
	+static SDL_Cursor* create_cursor(const char *image[])
	+{
	+ int i, row, col;
	+ Uint8 data[4*24];
	+ Uint8 mask[4*24];
	+ int hot_x, hot_y;
	+
	+ i = -1;
	+ for ( row=0; row<24; ++row ) {
	+ for ( col=0; col<24; ++col ) {
	+ if ( col % 8 ) {
	+ data[i] <<= 1;
	+ mask[i] <<= 1;
	+ } else {
	++i;
	- data[i]=mask[i]=0;
	+ data[i] = mask[i] = 0;
	}
	- switch(image[4+row][col]){
	+ switch (image[4+row][col]) {
	case '+':
	data[i] \|= 0x01;
	mask[i] \|= 0x01;
	break;
	case '.':
	mask[i] \|= 0x01;
	break;
	- default:
	+ case ' ':
	break;
	}
	}
	}
	- //Get the hotspot x and y locations from the last line of the cursor.
	- sscanf(image[4+row],"%d,%d",&hotspotX,&hotspotY);
	- return SDL_CreateCursor(data,mask,32,32,hotspotX,hotspotY);
	+ sscanf(image[4+row], "%d,%d", &hot_x, &hot_y);
	+ return SDL_CreateCursor(data, mask, 24, 24, hot_x, hot_y);
	+}
	+
	+static void loadCursors(){
	+ //These cursors are XPM files exported from GIMP.
	+ //They're based on OpenZone Black Slim cursor theme by ducakar.
	+ //http://kde-look.org/content/show.php/OpenZone?content=111343
	+
	+ static const char* cursor1_xpm[]={
	+ "24 24 3 1",
	+ " c None",
	+ ". c #FFFFFF",
	+ "+ c #000000",
	+ ". ",
	+ ".. ",
	+ ".+. ",
	+ ".++. ",
	+ ".+++. ",
	+ ".++++. ",
	+ ".+++++. ",
	+ ".++++++. ",
	+ ".+++++++. ",
	+ ".++++++++. ",
	+ ".+++++++++. ",
	+ ".+++++...... ",
	+ ".+++.++. ",
	+ ".++..++. ",
	+ ".+. .++. ",
	+ ".. .++. ",
	+ ". .. ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ "0,0"
	+ };
	+
	+ static const char* cursor2_xpm[]={
	+ "24 24 3 1",
	+ " c None",
	+ ". c #FFFFFF",
	+ "+ c #000000",
	+ " .. ",
	+ " .++. ",
	+ " .++. ",
	+ " .++. ",
	+ " .++. ",
	+ " .++. ",
	+ " .++... .. ",
	+ " ...++.++.++. ",
	+ ".++.++.++.++. ",
	+ ".++.+++++++++. ",
	+ ".++.+++++++++. ",
	+ ".++++++++++++. ",
	+ ".++++++++++++. ",
	+ ".++++++++++++. ",
	+ ".++++++++++++. ",
	+ " .++++++++++. ",
	+ " .......... ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ "0,5"
	+ };
	+
	+ static const char* cursor3_xpm[]={
	+ "24 24 3 1",
	+ " c None",
	+ ". c #FFFFFF",
	+ "+ c #000000",
	+ " ... ... ",
	+ ".+++. .+++. ",
	+ ".++++. .++++. ",
	+ ".+++++. .+++++. ",
	+ " .+++++.+++++. ",
	+ " .+++++++++. ",
	+ " .+++++++. ",
	+ " .+++++. ",
	+ " .+++++++. ",
	+ " .+++++++++. ",
	+ " .+++++.+++++. ",
	+ ".+++++. .+++++. ",
	+ ".++++. .++++. ",
	+ ".+++. .+++. ",
	+ " ... ... ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ "7,7"
	+ };
	+
	+ static const char* cursor4_xpm[]={
	+ "24 24 3 1",
	+ " c None",
	+ ". c #FFFFFF",
	+ "+ c #000000",
	+ "....... ",
	+ ".+++++. ",
	+ "...+... ",
	+ " .+. ",
	+ " .+. ",
	+ " .+. ",
	+ " .+. ",
	+ " .+. ",
	+ " .+. ",
	+ " .+. ",
	+ " .+. ",
	+ " .+. ",
	+ " .+. ",
	+ " .+. ",
	+ "...+... ",
	+ ".+++++. ",
	+ "....... ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ "3,8"
	+ };
	+
	+ static const char * cursor5_xpm[]={
	+ "24 24 3 1",
	+ " c None",
	+ ". c #FFFFFF",
	+ "+ c #000000",
	+ " .. .. ",
	+ " .++.++... ",
	+ " .++.++.++. ",
	+ " .++.++.++. ",
	+ " .++.++.++. ",
	+ " .++.++.++. ",
	+ " ...++.++.++. ",
	+ ".++.++.++.++. ",
	+ ".++.+++++++++. ",
	+ ".++.+++++++++. ",
	+ ".++++++++++++. ",
	+ ".++++++++++++. ",
	+ ".++++++++++++. ",
	+ ".++++++++++++. ",
	+ " .++++++++++. ",
	+ " .......... ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ "0,0"
	+ };
	+
	+ static const char* cursor6_xpm[] = {
	+ "24 24 3 1",
	+ " c None",
	+ ". c #FFFFFF",
	+ "+ c #000000",
	+ " .. .. .. ",
	+ " .++.++.++. ",
	+ " .++.++.++. ",
	+ " ...+++++++++. ",
	+ ".++.+++++++++. ",
	+ ".++++++++++++. ",
	+ ".++++++++++++. ",
	+ ".++++++++++++. ",
	+ ".++++++++++++. ",
	+ " .++++++++++. ",
	+ " .......... ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ " ",
	+ "0,0"
	+ };
	+
	+
	+ cursors[CURSOR_NORMAL]=create_cursor(cursor1_xpm);
	+ cursors[CURSOR_POINT]=create_cursor(cursor2_xpm);
	+ cursors[CURSOR_REMOVE]=create_cursor(cursor3_xpm);
	+ cursors[CURSOR_TEXT]=create_cursor(cursor4_xpm);
	+ cursors[CURSOR_DRAG1]=create_cursor(cursor5_xpm);
	+ cursors[CURSOR_DRAG2]=create_cursor(cursor6_xpm);
	+ SDL_SetCursor(cursors[CURSOR_NORMAL]);
	}

	bool loadFiles(){
	+ loadCursors();
	+
	//Load the fonts.
	if(!loadFonts())
	return false;

	//Show a loading screen
	{
	SDL_Rect r={0,0,screen->w,screen->h};
	SDL_FillRect(screen,&r,0);

	SDL_Color fg={255,255,255};
	SDL_Surface *surface=TTF_RenderUTF8_Blended(fontTitle,_("Loading..."),fg);
	if(surface!=NULL){
	r.x=(screen->w-surface->w)/2;
	r.y=(screen->h-surface->h)/2;
	SDL_BlitSurface(surface,NULL,screen,&r);
	SDL_FreeSurface(surface);
	}

	SDL_Flip(screen);
	}

	musicManager.destroy();
	//Load the music and play it.
	if(musicManager.loadMusic((getDataPath()+"music/menu.music")).empty()){
	printf("WARNING: Unable to load background music! \n");
	}
	musicManager.playMusic("menu",false);
	//Always load the default music list for fallback.
	musicManager.loadMusicList((getDataPath()+"music/default.list"));
	//Load the configured music list.
	getMusicManager()->loadMusicList((getDataPath()+"music/"+getSettings()->getValue("musiclist")+".list"));
	getMusicManager()->setMusicList(getSettings()->getValue("musiclist"));

	//Check if music is enabled.
	if(getSettings()->getBoolValue("music"))
	getMusicManager()->setEnabled();

	//Load the sound effects
	jumpSound=loadWAV((getDataPath()+"sfx/jump.wav").c_str());
	hitSound=loadWAV((getDataPath()+"sfx/hit.wav").c_str());
	saveSound=loadWAV((getDataPath()+"sfx/checkpoint.wav").c_str());
	swapSound=loadWAV((getDataPath()+"sfx/swap.wav").c_str());
	toggleSound=loadWAV((getDataPath()+"sfx/toggle.wav").c_str());
	errorSound=loadWAV((getDataPath()+"sfx/error.wav").c_str());
	collectSound=loadWAV((getDataPath()+"sfx/collect.wav").c_str());
	achievementSound=loadWAV((getDataPath()+"sfx/achievement.ogg").c_str());

	- //Load the cursor images from the Cursor.h file.
	- cursors[POINTER]=loadCursor(pointer);
	- cursors[CARROT]=loadCursor(ibeam);
	- cursors[DRAG]=loadCursor(closedhand);
	- cursors[SIZE_HOR]=loadCursor(size_hor);
	- cursors[SIZE_VER]=loadCursor(size_ver);
	- cursors[SIZE_FDIAG]=loadCursor(size_fdiag);
	- cursors[SIZE_BDIAG]=loadCursor(size_bdiag);
	- //Set the default cursor right now.
	- setCursor(cursors[POINTER]);
	-
	levelPackManager.destroy();
	//Now sum up all the levelpacks.
	vector<string> v=enumAllDirs(getDataPath()+"levelpacks/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelPackManager.loadLevelPack(getDataPath()+"levelpacks/"+*i);
	}
	v=enumAllDirs(getUserPath(USER_DATA)+"levelpacks/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelPackManager.loadLevelPack(getUserPath(USER_DATA)+"levelpacks/"+*i);
	}
	v=enumAllDirs(getUserPath(USER_DATA)+"custom/levelpacks/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelPackManager.loadLevelPack(getUserPath(USER_DATA)+"custom/levelpacks/"+*i);
	}
	//Now we add a special levelpack that will contain the levels not in a levelpack.
	LevelPack* levelsPack=new LevelPack;
	levelsPack->levelpackName="Levels";
	LevelPack* customLevelsPack=new LevelPack;
	customLevelsPack->levelpackName="Custom Levels";

	//List the addon levels and add them one for one.
	v=enumAllFiles(getUserPath(USER_DATA)+"levels/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelsPack->addLevel(getUserPath(USER_DATA)+"levels/"+*i);
	levelsPack->setLocked(levelsPack->getLevelCount()-1);
	}
	//List the custom levels and add them one for one.
	v=enumAllFiles(getUserPath(USER_DATA)+"custom/levels/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelsPack->addLevel(getUserPath(USER_DATA)+"custom/levels/"+*i);
	levelsPack->setLocked(levelsPack->getLevelCount()-1);

	customLevelsPack->addLevel(getUserPath(USER_DATA)+"custom/levels/"+*i);
	customLevelsPack->setLocked(customLevelsPack->getLevelCount()-1);
	}

	//Add them to the manager.
	levelPackManager.addLevelPack(levelsPack);
	levelPackManager.addLevelPack(customLevelsPack);

	//Load statistics
	statsMgr.loadPicture();
	statsMgr.registerAchievements();
	statsMgr.loadFile(getUserPath(USER_CONFIG)+"statistics");

	//Do something ugly and slow
	statsMgr.reloadCompletedLevelsAndAchievements();
	statsMgr.reloadOtherAchievements();

	//Load the theme, both menu and default.
	if(!loadTheme(getSettings()->getValue("theme")))
	return false;

	//Nothing failed so return true.
	return true;
	}

	bool loadSettings(){
	settings=new Settings(getUserPath(USER_CONFIG)+"meandmyshadow.cfg");
	settings->parseFile();

	//Now apply settings changed through command line arguments, if any.
	map<string,string>::iterator it;
	for(it=tmpSettings.begin();it!=tmpSettings.end();++it){
	settings->setValue(it->first,it->second);
	}
	tmpSettings.clear();

	//Always return true?
	return true;
	}

	bool saveSettings(){
	settings->save();

	//Always return true?
	return true;
	}

	Settings* getSettings(){
	return settings;
	}

	MusicManager* getMusicManager(){
	return &musicManager;
	}

	LevelPackManager* getLevelPackManager(){
	return &levelPackManager;
	}

	ScriptExecutor* getScriptExecutor(){
	return &scriptExecutor;
	}

	void flipScreen(){
	if(settings->getBoolValue("gl")){
	#ifdef HARDWARE_ACCELERATION
	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();

	//Create a texture from the screen surface.
	glBindTexture(GL_TEXTURE_2D,screenTexture);

	//Set the texture's stretching properties
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

	glTexImage2D(GL_TEXTURE_2D,0,screen->format->BytesPerPixel,screen->w,screen->h,0,GL_BGRA,GL_UNSIGNED_BYTE,screen->pixels);

	glBegin(GL_QUADS);
	glTexCoord2i(0,0); glVertex3f(0,0,0);
	glTexCoord2i(1,0); glVertex3f(SCREEN_WIDTH,0,0);
	glTexCoord2i(1,1); glVertex3f(SCREEN_WIDTH,SCREEN_HEIGHT,0);
	glTexCoord2i(0,1); glVertex3f(0,SCREEN_HEIGHT,0);
	glEnd();

	SDL_GL_SwapBuffers();
	#else
	//NOTE: Trying to flip the screen using gl while compiled without.
	cerr<<"FATAL ERROR: Unable to draw to screen using OpenGL (compiled without)."<<endl;
	#endif
	}else{
	SDL_Flip(screen);
	}
	}

	void clean(){
	//Save statistics
	statsMgr.saveFile(getUserPath(USER_CONFIG)+"statistics");

	//We delete the settings.
	if(settings){
	delete settings;
	settings=NULL;
	}

	//Get rid of the currentstate.
	//NOTE: The state is probably already deleted by the changeState function.
	if(currentState)
	delete currentState;

	//Destroy the GUI if present.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//Destroy the imageManager.
	imageManager.destroy();

	//Destroy the musicManager.
	musicManager.destroy();

	//Destroy all sounds
	Mix_FreeChunk(jumpSound);
	Mix_FreeChunk(hitSound);
	Mix_FreeChunk(saveSound);
	Mix_FreeChunk(swapSound);
	Mix_FreeChunk(toggleSound);
	Mix_FreeChunk(errorSound);
	Mix_FreeChunk(collectSound);
	Mix_FreeChunk(achievementSound);

	- //Destroy the cursors.
	- for(int i=0;i<CURSOR_TYPES;i++){
	- SDL_FreeCursor(cursors[i]);
	- cursors[i]=NULL;
	- }
	-
	//Destroy the levelPackManager.
	levelPackManager.destroy();
	levels=NULL;

	//Close all joysticks.
	inputMgr.closeAllJoysticks();

	//Close the fonts and quit SDL_ttf.
	TTF_CloseFont(fontTitle);
	TTF_CloseFont(fontGUI);
	TTF_CloseFont(fontGUISmall);
	TTF_CloseFont(fontText);
	TTF_Quit();

	//Remove the temp surface.
	SDL_FreeSurface(tempSurface);

	//Stop audio.and quit
	Mix_CloseAudio();
	#ifndef __APPLE__
	Mix_Quit();
	#endif
	//And finally quit SDL.
	SDL_Quit();
	}

	void setNextState(int newstate){
	//Only change the state when we aren't already exiting.
	if(nextState!=STATE_EXIT){
	nextState=newstate;
	}
	}

	void changeState(){
	//Check if there's a nextState.
	if(nextState!=STATE_NULL){
	//Delete the currentState.
	delete currentState;
	currentState=NULL;

	//Set the currentState to the nextState.
	stateID=nextState;
	nextState=STATE_NULL;

	//Init the state.
	switch(stateID){
	case STATE_GAME:
	currentState=new Game();
	break;
	case STATE_MENU:
	currentState=new Menu();
	break;
	case STATE_LEVEL_SELECT:
	currentState=new LevelPlaySelect();
	break;
	case STATE_LEVEL_EDIT_SELECT:
	currentState=new LevelEditSelect();
	break;
	case STATE_LEVEL_EDITOR:
	currentState=new LevelEditor();
	break;
	case STATE_OPTIONS:
	currentState=new Options();
	break;
	case STATE_ADDONS:
	currentState=new Addons();
	break;
	case STATE_CREDITS:
	currentState=new Credits();
	break;
	case STATE_STATISTICS:
	currentState=new StatisticsScreen();
	break;
	}
	//NOTE: STATE_EXIT isn't mentioned, meaning that currentState is null.
	//This way the game loop will break and the program will exit.

	//Fade out.
	int fade=255;
	SDL_BlitSurface(screen,NULL,tempSurface,NULL);
	while(fade>0){
	fade-=17;
	if(fade<0)
	fade=0;


	SDL_FillRect(screen,NULL,0);
	SDL_SetAlpha(tempSurface, SDL_SRCALPHA, fade);
	SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	flipScreen();
	SDL_Delay(25);
	}
	}
	}

	-void setCursor(SDL_Cursor* cursor){
	- SDL_SetCursor(cursor);
	-}
	-
	void musicStoppedHook(){
	//We just call the musicStopped method of the MusicManager.
	musicManager.musicStopped();
	}

	bool checkCollision(const SDL_Rect& a,const SDL_Rect& b){
	//Check if the left side of box a isn't past the right side of b.
	if(a.x>=b.x+b.w){
	return false;
	}
	//Check if the right side of box a isn't left of the left side of b.
	if(a.x+a.w<=b.x){
	return false;
	}
	//Check if the top side of box a isn't under the bottom side of b.
	if(a.y>=b.y+b.h){
	return false;
	}
	//Check if the bottom side of box a isn't above the top side of b.
	if(a.y+a.h<=b.y){
	return false;
	}

	//We have collision.
	return true;
	}

	void setCamera(const SDL_Rect* r,int count){
	//SetCamera only works in the Level editor and when mouse is inside window.
	if(stateID==STATE_LEVEL_EDITOR&&(SDL_GetAppState()&SDL_APPMOUSEFOCUS)){
	//Get the mouse coordinates.
	int x,y;
	SDL_GetMouseState(&x,&y);
	SDL_Rect mouse={x,y,0,0};

	//Don't continue here if mouse is inside one of the boxes given as parameter.
	for(int i=0;i<count;i++){
	if(checkCollision(mouse,r[i]))
	return;
	}

	//Check if the mouse is near the left edge of the screen.
	//Else check if the mouse is near the right edge.
	if(x<50){
	//We're near the left edge so move the camera.
	camera.x-=5;
	}else if(x>SCREEN_WIDTH-50){
	//We're near the right edge so move the camera.
	camera.x+=5;
	}

	//Check if the mouse is near the top edge of the screen.
	//Else check if the mouse is near the bottom edge.
	if(y<50){
	//We're near the top edge so move the camera.
	camera.y-=5;
	}else if(y>SCREEN_HEIGHT-50){
	//We're near the bottom edge so move the camera.
	camera.y+=5;
	}
	}
	}

	int parseArguments(int argc, char** argv){
	//Loop through all arguments.
	//We start at one since 0 is the command itself.
	for(int i=1;i<argc;i++){
	string argument=argv[i];

	//Check if the argument is the data-dir.
	if(argument=="--data-dir"){
	//We need a second argument so we increase i.
	i++;
	if(i>=argc){
	printf("ERROR: Missing argument for command '%s'\n\n",argument.c_str());
	return -1;
	}

	//Configure the dataPath with the given path.
	dataPath=argv[i];
	if(!getDataPath().empty()){
	char c=dataPath[dataPath.size()-1];
	if(c!='/'&&c!='\\') dataPath+="/";
	}
	}else if(argument=="--user-dir"){
	//We need a second argument so we increase i.
	i++;
	if(i>=argc){
	printf("ERROR: Missing argument for command '%s'\n\n",argument.c_str());
	return -1;
	}

	//Configure the userPath with the given path.
	userPath=argv[i];
	if(!userPath.empty()){
	char c=userPath[userPath.size()-1];
	if(c!='/'&&c!='\\') userPath+="/";
	}
	}else if(argument=="-f" \|\| argument=="-fullscreen" \|\| argument=="--fullscreen"){
	tmpSettings["fullscreen"]="1";
	}else if(argument=="-w" \|\| argument=="-windowed" \|\| argument=="--windowed"){
	tmpSettings["fullscreen"]="0";
	}else if(argument=="-mv" \|\| argument=="-music" \|\| argument=="--music"){
	//We need a second argument so we increase i.
	i++;
	if(i>=argc){
	printf("ERROR: Missing argument for command '%s'\n\n",argument.c_str());
	return -1;
	}

	//Now set the music volume.
	tmpSettings["music"]=argv[i];
	}else if(argument=="-sv" \|\| argument=="-sound" \|\| argument=="--sound"){
	//We need a second argument so we increase i.
	i++;
	if(i>=argc){
	printf("ERROR: Missing argument for command '%s'\n\n",argument.c_str());
	return -1;
	}

	//Now set sound volume.
	tmpSettings["sound"]=argv[i];
	}else if(argument=="-set" \|\| argument=="--set"){
	//We need a second and a third argument so we increase i.
	i+=2;
	if(i>=argc){
	printf("ERROR: Missing argument for command '%s'\n\n",argument.c_str());
	return -1;
	}

	//And set the setting.
	tmpSettings[argv[i-1]]=argv[i];
	}else if(argument=="-v" \|\| argument=="-version" \|\| argument=="--version"){
	//Print the version.
	printf("%s\n",version.c_str());
	return 0;
	}else if(argument=="-h" \|\| argument=="-help" \|\| argument=="--help"){
	//If the help is requested we'll return false without printing an error.
	//This way the usage/help text will be printed.
	return -1;
	}else{
	//Any other argument is unknow so we return false.
	printf("ERROR: Unknown argument %s\n\n",argument.c_str());
	return -1;
	}
	}

	//If everything went well we can return true.
	return 1;
	}

	//Special structure that will recieve the GUIEventCallbacks of the messagebox.
	struct msgBoxHandler:public GUIEventCallback{
	public:
	//Integer containing the ret(urn) value of the messageBox.
	int ret;
	public:
	//Constructor.
	msgBoxHandler():ret(0){}

	void GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	//Make sure it's a click event.
	if(eventType==GUIEventClick){
	//Set the return value.
	ret=obj->value;

	//After a click event we can delete the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	}
	};

	msgBoxResult msgBox(string prompt,msgBoxButtons buttons,const string& title){
	//Create the event handler.
	msgBoxHandler objHandler;
	//The GUI objects.
	GUIObject* obj;

	//Create the GUIObjectRoot, the height and y location is temp.
	//It depends on the content what it will be.
	GUIObject* root=new GUIObject((SCREEN_WIDTH-600)/2,200,600,200,GUIObjectFrame,title.c_str());

	//Integer containing the current y location used to grow dynamic depending on the content.
	int y=50;

	//Now process the prompt.
	{
	//Pointer to the string.
	char* lps=(char*)prompt.c_str();
	//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;

	//Add a GUIObjectLabel with the sentence.
	root->addChild(new GUIObject(0,y,root->width,25,GUIObjectLabel,lps,0,true,true,GUIGravityCenter));
	//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;
	}
	}
	//Add 70 to y to leave some space between the content and the buttons.
	y+=70;
	//Recalc the size of the message box.
	root->top=(SCREEN_HEIGHT-y)/2;
	root->height=y;

	//Now we need to add the buttons.
	//Integer containing the number of buttons to add.
	int count=0;
	//Array with the return codes for the buttons.
	int value[3]={0};
	//Array containing the captation for the buttons.
	string button[3]={"","",""};
	switch(buttons){
	case MsgBoxOKCancel:
	count=2;
	button[0]=_("OK");value[0]=MsgBoxOK;
	button[1]=_("Cancel");value[1]=MsgBoxCancel;
	break;
	case MsgBoxAbortRetryIgnore:
	count=3;
	button[0]=_("Abort");value[0]=MsgBoxAbort;
	button[1]=_("Retry");value[1]=MsgBoxRetry;
	button[2]=_("Ignore");value[2]=MsgBoxIgnore;
	break;
	case MsgBoxYesNoCancel:
	count=3;
	button[0]=_("Yes");value[0]=MsgBoxYes;
	button[1]=_("No");value[1]=MsgBoxNo;
	button[2]=_("Cancel");value[2]=MsgBoxCancel;
	break;
	case MsgBoxYesNo:
	count=2;
	button[0]=_("Yes");value[0]=MsgBoxYes;
	button[1]=_("No");value[1]=MsgBoxNo;
	break;
	case MsgBoxRetryCancel:
	count=2;
	button[0]=_("Retry");value[0]=MsgBoxRetry;
	button[1]=_("Cancel");value[1]=MsgBoxCancel;
	break;
	default:
	count=1;
	button[0]=_("OK");value[0]=MsgBoxOK;
	break;
	}

	//Now we start making the buttons.
	{
	//Reduce y so that the buttons fit inside the frame.
	y-=40;

	double places[3]={0.0};
	if(count==1){
	places[0]=0.5;
	}else if(count==2){
	places[0]=0.4;
	places[1]=0.6;
	}else if(count==3){
	places[0]=0.3;
	places[1]=0.5;
	places[2]=0.7;
	}

	//Loop to add the buttons.
	for(int i=0;i<count;i++){
	obj=new GUIObject(root->width*places[i],y,-1,36,GUIObjectButton,button[i].c_str(),value[i],true,true,GUIGravityCenter);
	obj->eventCallback=&objHandler;
	root->addChild(obj);
	}
	}

	//Now we dim the screen and keep the GUI rendering/updating.
	GUIOverlay* overlay=new GUIOverlay(root);
	overlay->enterLoop(true);

	//And return the result.
	return (msgBoxResult)objHandler.ret;
	}

	struct fileDialogHandler:public GUIEventCallback{
	public:
	//The ret(urn) value, true=ok and false=cancel
	bool ret;
	//Boolean if it's a save dialog.
	bool isSave;
	//Boolean if the file should be verified.
	bool verifyFile;
	//Boolean if files should be listed instead of directories.
	bool files;

	//Pointer to the textfield containing the filename.
	GUIObject* txtName;
	//Pointer to the listbox containing the different files.
	GUIListBox* lstFile;

	//The extension the files listed should have.
	const char* extension;
	//The current filename.
	string fileName;
	//The current search path.
	string path;

	//Vector containing the search paths.
	vector<string> searchPath;
	public:
	//Constructor.
	fileDialogHandler(bool isSave=false,bool verifyFile=false, bool files=true):ret(false),
	isSave(isSave),verifyFile(verifyFile),
	files(files),txtName(NULL),lstFile(NULL),extension(NULL){}

	void GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	//Check for the ok event.
	if(name=="cmdOK"){
	//Get the entered fileName from the text field.
	std::string s=txtName->caption;

	//If it doesn't contain a slash we need to add the path to the fileName.
	if(s.find_first_of("/")==string::npos)
	s=path+s;

	//If the string empty we return.
	if(s.empty() \|\| s.find_first_of("*?")!=string::npos)
	return;

	//We only need to check for extensions if it isn't a folder dialog.
	if(files){
	//If there isn't right extension add it.
	size_t found=s.find_first_of(".");
	if(found!=string::npos)
	s.replace(s.begin()+found+1,s.end(),extension);
	else if (s.substr(found+1)!=extension)
	s.append(string(".")+extension);
	}

	//Check if we should save or load the file.
	//
	if(isSave){
	//Open the file with read permission to check if it already exists.
	FILE* f;
	f=fopen(processFileName(s).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();

	//Prompt the user with a Yes or No question.
	/// TRANSLATORS: Filename is coming before this text
	if(msgBox(tfm::format(_("%s already exists.\nDo you want to overwrite it?"),s),MsgBoxYesNo,_("Overwrite Prompt"))!=MsgBoxYes){
	//He answered no, so we return.
	return;
	}
	}

	//Check if we should verify the file.
	//Verifying only applies to files not to directories.
	if(verifyFile && files){
	//Open the file with write permission.
	f=fopen(processFileName(s).c_str(),"wb");

	//Check if their aren't problems.
	if(f){
	//Close the file.
	fclose(f);
	}else{
	//Let the currentState render once to prevent multiple GUI overlapping and prevent the screen from going black.
	currentState->render();

	//The file can't be opened so tell the user.
	msgBox(tfm::format(_("Can't open file %s."),s),MsgBoxOKOnly,_("Error"));
	return;
	}
	}
	}else if(verifyFile && files){
	//We need to verify a file for opening.
	FILE *f;
	f=fopen(processFileName(s).c_str(),"rb");

	//Check if it didn't fail.
	if(f){
	//Succes, so close the file.
	fclose(f);
	}else{
	//Let the currentState render once to prevent multiple GUI overlapping and prevent the screen from going black.
	currentState->render();

	//Unable to open file so tell the user.
	msgBox(tfm::format(_("Can't open file %s."),s),MsgBoxOKOnly,_("Error"));
	return;
	}
	}

	//If we haven't returned then it's fine.
	//Set the fileName to the chosen file.
	fileName=s;

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

	//Set return to true.
	ret=true;
	}else if(name=="cmdCancel"){
	//Cancel means we can kill the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}else if(name=="lstFile"){
	//Get a pointer to the listbox.
	GUIListBox* obj1=lstFile;

	//Make sure the option exist and change textfield to it.
	if(obj1!=NULL && txtName!=NULL && obj1->value>=0 && obj1->value<(int)obj1->item.size()){
	txtName->caption=obj1->item[obj1->value];
	}
	}else if(name=="lstSearchIn"){
	//Get the searchpath listbox.
	GUISingleLineListBox obj1=dynamic_cast<GUISingleLineListBox>(obj);

	//Check if the entry exists.
	if(obj1!=NULL && lstFile!=NULL && obj1->value>=0 && obj1->value<(int)searchPath.size()){
	//Temp string.
	string s;

	//Get the new search path.
	path=searchPath[obj1->value];

	//Make sure it isn't empty.
	if(!path.empty()){
	//Process the filename.
	s=processFileName(path);
	}else{
	//It's empty so we give the userpath.
	s=getUserPath();
	}

	//Fill the list with files or directories.
	if(files) {
	lstFile->item=enumAllFiles(s,extension);
	}else
	lstFile->item=enumAllDirs(s);

	//Remove any selection from the list.
	lstFile->value=-1;
	}
	}
	}
	};

	bool fileDialog(string& fileName,const char* title,const char* extension,const char* path,bool isSave,bool verifyFile,bool files){
	//Pointer to GUIObject to make the GUI with.
	GUIObject* obj;

	//Create the fileDialogHandler, used for event handling.
	fileDialogHandler objHandler(isSave,verifyFile,files);
	//Vector containing the pathNames.
	vector<string> pathNames;

	//Set the extension of the objHandler.
	objHandler.extension=extension;

	//We now need to splits the given path into multiple path names.
	if(path && path[0]){
	//The string isn't empty.
	//Pointer to the paths string.
	char* lp=(char*)path;
	//Pointer to the first newline.
	char* lps=strchr(lp,'\n');
	//Pointer used for checking if their's another newline.
	//It will indicate if it's the last set or not.
	char* lpe;

	//Check for a newline.
	if(lps){
	//We have newline(s) so loop forever.
	//We can only break out of the loop when the string ends.
	for(;;){
	//Add the first searchpath.
	//This is the beginning of the string (lp) to the first newline. (lps)
	objHandler.searchPath.push_back(string(lp,lps-lp));

	//We should have another newline so search for it.
	lpe=strchr(lps+1,'\n');
	if(lpe){
	//We found it so we add that to the pathname.
	pathNames.push_back(string(lps+1,lpe-lps-1));
	//And start over again by setting lp to the start of a new set of searchPath/pathName.
	lp=lpe+1;
	}else{
	//There is no newline anymore, meaning the last entry, the rest of the string must be the pathName.
	pathNames.push_back(string(lps+1));
	//And break out of the loop.
	break;
	}

	//We haven't broken out so search for a newline.
	lps=strchr(lp,'\n');
	//If there isn't a newline break.
	if(!lps)
	break;
	}
	}else{
	//There is no newline thus the whole string is the searchPath.
	objHandler.searchPath.push_back(path);
	}
	}else{
	//Empty so put an empty string as searchPath.
	objHandler.searchPath.push_back(string());
	}

	//It's time to create the GUI.
	//If there are more than one pathNames we need to add a GUISingleLineListBox.
	int base_y=pathNames.empty()?20:60;

	//Create the frame.
	GUIObject* root=new GUIObject(100,100-base_y/2,600,400+base_y,GUIObjectFrame,title?title:(isSave?_("Save File"):_("Load File")));

	//Create the search path list box if needed.
	if(!pathNames.empty()){
	root->addChild(new GUIObject(8,40,184,36,GUIObjectLabel,_("Search In")));
	GUISingleLineListBox* obj1=new GUISingleLineListBox(160,40,432,36);
	obj1->item=pathNames;
	obj1->value=0;
	obj1->name="lstSearchIn";
	obj1->eventCallback=&objHandler;
	root->addChild(obj1);
	}

	//Add the FileName label and textfield.
	root->addChild(new GUIObject(8,20+base_y,184,36,GUIObjectLabel,_("File Name")));
	{
	//Fill the textbox with the given fileName.
	string s=fileName;

	if(!isSave){
	//But only if it isn't empty.
	if(s.empty() && extension && extension[0])
	s=string("*.")+string(extension);
	}

	//Create the textbox and add it to the GUI.
	objHandler.txtName=new GUIObject(160,20+base_y,432,36,GUIObjectTextBox,s.c_str());
	root->addChild(objHandler.txtName);
	}

	//Now we add the ListBox containing the files or directories.
	{
	GUIListBox* obj1=new GUIListBox(8,60+base_y,584,292);

	//Get the searchPath.
	string s=objHandler.searchPath[0];
	//Make sure it isn't empty.
	if(!s.empty()){
	objHandler.path=s;
	s=processFileName(s);
	}else{
	s=getUserPath();
	}

	//Check if we should list files or directories.
	if(files){
	//Fill the list with files.
	obj1->item=enumAllFiles(s,extension);
	}else{
	//Fill the list with directories.
	obj1->item=enumAllDirs(s);
	}
	obj1->name="lstFile";
	obj1->eventCallback=&objHandler;
	root->addChild(obj1);
	objHandler.lstFile=obj1;
	}

	//Now create the OK and Cancel buttons.
	obj=new GUIObject(200,360+base_y,192,36,GUIObjectButton,_("OK"));
	obj->name="cmdOK";
	obj->eventCallback=&objHandler;
	root->addChild(obj);
	obj=new GUIObject(400,360+base_y,192,36,GUIObjectButton,_("Cancel"));
	obj->name="cmdCancel";
	obj->eventCallback=&objHandler;
	root->addChild(obj);

	//Create the gui overlay.
	GUIOverlay* overlay=new GUIOverlay(root);
	overlay->enterLoop();

	//Now determine what the return value is (and if there is one).
	if(objHandler.ret)
	fileName=objHandler.fileName;
	return objHandler.ret;
	}
	diff --git a/src/Functions.h b/src/Functions.h
	index a0ba122..e9c637c 100644
	--- a/src/Functions.h
	+++ b/src/Functions.h
	@@ -1,257 +1,254 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef FUNCTIONS_H
	#define FUNCTIONS_H

	#include "Settings.h"
	#include "MusicManager.h"
	#include "LevelPackManager.h"
	#include "ScriptExecutor.h"
	#include "Globals.h"

	#include <SDL/SDL.h>
	#include <string>
	#include <vector>

	//gettext function
	//message: The message to translate.
	//Returns: The translated string or the original string if there is not translation available.
	#define _(message) (dictionaryManager!=NULL?dictionaryManager->get_dictionary().translate(message).c_str():std::string(message).c_str())
	//gettext function
	//dictionaryManager: Pointer to the dictionaryManager to use for the translation.
	//message: The message to translate.
	//Returns: The translated string or the original string if there is not translation available.
	#define _C(dictionaryManager, message) ((dictionaryManager)!=NULL?(dictionaryManager)->get_dictionary().translate(message).c_str():std::string(message).c_str())
	//dummy function for xgettext
	//message: The message to translate.
	//Returns: message parameter
	#define __(message) (message)

	//Loads an image.
	//file: The image file to load.
	//Returns: The SDL_surface containing the image.
	SDL_Surface* loadImage(std::string file);

	//Method for drawing an SDL_Surface onto another.
	//x: The x location to draw the source on the desination.
	//y: The y location to draw the source on the desination.
	//source: The SDL_Surface to draw.
	//dest: The SDL_Surface to draw on.
	//clip: Rectangle which part of the source should be drawn.
	void applySurface(int x,int y,SDL_Surface* source,SDL_Surface* dest,SDL_Rect* clip);

	//Method used to draw an rectangle.
	//x: The top left x location of the rectangle.
	//y: The top left y location of the rectangle.
	//w: The width of the rectangle,
	//h: The height of the rectangle.
	//dest: The SDL_Surface to draw on.
	//color: The color of the rectangle border to draw.
	void drawRect(int x,int y,int w,int h,SDL_Surface* dest,Uint32 color=0);

	//Method used to draw filled boxes with an anti-alliased border.
	//Mostly used for GUI components.
	//x: The top left x location of the box.
	//y: The top left y location of the box.
	//w: The width of the box,
	//h: The height of the box.
	//dest: The SDL_Surface to draw on.
	//color: The color of the rectangle background to draw.
	void drawGUIBox(int x,int y,int w,int h,SDL_Surface* dest,Uint32 color);

	//Method used to draw a line.
	//x1: The x location of the start point.
	//y1: The y location of the start point.
	//x2: The x location of the end point.
	//y2: The y location of the end point.
	//dest: The SDL_Surface to draw on.
	//color: The color of the line to draw.
	void drawLine(int x1,int y1,int x2,int y2,SDL_Surface* dest,Uint32 color=0);

	//Method used to draw a line with some arrows on it.
	//x1: The x location of the start point.
	//y1: The y location of the start point.
	//x2: The x location of the end point.
	//y2: The y location of the end point.
	//dest: The SDL_Surface to draw on.
	//color: The color of the line to draw.
	//spacing: The spacing between arrows.
	//offset: Offset of first arrow relative to the start point.
	//xize, ysize: The size of arrow.
	void drawLineWithArrow(int x1,int y1,int x2,int y2,SDL_Surface* dest,Uint32 color=0,int spacing=16,int offset=0,int xsize=5,int ysize=5);

	//Method that will load the fonts needed for the game.
	//NOTE: It's separate from loadFiles(), since it might get called separatly from the code when changing the language.
	bool loadFonts();
	//Method that will load the default theme again.
	//name: name of the theme to load or empty for scaling background
	//NOTE: It's separate from loadFiles(), since it might get called separatly from the code when changing resolution.
	bool loadTheme(string name);
	//This method will attempt to create the screen/window.
	//NOTE: It's separate from init(), since it might get called separatly from the code when changing resolution.
	bool createScreen();

	//Method that is called when a fullscreen window is created.
	//It will choose the resolution that is closest to the configured one.
	void pickFullscreenResolution();

	//This method is used to configure the window that is created by createScreen.
	//NOTE: It will do it in a WM specific way, so if the wm is unkown it will do nothing.
	//initial: Boolean that is true if it's the first time the window is configured.
	void configureWindow(bool initial);

	//Call this method when receive SDL_VIDEORESIZE event.
	void onVideoResize();

	//Initialises the game. This is done almost at the beginning of the program.
	//It initialises: SDL, SDL_Mixer, SDL_ttf, the screen and the block types.
	//Returns: True if everything goes well.
	bool init();
	//Loads some important files, like the background music and the default theme.
	//Returns: True if everything goes well.
	bool loadFiles();

	//This method will load the settings from the settings file.
	//Returns: False if there's an error while loading.
	bool loadSettings();
	//This method will save the settings to the settings file.
	//Returns: False if there's an error while saving.
	bool saveSettings();
	//Method used to get a pointer to the settings object.
	//Returns: A pointer to the settings object.
	Settings* getSettings();

	//Method used to get a pointer to the MusicManager object.
	//Returns: A pointer to the MusicManager object.
	MusicManager* getMusicManager();

	//Method used to get a pointer to the LevelPackManager object.
	//Returns: A pointer to the LevelPackManager object.
	LevelPackManager* getLevelPackManager();

	//Method used to get a pointer to the ScriptExecutor object.
	//Returns: A pointer to the ScriptExecutor object.
	ScriptExecutor* getScriptExecutor();

	//Method that will, depending on the rendering backend, draw the screen surface to the screen.
	void flipScreen();

	//Method used to clean up before quiting meandmyshadow.
	void clean();

	//Sets what the nextState will be.
	//newstate: Integer containing the id of the newstate.
	void setNextState(int newstate);
	//Method that will perform the state change.
	//It will fade out and in.
	void changeState();

	-//Method for changing the current cursor.
	-void setCursor(SDL_Cursor* cursor);
	-
	//This method is called when music is stopped.
	//NOTE: This method is outside the MusicManager because it couldn't be called otherwise.
	//Do not call this method anywhere in the code!
	void musicStoppedHook();

	//Checks collision between two SDL_Rects.
	//a: The first rectangle.
	//b: The second rectangle.
	//Returns: True if the two rectangles collide.
	bool checkCollision(const SDL_Rect& a,const SDL_Rect& b);

	//This method will check if the mouse is near a screen edge.
	//r: An array of SDL_Rect, does nothing if mouse inside these rectange(s).
	//count: Number of rectangles.
	//If so it will move the camera.
	//Note: This function only works with the leveleditor.
	void setCamera(const SDL_Rect* r,int count);

	//Parse the commandline arguments.
	//argc: Integer containing the number of aruguments there are.
	//argv: The arguments.
	//Returns: -1 if something goes wrong while parsing,
	// 0 if version is shown,
	// 1 if everything is alright
	int parseArguments(int argc, char** argv);

	//From http://en.wikipedia.org/wiki/Clamping_(graphics)
	//x: The value to clamp.
	//min: The minimum x can be.
	//max: The maximum x can be.
	//Returns: Integer containing the clamped value.
	int inline clamp(int x,int min,int max){
	return (x>max)?max:(x<min)?min:x;
	}

	//Enumeration containing the different messagebox button combinations.
	enum msgBoxButtons{
	//Only one button with the text OK.
	MsgBoxOKOnly=0,
	//Two buttons, one saying OK, the other Cancel.
	MsgBoxOKCancel=1,
	//Three buttons, Abort, Retry, Ignore.
	MsgBoxAbortRetryIgnore=2,
	//Three buttons, Yes, No or Cancel.
	MsgBoxYesNoCancel=3,
	//Two buttons, one saying Yes, the other No.
	MsgBoxYesNo=4,
	//Two buttons, one saying Retry, the other Cancel.
	MsgBoxRetryCancel=5,
	};

	//Enumeration containing the different result that can be retrieved from a messagebox.
	//It represents the button that has been pressed.
	enum msgBoxResult{
	//The OK button.
	MsgBoxOK=1,
	//The cancel button.
	MsgBoxCancel=2,
	//The abort button.
	MsgBoxAbort=3,
	//The retry button.
	MsgBoxRetry=4,
	//The ignore button.
	MsgBoxIgnore=5,
	//The yes button.
	MsgBoxYes=6,
	//The no button.
	MsgBoxNo=7,
	};

	//Method that prompts the user with a notification and/or question.
	//prompt: The message the user is prompted with.
	//buttons: Which buttons the messagebox should have.
	//title: The title of the message box.
	//Returns: A msgBoxResult which button has been pressed.
	msgBoxResult msgBox(std::string prompt,msgBoxButtons buttons,const std::string& title);

	//This method will show a file dialog in which the user can select a file.
	//NOTE: It doesn't support entering folders.
	//fileName: String that will contain the result, it can also be used to already chose the file.
	//title: The title of the fileDialog window.
	//extension: The extension the files must have, leave empty for all files.
	//path: The path to list the files of.
	//isSave: If the dialog is for saving files, and not loading.
	//verifyFile: Boolean if the selected should be verified.
	//files: Boolean if the fileDialog should display files, if not it will display directories.
	bool fileDialog(std::string& fileName,const char* title=NULL,const char* extension=NULL,const char* path=NULL,bool isSave=false,bool verifyFile=false,bool files=true);

	#endif
	diff --git a/src/GUIListBox.cpp b/src/GUIListBox.cpp
	index 4989c2b..aff2023 100644
	--- a/src/GUIListBox.cpp
	+++ b/src/GUIListBox.cpp
	@@ -1,393 +1,397 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "GUIListBox.h"
	using namespace std;

	GUIListBox::GUIListBox(int left,int top,int width,int height,bool enabled,bool visible,int gravity):
	GUIObject(left,top,width,height,0,NULL,-1,enabled,visible,gravity){
	//Set the state -1.
	state=-1;

	//Create the scrollbar and add it to the children.
	scrollBar=new GUIScrollBar(0,0,16,0,1,0,0,0,0,0,true,false);
	childControls.push_back(scrollBar);
	}

	bool GUIListBox::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	//Boolean if the event is processed.
	bool b=processed;

	//The GUIObject is only enabled when he and his parent are enabled.
	enabled=enabled && this->enabled;
	//The GUIObject is only enabled when he and his parent are enabled.
	visible=visible && this->visible;

	//Get the absolute position.
	x+=left;
	y+=top;

	//Calculate the scrollbar position.
	scrollBar->left=width-16;
	scrollBar->height=height;
	int m=item.size(),n=(height-4)/24;
	if(m>n){
	scrollBar->maxValue=m-n;
	scrollBar->smallChange=1;
	scrollBar->largeChange=n;
	scrollBar->visible=true;
	b=b\|\|scrollBar->handleEvents(x,y,enabled,visible,b);
	}else{
	scrollBar->value=0;
	scrollBar->maxValue=0;
	scrollBar->visible=false;
	}

	//Set state negative.
	state=-1;

	//Check if the GUIListBox is visible, enabled and no event has been processed before.
	if(enabled&&visible&&!b){
	//The mouse location (x=i, y=j) and the mouse button (k).
	int i,j;
	SDL_GetMouseState(&i,&j);

	//Convert the mouse location to a relative location.
	i-=x+2;
	j-=y+2;

	//Check if the mouse is inside the GUIListBox.
	if(i>=0&&i<width-4&&j>=0&&j<height-4){
	//Calculate the y location with the scrollbar position.
	int idx=j/24+scrollBar->value;

	//If the entry isn't above the max we have an event.
	if(idx>=0&&idx<(int)item.size()){
	state=idx;

	+ currentCursor=CURSOR_POINT;
	+
	//Check if the left mouse button is pressed.
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_LEFT && value!=idx){
	value=idx;

	//If event callback is configured then add an event to the queue.
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventClick};
	GUIEventQueue.push_back(e);
	}
	}
	}

	//Check for mouse wheel scrolling.
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_WHEELDOWN && scrollBar->enabled){
	scrollBar->value+=4;
	if(scrollBar->value > scrollBar->maxValue)
	scrollBar->value = scrollBar->maxValue;
	}else if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_WHEELUP && scrollBar->enabled){
	scrollBar->value-=4;
	if(scrollBar->value < 0)
	scrollBar->value = 0;
	}
	}
	}

	//Process child controls event except for the scrollbar.
	//That's why i starts at one.
	for(unsigned int i=1;i<childControls.size();i++){
	bool b1=childControls[i]->handleEvents(x,y,enabled,visible,b);

	//The event is processed when either our or the childs is true (or both).
	b=b\|\|b1;
	}
	return b;
	}

	void GUIListBox::render(int x,int y,bool draw){
	//Rectangle the size of the GUIObject, used to draw borders.
	SDL_Rect r;
	//There's no need drawing the GUIObject when it's invisible.
	if(!visible\|\|!draw)
	return;

	//Get the absolute x and y location.
	x+=left;
	y+=top;

	//Default background opacity
	int clr=128;
	//TODO: Add hover check?

	//Draw the box.
	Uint32 color=0xFFFFFFFF\|clr;
	drawGUIBox(x,y,width,height,screen,color);

	//We need to draw the items.
	//The number of items.
	int m=item.size();
	//The number of items that are visible.
	int n=(height-4)/24;
	//Integer containing the current entry that is being drawn.
	int i;
	//The y coordinate the current entries reaches.
	int j;

	//If the number of items is higer than fits on the screen set the begin value (m) to scrollBar->value+n.
	if(m>scrollBar->value+n)
	m=scrollBar->value+n;

	//Loop through the (visible) entries and draw them.
	for(i=scrollBar->value,j=y+1;i<m;i++,j+=24){
	//The background color for the entry.
	int clr=-1;
	//If i is the selected entry then give it a light gray background.
	if(value==i){
	clr=0xDDDDDDFF;
	}

	//Check if the current entry is selected. If so draw borders around it.
	if(state==i)
	drawGUIBox(x,j-1,width,25,screen,0x00000000);

	//Only draw when clr isn't -1.
	if(clr!=-1)
	drawGUIBox(x,j-1,width,25,screen,clr);

	//Now draw the text.
	const char* s=item[i].c_str();
	//Make sure the text isn't empty.
	if(s && s[0]){
	//Render black text.
	SDL_Color black={0,0,0,0};
	SDL_Surface *bm=TTF_RenderUTF8_Blended(fontText,s,black);

	//Calculate the text location, center it vertically.
	r.x=x+4;
	r.y=j+12-bm->h/2;

	//Draw the text and free the rendered surface.
	SDL_BlitSurface(bm,NULL,screen,&r);
	SDL_FreeSurface(bm);
	}
	}

	//We now need to draw all the children of the GUIObject.
	for(unsigned int i=0;i<childControls.size();i++){
	childControls[i]->render(x,y,draw);
	}
	}

	GUISingleLineListBox::GUISingleLineListBox(int left,int top,int width,int height,bool enabled,bool visible,int gravity):
	GUIObject(left,top,width,height,0,NULL,-1,enabled,visible,gravity),animation(0){}

	bool GUISingleLineListBox::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	//Boolean if the event is processed.
	bool b=processed;

	//The GUIObject is only enabled when he and his parent are enabled.
	enabled=enabled && this->enabled;
	//The GUIObject is only enabled when he and his parent are enabled.
	visible=visible && this->visible;

	//Get the absolute position.
	x+=left-gravityX;
	y+=top;

	state&=~0xF;
	if(enabled&&visible){
	//The mouse location (x=i, y=j) and the mouse button (k).
	int i,j,k;
	k=SDL_GetMouseState(&i,&j);

	//Convert the mouse location to a relative location.
	i-=x;
	j-=y;

	//The selected button.
	//0=nothing 1=left 2=right.
	int idx=0;

	//Check which button the mouse is above.
	if(i>=0&&i<width&&j>=0&&j<height){
	if(i<26 && i<width/2){
	//The left arrow.
	idx=1;
	+ currentCursor=CURSOR_POINT;
	}else if(i>=width-26){
	//The right arrow.
	idx=2;
	+ currentCursor=CURSOR_POINT;
	}
	}

	//If idx is 0 it means the mous doesn't hover any arrow so reset animation.
	if(idx==0)
	animation=0;

	//Check if there's a mouse button press or not.
	if(k&SDL_BUTTON(1)){
	if(((state>>4)&0xF)==idx)
	state\|=idx;
	}else{
	state\|=idx;
	}

	//Check if there's a mouse press.
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_LEFT && idx){
	state=idx\|(idx<<4);
	}else if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT && idx && ((state>>4)&0xF)==idx){
	int m=(int)item.size();
	if(m>0){
	if(idx==2){
	idx=value+1;
	if(idx<0\|\|idx>=m) idx=0;
	if(idx!=value){
	value=idx;

	//If there is an event callback then call it.
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventClick};
	GUIEventQueue.push_back(e);
	}
	}
	}else if(idx==1){
	idx=value-1;
	if(idx<0\|\|idx>=m) idx=m-1;
	if(idx!=value){
	value=idx;

	//If there is an event callback then call it.
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventClick};
	GUIEventQueue.push_back(e);
	}
	}
	}
	}
	}
	if(event.type==SDL_MOUSEBUTTONUP) state&=0xF;
	}else{
	//Set state zero.
	state=0;
	}

	//Also let the children handle their events.
	for(unsigned int i=0;i<childControls.size();i++){
	bool b1=childControls[i]->handleEvents(x,y,enabled,visible,b);

	//The event is processed when either our or the childs is true (or both).
	b=b\|\|b1;
	}
	return b;
	}

	void GUISingleLineListBox::render(int x,int y,bool draw){
	//Rectangle the size of the GUIObject, used to draw borders.
	SDL_Rect r;

	//There's no need drawing the GUIObject when it's invisible.
	if(!visible)
	return;

	//NOTE: logic in the render method since it's the only part that gets called every frame.
	if((state&0xF)==0x1 \|\| (state&0xF)==0x2){
	animation++;
	if(animation>20)
	animation=-20;
	}

	//Get the absolute x and y location.
	x+=left;
	y+=top;

	if(gravity==GUIGravityCenter)
	gravityX=int(width/2);
	else if(gravity==GUIGravityRight)
	gravityX=width;

	x-=gravityX;

	//Check if the enabled state changed or the caption, if so we need to clear the (old) cache.
	if(enabled!=cachedEnabled \|\| item[value].compare(cachedCaption)!=0){
	//Free the cache.
	SDL_FreeSurface(cache);
	cache=NULL;

	//And cache the new values.
	cachedEnabled=enabled;
	cachedCaption=item[value];
	}

	//Draw the text.
	if(value>=0 && value<(int)item.size()){
	//Get the text.
	const char* lp=item[value].c_str();

	//Check if the text is empty or not.
	if(lp!=NULL && lp[0]){
	if(!cache){
	SDL_Color color;
	if(inDialog)
	color=themeTextColorDialog;
	else
	color=themeTextColor;

	cache=TTF_RenderUTF8_Blended(fontGUI,lp,color);

	//If the text is too wide then we change to smaller font (?)
	//NOTE: The width is 32px smaller (2x16px for the arrows).
	if(cache->w>width-32){
	SDL_FreeSurface(cache);
	cache=TTF_RenderUTF8_Blended(fontGUISmall,lp,color);
	}
	}

	if(draw){
	//Center the text both vertically as horizontally.
	r.x=x+(width-cache->w)/2;
	r.y=y+(height-cache->h)/2-GUI_FONT_RAISE;

	//Draw the text and free the surface afterwards.
	SDL_BlitSurface(cache,NULL,screen,&r);
	}
	}
	}

	if(draw){
	//Draw the arrows.
	SDL_Rect r2={48,0,16,16};
	r.x=x;
	if((state&0xF)==0x1)
	r.x+=abs(animation/2);
	r.y=y+4;
	if(inDialog)
	applySurface(r.x,r.y,arrowLeft2,screen,NULL);
	else
	applySurface(r.x,r.y,arrowLeft1,screen,NULL);

	r.x=x+width-16;
	if((state&0xF)==0x2)
	r.x-=abs(animation/2);
	if(inDialog)
	applySurface(r.x,r.y,arrowRight2,screen,NULL);
	else
	applySurface(r.x,r.y,arrowRight1,screen,NULL);
	}

	//We now need to draw all the children of the GUIObject.
	for(unsigned int i=0;i<childControls.size();i++){
	childControls[i]->render(x,y,draw);
	}
	}
	diff --git a/src/GUIObject.cpp b/src/GUIObject.cpp
	index aee44ca..ba0849b 100644
	--- a/src/GUIObject.cpp
	+++ b/src/GUIObject.cpp
	@@ -1,586 +1,590 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "GUIObject.h"
	#include <iostream>
	#include <list>
	using namespace std;

	//Set the GUIObjectRoot to NULL.
	GUIObject* GUIObjectRoot=NULL;
	//Initialise the event queue.
	list<GUIEvent> GUIEventQueue;


	void GUIObjectHandleEvents(bool kill){
	//Check if user resizes the window.
	if(event.type==SDL_VIDEORESIZE){
	//onVideoResize();

	//Don't let other objects process this event (?)
	return;
	}

	//Make sure that GUIObjectRoot isn't null.
	if(GUIObjectRoot)
	GUIObjectRoot->handleEvents();

	//Check for SDL_QUIT.
	if(event.type==SDL_QUIT && kill){
	//We get a quit event so enter the exit state.
	setNextState(STATE_EXIT);
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	return;
	}

	//Keep calling events until there are none left.
	while(!GUIEventQueue.empty()){
	//Get one event and remove it from the queue.
	GUIEvent e=GUIEventQueue.front();
	GUIEventQueue.pop_front();

	//If an eventCallback exist call it.
	if(e.eventCallback){
	e.eventCallback->GUIEventCallback_OnEvent(e.name,e.obj,e.eventType);
	}
	}
	//We empty the event queue just to be sure.
	GUIEventQueue.clear();
	}

	GUIObject::~GUIObject(){
	if(cache){
	SDL_FreeSurface(cache);
	cache=NULL;
	}
	//We need to delete every child we have.
	for(unsigned int i=0;i<childControls.size();i++){
	delete childControls[i];
	}
	//Deleted the childs now empty the childControls vector.
	childControls.clear();
	}

	bool GUIObject::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	//Boolean if the event is processed.
	bool b=processed;

	//The GUIObject is only enabled when he and his parent are enabled.
	enabled=enabled && this->enabled;
	//The GUIObject is only enabled when he and his parent are enabled.
	visible=visible && this->visible;

	//Get the absolute position.
	x+=left-gravityX;
	y+=top;

	//Type specific event handling.
	switch(type){
	case GUIObjectButton:
	//Set state to 0.
	state=0;

	//Only check for events when the object is both enabled and visible.
	if(enabled&&visible){
	//The mouse location (x=i, y=j) and the mouse button (k).
	int i,j,k;
	k=SDL_GetMouseState(&i,&j);

	//Check if the mouse is inside the GUIObject.
	if(i>=x&&i<x+width&&j>=y&&j<y+height){
	//We have hover so set state to one.
	state=1;
	+ currentCursor=CURSOR_POINT;
	//Check for a mouse button press.
	if(k&SDL_BUTTON(1))
	state=2;

	//Check if there's a mouse press and the event hasn't been already processed.
	if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT && !b){
	//If event callback is configured then add an event to the queue.
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventClick};
	GUIEventQueue.push_back(e);
	}

	//Event has been processed.
	b=true;
	}
	}
	}
	break;
	case GUIObjectCheckBox:
	//Set state to 0.
	state=0;

	//Only check for events when the object is both enabled and visible.
	if(enabled&&visible){
	//The mouse location (x=i, y=j) and the mouse button (k).
	int i,j,k;
	k=SDL_GetMouseState(&i,&j);

	//Check if the mouse is inside the GUIObject.
	if(i>=x&&i<x+width&&j>=y&&j<y+height){
	//We have hover so set state to one.
	state=1;
	//Check for a mouse button press.
	if(k&SDL_BUTTON(1))
	state=2;

	+ currentCursor=CURSOR_POINT;
	+
	//Check if there's a mouse press and the event hasn't been already processed.
	if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT && !b){
	//It's a checkbox so toggle the value.
	value=value?0:1;

	//If event callback is configured then add an event to the queue.
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventClick};
	GUIEventQueue.push_back(e);
	}

	//Event has been processed.
	b=true;
	}
	}
	}
	break;
	case GUIObjectTextBox:
	//NOTE: We don't reset the state to have a "focus" effect.

	//Only check for events when the object is both enabled and visible.
	if(enabled&&visible){
	//Check if there's a key press and the event hasn't been already processed.
	if(state==2 && event.type==SDL_KEYDOWN && !b){
	//Get the keycode.
	int key=(int)event.key.keysym.unicode;

	//Check if the key is supported.
	if(key>=32&&key<=126){
	//Add the key to the text after the carrot.
	caption.insert((size_t)value,1,char(key));
	value=clamp(value+1,0,caption.length());

	//If there is an event callback then call it.
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventChange};
	GUIEventQueue.push_back(e);
	}
	}else if(event.key.keysym.sym==SDLK_BACKSPACE){
	//We need to remove a character so first make sure that there is text.
	if(caption.length()>0&&value>0){
	//Remove the character before the carrot.
	value=clamp(value-1,0,caption.length());
	caption.erase((size_t)value,1);

	//If there is an event callback then call it.
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventChange};
	GUIEventQueue.push_back(e);
	}
	}
	}else if(event.key.keysym.sym==SDLK_DELETE){
	//We need to remove a character so first make sure that there is text.
	if(caption.length()>0){
	//Remove the character after the carrot.
	value=clamp(value,0,caption.length());
	caption.erase((size_t)value,1);

	//If there is an event callback then call it.
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventChange};
	GUIEventQueue.push_back(e);
	}
	}
	}else if(event.key.keysym.sym==SDLK_RIGHT){
	value=clamp(value+1,0,caption.length());
	}else if(event.key.keysym.sym==SDLK_LEFT){
	value=clamp(value-1,0,caption.length());
	}

	//The event has been processed.
	b=true;
	}

	//The mouse location (x=i, y=j) and the mouse button (k).
	int i,j,k;
	k=SDL_GetMouseState(&i,&j);

	//Check if the mouse is inside the GUIObject.
	if(i>=x&&i<x+width&&j>=y&&j<y+height){
	//We can only increase our state. (nothing->hover->focus).
	if(state!=2){
	state=1;
	}
	+ currentCursor=CURSOR_TEXT;

	//Check for a mouse button press.
	if(k&SDL_BUTTON(1)){
	//We have focus.
	state=2;
	//TODO Move carrot to place clicked
	value=caption.length();
	}
	}else{
	//The mouse is outside the TextBox.
	//If we don't have focus but only hover we lose it.
	if(state==1){
	state=0;
	}

	//If it's a click event outside the textbox then we blur.
	if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT){
	//Set state to 0.
	state=0;
	}
	}
	}
	break;
	}

	//Also let the children handle their events.
	for(unsigned int i=0;i<childControls.size();i++){
	bool b1=childControls[i]->handleEvents(x,y,enabled,visible,b);

	//The event is processed when either our or the childs is true (or both).
	b=b\|\|b1;
	}
	return b;
	}

	//Found on gmane.comp.lib.sdl mailing list, see: http://comments.gmane.org/gmane.comp.lib.sdl/33664
	//Original code by "Patricia Curtis" and later modified by "Jason"
	static void SetSurfaceTrans(SDL_Surface* Src,double PercentTrans){
	Uint8 Sbpp = Src->format->BytesPerPixel;
	Uint8 *Sbits;

	#if SDL_BYTEORDER == SDL_BIG_ENDIAN
	int amask = 0x000000ff;
	int cmask = 0xffffff00;
	#else
	int amask = 0xff000000;
	int cmask = 0x00ffffff;
	int Shift = 24;
	#endif

	int x,y;
	Uint32 Pixels;
	Uint32 Alpha;

	for(y=0;y<Src->h;y++)
	{
	for(x=0;x<Src->w;x++)
	{
	Sbits = ((Uint8 )Src->pixels+(ySrc->pitch)+(x*Sbpp));
	Pixels = ((Uint32 )(Sbits));
	#if SDL_BYTEORDER == SDL_BIG_ENDIAN
	Alpha = Pixels & mask;
	#else
	Alpha = (Pixels&amask)>>Shift;
	#endif
	Alpha*=PercentTrans;

	#if SDL_BYTEORDER == SDL_BIG_ENDIAN
	((Uint32 )(Sbits)) = (Pixels & cmask)\|Alpha;
	#else
	((Uint32 )(Sbits)) = (Pixels & cmask)\|(Alpha<<Shift);
	#endif
	}
	}
	}

	void GUIObject::render(int x,int y,bool draw){
	//Rectangle the size of the GUIObject, used to draw borders.
	SDL_Rect r;

	//There's no need drawing the GUIObject when it's invisible.
	if(!visible)
	return;

	//Get the absolute x and y location.
	x+=left;
	y+=top;

	//Check if the enabled state changed or the caption, if so we need to clear the (old) cache.
	if(enabled!=cachedEnabled \|\| caption.compare(cachedCaption)!=0 \|\| width<=0){
	//Free the cache.
	SDL_FreeSurface(cache);
	cache=NULL;

	//And cache the new values.
	cachedEnabled=enabled;
	cachedCaption=caption;

	//Finally resize the widget
	if(autoWidth)
	width=-1;
	}


	//Now do the type specific rendering.
	switch(type){
	case GUIObjectLabel:
	{
	//The rectangle is simple.
	r.x=x;
	r.y=y;
	r.w=width;
	r.h=height;

	//We don't draw a background and/or border since that label is transparent.
	//Get the caption and make sure it isn't empty.
	const char* lp=caption.c_str();
	if(lp!=NULL && lp[0]){
	//Render the text using the small font.
	if(cache==NULL){
	SDL_Color color;
	if(inDialog)
	color=themeTextColorDialog;
	else
	color=themeTextColor;

	cache=TTF_RenderUTF8_Blended(fontText,lp,color);

	if(width<=0)
	width=cache->w;
	}

	if(draw){
	if(gravity==GUIGravityCenter)
	gravityX=(width-cache->w)/2;
	else if(gravity==GUIGravityRight)
	gravityX=width+cache->w;
	else
	gravityX=0;

	//Center the text vertically and draw it to the screen.
	r.y=y+(height - cache->h)/2;
	r.x+=gravityX;
	SDL_BlitSurface(cache,NULL,screen,&r);
	}
	}
	}
	break;
	case GUIObjectCheckBox:
	{
	//The rectangle is simple.
	r.x=x;
	r.y=y;
	r.w=width;
	r.h=height;

	//Get the text.
	const char* lp=caption.c_str();
	//Make sure it isn't empty.
	if(lp!=NULL && lp[0]){
	//We render black text.
	if(!cache){
	SDL_Color color;
	if(inDialog)
	color=themeTextColorDialog;
	else
	color=themeTextColor;

	cache=TTF_RenderUTF8_Blended(fontText,lp,color);
	}

	if(draw){
	//Calculate the location, center it vertically.
	r.x=x;
	r.y=y+(height - cache->h)/2;

	//Draw the text and free the surface.
	SDL_BlitSurface(cache,NULL,screen,&r);
	}
	}

	if(draw){
	//Draw the check (or not).
	SDL_Rect r1={0,0,16,16};
	if(value==1\|\|value==2)
	r1.x=value*16;
	r.x=x+width-20;
	r.y=y+(height-16)/2;
	SDL_BlitSurface(bmGUI,&r1,screen,&r);
	}
	}
	break;
	case GUIObjectButton:
	{
	//Get the text.
	const char* lp=caption.c_str();
	//Make sure the text isn't empty.
	if(lp!=NULL && lp[0]){
	if(!cache){
	SDL_Color color;
	if(inDialog)
	color=themeTextColorDialog;
	else
	color=themeTextColor;

	if(!smallFont)
	cache=TTF_RenderUTF8_Blended(fontGUI,lp,color);
	else
	cache=TTF_RenderUTF8_Blended(fontGUISmall,lp,color);

	if(!enabled)
	SetSurfaceTrans(cache,0.5);

	if(width<=0){
	width=cache->w+50;
	if(gravity==GUIGravityCenter){
	gravityX=int(width/2);
	}else if(gravity==GUIGravityRight){
	gravityX=width;
	}else{
	gravityX=0;
	}
	}
	}

	if(draw){
	//Center the text both vertically as horizontally.
	r.x=x-gravityX+(width-cache->w)/2;
	r.y=y+(height-cache->h)/2-GUI_FONT_RAISE;

	//Check if the arrows don't fall of.
	if(cache->w+32<=width){
	//Create a rectangle that selects the right image from bmGUI,
	SDL_Rect r2={64,0,16,16};
	if(state==1){
	if(inDialog){
	applySurface(x-gravityX+(width-cache->w)/2+4+cache->w+5,y+2,arrowLeft2,screen,NULL);
	applySurface(x-gravityX+(width-cache->w)/2-25,y+2,arrowRight2,screen,NULL);
	}else{
	applySurface(x-gravityX+(width-cache->w)/2+4+cache->w+5,y+2,arrowLeft1,screen,NULL);
	applySurface(x-gravityX+(width-cache->w)/2-25,y+2,arrowRight1,screen,NULL);
	}
	}else if(state==2){
	if(inDialog){
	applySurface(x-gravityX+(width-cache->w)/2+4+cache->w,y+2,arrowLeft2,screen,NULL);
	applySurface(x-gravityX+(width-cache->w)/2-20,y+2,arrowRight2,screen,NULL);
	}else{
	applySurface(x-gravityX+(width-cache->w)/2+4+cache->w,y+2,arrowLeft1,screen,NULL);
	applySurface(x-gravityX+(width-cache->w)/2-20,y+2,arrowRight1,screen,NULL);
	}
	}
	}

	//Draw the text and free the surface.
	SDL_BlitSurface(cache,NULL,screen,&r);
	}
	}
	}
	break;
	case GUIObjectTextBox:
	{
	if(draw){
	//Default background opacity
	int clr=50;
	//If hovering or focused make background more visible.
	if(state==1)
	clr=128;
	else if (state==2)
	clr=100;

	//Draw the box.
	Uint32 color=0xFFFFFF00\|clr;
	drawGUIBox(x,y,width,height,screen,color);
	}

	//Get the text.
	const char* lp=caption.c_str();
	//Make sure it isn't empty.
	if(lp!=NULL && lp[0]){
	if(!cache){
	//Draw the black text.
	SDL_Color black={0,0,0,0};
	cache=TTF_RenderUTF8_Blended(fontText,lp,black);
	}

	if(draw){
	//Calculate the location, center it vertically.
	r.x=x+2;
	r.y=y+(height - cache->h)/2;

	//Draw the text.
	SDL_Rect tmp={0,0,width-2,25};
	SDL_BlitSurface(cache,&tmp,screen,&r);
	//Only draw the carrot when focus.
	if(state==2){
	r.x=x;
	r.y=y+4;
	r.w=2;
	r.h=height-8;

	int advance;
	for(int n=0;n<value;n++){
	TTF_GlyphMetrics(fontText,caption[n],NULL,NULL,NULL,NULL,&advance);
	r.x+=advance;
	}

	//Make sure that the carrot is inside the textbox.
	if(r.x<x+width)
	SDL_FillRect(screen,&r,0);
	}
	}
	}else{
	//Only draw the carrot when focus.
	if(state==2&&draw){
	r.x=x+4;
	r.y=y+4;
	r.w=2;
	r.h=height-8;
	SDL_FillRect(screen,&r,0);
	}
	}
	}
	break;
	case GUIObjectFrame:
	{
	if(draw){
	//Create a rectangle the size of the button and fill it.
	Uint32 color=0xDDDDDDFF;
	drawGUIBox(x,y,width,height,screen,color);
	}

	//Get the title text.
	const char* lp=caption.c_str();
	//Make sure it isn't empty.
	if(lp!=NULL && lp[0]){
	if(!cache){
	cache=TTF_RenderUTF8_Blended(fontGUI,lp,themeTextColorDialog);
	}

	if(draw){
	//Calculate the location, center horizontally and vertically relative to the top.
	r.x=x+(width-cache->w)/2;
	r.y=y+6-GUI_FONT_RAISE;

	//Draw the text and free the surface.
	SDL_BlitSurface(cache,NULL,screen,&r);
	}
	}
	}
	break;
	}

	//We now need to draw all the children of the GUIObject.
	for(unsigned int i=0;i<childControls.size();i++){
	childControls[i]->render(x,y,draw);
	}
	}
	diff --git a/src/GUIScrollBar.cpp b/src/GUIScrollBar.cpp
	index 0b1f144..e073c1e 100644
	--- a/src/GUIScrollBar.cpp
	+++ b/src/GUIScrollBar.cpp
	@@ -1,390 +1,395 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "GUIScrollBar.h"
	using namespace std;

	void GUIScrollBar::calcPos(){
	//Floats ...
	float f,f2;

	//The value can't be below the minimum value or above the maximum.
	if(value<minValue)
	value=minValue;
	else if(value>maxValue)
	value=maxValue;

	//
	if(orientation){
	f=(float)(top+16);
	f2=(float)(height-32);
	}else{
	f=(float)(left+16);
	f2=(float)(width-32);
	}
	if(largeChange<=0) f2=-1;
	if(f2>0){
	float f1=0.0f;
	valuePerPixel = (maxValue - minValue + largeChange) / f2;
	if(valuePerPixel > 0.0001f) f1 = largeChange / valuePerPixel;
	if(f1 < 4 && f2 > 4){
	valuePerPixel = (maxValue - minValue) / (f2 - 4);
	f1 = 4;
	}
	thumbStart = f + (value - minValue) / valuePerPixel;
	thumbEnd = thumbStart + f1;
	}else{
	valuePerPixel = -1;
	thumbStart = f;
	thumbEnd = f - 1;
	}
	}

	bool GUIScrollBar::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	//Boolean if the event is processed.
	bool b=processed;

	//The GUIObject is only enabled when he and his parent are enabled.
	enabled=enabled && this->enabled;
	//The GUIObject is only enabled when he and his parent are enabled.
	visible=visible && this->visible;

	//Check if the mouse button is released.
	if(event.type==SDL_MOUSEBUTTONUP \|\| !(enabled&&visible)){
	//It so we have lost any focus at all.
	state=0;
	}else if(event.type==SDL_MOUSEMOTION \|\| event.type==SDL_MOUSEBUTTONDOWN){
	//The mouse button is down and it's moving
	int i,j,k,f,f1;
	state&=~0xFF;
	k=SDL_GetMouseState(&i,&j);
	i-=x;
	j-=y;
	bool bInControl_0;
	if(orientation){
	f=top;
	f1=f+height;
	bInControl_0=(i>=left&&i<left+width);
	i=j;
	}else{
	f=left;
	f1=f+width;
	bInControl_0=(j>=top&&j<top+height);
	}
	//===
	if((state&0x0000FF00)==0x300&&(k&SDL_BUTTON(1))&&event.type==SDL_MOUSEMOTION&&valuePerPixel>0){
	+ currentCursor=CURSOR_DRAG2;
	//drag thumb
	state\|=3;
	int val = criticalValue + (int)(((float)i - startDragPos) * valuePerPixel + 0.5f);
	if(val<minValue) val=minValue;
	else if(val>maxValue) val=maxValue;
	if(value!=val){
	value=val;
	changed=true;
	}
	b=true;
	}else if(bInControl_0){
	int f2,f3;
	if(valuePerPixel > 0){
	f2=f+16;
	f3=f1-16;
	}else{
	f2=f3=(f+f1)/2;
	}
	if(i<f){ //do nothing
	}else if(i<f2){ //-smallchange
	state=(state&~0xFF)\|1;
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) state=(state&~0x0000FF00)\|((state&0xFF)<<8);
	else if((state&0x0000FF00)&&((state&0xFF)!=((state>>8)&0xFF))) state&=~0xFF;
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT){
	int val=value-smallChange;
	if(val<minValue) val=minValue;
	if(value!=val){
	value=val;
	changed=true;
	}
	timer=8;
	}
	b=true;
	}else if(i>=f3 && i<f1){ //+smallchange
	state=(state&~0xFF)\|5;
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) state=(state&~0x0000FF00)\|((state&0xFF)<<8);
	else if((state&0x0000FF00)&&((state&0xFF)!=((state>>8)&0xFF))) state&=~0xFF;
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT){
	int val=value+smallChange;
	if(val>maxValue) val=maxValue;
	if(value!=val){
	value=val;
	changed=true;
	}
	timer=8;
	}
	b=true;
	}else if(valuePerPixel<=0){ //do nothing
	}else if(i<(int)thumbStart){ //-largechange
	state=(state&~0xFF)\|2;
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) state=(state&~0x0000FF00)\|((state&0xFF)<<8);
	else if((state&0x0000FF00)&&((state&0xFF)!=((state>>8)&0xFF))) state&=~0xFF;
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT){
	int val=value-largeChange;
	if(val<minValue) val=minValue;
	if(value!=val){
	value=val;
	changed=true;
	}
	timer=8;
	}
	if(state&0xFF) criticalValue = minValue + (int)(float(i - f2) * valuePerPixel + 0.5f);
	b=true;
	}else if(i<(int)thumbEnd){ //start drag
	+ currentCursor=CURSOR_DRAG1;
	state=(state&~0xFF)\|3;
	- if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) state=(state&~0x0000FF00)\|((state&0xFF)<<8);
	- else if((state&0x0000FF00)&&((state&0xFF)!=((state>>8)&0xFF))) state&=~0xFF;
	+ if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT){
	+ state=(state&~0x0000FF00)\|((state&0xFF)<<8);
	+ currentCursor=CURSOR_DRAG2;
	+ }else if((state&0x0000FF00)&&((state&0xFF)!=((state>>8)&0xFF))) state&=~0xFF;
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT){
	criticalValue=value;
	startDragPos = (float)i;
	+ currentCursor=CURSOR_DRAG2;
	}
	b=true;
	}else if(i<f3){ //+largechange
	state=(state&~0xFF)\|4;
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) state=(state&~0x0000FF00)\|((state&0xFF)<<8);
	else if((state&0x0000FF00)&&((state&0xFF)!=((state>>8)&0xFF))) state&=~0xFF;
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT){
	int val=value+largeChange;
	if(val>maxValue) val=maxValue;
	if(value!=val){
	value=val;
	changed=true;
	}
	timer=8;
	}
	if(state&0xFF) criticalValue = minValue - largeChange + (int)(float(i - f2) * valuePerPixel + 0.5f);
	b=true;
	}
	}
	}

	//Get the absolute position.
	x+=left;
	y+=top;

	//Also let the children handle their events.
	for(unsigned int i=0;i<childControls.size();i++){
	bool b1=childControls[i]->handleEvents(x,y,enabled,visible,b);

	//The event is processed when either our or the childs is true (or both).
	b=b\|\|b1;
	}
	return b;
	}

	void GUIScrollBar::renderScrollBarButton(int index,int x1,int y1,int x2,int y2,int srcleft,int srctop){
	//Make sure the button isn't inverted.
	if(x2<=x1\|\|y2<=y1)
	return;

	//The color.
	int clr=-1;
	//Rectangle the size of the button.
	SDL_Rect r={x1,y1,x2-x1,y2-y1};

	//Check
	if((state&0xFF)==index){
	if(((state>>8)&0xFF)==index){
	//Set the color gray.
	clr=0xDDDDDDFF;
	}else{
	//Set the color to lightgray.
	clr=0xFFFFFFFF;
	}
	}

	//Draw a box.
	drawGUIBox(r.x,r.y,r.w,r.h,screen,clr);

	//Boolean if there should be an image on the button.
	bool b;
	//The check depends on the orientation.
	if(orientation)
	b=(y2-y1>=14);
	else
	b=(x2-x1>=14);

	//Check if the image can be drawn.
	if(b&&srcleft>=0&&srctop>=0){
	//It can thus draw it.
	SDL_Rect r1={srcleft,srctop,16,16};
	r.x=(x1+x2)/2-8;
	r.y=(y1+y2)/2-8;
	SDL_BlitSurface(bmGUI,&r1,screen,&r);
	}
	}

	void GUIScrollBar::render(int x,int y,bool draw){
	//There's no use in rendering the scrollbar when invisible.
	if(!visible)
	return;

	//Check if the scrollbar is enabled.
	if(enabled){
	//Check if the state is right.
	if((state&0xFF)==((state>>8)&0xFF)){
	//Switch the state (change)/
	switch(state&0xFF){
	case 1:
	//It's a small negative change.
	//Check if it's time.
	if((--timer)<=0){
	//Reduce the value.
	int val=value-smallChange;

	//Make sure it doesn't go too low.
	if(val<minValue)
	val=minValue;
	if(value!=val){
	value=val;
	changed=true;
	}

	//Set the time to two.
	timer=2;
	}
	break;
	case 2:
	//It's a lager negative change.
	//Check if it's time.
	if((--timer)<=0){
	if(value<criticalValue)
	state&=~0xFF;
	else{
	//Reduce the value.
	int val=value-largeChange;

	//Make sure it doesn't go too low.
	if(val<minValue)
	val=minValue;
	if(value!=val){
	value=val;
	changed=true;
	}

	//Set the time to two.
	timer=2;
	}
	}
	break;
	case 4:
	//It's a lager positive change.
	//Check if it's time.
	if((--timer)<=0){
	if(value>criticalValue)
	state&=~0xFF;
	else{
	//Increase the value.
	int val=value+largeChange;

	//Make sure it doesn't go too high.
	if(val>maxValue)
	val=maxValue;
	if(value!=val){
	value=val;
	changed=true;
	}

	//Set the time to two.
	timer=2;
	}
	}
	break;
	case 5:
	//It's a small positive change.
	//Check if it's time.
	if((--timer)<=0){
	//Increase the value.
	int val=value+smallChange;

	//Make sure ti doesn't go too high.
	if(val>maxValue)
	val=maxValue;
	if(value!=val){
	value=val;
	changed=true;
	}

	//Set the time to two.
	timer=2;
	}
	break;
	}
	}
	}

	//If the scrollbar changed then invoke a GUIEvent.
	if(changed){
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventChange};
	GUIEventQueue.push_back(e);
	}
	changed=false;
	}

	//We calculate the position since it could have changed.
	calcPos();

	//Now the actual drawing begins.
	if(orientation&&draw){
	//The scrollbar is vertically orientated.
	if(valuePerPixel>0){
	//There are four buttons so draw them.
	renderScrollBarButton(2,x+left,y+top,x+left+width,y+top+height,-1,-1);
	renderScrollBarButton(1,x+left,y+top,x+left+width,y+top+16,80,0);
	renderScrollBarButton(3,x+left,y-1+(int)thumbStart,x+left+width,y+1+(int)thumbEnd,0,16);
	renderScrollBarButton(5,x+left,y+top+height-16,x+left+width,y+top+height,96,0);
	}else{
	//There are two buttons so draw them.
	int f=top+height/2;
	renderScrollBarButton(1,x+left,y+top,x+left+width,y+1+f,80,0);
	renderScrollBarButton(5,x+left,y+f,x+left+width,y+top+height,96,0);
	}
	}else{
	//The scrollbar is horizontally orientated.
	if(valuePerPixel>0){
	//There are five buttons so draw them.
	renderScrollBarButton(1,x+left,y+top,x+left+16,y+top+height,80,16);
	renderScrollBarButton(2,x+left+15,y+top,x+(int)thumbStart,y+top+height,-1,-1);
	renderScrollBarButton(3,x-1+(int)thumbStart,y+top,x+1+(int)thumbEnd,y+top+height,16,16);
	renderScrollBarButton(4,x+(int)thumbEnd,y+top,x+left+width-15,y+top+height,-1,-1);
	renderScrollBarButton(5,x+left+width-16,y+top,x+left+width,y+top+height,96,16);
	}else{
	//There are two buttons so draw them.
	int f=left+width/2;
	renderScrollBarButton(1,x+left,y+top,x+1+f,y+top+height,80,16);
	renderScrollBarButton(5,x+f,y+top,x+left+width,y+top+height,96,16);
	}
	}

	//Get the absolute position.
	x+=left;
	y+=top;

	//We now need to draw all the children of the GUIObject.
	for(unsigned int i=0;i<childControls.size();i++){
	childControls[i]->render(x,y,draw);
	}
	}
	diff --git a/src/GUISlider.cpp b/src/GUISlider.cpp
	index 7d54bc9..80eeefd 100644
	--- a/src/GUISlider.cpp
	+++ b/src/GUISlider.cpp
	@@ -1,291 +1,297 @@
	/*
	* Copyright (C) 2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "GUISlider.h"
	using namespace std;

	void GUISlider::calcPos(){
	//Floats ...
	float f,f2;

	//The value can't be below the minimum value or above the maximum.
	if(value<minValue)
	value=minValue;
	else if(value>maxValue)
	value=maxValue;

	//
	f=(float)(left+1);
	f2=(float)(width-2);

	if(largeChange<=0) f2=-1;
	if(f2>0){
	float f1=0.0f;
	valuePerPixel = (maxValue - minValue + largeChange) / f2;
	if(valuePerPixel > 0.0001f) f1 = largeChange / valuePerPixel;
	if(f1 < 4 && f2 > 4){
	valuePerPixel = (maxValue - minValue) / (f2 - 4);
	f1 = 4;
	}
	thumbStart = f + (value - minValue) / valuePerPixel;
	thumbEnd = thumbStart + f1;
	}else{
	valuePerPixel = -1;
	thumbStart = f;
	thumbEnd = f - 1;
	}
	}

	bool GUISlider::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	//Boolean if the event is processed.
	bool b=processed;

	//The GUIObject is only enabled when he and his parent are enabled.
	enabled=enabled && this->enabled;
	//The GUIObject is only enabled when he and his parent are enabled.
	visible=visible && this->visible;

	//Check if the mouse button is released.
	if(event.type==SDL_MOUSEBUTTONUP \|\| !(enabled&&visible)){
	//It so we have lost any focus at all.
	state=0;
	+ currentCursor=CURSOR_DRAG1;
	}else if(event.type==SDL_MOUSEMOTION \|\| event.type==SDL_MOUSEBUTTONDOWN){
	//The mouse button is down and it's moving
	int i,j,k,f,f1;
	state&=~0xFF;
	k=SDL_GetMouseState(&i,&j);
	i-=x;
	j-=y;
	bool bInControl_0;

	f=left;
	f1=f+width;
	bInControl_0=(j>=top&&j<top+height);

	//===
	if((state&0x0000FF00)==0x300&&(k&SDL_BUTTON(1))&&event.type==SDL_MOUSEMOTION&&valuePerPixel>0){
	//drag thumb
	+ currentCursor=CURSOR_DRAG2;
	state\|=3;
	int val = criticalValue + (int)(((float)i - startDragPos) * valuePerPixel + 0.5f);
	if(val<minValue) val=minValue;
	else if(val>maxValue) val=maxValue;
	if(value!=val){
	value=val;
	changed=true;
	}
	b=true;
	}else if(bInControl_0){
	int f2,f3;
	if(valuePerPixel > 0){
	f2=f+16;
	f3=f1-16;
	}else{
	f2=f3=(f+f1)/2;
	}
	if(i<f){ //do nothing
	}else if(valuePerPixel<=0){ //do nothing
	}else if(i<(int)thumbStart){ //-largechange
	state=(state&~0xFF)\|2;
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) state=(state&~0x0000FF00)\|((state&0xFF)<<8);
	else if((state&0x0000FF00)&&((state&0xFF)!=((state>>8)&0xFF))) state&=~0xFF;
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT){
	int val=value-largeChange;
	if(val<minValue) val=minValue;
	if(value!=val){
	value=val;
	changed=true;
	}
	timer=8;
	}
	if(state&0xFF) criticalValue = minValue + (int)(float(i - f2) * valuePerPixel + 0.5f);
	b=true;
	}else if(i<(int)thumbEnd){ //start drag
	state=(state&~0xFF)\|3;
	- if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) state=(state&~0x0000FF00)\|((state&0xFF)<<8);
	- else if((state&0x0000FF00)&&((state&0xFF)!=((state>>8)&0xFF))) state&=~0xFF;
	+ currentCursor=CURSOR_DRAG1;
	+ if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT){
	+ state=(state&~0x0000FF00)\|((state&0xFF)<<8);
	+ currentCursor=CURSOR_DRAG2;
	+ }else if((state&0x0000FF00)&&((state&0xFF)!=((state>>8)&0xFF))) state&=~0xFF;
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT){
	criticalValue=value;
	startDragPos = (float)i;
	+ currentCursor=CURSOR_DRAG2;
	}
	b=true;
	}else if(i<f3){ //+largechange
	state=(state&~0xFF)\|4;
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) state=(state&~0x0000FF00)\|((state&0xFF)<<8);
	else if((state&0x0000FF00)&&((state&0xFF)!=((state>>8)&0xFF))) state&=~0xFF;
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT){
	int val=value+largeChange;
	if(val>maxValue) val=maxValue;
	if(value!=val){
	value=val;
	changed=true;
	}
	timer=8;
	}
	if(state&0xFF) criticalValue = minValue - largeChange + (int)(float(i - f2) * valuePerPixel + 0.5f);
	b=true;
	}
	}
	}

	//Get the absolute position.
	x+=left;
	y+=top;

	//Also let the children handle their events.
	for(unsigned int i=0;i<childControls.size();i++){
	bool b1=childControls[i]->handleEvents(x,y,enabled,visible,b);

	//The event is processed when either our or the childs is true (or both).
	b=b\|\|b1;
	}
	return b;
	}

	void GUISlider::renderScrollBarButton(int index,int x1,int y1,int x2,int y2,int srcleft,int srctop){
	//Make sure the button isn't inverted.
	if(x2<=x1\|\|y2<=y1)
	return;

	//The color.
	int clr=-1;
	//Rectangle the size of the button.
	SDL_Rect r={x1,y1,x2-x1,y2-y1};

	//Check
	if((state&0xFF)==index){
	if(((state>>8)&0xFF)==index){
	//Set the color gray.
	clr=0xDDDDDDFF;
	}else{
	//Set the color to lightgray.
	clr=0xFFFFFFFF;
	}
	}

	//Draw a box.
	drawGUIBox(r.x,r.y,r.w,r.h,screen,clr);

	//Boolean if there should be an image on the button.
	bool b;
	b=(x2-x1>=14);

	//Check if the image can be drawn.
	if(b&&srcleft>=0&&srctop>=0){
	//It can thus draw it.
	SDL_Rect r1={srcleft,srctop,16,16};
	r.x=(x1+x2)/2-8;
	r.y=(y1+y2)/2-8;
	SDL_BlitSurface(bmGUI,&r1,screen,&r);
	}
	}

	void GUISlider::render(int x,int y,bool draw){
	//There's no use in rendering the scrollbar when invisible.
	if(!visible\|\|!draw)
	return;

	//Check if the scrollbar is enabled.
	if(enabled){
	//Check if the state is right.
	if((state&0xFF)==((state>>8)&0xFF)){
	//Switch the state (change)/
	switch(state&0xFF){
	case 2:
	//It's a lager negative change.
	//Check if it's time.
	if((--timer)<=0){
	if(value<criticalValue)
	state&=~0xFF;
	else{
	//Reduce the value.
	int val=value-largeChange;

	//Make sure it doesn't go too low.
	if(val<minValue)
	val=minValue;
	if(value!=val){
	value=val;
	changed=true;
	}

	//Set the time to two.
	timer=2;
	}
	}
	break;
	case 4:
	//It's a lager positive change.
	//Check if it's time.
	if((--timer)<=0){
	if(value>criticalValue)
	state&=~0xFF;
	else{
	//Increase the value.
	int val=value+largeChange;

	//Make sure it doesn't go too high.
	if(val>maxValue)
	val=maxValue;
	if(value!=val){
	value=val;
	changed=true;
	}

	//Set the time to two.
	timer=2;
	}
	}
	break;
	}
	}
	}

	//If the scrollbar changed then invoke a GUIEvent.
	if(changed){
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventChange};
	GUIEventQueue.push_back(e);
	}
	changed=false;
	}

	//We calculate the position since it could have changed.
	calcPos();

	//Now the actual drawing begins.
	if(valuePerPixel>0){
	//Draw the line the slider moves along.
	drawGUIBox(x+left,y+top+(height-4)/2,width,4,screen,0);
	renderScrollBarButton(2,x-1+(int)thumbStart,y+top+(height/4),x+1+(int)thumbEnd,y+top+(height/4)*3,16,16);
	}else{
	//There are two buttons so draw them.
	int f=left+width/2;
	renderScrollBarButton(1,x+left,y+top,x+1+f,y+top+height,48,0);
	renderScrollBarButton(5,x+f,y+top,x+left+width,y+top+height,64,0);
	}

	//Get the absolute position.
	x+=left;
	y+=top;

	//We now need to draw all the children of the GUIObject.
	for(unsigned int i=0;i<childControls.size();i++){
	childControls[i]->render(x,y,draw);
	}
	}
	diff --git a/src/GUIWindow.cpp b/src/GUIWindow.cpp
	index c2362db..bb6a5d1 100644
	--- a/src/GUIWindow.cpp
	+++ b/src/GUIWindow.cpp
	@@ -1,204 +1,158 @@
	/*
	* Copyright (C) 2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "GUIWindow.h"
	using namespace std;

	GUIWindow::GUIWindow(int left,int top,int width,int height,bool enabled,bool visible,const char* caption):
	GUIObject(left,top,width,height,0,caption,-1,enabled,visible){
	-
	- //Set some default values.
	- dragging=false;
	- resizing=false;
	- minWidth=minHeight=0;
	- maxWidth=maxHeight=0;
	}

	bool GUIWindow::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	//Boolean if the event is processed.
	bool b=processed;

	//The GUIObject is only enabled when he and his parent are enabled.
	enabled=enabled && this->enabled;
	//The GUIObject is only enabled when he and his parent are enabled.
	visible=visible && this->visible;

	//Get the absolute position.
	x+=left;
	y+=top;

	//NOTE: We don't reset the state to have a "focus" effect.
	//Only check for events when the object is both enabled and visible.
	if(enabled&&visible){
	//Check if the titlebar is hit.
	- bool clicked=(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_LEFT);
	-
	- //Check if the mouse is inside the window.
	- SDL_Rect mouse={event.button.x,event.button.y,0,0};
	- SDL_Rect titlebar={x,y,width,48};
	-
	- //FIXME: Only set the cursor to POINTER when moving away from the GUIWindow?
	- if(clicked && checkCollision(mouse,titlebar)){
	- //Mouse pressed inside the window,so assume dragging
	- setCursor(cursors[DRAG]);
	- dragging=true;
	- }
	-
	- if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT){
	+ if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_LEFT){
	+ //Check if the mouse is inside the window.
	+ //NOTE: Perhaps only allow dragging when clicking on the 'titlebar'?
	+ SDL_Rect mouse={event.button.x,event.button.y,0,0};
	+ SDL_Rect r={x,y,width,height};
	+
	+ if(checkCollision(mouse,r)){
	+ //Now begin dragging the toolbox
	+ dragging=true;
	+ currentCursor=CURSOR_DRAG2;
	+ }
	+ }else if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT){
	//Stop dragging
	dragging=false;
	- //And set the cursor to the default pointer.
	- setCursor(cursors[POINTER]);
	+ currentCursor=CURSOR_DRAG1;

	SDL_Rect mouse={event.button.x,event.button.y,0,0};

	//Check if close button clicked
	{
	SDL_Rect r={left+width-36,top+12,24,24};
	if(checkCollision(mouse,r)){
	this->visible=false;
	return true;
	}
	}
	}else if(event.type==SDL_MOUSEMOTION){
	if((event.motion.state & SDL_BUTTON_LMASK)==0){
	- //Stop dragging or resizing.
	dragging=false;
	- resizing=false;
	-
	- //And set the cursor to the default pointer.
	- setCursor(cursors[POINTER]);
	+ currentCursor=CURSOR_DRAG1;
	}else if(dragging){
	move(left+event.motion.xrel,top+event.motion.yrel);
	- }else if(resizing){
	- //TODO: Take the resize direction into account.
	- resize(left,top,width+event.motion.xrel,height+event.motion.yrel);
	+ currentCursor=CURSOR_DRAG2;
	}
	}
	}

	//Process child controls event.
	for(unsigned int i=0;i<childControls.size();i++){
	bool b1=childControls[i]->handleEvents(x,y,enabled,visible,b);

	//The event is processed when either our or the childs is true (or both).
	b=b\|\|b1;
	}
	return b;
	}

	void GUIWindow::move(int x,int y){
	//Check the horizontal bounds.
	if(x>SCREEN_WIDTH-width)
	x=SCREEN_WIDTH-width;
	else if(x<0)
	x=0;
	//Check the vertical bounds.
	if(y>SCREEN_HEIGHT-height)
	y=SCREEN_HEIGHT-height;
	else if(y<0)
	y=0;

	//And set the new position.
	left=x;
	top=y;
	}

	-void GUIWindow::resize(int x,int y,int width,int height){
	- //Check for the minimum width.
	- if(minWidth){
	- if(width<minWidth)
	- width=minWidth;
	- }
	- //Check for the minimum height.
	- if(minHeight){
	- if(height<minHeight)
	- height=minHeight;
	- }
	- //Check for maximum width.
	- if(maxWidth){
	- if(width>maxWidth)
	- width=maxWidth;
	- }
	- //Check for maximum height.
	- if(maxHeight){
	- if(height>maxHeight)
	- height=maxHeight;
	- }
	-
	- //Now set the values.
	- this->left=x;
	- this->top=y;
	- this->width=width;
	- this->height=height;
	-}
	-
	void GUIWindow::render(int x,int y,bool draw){
	//Rectangle the size of the GUIObject, used to draw borders.
	SDL_Rect r;
	//There's no need drawing the GUIObject when it's invisible.
	if(!visible\|\|!draw)
	return;

	//Get the absolute x and y location.
	x+=left;
	y+=top;

	//Draw the frame.
	Uint32 color=0xFFFFFFFF;
	drawGUIBox(x,y,width,height,screen,color);
	- //Draw the titlebar.
	- color=0x00000088;
	- drawGUIBox(x,y,width,48,screen,color);

	//Get the mouse position.
	int mouseX,mouseY;
	SDL_GetMouseState(&mouseX,&mouseY);
	SDL_Rect mouse={mouseX,mouseY,0,0};

	//Draw the close button.
	{
	//check highlight
	SDL_Rect r={left+width-36,top+12,24,24};

	if(checkCollision(mouse,r)){
	drawGUIBox(r.x,r.y,r.w,r.h,screen,0x999999FFU);
	+ currentCursor=CURSOR_POINT;
	}

	SDL_Rect r1={112,0,16,16};
	applySurface(left+width-32,top+16,bmGUI,screen,&r1);
	}

	//Draw the caption.
	{
	SDL_Rect captionRect={6,8,width-16,32};
	//The color black.
	SDL_Color black={0,0,0,0};
	SDL_Surface* bm=TTF_RenderUTF8_Blended(fontGUI,caption.c_str(),black);
	applySurface(x+captionRect.x+(captionRect.w-bm->w)/2,
	y+captionRect.y+(captionRect.h-bm->h)/2,bm,screen,NULL);

	SDL_FreeSurface(bm);
	}

	//We now need to draw all the children of the GUIObject.
	for(unsigned int i=0;i<childControls.size();i++){
	childControls[i]->render(x,y,draw);
	}
	}
	diff --git a/src/GUIWindow.h b/src/GUIWindow.h
	index 77e4714..f936d3d 100644
	--- a/src/GUIWindow.h
	+++ b/src/GUIWindow.h
	@@ -1,74 +1,60 @@
	/*
	* Copyright (C) 2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef GUIWINDOW_H
	#define GUIWINDOW_H

	#include "GUIObject.h"

	//It extends GUIObject because it's a special GUIObject.
	class GUIWindow:public GUIObject{
	private:
	//Boolean if the window is being dragged.
	bool dragging;
	-
	- //Boolean if the window is being resized.
	- bool resizing;
	public:
	- //The minimum and maximum size of the window.
	- int minWidth,minHeight;
	- int maxWidth,maxHeight;
	-
	//Constructor.
	//left: The relative x location of the GUIWindow.
	//top: The relative y location of the GUIWindow.
	//witdh: The width of the GUIWindow.
	//height: The height of the GUIWindow.
	//enabled: Boolean if the GUIWindow is enabled or not.
	//visible: Boolean if the GUIWindow is visisble or not.
	//caption: The title of the Window.
	GUIWindow(int left=0,int top=0,int width=0,int height=0,bool enabled=true,bool visible=true,const char* caption=NULL);

	//Method used for moving the window around, also used internally by handleEvents.
	//x: The desired x location to move the window to.
	//y: The desired y location to move the window to.
	void move(int x,int y);
	-
	- //Method that will resize the window.
	- //x: The new x location of the window.
	- //y: The new y location of the window.
	- //width: The new width of the resized window.
	- //height: The new height of the resized window.
	- void resize(int x,int y,int width,int height);

	//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 GUITextArea.
	//x: The x location to draw the GUITextArea. (x+left)
	//y: The y location to draw the GUITextArea. (y+top)
	virtual void render(int x=0,int y=0,bool draw=true);
	};

	#endif
	diff --git a/src/Globals.cpp b/src/Globals.cpp
	index ba6f342..758e08d 100644
	--- a/src/Globals.cpp
	+++ b/src/Globals.cpp
	@@ -1,104 +1,106 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "Globals.h"
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	#include <SDL/SDL_mixer.h>
	#include <SDL/SDL_ttf.h>
	#endif
	#include "libs/tinygettext/tinygettext.hpp"

	//Set the defautl value for the screen width and height.
	int SCREEN_WIDTH=800;
	int SCREEN_HEIGHT=600;

	//Set the default value for the level width and height.
	int LEVEL_HEIGHT=0;
	int LEVEL_WIDTH=0;

	//The language that in which the game should be translated.
	std::string language;
	//The DictionaryManager that is used to translate the game itself.
	tinygettext::DictionaryManager* dictionaryManager=NULL;

	//Set both the screen and the tempSurface to NULL.
	SDL_Surface* screen=NULL;
	SDL_Surface* tempSurface=NULL;

	//Font that is used for titles.
	//Knewave large.
	TTF_Font* fontTitle=NULL;
	//Font that is used for captions of buttons and other GUI elements.
	//Knewave small.
	TTF_Font* fontGUI=NULL;
	//Font that is used for long captions of buttons and other GUI elements.
	//Knewave small.
	TTF_Font* fontGUISmall=NULL;
	//Font that is used for (long) text.
	//Blokletter-Viltstift small.
	TTF_Font* fontText=NULL;

	+//Currently used cursor type.
	+CursorType currentCursor=CURSOR_NORMAL;
	+//Array of actual data for cursors.
	+SDL_Cursor* cursors[CURSOR_MAX]={NULL};
	+
	//Small arrows used for GUI widgets.
	//2 directions and 2 different/same colors depending on theme.
	SDL_Surface* arrowLeft1=NULL;
	SDL_Surface* arrowRight1=NULL;
	SDL_Surface* arrowLeft2=NULL;
	SDL_Surface* arrowRight2=NULL;

	//Sound played when the player jumps.
	Mix_Chunk* jumpSound=NULL;
	//Sound played when the player dies.
	Mix_Chunk* hitSound=NULL;
	//Sound played when the saves a state.
	Mix_Chunk* saveSound=NULL;
	//Sound played when the player swaps.
	Mix_Chunk* swapSound=NULL;
	//Sound played when the player toggles a switch.
	Mix_Chunk* toggleSound=NULL;
	//The sound played when the player tries something that doesn't work.
	//For example a broken portal or swapping the shadow into a shadow block.
	Mix_Chunk* errorSound=NULL;
	//Sound played when the player picks up a collectable.
	Mix_Chunk* collectSound=NULL;
	//Sound played when an achievement is achieved..
	Mix_Chunk* achievementSound=NULL;

	//Set the current stateID and the nextState.
	int stateID=STATE_NULL;
	int nextState=STATE_NULL;

	//The name of the current level.
	std::string levelName;

	//Initialise the camera.
	//Start location is 0, size is the same as the screen size.
	SDL_Rect camera={0,0,SCREEN_WIDTH,SCREEN_HEIGHT};

	//The SDL_Event object.
	SDL_Event event;

	//Themable colors
	SDL_Color themeTextColor={0,0,0};
	SDL_Color themeTextColorDialog={0,0,0};
	-
	-//Array containing the SDL_Cursors.
	-SDL_Cursor* cursors[CURSOR_TYPES];
	diff --git a/src/Globals.h b/src/Globals.h
	index 86a8f91..531160d 100644
	--- a/src/Globals.h
	+++ b/src/Globals.h
	@@ -1,259 +1,250 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef GLOBALS_H
	#define GLOBALS_H

	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	#include <SDL/SDL_mixer.h>
	#include <SDL/SDL_ttf.h>
	#endif
	#include <string>
	#include "libs/tinygettext/tinygettext.hpp"

	#if defined (WIN32) \|\| defined (__APPLE__)
	//#define DATA_PATH
	#else
	#include "config.h"
	#endif

	#define TITLE_FONT_RAISE 19
	#define GUI_FONT_RAISE 5

	//Global constants
	//The width of the screen.
	extern int SCREEN_WIDTH;
	//The height of the screen.
	extern int SCREEN_HEIGHT;
	//The depth of the screen.
	const int SCREEN_BPP=32;

	//SDL interprets each pixel as a 32-bit number,
	// so our masks must depend on the endianness (byte order) of the machine.
	//NOTE: We define them here so we only have to do it once.
	#if SDL_BYTEORDER == SDL_BIG_ENDIAN
	const Uint32 RMASK=0xFF000000;
	const Uint32 GMASK=0x00FF0000;
	const Uint32 BMASK=0x0000FF00;
	const Uint32 AMASK=0x000000FF;
	#else
	const Uint32 RMASK=0x000000FF;
	const Uint32 GMASK=0x0000FF00;
	const Uint32 BMASK=0x00FF0000;
	const Uint32 AMASK=0xFF000000;
	#endif

	//String containing the version, used in the titelbar.
	const std::string version="V0.5 Development version";

	//The height of the current level.
	extern int LEVEL_HEIGHT;
	//The width of the current level.
	extern int LEVEL_WIDTH;

	//The target frames per seconds.
	const int FPS=40;

	//The language that in which the game should be translated.
	extern std::string language;
	//The DictionaryManager that is used to translate the game itself.
	extern tinygettext::DictionaryManager* dictionaryManager;

	//The screen surface, it's used to draw on before it's drawn to the real screen.
	extern SDL_Surface* screen;
	//SDL_Surface with the same dimensions as screen which can be used for all kinds of (temp) drawing.
	extern SDL_Surface* tempSurface;

	//Font that is used for titles.
	//Knewave large.
	extern TTF_Font* fontTitle;
	//Font that is used for captions of buttons and other GUI elements.
	//Knewave small.
	extern TTF_Font* fontGUI;
	//Font that is used for long captions of buttons and other GUI elements.
	//Knewave smaller.
	extern TTF_Font* fontGUISmall;
	//Font that is used for (long) text.
	//Blokletter-Viltstift small.
	extern TTF_Font* fontText;

	+//Different cursor types.
	+enum CursorType{
	+ CURSOR_NORMAL,
	+ CURSOR_POINT,
	+ CURSOR_REMOVE,
	+ CURSOR_TEXT,
	+ CURSOR_DRAG1,
	+ CURSOR_DRAG2,
	+ CURSOR_MAX
	+};
	+//Currently used cursor type.
	+extern CursorType currentCursor;
	+//Array of actual data for cursors.
	+extern SDL_Cursor* cursors[CURSOR_MAX];
	+
	//Small arrows used for GUI widgets.
	//2 directions and 2 different/same colors depending on theme.
	extern SDL_Surface* arrowLeft1;
	extern SDL_Surface* arrowRight1;
	extern SDL_Surface* arrowLeft2;
	extern SDL_Surface* arrowRight2;

	//Sound played when the player jumps.
	extern Mix_Chunk* jumpSound;
	//Sound played when the player dies.
	extern Mix_Chunk* hitSound;
	//Sound played when the saves a state.
	extern Mix_Chunk* saveSound;
	//Sound played when the player swaps.
	extern Mix_Chunk* swapSound;
	//Sound played when the player toggles a switch.
	extern Mix_Chunk* toggleSound;
	//The sound played when the player tries something that doesn't work.
	//For example a broken portal or swapping the shadow into a shadow block.
	extern Mix_Chunk* errorSound;
	//Sound played when the player picks up a collectable.
	extern Mix_Chunk* collectSound;
	//Sound played when an achievement is achieved..
	extern Mix_Chunk* achievementSound;

	//Event, used for event handling.
	extern SDL_Event event;

	//GUI
	class GUIObject;
	extern GUIObject *GUIObjectRoot;

	//The state id of the current state.
	extern int stateID;
	//Integer containing what the next state will be.
	extern int nextState;

	//String containing the name of the current level.
	extern std::string levelName;

	//SDL rectangle used to store the camera.
	//x is the x location of the camera.
	//y is the y location of the camera.
	//w is the width of the camera. (equal to SCREEN_WIDTH)
	//h is the height of the camera. (equal to SCREEN_HEIGHT)
	extern SDL_Rect camera;

	//Themable colors
	extern SDL_Color themeTextColor;
	extern SDL_Color themeTextColorDialog;

	-//Enumeration containing the different cursor types there are.
	-enum CursorState
	-{
	- //The default pointer.
	- POINTER,
	-
	- //The vertical ibeam, used to indicate text input.
	- CARROT,
	-
	- //A closed hand, used for indicating a drag action.
	- DRAG,
	-
	- //The different (window) size cursor icons.
	- SIZE_HOR,
	- SIZE_VER,
	- SIZE_FDIAG,
	- SIZE_BDIAG,
	-
	- //The number of cursor types there are.
	- CURSOR_TYPES
	-};
	-//Array containing the SDL_Cursors.
	-extern SDL_Cursor* cursors[CURSOR_TYPES];
	-
	//Enumeration containing the ids of the game states.
	enum GameStates
	{
	//State null is a special state used to indicate no state.
	//This is used when no next state is defined.
	STATE_NULL,

	//This state is before the actual leveleditor used to make levelpacks.
	STATE_LEVEL_EDIT_SELECT,
	//This state is for the level editor.
	STATE_LEVEL_EDITOR,
	//This state is for the main menu.
	STATE_MENU,
	//This state is for the actual game.
	STATE_GAME,
	//Special state used when exiting meandmyshadow.

	STATE_EXIT,
	//This state is for the help screen.

	STATE_LEVEL_SELECT,
	//This state is for the options screen.
	STATE_OPTIONS,
	//This state is for the addon screen.
	STATE_ADDONS,
	//This state is for credits screen
	STATE_CREDITS,
	//This state is for statistics screen
	STATE_STATISTICS,
	};

	//Enumeration containing the ids of the different block types.
	enum GameTileType{
	//The normal solid block.
	TYPE_BLOCK=0,
	//Block representing the start location of the player.
	TYPE_START_PLAYER,
	//Block representing the start location of the shadow.
	TYPE_START_SHADOW,
	//The exit of the level.
	TYPE_EXIT,
	//The shadow block which is only solid for the shadow.
	TYPE_SHADOW_BLOCK,
	//Block that can kill both the player and the shadow.
	TYPE_SPIKES,

	//Special point where the player can save.
	TYPE_CHECKPOINT,
	//Block that will switch the location of the player and the shadow when invoked.
	TYPE_SWAP,
	//Block that will crumble to dust when stepped on it for the third time.
	TYPE_FRAGILE,

	//Normal block that moves along a path.
	TYPE_MOVING_BLOCK,
	//Shadow block that moves along a path.
	TYPE_MOVING_SHADOW_BLOCK,
	//A spike block that moves along a path.
	TYPE_MOVING_SPIKES,

	//Special block which, once entered, moves the player/shadow to a different portal.
	TYPE_PORTAL,
	//A block with a button which can activate or stop moving blocks, converyor belts
	TYPE_BUTTON,
	//A switch which can activate or stop moving blocks, converyor belts
	TYPE_SWITCH,

	//Solid block which works like
	TYPE_CONVEYOR_BELT,
	TYPE_SHADOW_CONVEYOR_BELT,

	//Block that contains a message that can be read.
	TYPE_NOTIFICATION_BLOCK,

	//A collectable that is able to open locked doors
	TYPE_COLLECTABLE,

	//Block that can be pushed by the player and the shadow.
	//Pushable blocks can push other pushable blocks.
	TYPE_PUSHABLE,

	//The (max) number of tiles.
	TYPE_MAX
	};

	#endif
	diff --git a/src/LevelEditor.cpp b/src/LevelEditor.cpp
	index c81ba53..2b8fc28 100644
	--- a/src/LevelEditor.cpp
	+++ b/src/LevelEditor.cpp
	@@ -1,3342 +1,3338 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. 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 "LevelPack.h"
	#include "LevelEditor.h"
	#include "TreeStorageNode.h"
	#include "POASerializer.h"
	#include "GUIListBox.h"
	#include "GUITextArea.h"
	#include "GUIOverlay.h"
	#include "GUIWindow.h"
	#include "InputManager.h"
	#include "StatisticsManager.h"
	#include <fstream>
	#include <iostream>
	#include <vector>
	#include <algorithm>
	#include <string.h>
	#include <stdlib.h>
	#include <stdio.h>
	#ifdef WIN32
	#include <windows.h>
	#include <shlobj.h>
	#else
	#include <strings.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include <dirent.h>
	#endif

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

	static int levelTime,levelRecordings;
	static GUIObject levelTimeProperty,levelRecordingsProperty;

	//Array containing translateble block names
	static const char* blockNames[TYPE_MAX]={
	__("Block"),__("Player Start"),__("Shadow Start"),
	__("Exit"),__("Shadow Block"),__("Spikes"),
	__("Checkpoint"),__("Swap"),__("Fragile"),
	__("Moving Block"),__("Moving Shadow Block"),__("Moving Spikes"),
	__("Teleporter"),__("Button"),__("Switch"),
	__("Conveyor Belt"),__("Shadow Conveyor Belt"),__("Notification Block"),__("Collectable"),__("Puhsable")
	};

	//Array indicates if block is configurable
	static const bool isConfigurable[TYPE_MAX]={
	false,false,false,
	false,false,false,
	false,false,true,
	true,true,true,
	true,true,true,
	true,true,true,false
	};

	//Array indicates if block is linkable
	static const bool isLinkable[TYPE_MAX]={
	false,false,false,
	false,false,false,
	false,false,false,
	true,true,true,
	true,true,true,
	false,false,false,false
	};

	/////////////////LevelEditorToolbox////////////////////////

	class LevelEditorToolbox:public GUIWindow{
	private:
	//The parent object
	LevelEditor* parent;

	public:
	int startRow,maxRow;

	public:
	LevelEditorToolbox(LevelEditor* parent):GUIWindow(0,0,320,180,true,false,_("Toolbox")){
	this->parent=parent;

	//calc row count
	startRow=0;
	maxRow=(LevelEditor::EDITOR_ORDER_MAX+4)/5;
	-
	- this->minWidth=320;
	- this->minHeight=180;
	- this->maxWidth=640;
	- this->maxHeight=520;
	-
	}
	void render(int x=0,int y=0,bool draw=true){
	GUIWindow::render(x,y,draw);
	if(visible){
	//get mouse position
	int x,y;
	SDL_GetMouseState(&x,&y);
	SDL_Rect mouse={x,y,0,0};

	//the tool tip of item
	SDL_Rect tooltipRect;
	string tooltip;

	//draw avaliable item
	for(int i=0;i<2;i++){
	int j=startRow+i;
	if(j>=maxRow) j-=maxRow;

	for(int k=0;k<5;k++){
	int idx=j*5+k;
	if(idx<0 \|\| idx>=LevelEditor::EDITOR_ORDER_MAX) break;

	SDL_Rect r={left+k60+10,top+i60+50,60,60};

	//check highlight
	if(checkCollision(mouse,r)){
	+ currentCursor=CURSOR_POINT;
	tooltipRect=r;
	tooltip=_(blockNames[LevelEditor::editorTileOrder[idx]]);

	if(parent->currentType==idx){
	drawGUIBox(r.x,r.y,r.w,r.h,screen,0x999999FFU);
	}else{
	SDL_FillRect(screen,&r,0xCCCCCC);
	}
	}else if(parent->currentType==idx){
	drawGUIBox(r.x,r.y,r.w,r.h,screen,0xCCCCCCFFU);
	}

	ThemeBlock* obj=objThemes.getBlock(LevelEditor::editorTileOrder[idx]);
	if(obj){
	obj->editorPicture.draw(screen,r.x+5,r.y+5);
	}
	}
	}

	//draw tooltip
	if(!tooltip.empty()){
	//The back and foreground colors.
	SDL_Color fg={0,0,0};

	//Tool specific text.
	SDL_Surface* tip=TTF_RenderUTF8_Blended(fontText,tooltip.c_str(),fg);

	//Draw only if there's a tooltip available
	if(tip!=NULL){
	if(tooltipRect.y+tooltipRect.h+tip->h>SCREEN_HEIGHT-20)
	tooltipRect.y-=tip->h;
	else
	tooltipRect.y+=tooltipRect.h;

	if(tooltipRect.x+tip->w>SCREEN_WIDTH-20)
	tooltipRect.x=SCREEN_WIDTH-20-tip->w;

	//Draw borders around text
	Uint32 color=0xFFFFFF00\|230;
	drawGUIBox(tooltipRect.x-2,tooltipRect.y-2,tip->w+4,tip->h+4,screen,color);

	//Draw tooltip's text
	SDL_BlitSurface(tip,NULL,screen,&tooltipRect);
	SDL_FreeSurface(tip);
	}
	}
	}
	}
	bool handleEvents(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false){
	//Let the GUIWindow handle its events.
	if(GUIWindow::handleEvents(x,y,enabled,visible,processed))
	return true;

	//The event hasn't been handled by the GUIWindow.
	//Only check for events when the object is both enabled and visible.
	if(enabled&&visible){
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_LEFT){
	SDL_Rect mouse={event.button.x,event.button.y,0,0};

	//Check if item is clicked
	for(int i=0;i<2;i++){
	int j=startRow+i;
	if(j>=maxRow) j-=maxRow;

	for(int k=0;k<5;k++){
	int idx=j*5+k;
	if(idx<0 \|\| idx>=LevelEditor::EDITOR_ORDER_MAX) break;

	SDL_Rect r={left+k60+10,top+i60+50,60,60};

	//check highlight
	if(checkCollision(mouse,r)){
	parent->currentType=idx;
	return true;
	}
	}
	}
	}
	}

	//No event handled so return false.
	return false;
	}
	};

	/////////////////LevelEditorSelectionPopup/////////////////

	class LevelEditorSelectionPopup{
	private:
	//The parent object
	LevelEditor* parent;

	//The position of window
	SDL_Rect rect;

	//GUI image
	SDL_Surface *bmGUI;

	//The selection
	std::vector<GameObject*> selection;

	//The scrollbar
	GUIScrollBar *scrollBar;

	//Highlighted object
	GameObject* highlightedObj;

	//Highlighted button index. 0=none 1=select/deselect 2=configure 3=link 4=delete
	int highlightedBtn;
	public:
	int startRow,showedRow;
	bool dragging;

	//If selection is dirty
	bool dirty;

	public:
	SDL_Rect getRect(){
	return rect;
	}
	int width(){
	return rect.w;
	}
	int height(){
	return rect.h;
	}
	void updateScrollBar(){
	int m=selection.size()-showedRow;
	if(m>0){
	if(startRow<0) startRow=0;
	else if(startRow>m) startRow=m;

	if(scrollBar==NULL){
	scrollBar=new GUIScrollBar(0,0,16,rect.h-16,ScrollBarVertical,startRow,0,m,1,showedRow);
	}

	scrollBar->visible=true;
	scrollBar->maxValue=m;
	scrollBar->value=startRow;
	}else{
	startRow=0;
	if(scrollBar){
	scrollBar->visible=false;
	scrollBar->value=0;
	}
	}
	}
	void updateSelection(){
	if(parent!=NULL){
	std::vector<GameObject*>& v=parent->levelObjects;

	for(int i=selection.size()-1;i>=0;i--){
	if(find(v.begin(),v.end(),selection[i])==v.end()){
	selection.erase(selection.begin()+i);
	}
	}

	updateScrollBar();
	}
	}
	void dismiss(){
	if(parent!=NULL && parent->selectionPopup==this){
	parent->selectionPopup=NULL;
	}
	delete this;
	}
	LevelEditorSelectionPopup(LevelEditor* parent, std::vector<GameObject*>& selection, int x=0, int y=0){
	this->parent=parent;
	this->selection=selection;

	dirty=false;
	dragging=false;
	scrollBar=NULL;
	highlightedObj=NULL;
	highlightedBtn=0;

	//calc window size
	startRow=0;
	showedRow=selection.size();
	int m=SCREEN_HEIGHT/64-1;
	if(showedRow>m) showedRow=m;

	rect.w=320;
	rect.h=showedRow*64+16;

	if(x>SCREEN_WIDTH-rect.w) x=SCREEN_WIDTH-rect.w;
	else if(x<0) x=0;
	if(y>SCREEN_HEIGHT-rect.h) y=SCREEN_HEIGHT-rect.h;
	else if(y<0) y=0;
	rect.x=x;
	rect.y=y;

	updateScrollBar();

	//Load the gui images.
	bmGUI=loadImage(getDataPath()+"gfx/gui.png");
	}
	~LevelEditorSelectionPopup(){
	if(scrollBar) delete scrollBar;
	}
	void move(int x,int y){
	if(x>SCREEN_WIDTH-rect.w) x=SCREEN_WIDTH-rect.w;
	else if(x<0) x=0;
	if(y>SCREEN_HEIGHT-rect.h) y=SCREEN_HEIGHT-rect.h;
	else if(y<0) y=0;
	rect.x=x;
	rect.y=y;
	}
	void render(){
	//Check dirty
	if(dirty){
	updateSelection();
	if(selection.empty()){
	dismiss();
	return;
	}
	dirty=false;
	}

	//background
	drawGUIBox(rect.x,rect.y,rect.w,rect.h,screen,0xFFFFFFFFU);

	//get mouse position
	int x,y;
	SDL_GetMouseState(&x,&y);
	SDL_Rect mouse={x,y,0,0};

	//the tool tip of item
	SDL_Rect tooltipRect;
	string tooltip;

	if(scrollBar && scrollBar->visible){
	startRow=scrollBar->value;
	}

	highlightedObj=NULL;
	highlightedBtn=0;

	//draw avaliable item
	for(int i=0;i<showedRow;i++){
	int j=startRow+i;
	if(j>=(int)selection.size()) break;

	SDL_Rect r={rect.x+8,rect.y+i*64+8,rect.w-16,64};
	if(scrollBar && scrollBar->visible) r.w-=24;

	//check highlight
	if(checkCollision(mouse,r)){
	highlightedObj=selection[j];
	SDL_FillRect(screen,&r,0xCCCCCC);
	}

	int type=selection[j]->type;

	//draw tile picture
	ThemeBlock* obj=objThemes.getBlock(type);
	if(obj){
	obj->editorPicture.draw(screen,r.x+7,r.y+7);
	}

	//draw name
	SDL_Color fg={0,0,0};
	SDL_Surface* txt=TTF_RenderUTF8_Blended(fontText,_(blockNames[type]),fg);
	if(txt!=NULL){
	SDL_Rect r2={r.x+64,r.y+(64-txt->h)/2,0,0};
	SDL_BlitSurface(txt,NULL,screen,&r2);
	SDL_FreeSurface(txt);
	}

	if(parent!=NULL){
	//draw selected
	{
	std::vector<GameObject*> &v=parent->selection;
	bool isSelected=find(v.begin(),v.end(),selection[j])!=v.end();

	SDL_Rect r1={isSelected?16:0,0,16,16};
	SDL_Rect r2={r.x+r.w-96,r.y+20,24,24};
	if(checkCollision(mouse,r2)){
	drawGUIBox(r2.x,r2.y,r2.w,r2.h,screen,0x999999FFU);
	tooltipRect=r2;
	tooltip=_("Select");
	highlightedBtn=1;
	}
	r2.x+=4;
	r2.y+=4;
	SDL_BlitSurface(bmGUI,&r1,screen,&r2);
	}

	//draw configure
	if(isConfigurable[type]){
	SDL_Rect r1={112,16,16,16};
	SDL_Rect r2={r.x+r.w-72,r.y+20,24,24};
	if(checkCollision(mouse,r2)){
	drawGUIBox(r2.x,r2.y,r2.w,r2.h,screen,0x999999FFU);
	tooltipRect=r2;
	tooltip=_("Configure");
	highlightedBtn=2;
	}
	r2.x+=4;
	r2.y+=4;
	SDL_BlitSurface(bmGUI,&r1,screen,&r2);
	}

	//draw link
	if(isLinkable[type]){
	SDL_Rect r1={112,32,16,16};
	SDL_Rect r2={r.x+r.w-48,r.y+20,24,24};
	if(checkCollision(mouse,r2)){
	drawGUIBox(r2.x,r2.y,r2.w,r2.h,screen,0x999999FFU);
	tooltipRect=r2;
	tooltip=_("Link");
	highlightedBtn=3;
	}
	r2.x+=4;
	r2.y+=4;
	SDL_BlitSurface(bmGUI,&r1,screen,&r2);
	}

	//draw delete
	{
	SDL_Rect r1={112,0,16,16};
	SDL_Rect r2={r.x+r.w-24,r.y+20,24,24};
	if(checkCollision(mouse,r2)){
	drawGUIBox(r2.x,r2.y,r2.w,r2.h,screen,0x999999FFU);
	tooltipRect=r2;
	tooltip=_("Delete");
	highlightedBtn=4;
	}
	r2.x+=4;
	r2.y+=4;
	SDL_BlitSurface(bmGUI,&r1,screen,&r2);
	}
	}
	}

	//draw scrollbar
	if(scrollBar && scrollBar->visible){
	scrollBar->render(rect.x+rect.w-24,rect.y+8);
	}

	//draw tooltip
	if(!tooltip.empty()){
	//The back and foreground colors.
	SDL_Color fg={0,0,0};

	//Tool specific text.
	SDL_Surface* tip=TTF_RenderUTF8_Blended(fontText,tooltip.c_str(),fg);

	//Draw only if there's a tooltip available
	if(tip!=NULL){
	tooltipRect.y-=4;
	tooltipRect.h+=8;
	if(tooltipRect.y+tooltipRect.h+tip->h>SCREEN_HEIGHT-20)
	tooltipRect.y-=tip->h;
	else
	tooltipRect.y+=tooltipRect.h;

	if(tooltipRect.x+tip->w>SCREEN_WIDTH-20)
	tooltipRect.x=SCREEN_WIDTH-20-tip->w;

	//Draw borders around text
	Uint32 color=0xFFFFFF00\|230;
	drawGUIBox(tooltipRect.x-2,tooltipRect.y-2,tip->w+4,tip->h+4,screen,color);

	//Draw tooltip's text
	SDL_BlitSurface(tip,NULL,screen,&tooltipRect);
	SDL_FreeSurface(tip);
	}
	}
	}
	void handleEvents(){
	//Check dirty
	if(dirty){
	updateSelection();
	if(selection.empty()){
	dismiss();
	return;
	}
	dirty=false;
	}

	//Check scrollbar event
	if(scrollBar && scrollBar->visible){
	if(scrollBar->handleEvents(rect.x+rect.w-24,rect.y+8)) return;
	}

	if(event.type==SDL_MOUSEBUTTONDOWN){
	//check mousewheel
	if(event.button.button==SDL_BUTTON_WHEELUP){
	startRow-=2;
	updateScrollBar();
	return;
	}else if(event.button.button==SDL_BUTTON_WHEELDOWN){
	startRow+=2;
	updateScrollBar();
	return;
	}

	//begin drag
	if(event.button.button==SDL_BUTTON_LEFT) dragging=true;
	}
	else if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT){
	//end drag
	dragging=false;

	SDL_Rect mouse={event.button.x,event.button.y,0,0};

	//Check if close it
	if(!checkCollision(mouse,rect)){
	dismiss();
	return;
	}

	//Check if item is clicked
	if(highlightedObj!=NULL && highlightedBtn>0 && parent!=NULL){
	std::vector<GameObject*>& v=parent->levelObjects;

	if(find(v.begin(),v.end(),highlightedObj)!=v.end()){
	switch(highlightedBtn){
	case 1:
	{
	std::vector<GameObject*>& v2=parent->selection;
	std::vector<GameObject*>::iterator it=find(v2.begin(),v2.end(),highlightedObj);

	if(it==v2.end()){
	v2.push_back(highlightedObj);
	}else{
	v2.erase(it);
	}
	}
	break;
	case 2:
	parent->tool=LevelEditor::CONFIGURE;
	parent->onEnterObject(highlightedObj);
	break;
	case 3:
	{
	std::vector<GameObject*>& v2=parent->selection;

	parent->tool=LevelEditor::CONFIGURE;
	parent->onRightClickObject(highlightedObj,find(v2.begin(),v2.end(),highlightedObj)!=v2.end());

	dismiss();
	}
	break;
	case 4:
	parent->removeObject(highlightedObj);
	break;
	}
	}
	}
	}
	else if(event.type==SDL_MOUSEMOTION){
	if((event.motion.state & SDL_BUTTON_LMASK)==0){
	dragging=false;
	}else if(dragging){
	move(rect.x+event.motion.xrel,rect.y+event.motion.yrel);
	}
	}
	}
	};

	/////////////////MovingPosition////////////////////////////
	MovingPosition::MovingPosition(int x,int y,int time){
	this->x=x;
	this->y=y;
	this->time=time;
	}

	MovingPosition::~MovingPosition(){}

	void MovingPosition::updatePosition(int x,int y){
	this->x=x;
	this->y=y;
	}


	/////////////////LEVEL EDITOR//////////////////////////////
	LevelEditor::LevelEditor():Game(true){
	//Get the target time and recordings.
	levelTime=levels->getLevel()->targetTime;
	levelRecordings=levels->getLevel()->targetRecordings;

	//This will set some default settings.
	reset();

	//The level is loaded by the game, so do postLoad.
	postLoad();

	//Create the GUI root.
	GUIObjectRoot=new GUIObject(0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

	//Load the toolbar.
	toolbar=loadImage(getDataPath()+"gfx/menu/toolbar.png");
	SDL_Rect tmp={(SCREEN_WIDTH-460)/2,SCREEN_HEIGHT-50,460,50};
	toolbarRect=tmp;

	toolbox=NULL;
	selectionPopup=NULL;

	movingSpeedWidth=-1;

	//Load the selectionMark.
	selectionMark=loadImage(getDataPath()+"gfx/menu/selection.png");

	//Load the movingMark.
	movingMark=loadImage(getDataPath()+"gfx/menu/moving.png");

	//Create the semi transparent surface.
	placement=SDL_CreateRGBSurface(SDL_SWSURFACE\|SDL_SRCALPHA,SCREEN_WIDTH,SCREEN_HEIGHT,32,RMASK,GMASK,BMASK,0);
	SDL_SetColorKey(placement,SDL_SRCCOLORKEY\|SDL_RLEACCEL,SDL_MapRGB(placement->format,255,0,255));
	SDL_SetAlpha(placement,SDL_SRCALPHA,125);

	//Count the level editing time.
	statsMgr.startLevelEdit();
	}

	LevelEditor::~LevelEditor(){
	//Loop through the levelObjects and delete them.
	for(unsigned int i=0;i<levelObjects.size();i++)
	delete levelObjects[i];
	levelObjects.clear();
	selection.clear();

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

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

	//Delete the popup
	if(selectionPopup){
	delete selectionPopup;
	selectionPopup=NULL;
	}

	//Reset the camera.
	camera.x=0;
	camera.y=0;

	//Count the level editing time.
	statsMgr.endLevelEdit();
	}

	void LevelEditor::reset(){
	//Set some default values.
	playMode=false;
	tool=ADD;
	currentType=0;
	pressedShift=false;
	pressedLeftMouse=false;
	dragging=false;
	selectionDrag=false;
	dragCenter=NULL;
	if(LEVEL_WIDTH<SCREEN_WIDTH)
	camera.x=-(SCREEN_WIDTH-LEVEL_WIDTH)/2;
	else
	camera.x=0;
	if(LEVEL_HEIGHT<SCREEN_HEIGHT)
	camera.y=-(SCREEN_HEIGHT-LEVEL_HEIGHT)/2;
	else
	camera.y=0;
	cameraXvel=0;
	cameraYvel=0;
	objectProperty=NULL;
	secondObjectProperty=NULL;
	configuredObject=NULL;
	linking=false;
	linkingTrigger=NULL;
	currentId=0;
	movingBlock=NULL;
	moving=false;
	movingSpeed=10;
	tooltip=-1;

	//Set the player and shadow to their starting position.
	player.setPosition(player.fx,player.fy);
	shadow.setPosition(shadow.fx,shadow.fy);

	selection.clear();
	clipboard.clear();
	triggers.clear();
	movingBlocks.clear();
	}

	void LevelEditor::loadLevelFromNode(TreeStorageNode* obj, const std::string& fileName){
	//call the method of base class.
	Game::loadLevelFromNode(obj,fileName);

	//now do our own stuff.
	string s=editorData["time"];
	if(s.empty() \|\| !(s[0]>='0' && s[0]<='9')){
	levelTime=-1;
	}else{
	levelTime=atoi(s.c_str());
	}

	s=editorData["recordings"];
	if(s.empty() \|\| !(s[0]>='0' && s[0]<='9')){
	levelRecordings=-1;
	}else{
	levelRecordings=atoi(s.c_str());
	}
	}

	void LevelEditor::saveLevel(string fileName){
	//Create the output stream and check if it starts.
	std::ofstream save(fileName.c_str());
	if(!save) return;

	//The dimensions of the level.
	int maxX=0;
	int maxY=0;

	//The storageNode to put the level data in before writing it away.
	TreeStorageNode node;
	char s[64];

	//The name of the level.
	if(!levelName.empty()){
	node.attributes["name"].push_back(levelName);

	//Update the level name in the levelpack.
	levels->getLevel()->name=levelName;
	}

	//The leveltheme.
	if(!levelTheme.empty())
	node.attributes["theme"].push_back(levelTheme);

	//target time and recordings.
	{
	char c[32];
	if(levelTime>=0){
	sprintf(c,"%d",levelTime);
	node.attributes["time"].push_back(c);
	}
	if(levelRecordings>=0){
	sprintf(c,"%d",levelRecordings);
	node.attributes["recordings"].push_back(c);
	}
	}

	//The width of the level.
	maxX=LEVEL_WIDTH;
	sprintf(s,"%d",maxX);
	node.attributes["size"].push_back(s);

	//The height of the level.
	maxY=LEVEL_HEIGHT;
	sprintf(s,"%d",maxY);
	node.attributes["size"].push_back(s);

	//Loop through the gameObjects and save them.
	for(int o=0;o<(signed)levelObjects.size();o++){
	int objectType=levelObjects[o]->type;

	//Check if it's a legal gameObject type.
	if(objectType>=0 && objectType<TYPE_MAX){
	TreeStorageNode* obj1=new TreeStorageNode;
	node.subNodes.push_back(obj1);

	//It's a tile so name the node tile.
	obj1->name="tile";

	//Write away the type of the gameObject.
	sprintf(s,"%d",objectType);
	obj1->value.push_back(blockName[objectType]);

	//Get the box for the location of the gameObject.
	SDL_Rect box=levelObjects[o]->getBox(BoxType_Base);
	//Put the location in the storageNode.
	sprintf(s,"%d",box.x);
	obj1->value.push_back(s);
	sprintf(s,"%d",box.y);
	obj1->value.push_back(s);

	//Loop through the editor data and save it also.
	vector<pair<string,string> > obj;
	levelObjects[o]->getEditorData(obj);
	for(unsigned int i=0;i<obj.size();i++){
	if((!obj[i].first.empty()) && (!obj[i].second.empty())){
	obj1->attributes[obj[i].first].push_back(obj[i].second);
	}
	}
	}
	}

	//Create a POASerializer and write away the level node.
	POASerializer objSerializer;
	objSerializer.writeNode(&node,save,true,true);
	}


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

	//If playing/testing we should the game handle the events.
	if(playMode){
	Game::handleEvents();

	//Also check if we should exit the playMode.
	if(inputMgr.isKeyDownEvent(INPUTMGR_ESCAPE)){
	//Reset the game and disable playMode.
	Game::reset(true);
	playMode=false;
	camera.x=cameraSave.x;
	camera.y=cameraSave.y;

	//NOTE: To prevent the mouse to still "be pressed" we set it to false.
	pressedLeftMouse=false;
	}
	}else{
	//Also check if we should exit the editor.
	if(inputMgr.isKeyDownEvent(INPUTMGR_ESCAPE)){
	//Before we quit ask a make sure question.
	if(msgBox(_("Are you sure you want to quit?"),MsgBoxYesNo,_("Quit prompt"))==MsgBoxYes){
	//We exit the level editor.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	setNextState(STATE_LEVEL_EDIT_SELECT);

	//Play the menu music again.
	getMusicManager()->playMusic("menu");
	}
	}

	//Check if we should redirect the event to selection popup
	if(selectionPopup!=NULL){
	if(event.type==SDL_MOUSEBUTTONDOWN
	\|\| event.type==SDL_MOUSEBUTTONUP
	\|\| event.type==SDL_MOUSEMOTION)
	{
	selectionPopup->handleEvents();
	return;
	}
	}

	//Check if toolbar is clicked.
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_LEFT && tooltip>=0){
	int t=tooltip;

	if(t<NUMBER_TOOLS){
	tool=(Tools)t;

	//Check if we should show tool box
	if(tool==ADD){
	//show the tool box
	if(toolbox==NULL){
	toolbox=new LevelEditorToolbox(this);
	toolbox->move(event.button.x,event.button.y-toolbox->height-20);
	GUIObjectRoot->addChild(toolbox);
	}
	if(!toolbox->visible){
	toolbox->visible=true;
	}
	}
	}else{
	//The selected button isn't a tool.
	//Now check which button it is.
	if(t==NUMBER_TOOLS){
	playMode=true;
	cameraSave.x=camera.x;
	cameraSave.y=camera.y;

	if(tool==CONFIGURE){
	//Also stop linking or moving.
	if(linking){
	linking=false;
	linkingTrigger=NULL;
	}

	if(moving){
	//Write the path to the moving block.
	std::map<std::string,std::string> editorData;
	char s[64], s0[64];

	sprintf(s,"%d",int(movingBlocks[movingBlock].size()));
	editorData["MovingPosCount"]=s;
	//Loop through the positions.
	for(unsigned int o=0;o<movingBlocks[movingBlock].size();o++){
	sprintf(s0+1,"%d",o);
	sprintf(s,"%d",movingBlocks[movingBlock][o].x);
	s0[0]='x';
	editorData[s0]=s;
	sprintf(s,"%d",movingBlocks[movingBlock][o].y);
	s0[0]='y';
	editorData[s0]=s;
	sprintf(s,"%d",movingBlocks[movingBlock][o].time);
	s0[0]='t';
	editorData[s0]=s;
	}
	movingBlock->setEditorData(editorData);

	moving=false;
	movingBlock=NULL;
	}
	}
	}
	if(t==NUMBER_TOOLS+2){
	//Open up level settings dialog
	levelSettings();
	}
	if(t==NUMBER_TOOLS+4){
	//Go back to the level selection screen of Level Editor
	setNextState(STATE_LEVEL_EDIT_SELECT);
	//Change the music back to menu music.
	getMusicManager()->playMusic("menu");
	}
	if(t==NUMBER_TOOLS+3){
	//Save current level
	saveLevel(levelFile);
	//And give feedback to the user.
	if(levelName.empty())
	msgBox(tfm::format(_("Level \"%s\" saved"),fileNameFromPath(levelFile)),MsgBoxOKOnly,_("Saved"));
	else
	msgBox(tfm::format(_("Level \"%s\" saved"),levelName),MsgBoxOKOnly,_("Saved"));
	}
	}

	return;
	}

	//check if shift is pressed.
	if(inputMgr.isKeyDownEvent(INPUTMGR_SHIFT)){
	pressedShift=true;
	}
	if(inputMgr.isKeyUpEvent(INPUTMGR_SHIFT)){
	pressedShift=false;
	}

	//Check if delete is pressed.
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_DELETE){
	if(!selection.empty()){
	//Loop through the selected game objects.
	while(!selection.empty()){
	//Remove the objects in the selection.
	removeObject(selection[0]);
	}

	//And clear the selection vector.
	selection.clear();
	dragCenter=NULL;
	selectionDrag=false;
	}
	}

	//Check for copy (Ctrl+c) or cut (Ctrl+x).
	if(event.type==SDL_KEYDOWN && (event.key.keysym.sym==SDLK_c \|\| event.key.keysym.sym==SDLK_x) && (event.key.keysym.mod & KMOD_CTRL)){
	//Clear the current clipboard.
	clipboard.clear();

	//Check if the selection isn't empty.
	if(!selection.empty()){
	//Loop through the selection to find the left-top block.
	int x=selection[0]->getBox().x;
	int y=selection[0]->getBox().y;
	for(unsigned int o=1; o<selection.size(); o++){
	if(selection[o]->getBox().x<x \|\| selection[o]->getBox().y<y){
	x=selection[o]->getBox().x;
	y=selection[o]->getBox().y;
	}
	}

	//Loop through the selection for the actual copying.
	for(unsigned int o=0; o<selection.size(); o++){
	//Get the editor data of the object.
	vector<pair<string,string> > obj;
	selection[o]->getEditorData(obj);

	//Loop through the editor data and convert it.
	map<string,string> objMap;
	for(unsigned int i=0;i<obj.size();i++){
	objMap[obj[i].first]=obj[i].second;
	}
	//Add some entries to the map.
	char s[64];
	sprintf(s,"%d",selection[o]->getBox().x-x);
	objMap["x"]=s;
	sprintf(s,"%d",selection[o]->getBox().y-y);
	objMap["y"]=s;
	sprintf(s,"%d",selection[o]->type);
	objMap["type"]=s;

	//Overwrite the id to prevent triggers, portals, buttons, movingblocks, etc. from malfunctioning.
	//We give an empty string as id, which is invalid and thus suitable.
	objMap["id"]="";
	//Do the same for destination if the type is portal.
	if(selection[o]->type==TYPE_PORTAL){
	objMap["destination"]="";
	}

	//And add the map to the clipboard vector.
	clipboard.push_back(objMap);

	if(event.key.keysym.sym==SDLK_x){
	//Cutting means deleting the game object.
	removeObject(selection[o]);
	o--;
	}
	}

	//Only clear the selection when Ctrl+x;
	if(event.key.keysym.sym==SDLK_x){
	selection.clear();
	dragCenter=NULL;
	selectionDrag=false;
	}
	}
	}

	//Check for paste (Ctrl+v).
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_v && (event.key.keysym.mod & KMOD_CTRL)){
	//First make sure that the clipboard isn't empty.
	if(!clipboard.empty()){
	//Clear the current selection.
	selection.clear();

	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	x+=camera.x;
	y+=camera.y;

	//Apply snap to grid.
	if(!pressedShift){
	snapToGrid(&x,&y);
	}else{
	x-=25;
	y-=25;
	}

	//Integers containing the diff of the x that occurs when placing a block outside the level size on the top or left.
	//We use it to compensate the corrupted x and y locations of the other clipboard blocks.
	int diffX=0;
	int diffY=0;


	//Loop through the clipboard.
	for(unsigned int o=0;o<clipboard.size();o++){
	Block* block=new Block(0,0,atoi(clipboard[o]["type"].c_str()),this);
	block->setPosition(atoi(clipboard[o]["x"].c_str())+x+diffX,atoi(clipboard[o]["y"].c_str())+y+diffY);
	block->setEditorData(clipboard[o]);

	if(block->getBox().x<0){
	//A block on the left side of the level, meaning we need to shift everything.
	//First calc the difference.
	diffX+=(0-(block->getBox().x));
	}
	if(block->getBox().y<0){
	//A block on the left side of the level, meaning we need to shift everything.
	//First calc the difference.
	diffY+=(0-(block->getBox().y));
	}

	//And add the object using the addObject method.
	addObject(block);

	//Also add the block to the selection.
	selection.push_back(block);
	}
	}
	}

	//Check if the return button is pressed.
	//If so run the configure tool.
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_RETURN){
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	//Create the rectangle.
	SDL_Rect mouse={x+camera.x,y+camera.y,0,0};

	//Loop through the selected game objects.
	for(unsigned int o=0; o<levelObjects.size(); o++){
	//Check for collision.
	if(checkCollision(mouse,levelObjects[o]->getBox())){
	tool=CONFIGURE;
	//Invoke the onEnterObject.
	onEnterObject(levelObjects[o]);
	//Break out of the for loop.
	break;
	}
	}
	}

	//Check for the arrow keys, used for moving the camera when playMode=false.
	cameraXvel=0;
	cameraYvel=0;
	if(inputMgr.isKeyDown(INPUTMGR_RIGHT)){
	if(pressedShift){
	cameraXvel+=10;
	}else{
	cameraXvel+=5;
	}
	}
	if(inputMgr.isKeyDown(INPUTMGR_LEFT)){
	if(pressedShift){
	cameraXvel-=10;
	}else{
	cameraXvel-=5;
	}
	}
	if(inputMgr.isKeyDown(INPUTMGR_UP)){
	if(pressedShift){
	cameraYvel-=10;
	}else{
	cameraYvel-=5;
	}
	}
	if(inputMgr.isKeyDown(INPUTMGR_DOWN)){
	if(pressedShift){
	cameraYvel+=10;
	}else{
	cameraYvel+=5;
	}
	}

	//Check if the left mouse button is pressed/holded.
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_LEFT){
	pressedLeftMouse=true;
	}
	if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT){
	pressedLeftMouse=false;

	//We also need to check if dragging is true.
	if(dragging){
	//Set dragging false and call the onDrop event.
	dragging=false;
	int x,y;
	SDL_GetMouseState(&x,&y);
	//We call the drop event.
	onDrop(x+camera.x,y+camera.y);
	}
	}

	//Check if the mouse is dragging.
	if(pressedLeftMouse && event.type==SDL_MOUSEMOTION){
	if(abs(event.motion.xrel)+abs(event.motion.yrel)>=2){
	//Check if this is the start of the dragging.
	if(!dragging){
	//The mouse is moved enough so let's set dragging true.
	dragging=true;
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	//We call the dragStart event.
	onDragStart(x+camera.x,y+camera.y);
	}else{
	//Dragging was already true meaning we call onDrag() instead of onDragStart().
	onDrag(event.motion.xrel,event.motion.yrel);
	}
	}
	}

	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	//Create the rectangle.
	SDL_Rect mouse={x,y,0,0};

	//Check if mouse is in the tool box
	SDL_Rect toolboxRect;
	if(toolbox!=NULL){
	toolboxRect.x=toolbox->left;
	toolboxRect.y=toolbox->top;
	toolboxRect.w=toolbox->width;
	toolboxRect.h=toolbox->height;
	}
	//TODO: Create universal method for every GUIWindow (and other GUI elements).
	bool mouseInToolbox=(toolbox!=NULL && !playMode && tool==ADD && toolbox->visible
	&& (checkCollision(mouse,toolboxRect)));

	//Check if we scroll up, meaning the currentType++;
	if((event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELUP) \|\| inputMgr.isKeyDownEvent(INPUTMGR_NEXT)){
	switch(tool){
	case ADD:
	//Only change the current type when using the add tool.
	//TODO: Move this code inside the toolbox class.
	if(mouseInToolbox){
	if((--toolbox->startRow)<0){
	toolbox->startRow=toolbox->maxRow-1;
	}
	}else{
	currentType++;
	if(currentType>=EDITOR_ORDER_MAX){
	currentType=0;
	}
	}
	break;
	case CONFIGURE:
	//When in configure mode.
	movingSpeed++;
	//The movingspeed is capped at 100.
	if(movingSpeed>100){
	movingSpeed=100;
	}
	break;
	default:
	//When in other mode, just scrolling the map
	if(pressedShift) camera.x-=200;
	else camera.y-=200;
	break;
	}
	}
	//Check if we scroll down, meaning the currentType--;
	if((event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELDOWN) \|\| inputMgr.isKeyDownEvent(INPUTMGR_PREVIOUS)){
	switch(tool){
	case ADD:
	//Only change the current type when using the add tool.
	//TODO: Move this code inside the toolbox class.
	if(mouseInToolbox){
	if((++toolbox->startRow)>=toolbox->maxRow){
	toolbox->startRow=0;
	}
	}else{
	currentType--;
	if(currentType<0){
	currentType=EDITOR_ORDER_MAX-1;
	}
	}
	break;
	case CONFIGURE:
	//When in configure mode.
	movingSpeed--;
	if(movingSpeed<=0){
	movingSpeed=1;
	}
	break;
	default:
	//When in other mode, just scrolling the map
	if(pressedShift) camera.x+=200;
	else camera.y+=200;
	break;
	}
	}

	//Check if we should enter playMode.
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_p){
	playMode=true;
	cameraSave.x=camera.x;
	cameraSave.y=camera.y;
	}
	//Check for tool shortcuts.
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_a){
	tool=ADD;
	}
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_s){
	tool=SELECT;
	}
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_d){
	//We clear the selection since that can't be used in the deletion tool.
	selection.clear();
	tool=REMOVE;
	}
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_w){
	tool=CONFIGURE;
	}

	//Check for certain events.

	//First make sure the mouse isn't above the toolbar.
	if(checkCollision(mouse,toolbarRect)==false){
	//Check if mouse is in the tool box
	//TODO: Include every GUIWindow (and GUI elements).
	if(!mouseInToolbox){
	//We didn't hit the toolbar so convert the mouse location to ingame location.
	mouse.x+=camera.x;
	mouse.y+=camera.y;

	//Boolean if there's a click event fired.
	bool clickEvent=false;
	//Check if a mouse button is pressed.
	if(event.type==SDL_MOUSEBUTTONUP){
	std::vector<GameObject*> clickObjects;

	//Loop through the objects to check collision.
	for(unsigned int o=0; o<levelObjects.size(); o++){
	if(checkCollision(levelObjects[o]->getBox(),mouse)==true){
	clickObjects.push_back(levelObjects[o]);
	}
	}

	if(clickObjects.size()==1){
	//We have collision meaning that the mouse is above an object.
	std::vector<GameObject*>::iterator it;
	it=find(selection.begin(),selection.end(),clickObjects[0]);

	//Set event true since there's a click event.
	clickEvent=true;

	//Check if the clicked object is in the selection or not.
	bool isSelected=(it!=selection.end());
	if(event.button.button==SDL_BUTTON_LEFT){
	onClickObject(clickObjects[0],isSelected);
	}else if(event.button.button==SDL_BUTTON_RIGHT){
	onRightClickObject(clickObjects[0],isSelected);
	}
	}else if(clickObjects.size()>1){
	//There are more than one object under the mouse
	clickEvent=true;

	SDL_Rect r=clickObjects[0]->getBox();

	if(selectionPopup!=NULL) delete selectionPopup;
	selectionPopup=new LevelEditorSelectionPopup(this,clickObjects,
	r.x-camera.x,r.y-camera.y);
	}
	}

	//If event is false then we clicked on void.
	if(!clickEvent){
	if(event.type==SDL_MOUSEBUTTONUP){
	if(event.button.button==SDL_BUTTON_LEFT){
	//Left mouse button on void.
	onClickVoid(mouse.x,mouse.y);
	}else if(event.button.button==SDL_BUTTON_RIGHT && tool==CONFIGURE){
	//Stop linking.
	linking=false;
	linkingTrigger=NULL;

	//Write the path to the moving block.
	if(moving){
	std::map<std::string,std::string> editorData;
	char s[64], s0[64];

	sprintf(s,"%d",int(movingBlocks[movingBlock].size()));
	editorData["MovingPosCount"]=s;
	//Loop through the positions.
	for(unsigned int o=0;o<movingBlocks[movingBlock].size();o++){
	sprintf(s0+1,"%d",o);
	sprintf(s,"%d",movingBlocks[movingBlock][o].x);
	s0[0]='x';
	editorData[s0]=s;
	sprintf(s,"%d",movingBlocks[movingBlock][o].y);
	s0[0]='y';
	editorData[s0]=s;
	sprintf(s,"%d",movingBlocks[movingBlock][o].time);
	s0[0]='t';
	editorData[s0]=s;
	}
	movingBlock->setEditorData(editorData);

	//Stop moving.
	moving=false;
	movingBlock=NULL;
	}
	}
	}
	}
	}
	}

	//Check for backspace when moving to remove a movingposition.
	if(moving && event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_BACKSPACE){
	if(movingBlocks[movingBlock].size()>0){
	movingBlocks[movingBlock].pop_back();
	}
	}

	//Check for the tab key, level settings.
	if(inputMgr.isKeyDownEvent(INPUTMGR_TAB)){
	//Show the levelSettings.
	levelSettings();
	}

	//Check if we should a new level. (Ctrl+n)
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_n && (event.key.keysym.mod & KMOD_CTRL)){
	reset();
	//NOTE: We don't have anything to load from so we create an empty TreeStorageNode.
	Game::loadLevelFromNode(new TreeStorageNode,"");

	//Hide selection popup (if any)
	if(selectionPopup!=NULL){
	delete selectionPopup;
	selectionPopup=NULL;
	}
	}
	//Check if we should save the level (Ctrl+s) or save levelpack (Ctrl+Shift+s).
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_s && (event.key.keysym.mod & KMOD_CTRL)){
	saveLevel(levelFile);
	//And give feedback to the user.
	if(levelName.empty())
	msgBox(tfm::format(_("Level \"%s\" saved"),fileNameFromPath(levelFile)),MsgBoxOKOnly,_("Saved"));
	else
	msgBox(tfm::format(_("Level \"%s\" saved"),levelName),MsgBoxOKOnly,_("Saved"));
	}
	}
	}

	void LevelEditor::levelSettings(){
	//It isn't so open a popup asking for a name.
	GUIObject* root=new GUIObject((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-300)/2,600,300,GUIObjectFrame,_("Level settings"));
	GUIObject* obj;

	//NOTE: We reuse the objectProperty and secondProperty.
	obj=new GUIObject(40,50,240,36,GUIObjectLabel,_("Name:"));
	root->addChild(obj);
	obj=new GUIObject(140,50,410,36,GUIObjectTextBox,levelName.c_str());
	objectProperty=obj;
	root->addChild(obj);

	obj=new GUIObject(40,100,240,36,GUIObjectLabel,_("Theme:"));
	root->addChild(obj);
	obj=new GUIObject(140,100,410,36,GUIObjectTextBox,levelTheme.c_str());
	secondObjectProperty=obj;
	root->addChild(obj);

	//target time and recordings.
	{
	char c[32];

	if(levelTime>=0){
	sprintf(c,"%-.2f",levelTime/40.0f);
	}else{
	c[0]='\0';
	}
	obj=new GUIObject(40,150,240,36,GUIObjectLabel,_("Target time (s):"));
	root->addChild(obj);
	obj=new GUIObject(290,150,260,36,GUIObjectTextBox,c);
	levelTimeProperty=obj;
	root->addChild(obj);

	if(levelRecordings>=0){
	sprintf(c,"%d",levelRecordings);
	}else{
	c[0]='\0';
	}
	obj=new GUIObject(40,200,240,36,GUIObjectLabel,_("Target recordings:"));
	root->addChild(obj);
	obj=new GUIObject(290,200,260,36,GUIObjectTextBox,c);
	levelRecordingsProperty=obj;
	root->addChild(obj);
	}


	//Ok and cancel buttons.
	obj=new GUIObject(root->width*0.3,300-44,-1,36,GUIObjectButton,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="lvlSettingsOK";
	obj->eventCallback=this;
	root->addChild(obj);
	obj=new GUIObject(root->width*0.7,300-44,-1,36,GUIObjectButton,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="lvlSettingsCancel";
	obj->eventCallback=this;
	root->addChild(obj);

	//NOTE: We don't need to store a pointer since it will auto cleanup itself.
	new GUIOverlay(root);
	}

	void LevelEditor::postLoad(){
	//We need to find the triggers.
	for(unsigned int o=0;o<levelObjects.size();o++){
	//Get the editor data.
	vector<pair<string,string> > objMap;
	levelObjects[o]->getEditorData(objMap);

	//Check for the highest id.
	for(unsigned int i=0;i<objMap.size();i++){
	if(objMap[i].first=="id"){
	unsigned int id=atoi(objMap[i].second.c_str());
	if(id>=currentId){
	currentId=id+1;
	}
	}
	}

	switch(levelObjects[o]->type){
	case TYPE_BUTTON:
	case TYPE_SWITCH:
	{
	//Add the object to the triggers vector.
	vector<GameObject*> linked;
	triggers[levelObjects[o]]=linked;
	//Now loop through the levelObjects in search for objects with the same id.
	for(unsigned int oo=0;oo<levelObjects.size();oo++){
	//Check if it isn't the same object but has the same id.
	if(o!=oo && (dynamic_cast<Block>(levelObjects[o]))->id==(dynamic_cast<Block>(levelObjects[oo]))->id){
	//Add the object to the link vector of the trigger.
	triggers[levelObjects[o]].push_back(levelObjects[oo]);
	}
	}
	break;
	}
	case TYPE_PORTAL:
	{
	//Add the object to the triggers vector.
	vector<GameObject*> linked;
	triggers[levelObjects[o]]=linked;

	//If the destination is empty we return.
	if((dynamic_cast<Block*>(levelObjects[o]))->destination.empty()){
	break;
	}

	//Now loop through the levelObjects in search for objects with the same id as destination.
	for(unsigned int oo=0;oo<levelObjects.size();oo++){
	//Check if it isn't the same object but has the same id.
	if(o!=oo && (dynamic_cast<Block>(levelObjects[o]))->destination==(dynamic_cast<Block>(levelObjects[oo]))->id){
	//Add the object to the link vector of the trigger.
	triggers[levelObjects[o]].push_back(levelObjects[oo]);
	}
	}
	break;
	}
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	{
	//Add the object to the movingBlocks vector.
	vector<MovingPosition> positions;
	movingBlocks[levelObjects[o]]=positions;

	//Get the number of entries of the editor data.
	int m=objMap.size();

	//Check if the editor data isn't empty.
	if(m>0){
	//Integer containing the positions.
	int pos=0;
	int currentPos=0;

	//Get the number of movingpositions.
	pos=atoi(objMap[1].second.c_str());

	while(currentPos<pos){
	int x=atoi(objMap[currentPos*3+4].second.c_str());
	int y=atoi(objMap[currentPos*3+5].second.c_str());
	int t=atoi(objMap[currentPos*3+6].second.c_str());

	//Create a new movingPosition.
	MovingPosition position(x,y,t);
	movingBlocks[levelObjects[o]].push_back(position);

	//Increase currentPos by one.
	currentPos++;
	}
	}

	break;
	}
	default:
	break;
	}
	}
	}

	void LevelEditor::snapToGrid(int* x,int* y){
	//Check if the x location is negative.
	if(*x<0){
	x=-((abs(x-50)/50)*50);
	}else{
	x=(x/50)*50;
	}

	//Now the y location.
	if(*y<0){
	y=-((abs(y-50)/50)*50);
	}else{
	y=(y/50)*50;
	}
	}

	void LevelEditor::onClickObject(GameObject* obj,bool selected){
	switch(tool){
	//NOTE: We put CONFIGURE above ADD and SELECT to use the same method of selection.
	//Meaning there's no break at the end of CONFIGURE.
	case CONFIGURE:
	{
	//Check if we are linking.
	if(linking){
	//Check if the obj is valid to link to.
	switch(obj->type){
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	{
	//It's only valid when not linking a portal.
	if(linkingTrigger->type==TYPE_PORTAL){
	//You can't link a portal to moving blocks, etc.
	//Stop linking and return.
	linkingTrigger=NULL;
	linking=false;
	return;
	}
	break;
	}
	case TYPE_PORTAL:
	{
	//Make sure that the linkingTrigger is also a portal.
	if(linkingTrigger->type!=TYPE_PORTAL){
	//The linkingTrigger isn't a portal so stop linking and return.
	linkingTrigger=NULL;
	linking=false;
	return;
	}
	break;
	}
	default:
	//It isn't valid so stop linking and return.
	linkingTrigger=NULL;
	linking=false;
	return;
	break;
	}

	//Check if the linkingTrigger can handle multiple or only one link.
	switch(linkingTrigger->type){
	case TYPE_PORTAL:
	{
	//Portals can only link to one so remove all existing links.
	triggers[linkingTrigger].clear();
	triggers[linkingTrigger].push_back(obj);
	break;
	}
	default:
	{
	//The most can handle multiple links.
	triggers[linkingTrigger].push_back(obj);
	break;
	}
	}

	//Check if it's a portal.
	if(linkingTrigger->type==TYPE_PORTAL){
	//Portals need to get the id of the other instead of give it's own id.
	vector<pair<string,string> > objMap;
	obj->getEditorData(objMap);
	int m=objMap.size();
	if(m>0){
	std::map<std::string,std::string> editorData;
	char s[64];
	sprintf(s,"%d",atoi(objMap[0].second.c_str()));
	editorData["destination"]=s;
	linkingTrigger->setEditorData(editorData);
	}
	}else{
	//Give the object the same id as the trigger.
	vector<pair<string,string> > objMap;
	linkingTrigger->getEditorData(objMap);
	int m=objMap.size();
	if(m>0){
	std::map<std::string,std::string> editorData;
	char s[64];
	sprintf(s,"%d",atoi(objMap[0].second.c_str()));
	editorData["id"]=s;
	obj->setEditorData(editorData);
	}
	}


	//We return to prevent configuring stuff like conveyor belts, etc...
	linking=false;
	linkingTrigger=NULL;
	return;
	}

	//If we're moving add a movingposition.
	if(moving){
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	x+=camera.x;
	y+=camera.y;

	//Apply snap to grid.
	if(!pressedShift){
	snapToGrid(&x,&y);
	}else{
	x-=25;
	y-=25;
	}

	x-=movingBlock->getBox().x;
	y-=movingBlock->getBox().y;

	//Calculate the length.
	//First get the delta x and y.
	int dx,dy;
	if(movingBlocks[movingBlock].empty()){
	dx=x;
	dy=y;
	}else{
	dx=x-movingBlocks[movingBlock].back().x;
	dy=y-movingBlocks[movingBlock].back().y;
	}

	double length=sqrt(double(dxdx+dydy));
	movingBlocks[movingBlock].push_back(MovingPosition(x,y,(int)(length*(10/(double)movingSpeed))));
	return;
	}

	//Now handle it as if the user pressed enter (show block properties dialog).
	onEnterObject(obj);
	}
	case SELECT:
	case ADD:
	{
	//Check if object is already selected.
	if(!selected){
	//First check if shift is pressed or not.
	if(!pressedShift){
	//Clear the selection.
	selection.clear();
	}

	//Add the object to the selection.
	selection.push_back(obj);
	}
	break;
	}
	case REMOVE:
	{
	//Remove the object.
	removeObject(obj);
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::onRightClickObject(GameObject* obj,bool selected){
	switch(tool){
	case CONFIGURE:
	{
	//Make sure we aren't doing anything special.
	if(moving \|\| linking)
	break;

	//Check if it's a trigger.
	if(obj->type==TYPE_PORTAL \|\| obj->type==TYPE_BUTTON \|\| obj->type==TYPE_SWITCH){
	//Set linking true.
	linking=true;
	linkingTrigger=obj;
	}

	//Check if it's a moving block.
	if(obj->type==TYPE_MOVING_BLOCK \|\| obj->type==TYPE_MOVING_SHADOW_BLOCK \|\| obj->type==TYPE_MOVING_SPIKES){
	//Set moving true.
	moving=true;
	movingBlock=obj;
	}
	break;
	}
	case SELECT:
	case ADD:
	{
	//We deselect the object if it's selected.
	if(selected){
	std::vector<GameObject*>::iterator it;
	it=find(selection.begin(),selection.end(),obj);

	//Remove the object from selection.
	if(it!=selection.end()){
	selection.erase(it);
	}
	}else{
	//It wasn't a selected object so switch to configure mode.
	//Check if it's the right type of object.
	if(obj->type==TYPE_MOVING_BLOCK \|\| obj->type==TYPE_MOVING_SHADOW_BLOCK \|\| obj->type==TYPE_MOVING_SPIKES \|\|
	obj->type==TYPE_PORTAL \|\| obj->type==TYPE_BUTTON \|\| obj->type==TYPE_SWITCH){
	tool=CONFIGURE;
	onRightClickObject(obj,selected);
	}

	}
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::onClickVoid(int x,int y){
	switch(tool){
	case SELECT:
	{
	//We need to clear the selection.
	selection.clear();
	break;
	}
	case ADD:
	{
	//We need to clear the selection.
	selection.clear();

	//Now place an object.
	//Apply snap to grid.
	if(!pressedShift){
	snapToGrid(&x,&y);
	}else{
	x-=25;
	y-=25;
	}
	addObject(new Block(x,y,editorTileOrder[currentType],this));
	break;
	}
	case CONFIGURE:
	{
	//We need to clear the selection.
	selection.clear();

	//If we're linking we should stop, user abort.
	if(linking){
	linking=false;
	linkingTrigger=NULL;
	//And return.
	return;
	}

	//If we're moving we should add a point.
	if(moving){
	//Apply snap to grid.
	if(!pressedShift){
	snapToGrid(&x,&y);
	}else{
	x-=25;
	y-=25;
	}

	x-=movingBlock->getBox().x;
	y-=movingBlock->getBox().y;

	//Calculate the length.
	//First get the delta x and y.
	int dx,dy;
	if(movingBlocks[movingBlock].empty()){
	dx=x;
	dy=y;
	}else{
	dx=x-movingBlocks[movingBlock].back().x;
	dy=y-movingBlocks[movingBlock].back().y;
	}

	double length=sqrt(double(dxdx+dydy));
	movingBlocks[movingBlock].push_back(MovingPosition(x,y,(int)(length*(10/(double)movingSpeed))));

	//And return.
	return;
	}
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::onDragStart(int x,int y){
	switch(tool){
	case SELECT:
	case ADD:
	case CONFIGURE:
	{
	//We can drag the selection so check if the selection isn't empty.
	if(!selection.empty()){
	//The selection isn't empty so search the dragCenter.
	//Create a mouse rectangle.
	SDL_Rect mouse={x,y,0,0};

	//Loop through the objects to check collision.
	for(unsigned int o=0; o<selection.size(); o++){
	if(checkCollision(selection[o]->getBox(),mouse)==true){
	//We have collision so set the dragCenter.
	dragCenter=selection[o];
	selectionDrag=true;
	}
	}
	}
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::onDrag(int dx,int dy){
	switch(tool){
	case REMOVE:
	{
	//No matter what we delete the item the mouse is above.
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	//Create the rectangle.
	SDL_Rect mouse={x+camera.x,y+camera.y,0,0};

	//Loop through the objects to check collision.
	for(unsigned int o=0; o<levelObjects.size(); o++){
	if(checkCollision(levelObjects[o]->getBox(),mouse)==true){
	//Remove the object.
	removeObject(levelObjects[o]);
	}
	}
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::onDrop(int x,int y){
	switch(tool){
	case SELECT:
	case ADD:
	case CONFIGURE:
	{
	//Check if the drag center isn't null.
	if(dragCenter==NULL) return;
	//The location of the dragCenter.
	SDL_Rect r=dragCenter->getBox();
	//Apply snap to grid.
	if(!pressedShift){
	snapToGrid(&x,&y);
	}else{
	x-=25;
	y-=25;
	}

	//Loop through the selection.
	for(unsigned int o=0; o<selection.size(); o++){
	SDL_Rect r1=selection[o]->getBox();
	//We need to place the object at his drop place.
	moveObject(selection[o],(r1.x-r.x)+x,(r1.y-r.y)+y);
	}

	//Make sure the dragCenter is null and set selectionDrag false.
	dragCenter=NULL;
	selectionDrag=false;
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::onCameraMove(int dx,int dy){
	switch(tool){
	case REMOVE:
	{
	//Only delete when the left mouse button is pressed.
	if(pressedLeftMouse){
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	//Create the rectangle.
	SDL_Rect mouse={x+camera.x,y+camera.y,0,0};

	//Loop through the objects to check collision.
	for(unsigned int o=0; o<levelObjects.size(); o++){
	if(checkCollision(levelObjects[o]->getBox(),mouse)==true){
	//Remove the object.
	removeObject(levelObjects[o]);
	}
	}
	}
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::onEnterObject(GameObject* obj){
	switch(tool){
	case CONFIGURE:
	{
	//Check if the type is an moving block.
	if(obj->type==TYPE_MOVING_BLOCK \|\| obj->type==TYPE_MOVING_SHADOW_BLOCK \|\| obj->type==TYPE_MOVING_SPIKES){
	//Get the properties.
	vector<pair<string,string> > objMap;
	obj->getEditorData(objMap);
	int m=objMap.size();
	if(m>0){
	//Set the object we configure.
	configuredObject=obj;

	//Check if the moving block has a path..
	string s1;
	bool path=false;
	if(!movingBlocks[obj].empty()){
	s1=_("Defined");
	path=true;
	}else{
	s1=_("None");
	}

	//Now create the GUI.
	string s;
	switch(obj->type){
	case TYPE_MOVING_BLOCK:
	s=_("Moving block");
	break;
	case TYPE_MOVING_SHADOW_BLOCK:
	s=_("Moving shadow block");
	break;
	case TYPE_MOVING_SPIKES:
	s=_("Moving spikes");
	break;

	}
	GUIObject* root=new GUIObject((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-200)/2,600,200,GUIObjectFrame,s.c_str());
	GUIObject* obj;

	obj=new GUIObject(70,50,280,36,GUIObjectCheckBox,_("Enabled"),(objMap[2].second!="1"));
	obj->name="cfgMovingBlockEnabled";
	obj->eventCallback=this;
	objectProperty=obj;
	root->addChild(obj);

	obj=new GUIObject(70,80,280,36,GUIObjectCheckBox,_("Loop"),(objMap[3].second!="0"));
	obj->name="cfgMovingBlockLoop";
	obj->eventCallback=this;
	secondObjectProperty=obj;
	root->addChild(obj);

	obj=new GUIObject(70,110,280,36,GUIObjectLabel,_("Path"));
	root->addChild(obj);
	GUIObject* label=new GUIObject(330,110,-1,36,GUIObjectLabel,s1.c_str());
	root->addChild(label);
	label->render(0,0,false);

	if(path){
	obj=new GUIObject(label->left+label->width,110,36,36,GUIObjectButton,"x");
	obj->name="cfgMovingBlockClrPath";
	obj->eventCallback=this;
	root->addChild(obj);
	}else{
	//NOTE: The '+' is translated 5 pixels down to align with the 'x'.
	obj=new GUIObject(label->left+label->width,115,36,36,GUIObjectButton,"+");
	obj->name="cfgMovingBlockMakePath";
	obj->eventCallback=this;
	root->addChild(obj);
	}

	obj=new GUIObject(root->width*0.3,200-44,-1,36,GUIObjectButton,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgMovingBlockOK";
	obj->eventCallback=this;
	root->addChild(obj);
	obj=new GUIObject(root->width*0.7,200-44,-1,36,GUIObjectButton,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgCancel";
	obj->eventCallback=this;
	root->addChild(obj);

	//Create the GUI overlay.
	//NOTE: We don't need to store a pointer since it will auto cleanup itself.
	new GUIOverlay(root);
	}
	}

	//Check which type of object it is.
	if(obj->type==TYPE_NOTIFICATION_BLOCK){
	//Get the properties.
	vector<pair<string,string> > objMap;
	obj->getEditorData(objMap);
	int m=objMap.size();
	if(m>0){
	//Set the object we configure.
	configuredObject=obj;

	//Now create the GUI.
	GUIObject* root=new GUIObject((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-250)/2,600,250,GUIObjectFrame,_("Notification block"));
	GUIObject* obj;

	obj=new GUIObject(40,50,240,36,GUIObjectLabel,_("Enter message here:"));
	root->addChild(obj);
	obj=new GUITextArea(50,90,500,100);
	string tmp=objMap[1].second.c_str();
	//Change \n with the characters '\n'.
	while(tmp.find("\\n")!=string::npos){
	tmp=tmp.replace(tmp.find("\\n"),2,"\n");
	}
	obj->caption=tmp.c_str();
	//Set the textField.
	objectProperty=obj;
	root->addChild(obj);

	obj=new GUIObject(root->width*0.3,250-44,-1,36,GUIObjectButton,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgNotificationBlockOK";
	obj->eventCallback=this;
	root->addChild(obj);
	obj=new GUIObject(root->width*0.7,250-44,-1,36,GUIObjectButton,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgCancel";
	obj->eventCallback=this;
	root->addChild(obj);

	//Create the GUI overlay.
	//NOTE: We don't need to store a pointer since it will auto cleanup itself.
	new GUIOverlay(root);
	}
	}
	if(obj->type==TYPE_CONVEYOR_BELT \|\| obj->type==TYPE_SHADOW_CONVEYOR_BELT){
	//Get the properties and check if
	vector<pair<string,string> > objMap;
	obj->getEditorData(objMap);
	int m=objMap.size();
	if(m>0){
	//Set the object we configure.
	configuredObject=obj;

	//Now create the GUI.
	string s;
	if(obj->type==TYPE_CONVEYOR_BELT){
	s=_("Conveyor belt");
	}else{
	s=_("Shadow Conveyor belt");
	}

	GUIObject* root=new GUIObject((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-200)/2,600,200,GUIObjectFrame,s.c_str());
	GUIObject* obj;

	obj=new GUIObject(40,60,220,36,GUIObjectCheckBox,_("Enabled"),(objMap[1].second!="1"));
	obj->name="cfgConveyorBlockEnabled";
	obj->eventCallback=this;
	objectProperty=obj;
	root->addChild(obj);

	obj=new GUIObject(40,100,240,36,GUIObjectLabel,_("Enter speed here:"));
	root->addChild(obj);
	obj=new GUIObject(240,100,320,36,GUIObjectTextBox,objMap[2].second.c_str());
	//Set the textField.
	secondObjectProperty=obj;
	root->addChild(obj);


	obj=new GUIObject(root->width*0.3,200-44,-1,36,GUIObjectButton,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgConveyorBlockOK";
	obj->eventCallback=this;
	root->addChild(obj);
	obj=new GUIObject(root->width*0.7,200-44,-1,36,GUIObjectButton,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgCancel";
	obj->eventCallback=this;
	root->addChild(obj);

	//Create the GUI overlay.
	//NOTE: We don't need to store a pointer since it will auto cleanup itself.
	new GUIOverlay(root);
	}
	}

	if(obj->type==TYPE_PORTAL){
	//Get the properties and check if
	vector<pair<string,string> > objMap;
	obj->getEditorData(objMap);
	int m=objMap.size();
	if(m>0){
	//Set the object we configure.
	configuredObject=obj;

	//Check how many targets there are for this object.
	string s1;
	bool target=false;
	if(!triggers[obj].empty()){
	s1=_("Defined");
	target=true;
	}else{
	s1=_("None");
	}

	//Now create the GUI.
	GUIObject* root=new GUIObject((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-200)/2,600,200,GUIObjectFrame,_("Portal"));
	GUIObject* obj;

	obj=new GUIObject(70,60,310,36,GUIObjectCheckBox,_("Activate on touch"),(objMap[1].second=="1"));
	obj->name="cfgPortalAutomatic";
	obj->eventCallback=this;
	objectProperty=obj;
	root->addChild(obj);

	obj=new GUIObject(70,100,240,36,GUIObjectLabel,_("Targets:"));
	root->addChild(obj);

	GUIObject* label=new GUIObject(360,100,-1,36,GUIObjectLabel,s1.c_str());
	root->addChild(label);
	label->render(0,0,false);

	//Check if there are targets defined.
	if(target){
	obj=new GUIObject(label->left+label->width,100,36,36,GUIObjectButton,"x");
	obj->name="cfgPortalUnlink";
	obj->eventCallback=this;
	root->addChild(obj);
	}else{
	//NOTE: The '+' is translated 5 pixels down to align with the 'x'.
	obj=new GUIObject(label->left+label->width,105,36,36,GUIObjectButton,"+");
	obj->name="cfgPortalLink";
	obj->eventCallback=this;
	root->addChild(obj);
	}

	obj=new GUIObject(root->width*0.3,200-44,-1,36,GUIObjectButton,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgPortalOK";
	obj->eventCallback=this;
	root->addChild(obj);
	obj=new GUIObject(root->width*0.7,200-44,-1,36,GUIObjectButton,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgCancel";
	obj->eventCallback=this;
	root->addChild(obj);

	//Create the GUI overlay.
	//NOTE: We don't need to store a pointer since it will auto cleanup itself.
	new GUIOverlay(root);
	}
	}

	if(obj->type==TYPE_BUTTON \|\| obj->type==TYPE_SWITCH){
	//Get the properties and check if
	vector<pair<string,string> > objMap;
	obj->getEditorData(objMap);
	int m=objMap.size();
	if(m>0){
	//Set the object we configure.
	configuredObject=obj;

	//Check how many targets there are for this object.
	string s1;
	bool targets=false;
	if(!triggers[obj].empty()){
	s1=tfm::format(_("%d Defined"),(int)triggers[obj].size());
	targets=true;
	}else{
	s1=_("None");
	}

	//Now create the GUI.
	string s;
	if(obj->type==TYPE_BUTTON){
	s=_("Button");
	}else{
	s=_("Switch");
	}
	GUIObject* root=new GUIObject((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-200)/2,600,200,GUIObjectFrame,s.c_str());
	GUIObject* obj;

	obj=new GUIObject(70,60,240,36,GUIObjectLabel,_("Behaviour:"));
	root->addChild(obj);

	obj=new GUISingleLineListBox(250,60,300,36);
	obj->name="lstBehaviour";
	vector<string> v;
	v.push_back(_("On"));
	v.push_back(_("Off"));
	v.push_back(_("Toggle"));
	(dynamic_cast<GUISingleLineListBox*>(obj))->item=v;

	//Get the current behaviour.
	if(objMap[1].second=="on"){
	obj->value=0;
	}else if(objMap[1].second=="off"){
	obj->value=1;
	}else{
	//There's no need to check for the last one, since it's also the default.
	obj->value=2;
	}
	objectProperty=obj;
	root->addChild(obj);

	obj=new GUIObject(70,100,240,36,GUIObjectLabel,_("Targets:"));
	root->addChild(obj);

	GUIObject* label=new GUIObject(250,100,-1,36,GUIObjectLabel,s1.c_str());
	root->addChild(label);
	label->render(0,0,false);

	//NOTE: The '+' is translated 5 pixels down to align with the 'x'.
	obj=new GUIObject(label->left+label->width,105,36,36,GUIObjectButton,"+");
	obj->name="cfgTriggerLink";
	obj->eventCallback=this;
	root->addChild(obj);

	//Check if there are targets defined.
	if(targets){
	obj=new GUIObject(label->left+label->width+40,100,36,36,GUIObjectButton,"x");
	obj->name="cfgTriggerUnlink";
	obj->eventCallback=this;
	root->addChild(obj);
	}


	obj=new GUIObject(root->width*0.3,200-44,-1,36,GUIObjectButton,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgTriggerOK";
	obj->eventCallback=this;
	root->addChild(obj);
	obj=new GUIObject(root->width*0.7,200-44,-1,36,GUIObjectButton,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgCancel";
	obj->eventCallback=this;
	root->addChild(obj);

	//Create the GUI overlay.
	//NOTE: We don't need to store a pointer since it will auto cleanup itself.
	new GUIOverlay(root);
	}
	}
	if(obj->type==TYPE_FRAGILE){
	//Get the properties and check if it contains the state data.
	vector<pair<string,string> > objMap;
	obj->getEditorData(objMap);
	int m=objMap.size();
	if(m>0){
	//Set the object we configure.
	configuredObject=obj;

	//Create the GUI.
	GUIObject* root=new GUIObject((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-200)/2,600,200,GUIObjectFrame,_("Fragile"));
	GUIObject* obj;

	obj=new GUIObject(70,60,240,36,GUIObjectLabel,_("State:"));
	root->addChild(obj);

	obj=new GUISingleLineListBox(250,60,300,36);
	obj->name="lstBehaviour";
	vector<string> v;
	v.push_back(_("Complete"));
	v.push_back(_("One step"));
	v.push_back(_("Two steps"));
	v.push_back(_("Gone"));
	(dynamic_cast<GUISingleLineListBox*>(obj))->item=v;

	//Get the current state.
	obj->value=atoi(objMap[1].second.c_str());
	objectProperty=obj;
	root->addChild(obj);

	obj=new GUIObject(root->width*0.3,200-44,-1,36,GUIObjectButton,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgFragileOK";
	obj->eventCallback=this;
	root->addChild(obj);
	obj=new GUIObject(root->width*0.7,200-44,-1,36,GUIObjectButton,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgCancel";
	obj->eventCallback=this;
	root->addChild(obj);

	//Create the GUI overlay.
	//NOTE: We don't need to store a pointer since it will auto cleanup itself.
	new GUIOverlay(root);
	}
	}

	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::addObject(GameObject* obj){
	//Increase totalCollectables everytime we add a new collectable
	if (obj->type==TYPE_COLLECTABLE) {
	totalCollectables++;
	}

	//If it's a player or shadow start then we need to remove the previous one.
	if(obj->type==TYPE_START_PLAYER \|\| obj->type==TYPE_START_SHADOW){
	//Loop through the levelObjects.
	for(unsigned int o=0; o<levelObjects.size(); o++){
	//Check if the type is the same.
	if(levelObjects[o]->type==obj->type){
	removeObject(levelObjects[o]);
	}
	}
	}

	//Add it to the levelObjects.
	levelObjects.push_back(obj);

	//Check if the object is inside the level dimensions, etc.
	//Just call moveObject() to perform this.
	moveObject(obj,obj->getBox().x,obj->getBox().y);

	//GameObject type specific stuff.
	switch(obj->type){
	case TYPE_BUTTON:
	case TYPE_SWITCH:
	case TYPE_PORTAL:
	{
	//Add the object to the triggers.
	vector<GameObject*> linked;
	triggers[obj]=linked;

	//Give it it's own id.
	std::map<std::string,std::string> editorData;
	char s[64];
	sprintf(s,"%d",currentId);
	currentId++;
	editorData["id"]=s;
	obj->setEditorData(editorData);
	break;
	}
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	{
	//Add the object to the moving blocks.
	vector<MovingPosition> positions;
	movingBlocks[obj]=positions;

	//Get the editor data.
	vector<pair<string,string> > objMap;
	obj->getEditorData(objMap);

	//Get the number of entries of the editor data.
	int m=objMap.size();

	//Check if the editor data isn't empty.
	if(m>0){
	//Integer containing the positions.
	int pos=0;
	int currentPos=0;

	//Get the number of movingpositions.
	pos=atoi(objMap[1].second.c_str());

	while(currentPos<pos){
	int x=atoi(objMap[currentPos*3+4].second.c_str());
	int y=atoi(objMap[currentPos*3+5].second.c_str());
	int t=atoi(objMap[currentPos*3+6].second.c_str());

	//Create a new movingPosition.
	MovingPosition position(x,y,t);
	movingBlocks[obj].push_back(position);

	//Increase currentPos by one.
	currentPos++;
	}
	}

	//Give it it's own id.
	std::map<std::string,std::string> editorData;
	char s[64];
	sprintf(s,"%d",currentId);
	currentId++;
	editorData["id"]=s;
	obj->setEditorData(editorData);
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::moveObject(GameObject* obj,int x,int y){
	//Set the obj at it's new position.
	obj->setPosition(x,y);

	//Check if the object is inside the level dimensions.
	//If not let the level grow.
	if(obj->getBox().x+50>LEVEL_WIDTH){
	LEVEL_WIDTH=obj->getBox().x+50;
	}
	if(obj->getBox().y+50>LEVEL_HEIGHT){
	LEVEL_HEIGHT=obj->getBox().y+50;
	}
	if(obj->getBox().x<0 \|\| obj->getBox().y<0){
	//A block on the left (or top) side of the level, meaning we need to shift everything.
	//First calc the difference.
	int diffx=(0-(obj->getBox().x));
	int diffy=(0-(obj->getBox().y));

	if(diffx<0) diffx=0;
	if(diffy<0) diffy=0;

	//Change the level size first.
	//The level grows with the difference, 0-(x+50).
	LEVEL_WIDTH+=diffx;
	LEVEL_HEIGHT+=diffy;
	//cout<<"x:"<<diffx<<",y:"<<diffy<<endl; //debug
	camera.x+=diffx;
	camera.y+=diffy;

	//Set the position of player and shadow
	//(although it's unnecessary if there is player and shadow start)
	player.setPosition(player.getBox().x+diffx,player.getBox().y+diffy);
	shadow.setPosition(shadow.getBox().x+diffx,shadow.getBox().y+diffy);

	for(unsigned int o=0; o<levelObjects.size(); o++){
	//FIXME: shouldn't recuesive call me (to prevent stack overflow bugs)
	moveObject(levelObjects[o],levelObjects[o]->getBox().x+diffx,levelObjects[o]->getBox().y+diffy);
	}
	}

	//If the object is a player or shadow start then change the start position of the player or shadow.
	if(obj->type==TYPE_START_PLAYER){
	//Center the player horizontally.
	player.fx=obj->getBox().x+(50-23)/2;
	player.fy=obj->getBox().y;
	//Now reset the player to get him to it's new start position.
	player.reset(true);
	}
	if(obj->type==TYPE_START_SHADOW){
	//Center the shadow horizontally.
	shadow.fx=obj->getBox().x+(50-23)/2;
	shadow.fy=obj->getBox().y;
	//Now reset the shadow to get him to it's new start position.
	shadow.reset(true);
	}
	}

	void LevelEditor::removeObject(GameObject* obj){
	std::vector<GameObject*>::iterator it;
	std::map<GameObject,vector<GameObject> >::iterator mapIt;

	//Increase totalCollectables everytime we add a new collectable
	if (obj->type==TYPE_COLLECTABLE) {
	totalCollectables--;
	}

	//Check if the object is in the selection.
	it=find(selection.begin(),selection.end(),obj);
	if(it!=selection.end()){
	//It is so we delete it.
	selection.erase(it);
	}

	//Check if the object is in the triggers.
	mapIt=triggers.find(obj);
	if(mapIt!=triggers.end()){
	//It is so we remove it.
	triggers.erase(mapIt);
	}

	//Boolean if it could be a target.
	if(obj->type==TYPE_MOVING_BLOCK \|\| obj->type==TYPE_MOVING_SHADOW_BLOCK \|\| obj->type==TYPE_MOVING_SPIKES
	\|\| obj->type==TYPE_CONVEYOR_BELT \|\| obj->type==TYPE_SHADOW_CONVEYOR_BELT \|\| obj->type==TYPE_PORTAL){
	for(mapIt=triggers.begin();mapIt!=triggers.end();++mapIt){
	//Now loop the target vector.
	for(unsigned int o=0;o<(*mapIt).second.size();o++){
	//Check if the obj is in the target vector.
	if((*mapIt).second[o]==obj){
	(mapIt).second.erase(find((mapIt).second.begin(),(*mapIt).second.end(),obj));
	o--;
	}
	}
	}
	}

	//Check if the object is in the movingObjects.
	std::map<GameObject*,vector<MovingPosition> >::iterator movIt;
	movIt=movingBlocks.find(obj);
	if(movIt!=movingBlocks.end()){
	//It is so we remove it.
	movingBlocks.erase(movIt);
	}

	//Now we remove the object from the levelObjects.
	it=find(levelObjects.begin(),levelObjects.end(),obj);
	if(it!=levelObjects.end()){
	levelObjects.erase(it);
	}
	delete obj;
	obj=NULL;

	//Set dirty of selection popup
	if(selectionPopup!=NULL) selectionPopup->dirty=true;
	}

	void LevelEditor::GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	//Check for GUI events.
	//Notification block configure events.
	if(name=="cfgNotificationBlockOK"){
	if(GUIObjectRoot){
	//Set the message of the notification block.
	std::map<std::string,std::string> editorData;
	editorData["message"]=objectProperty->caption;
	configuredObject->setEditorData(editorData);

	//And delete the GUI.
	objectProperty=NULL;
	secondObjectProperty=NULL;
	configuredObject=NULL;
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	//Conveyor belt block configure events.
	if(name=="cfgConveyorBlockOK"){
	if(GUIObjectRoot){
	//Set the message of the notification block.
	std::map<std::string,std::string> editorData;
	editorData["speed"]=secondObjectProperty->caption;
	editorData["disabled"]=(objectProperty->value==0)?"1":"0";
	configuredObject->setEditorData(editorData);

	//And delete the GUI.
	objectProperty=NULL;
	secondObjectProperty=NULL;
	configuredObject=NULL;
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	//Moving block configure events.
	if(name=="cfgMovingBlockOK"){
	if(GUIObjectRoot){
	//Set if the moving block is enabled/disabled.
	std::map<std::string,std::string> editorData;
	editorData["disabled"]=(objectProperty->value==0)?"1":"0";
	editorData["loop"]=(secondObjectProperty->value==1)?"1":"0";
	configuredObject->setEditorData(editorData);

	//And delete the GUI.
	objectProperty=NULL;
	secondObjectProperty=NULL;
	configuredObject=NULL;
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	if(name=="cfgMovingBlockClrPath"){
	if(GUIObjectRoot){
	//Set the message of the notification block.
	std::map<std::string,std::string> editorData;
	editorData["MovingPosCount"]="0";
	configuredObject->setEditorData(editorData);

	std::map<GameObject*,vector<MovingPosition> >::iterator it;
	it=movingBlocks.find(configuredObject);
	if(it!=movingBlocks.end()){
	(*it).second.clear();
	}

	//And delete the GUI.
	objectProperty=NULL;
	secondObjectProperty=NULL;
	configuredObject=NULL;
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	if(name=="cfgMovingBlockMakePath"){
	if(GUIObjectRoot){
	//Set moving.
	moving=true;
	movingBlock=configuredObject;

	//And delete the GUI.
	objectProperty=NULL;
	secondObjectProperty=NULL;
	configuredObject=NULL;
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	//Portal block configure events.
	if(name=="cfgPortalOK"){
	if(GUIObjectRoot){
	//Set the message of the notification block.
	std::map<std::string,std::string> editorData;
	editorData["automatic"]=(objectProperty->value==1)?"1":"0";
	configuredObject->setEditorData(editorData);

	//And delete the GUI.
	objectProperty=NULL;
	secondObjectProperty=NULL;
	configuredObject=NULL;
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	if(name=="cfgPortalLink"){
	//We set linking true.
	linking=true;
	linkingTrigger=configuredObject;

	//And delete the GUI.
	objectProperty=NULL;
	secondObjectProperty=NULL;
	configuredObject=NULL;
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	}
	GUIObjectRoot=NULL;
	}
	if(name=="cfgPortalUnlink"){
	std::map<GameObject,vector<GameObject> >::iterator it;
	it=triggers.find(configuredObject);
	if(it!=triggers.end()){
	//Remove the targets.
	(*it).second.clear();
	}

	//We reset the destination.
	std::map<std::string,std::string> editorData;
	editorData["destination"]="";
	configuredObject->setEditorData(editorData);

	//And delete the GUI.
	objectProperty=NULL;
	secondObjectProperty=NULL;
	configuredObject=NULL;
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	}
	GUIObjectRoot=NULL;
	}
	//Trigger block configure events.
	if(name=="cfgTriggerOK"){
	if(GUIObjectRoot){
	//Set the message of the notification block.
	std::map<std::string,std::string> editorData;
	editorData["behaviour"]=(dynamic_cast<GUISingleLineListBox*>(objectProperty))->item[objectProperty->value];
	configuredObject->setEditorData(editorData);

	//And delete the GUI.
	objectProperty=NULL;
	secondObjectProperty=NULL;
	configuredObject=NULL;
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	if(name=="cfgTriggerLink"){
	//We set linking true.
	linking=true;
	linkingTrigger=configuredObject;

	//And delete the GUI.
	objectProperty=NULL;
	secondObjectProperty=NULL;
	configuredObject=NULL;
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	}
	GUIObjectRoot=NULL;
	}
	if(name=="cfgTriggerUnlink"){
	std::map<GameObject,vector<GameObject> >::iterator it;
	it=triggers.find(configuredObject);
	if(it!=triggers.end()){
	//Remove the targets.
	(*it).second.clear();
	}

	//We give the trigger a new id to prevent activating unlinked targets.
	std::map<std::string,std::string> editorData;
	char s[64];
	sprintf(s,"%d",currentId);
	currentId++;
	editorData["id"]=s;
	configuredObject->setEditorData(editorData);

	//And delete the GUI.
	objectProperty=NULL;
	secondObjectProperty=NULL;
	configuredObject=NULL;
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	}
	GUIObjectRoot=NULL;
	}

	//Fragile configuration.
	if(name=="cfgFragileOK"){
	std::map<std::string,std::string> editorData;
	char s[64];
	sprintf(s,"%d",objectProperty->value);
	editorData["state"]=s;
	configuredObject->setEditorData(editorData);

	//And delete the GUI.
	objectProperty=NULL;
	secondObjectProperty=NULL;
	configuredObject=NULL;
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	}
	GUIObjectRoot=NULL;
	}

	//Cancel.
	if(name=="cfgCancel"){
	if(GUIObjectRoot){
	//Delete the GUI.
	objectProperty=NULL;
	secondObjectProperty=NULL;
	configuredObject=NULL;
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}

	//LevelSetting events.
	if(name=="lvlSettingsOK"){
	levelName=objectProperty->caption;
	levelTheme=secondObjectProperty->caption;

	//target time and recordings.
	string s=levelTimeProperty->caption;
	if(s.empty() \|\| !(s[0]>='0' && s[0]<='9')){
	levelTime=-1;
	}else{
	levelTime=int(atof(s.c_str())*40.0+0.5);
	}

	s=levelRecordingsProperty->caption;
	if(s.empty() \|\| !(s[0]>='0' && s[0]<='9')){
	levelRecordings=-1;
	}else{
	levelRecordings=atoi(s.c_str());
	}

	//And delete the GUI.
	if(GUIObjectRoot){
	objectProperty=NULL;
	secondObjectProperty=NULL;
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	if(name=="lvlSettingsCancel"){
	if(GUIObjectRoot){
	//Delete the GUI.
	objectProperty=NULL;
	secondObjectProperty=NULL;
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	}

	////////////////LOGIC////////////////////
	void LevelEditor::logic(){
	if(playMode){
	//PlayMode so let the game do it's logic.
	Game::logic();
	}else{
	//Move the camera.
	if(cameraXvel!=0 \|\| cameraYvel!=0){
	camera.x+=cameraXvel;
	camera.y+=cameraYvel;
	//Call the onCameraMove event.
	onCameraMove(cameraXvel,cameraYvel);
	}
	//Move the camera with the mouse.
	{
	SDL_Rect r[3]={toolbarRect};
	int m=1;
	if(toolbox!=NULL && tool==ADD && toolbox->visible){
	m++;
	r[m].x=toolbox->left;
	r[m].y=toolbox->top;
	r[m].w=toolbox->width;
	r[m].h=toolbox->height;
	}
	if(selectionPopup!=NULL)
	r[m++]=selectionPopup->getRect();
	setCamera(r,m);
	}

	//It isn't playMode so the mouse should be checked.
	tooltip=-1;
	//Get the mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	SDL_Rect mouse={x,y,0,0};

	//We loop through the number of tools + the number of buttons.
	for(int t=0; t<NUMBER_TOOLS+6; t++){
	SDL_Rect toolRect={(SCREEN_WIDTH-460)/2+(t40)+((t+1)10),SCREEN_HEIGHT-45,40,40};

	//Check for collision.
	if(checkCollision(mouse,toolRect)==true){
	//Set the tooltip tool.
	tooltip=t;
	+ currentCursor=CURSOR_POINT;
	}
	}
	}
	}

	/////////////////RENDER//////////////////////
	void LevelEditor::render(){
	//Always let the game render the game.
	Game::render();

	//Only render extra stuff like the toolbar, selection, etc.. when not in playMode.
	if(!playMode){
	//Render the selectionmarks.
	//TODO: Check if block is in sight.
	for(unsigned int o=0; o<selection.size(); o++){
	//Get the location to draw.
	SDL_Rect r=selection[o]->getBox();
	r.x-=camera.x;
	r.y-=camera.y;

	//Draw the selectionMarks.
	applySurface(r.x,r.y,selectionMark,screen,NULL);
	applySurface(r.x+r.w-5,r.y,selectionMark,screen,NULL);
	applySurface(r.x,r.y+r.h-5,selectionMark,screen,NULL);
	applySurface(r.x+r.w-5,r.y+r.h-5,selectionMark,screen,NULL);
	}

	//Clear the placement surface.
	SDL_FillRect(placement,NULL,0x00FF00FF);

	Uint32 color=SDL_MapRGB(placement->format,themeTextColor.r,themeTextColor.g,themeTextColor.b);

	//Draw the dark areas marking the outside of the level.
	SDL_Rect r;
	if(camera.x<0){
	//Draw left side.
	r.x=0;
	r.y=0;
	r.w=0-camera.x;
	r.h=SCREEN_HEIGHT;
	SDL_FillRect(placement,&r,color);
	}
	if(camera.x>LEVEL_WIDTH-SCREEN_WIDTH){
	//Draw right side.
	r.x=LEVEL_WIDTH-camera.x;
	r.y=0;
	r.w=SCREEN_WIDTH-(LEVEL_WIDTH-camera.x);
	r.h=SCREEN_HEIGHT;
	SDL_FillRect(placement,&r,color);
	}
	if(camera.y<0){
	//Draw the top.
	r.x=0;
	r.y=0;
	r.w=SCREEN_WIDTH;
	r.h=0-camera.y;
	SDL_FillRect(placement,&r,color);
	}
	if(camera.y>LEVEL_HEIGHT-SCREEN_HEIGHT){
	//Draw the bottom.
	r.x=0;
	r.y=LEVEL_HEIGHT-camera.y;
	r.w=SCREEN_WIDTH;
	r.h=SCREEN_HEIGHT-(LEVEL_HEIGHT-camera.y);
	SDL_FillRect(placement,&r,color);
	}

	//Check if we should draw on the placement surface.
	if(selectionDrag){
	showSelectionDrag();
	}else{
	if(tool==ADD){
	showCurrentObject();
	}
	if(tool==CONFIGURE){
	showConfigure();
	}
	}

	//Draw the level borders.
	drawRect(-camera.x,-camera.y,LEVEL_WIDTH,LEVEL_HEIGHT,screen);

	//Render the placement surface.
	applySurface(0,0,placement,screen,NULL);

	//Render the hud layer.
	renderHUD();

	//Render tool box (if any)
	if(toolbox!=NULL && tool==ADD && toolbox->visible){
	toolbox->render();
	}

	//On top of all render the toolbar.
	applySurface(toolbarRect.x,toolbarRect.y,toolbar,screen,NULL);
	//Now render a tooltip.
	if(tooltip>=0){
	//The back and foreground colors.
	SDL_Color fg={0,0,0};

	//Tool specific text.
	SDL_Surface* tip=NULL;
	switch(tooltip){
	case 0:
	tip=TTF_RenderUTF8_Blended(fontText,_("Select"),fg);
	break;
	case 1:
	tip=TTF_RenderUTF8_Blended(fontText,_("Add"),fg);
	break;
	case 2:
	tip=TTF_RenderUTF8_Blended(fontText,_("Delete"),fg);
	break;
	case 3:
	tip=TTF_RenderUTF8_Blended(fontText,_("Configure"),fg);
	break;
	case 4:
	tip=TTF_RenderUTF8_Blended(fontText,_("Play"),fg);
	break;
	case 6:
	tip=TTF_RenderUTF8_Blended(fontText,_("Level settings"),fg);
	break;
	case 7:
	tip=TTF_RenderUTF8_Blended(fontText,_("Save level"),fg);
	break;
	case 8:
	tip=TTF_RenderUTF8_Blended(fontText,_("Back to menu"),fg);
	break;
	default:
	break;
	}

	//Draw only if there's a tooltip available
	if(tip!=NULL){
	SDL_Rect r={(SCREEN_WIDTH-440)/2+(tooltip40)+(tooltip10),SCREEN_HEIGHT-45,40,40};
	r.y=SCREEN_HEIGHT-50-tip->h;
	if(r.x+tip->w>SCREEN_WIDTH-50)
	r.x=SCREEN_WIDTH-50-tip->w;

	//Draw borders around text
	Uint32 color=0xFFFFFF00\|230;
	drawGUIBox(r.x-2,r.y-2,tip->w+4,tip->h+4,screen,color);

	//Draw tooltip's text
	SDL_BlitSurface(tip,NULL,screen,&r);
	SDL_FreeSurface(tip);
	}
	}

	//Draw a rectangle around the current tool.
	color=0xFFFFFF00;
	drawGUIBox((SCREEN_WIDTH-440)/2+(tool40)+(tool10),SCREEN_HEIGHT-46,42,42,screen,color);

	//Render selection popup (if any)
	if(selectionPopup!=NULL){
	if(linking){
	//If we switch to linking mode then delete it
	delete selectionPopup;
	selectionPopup=NULL;
	}else{
	selectionPopup->render();
	}
	}
	}
	}

	void LevelEditor::renderHUD(){
	//Switch the tool.
	switch(tool){
	case CONFIGURE:
	//If moving show the moving speed in the top right corner.
	if(moving){
	//Calculate width of text "Movespeed: 100" to keep the same position with every value
	if (movingSpeedWidth==-1){
	int w;
	TTF_SizeUTF8(fontText,tfm::format(_("Movespeed: %s"),100).c_str(),&w,NULL);
	movingSpeedWidth=w+4;
	}

	//Now render the text.
	SDL_Color black={0,0,0,0};
	SDL_Surface* bm=TTF_RenderUTF8_Blended(fontText,tfm::format(_("Movespeed: %s"),movingSpeed).c_str(),black);

	//Draw the text in box and free the surface.
	drawGUIBox(SCREEN_WIDTH-movingSpeedWidth-2,-2,movingSpeedWidth+8,bm->h+6,screen,0xDDDDDDDD);
	applySurface(SCREEN_WIDTH-movingSpeedWidth,2,bm,screen,NULL);
	SDL_FreeSurface(bm);
	}
	break;
	default:
	break;
	}
	}

	void LevelEditor::showCurrentObject(){
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	x+=camera.x;
	y+=camera.y;

	//Check if we should snap the block to grid or not.
	if(!pressedShift){
	snapToGrid(&x,&y);
	}else{
	x-=25;
	y-=25;
	}

	//Check if the currentType is a legal type.
	if(currentType>=0 && currentType<EDITOR_ORDER_MAX){
	ThemeBlock* obj=objThemes.getBlock(editorTileOrder[currentType]);
	if(obj){
	obj->editorPicture.draw(placement,x-camera.x,y-camera.y);
	}
	}
	}

	void LevelEditor::showSelectionDrag(){
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	//Create the rectangle.
	x+=camera.x;
	y+=camera.y;

	//Check if we should snap the block to grid or not.
	if(!pressedShift){
	snapToGrid(&x,&y);
	}else{
	x-=25;
	y-=25;
	}

	//Check if the drag center isn't null.
	if(dragCenter==NULL) return;
	//The location of the dragCenter.
	SDL_Rect r=dragCenter->getBox();

	//Loop through the selection.
	//TODO: Check if block is in sight.
	for(unsigned int o=0; o<selection.size(); o++){
	ThemeBlock* obj=objThemes.getBlock(selection[o]->type);
	if(obj){
	SDL_Rect r1=selection[o]->getBox();
	obj->editorPicture.draw(placement,(r1.x-r.x)+x-camera.x,(r1.y-r.y)+y-camera.y);
	}
	}
	}

	void LevelEditor::showConfigure(){
	//arrow animation value. go through 0-65535 and loops.
	static unsigned short arrowAnimation=0;
	arrowAnimation++;

	//By default use black color for arrows.
	Uint32 color=0x00000000;

	//Theme can change the color.
	//TODO: use the actual color from the theme.
	if(themeTextColor.r>128 && themeTextColor.g>128 && themeTextColor.b>128)
	color=0xffffffff;

	//Draw the trigger lines.
	{
	map<GameObject,vector<GameObject> >::iterator it;
	for(it=triggers.begin();it!=triggers.end();++it){
	//Check if the trigger has linked targets.
	if(!(*it).second.empty()){
	//The location of the trigger.
	SDL_Rect r=(*it).first->getBox();

	//Loop through the targets.
	for(unsigned int o=0;o<(*it).second.size();o++){
	//Get the location of the target.
	SDL_Rect r1=(*it).second[o]->getBox();

	//Draw the line from the center of the trigger to the center of the target.
	drawLineWithArrow(r.x-camera.x+25,r.y-camera.y+25,r1.x-camera.x+25,r1.y-camera.y+25,placement,color,32,arrowAnimation%32);

	//Also draw two selection marks.
	applySurface(r.x-camera.x+25-2,r.y-camera.y+25-2,selectionMark,screen,NULL);
	applySurface(r1.x-camera.x+25-2,r1.y-camera.y+25-2,selectionMark,screen,NULL);
	}
	}
	}

	//Draw a line to the mouse from the linkingTrigger when linking.
	if(linking){
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);

	//Draw the line from the center of the trigger to mouse.
	drawLineWithArrow(linkingTrigger->getBox().x-camera.x+25,linkingTrigger->getBox().y-camera.y+25,x,y,placement,color,32,arrowAnimation%32);
	}
	}

	//Draw the moving positions.
	map<GameObject*,vector<MovingPosition> >::iterator it;
	for(it=movingBlocks.begin();it!=movingBlocks.end();++it){
	//Check if the block has positions.
	if(!(*it).second.empty()){
	//The location of the moving block.
	SDL_Rect block=(*it).first->getBox();
	block.x+=25-camera.x;
	block.y+=25-camera.y;

	//The location of the previous position.
	//The first time it's the moving block's position self.
	SDL_Rect r=block;

	//Loop through the positions.
	for(unsigned int o=0;o<(*it).second.size();o++){
	//Draw the line from the center of the previous position to the center of the position.
	//x and y are the coordinates for the current moving position.
	int x=block.x+(*it).second[o].x;
	int y=block.y+(*it).second[o].y;

	//Check if we need to draw line
	double dx=r.x-x;
	double dy=r.y-y;
	double d=sqrt(dxdx+dydy);
	if(d>0.001f){
	if(it->second[o].time>0){
	//Calculate offset to contain the moving speed.
	int offset=int(d*arrowAnimation/it->second[o].time)%32;
	drawLineWithArrow(r.x,r.y,x,y,placement,color,32,offset);
	}else{
	//time==0 ???? so don't draw arrow at all
	drawLine(r.x,r.y,x,y,placement);
	}
	}

	//And draw a marker at the end.
	applySurface(x-13,y-13,movingMark,screen,NULL);

	//Get the box of the previous position.
	SDL_Rect tmp={x,y,0,0};
	r=tmp;
	}
	}
	}

	//Draw a line to the mouse from the previous moving pos.
	if(moving){
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);

	//Check if we should snap the block to grid or not.
	if(!pressedShift){
	x+=camera.x;
	y+=camera.y;
	snapToGrid(&x,&y);
	x-=camera.x;
	y-=camera.y;
	}else{
	x-=25;
	y-=25;
	}

	int posX,posY;

	//Check if there are moving positions for the moving block.
	if(!movingBlocks[movingBlock].empty()){
	//Draw the line from the center of the previouse moving positions to mouse.
	posX=movingBlocks[movingBlock].back().x;
	posY=movingBlocks[movingBlock].back().y;

	posX-=camera.x;
	posY-=camera.y;

	posX+=movingBlock->getBox().x;
	posY+=movingBlock->getBox().y;
	}else{
	//Draw the line from the center of the movingblock to mouse.
	posX=movingBlock->getBox().x-camera.x;
	posY=movingBlock->getBox().y-camera.y;
	}

	//Calculate offset to contain the moving speed.
	int offset=int(double(arrowAnimation)*movingSpeed/10.0)%32;

	drawLineWithArrow(posX+25,posY+25,x+25,y+25,placement,color,32,offset);
	applySurface(x+12,y+12,movingMark,screen,NULL);
	}

	}

	void LevelEditor::resize(){
	//Call the resize method of the Game.
	Game::resize();

	//Now update the placement surface.
	if(placement)
	SDL_FreeSurface(placement);
	placement=SDL_CreateRGBSurface(SDL_SWSURFACE\|SDL_SRCALPHA,SCREEN_WIDTH,SCREEN_HEIGHT,32,RMASK,GMASK,BMASK,0);
	SDL_SetColorKey(placement,SDL_SRCCOLORKEY\|SDL_RLEACCEL,SDL_MapRGB(placement->format,255,0,255));
	SDL_SetAlpha(placement,SDL_SRCALPHA,125);

	//Move the toolbar's position rect used for collision.
	toolbarRect.x=(SCREEN_WIDTH-460)/2;
	toolbarRect.y=SCREEN_HEIGHT-50;
	}

	//Filling the order array
	const int LevelEditor::editorTileOrder[EDITOR_ORDER_MAX]={
	TYPE_BLOCK,
	TYPE_SHADOW_BLOCK,
	TYPE_SPIKES,
	TYPE_FRAGILE,
	TYPE_MOVING_BLOCK,
	TYPE_MOVING_SHADOW_BLOCK,
	TYPE_MOVING_SPIKES,
	TYPE_CONVEYOR_BELT,
	TYPE_SHADOW_CONVEYOR_BELT,
	TYPE_BUTTON,
	TYPE_SWITCH,
	TYPE_PORTAL,
	TYPE_SWAP,
	TYPE_CHECKPOINT,
	TYPE_NOTIFICATION_BLOCK,
	TYPE_START_PLAYER,
	TYPE_START_SHADOW,
	TYPE_EXIT,
	TYPE_COLLECTABLE,
	TYPE_PUSHABLE
	};
	diff --git a/src/LevelSelect.cpp b/src/LevelSelect.cpp
	index bfc9b23..65489cc 100644
	--- a/src/LevelSelect.cpp
	+++ b/src/LevelSelect.cpp
	@@ -1,420 +1,422 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "GameState.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "Objects.h"
	#include "LevelSelect.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "GUIScrollBar.h"
	#include "InputManager.h"
	#include "Game.h"
	#ifdef __APPLE__
	#include <SDL_ttf/SDL_ttf.h>
	#else
	#include <SDL/SDL_ttf.h>
	#endif
	#include <stdio.h>
	#include <string>
	#include <sstream>
	#include <iostream>

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

	////////////////////NUMBER////////////////////////
	Number::Number(){
	image=NULL;
	number=0;
	medal=0;
	selected=false;
	locked=false;

	//Set the default dimensions.
	box.x=0;
	box.y=0;
	box.h=50;
	box.w=50;

	//Load the medals image.
	medals=loadImage(getDataPath()+"gfx/medals.png");
	}

	Number::~Number(){
	//We only need to free the SDLSurface.
	if(image) SDL_FreeSurface(image);
	}

	void Number::init(int number,SDL_Rect box){
	//First set the number and update our status.
	this->number=number;

	//Write our text, number+1 since the counting doens't start with 0, but with 1.
	std::stringstream text;
	number++;
	text<<number;

	//Create the text image.
	SDL_Color black={0,0,0};
	if(image) SDL_FreeSurface(image);
	//Create the text image.
	//Also check which font to use, if the number is higher than 100 use the small font.
	image=TTF_RenderUTF8_Blended(fontGUI,text.str().c_str(),black);

	//Set the new location of the number.
	this->box.x=box.x;
	this->box.y=box.y;

	//Load background blocks.
	objThemes.getBlock(TYPE_BLOCK,true)->createInstance(&block);
	block.changeState("unlocked");

	objThemes.getBlock(TYPE_SHADOW_BLOCK,true)->createInstance(&blockLocked);
	blockLocked.changeState("locked");
	}

	void Number::init(std::string text,SDL_Rect box){
	//First set the number and update our status.
	this->number=-1;

	//Create the text image.
	SDL_Color black={0,0,0};
	if(image) SDL_FreeSurface(image);
	image=TTF_RenderUTF8_Blended(fontGUI,text.c_str(),black);

	//Set the new location of the number.
	this->box.x=box.x;
	this->box.y=box.y;

	//Load background blocks.
	objThemes.getBlock(TYPE_BLOCK,true)->createInstance(&block);
	block.changeState("unlocked");

	objThemes.getBlock(TYPE_SHADOW_BLOCK,true)->createInstance(&blockLocked);
	blockLocked.changeState("locked");
	}

	void Number::show(int dy){
	//First draw the background, also apply the yOffset(dy).
	if(!locked)
	block.draw(screen,box.x,box.y-dy);
	else
	blockLocked.draw(screen,box.x,box.y-dy);
	//Now draw the text image over the background.
	//We draw it centered inside the box.
	applySurface((box.x+25-(image->w/2)),box.y-dy,image,screen,NULL);

	//Draw the selection mark.
	if(selected){
	drawGUIBox(box.x,box.y-dy,50,50,screen,0xFFFFFF23);
	}

	//Draw the medal.
	if(medal>0){
	SDL_Rect r={(medal-1)*30,0,30,30};
	applySurface(box.x+30,(box.y+30)-dy,medals,screen,&r);
	}
	}

	void Number::setLocked(bool locked){
	this->locked=locked;
	}

	void Number::setMedal(int medal){
	this->medal=medal;
	}


	/////////////////////LEVEL SELECT/////////////////////
	LevelSelect::LevelSelect(string titleText,LevelPackManager::LevelPackLists packType){
	//clear the selected level
	selectedNumber=NULL;

	//Calculate the LEVELS_PER_ROW and LEVEL_ROWS if they aren't calculated already.
	calcRows();

	//Render the title.
	title=TTF_RenderUTF8_Blended(fontTitle,titleText.c_str(),themeTextColor);

	//create GUI (test only)
	GUIObject* obj;
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	GUIObjectRoot=new GUIObject(0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

	//the level select scroll bar
	levelScrollBar=new GUIScrollBar(SCREEN_WIDTH*0.9,184,16,SCREEN_HEIGHT-344,ScrollBarVertical,0,0,0,1,4,true,false);
	GUIObjectRoot->addChild(levelScrollBar);

	//level pack description
	levelpackDescription=new GUIObject(0,140,SCREEN_WIDTH,32,GUIObjectLabel,"",0,true,true,GUIGravityCenter);
	GUIObjectRoot->addChild(levelpackDescription);

	levelpacks=new GUISingleLineListBox((SCREEN_WIDTH-500)/2,104,500,32);
	levelpacks->name="cmdLvlPack";
	levelpacks->eventCallback=this;
	vector<string> v=getLevelPackManager()->enumLevelPacks(packType);
	levelpacks->item=v;
	levelpacks->value=0;

	//Check if we can find the lastlevelpack.
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	if(*i==getSettings()->getValue("lastlevelpack")){
	levelpacks->value=i-v.begin();
	}
	}

	//Get the name of the selected levelpack.
	string levelpackName=levelpacks->item[levelpacks->value];
	string s1=getUserPath(USER_DATA)+"progress/"+levelpackName+".progress";

	//Load the progress.
	levels=getLevelPackManager()->getLevelPack(v[levelpacks->value]);
	levels->loadProgress(s1);

	//And add the levelpack single line listbox to the GUIObjectRoot.
	GUIObjectRoot->addChild(levelpacks);

	obj=new GUIObject(20,20,-1,32,GUIObjectButton,_("Back"));
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->addChild(obj);

	section=1;
	}

	LevelSelect::~LevelSelect(){
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	levelScrollBar=NULL;
	levelpackDescription=NULL;

	selectedNumber=NULL;

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

	void LevelSelect::calcRows(){
	//Calculate the number of rows and the number of levels per row.
	LEVELS_PER_ROW=(SCREEN_WIDTH*0.8)/64;
	int LEVEL_ROWS=(SCREEN_HEIGHT-344)/64;
	LEVELS_DISPLAYED_IN_SCREEN=LEVELS_PER_ROW*LEVEL_ROWS;
	}

	void LevelSelect::selectNumberKeyboard(int x,int y){
	if(section==2){
	//Move selection
	int realNumber=0;
	if(selectedNumber)
	realNumber=selectedNumber->getNumber()+x+(y*LEVELS_PER_ROW);

	//If selection is outside of the map grid, change section
	if(realNumber<0 \|\| realNumber>(int)numbers.size()-1){
	section=1;
	for(int i=0;i<levels->getLevelCount();i++){
	numbers[i].selected=false;
	refresh();
	}
	}else{
	//If not, move selection
	if(!numbers[realNumber].getLocked()){
	for(int i=0;i<levels->getLevelCount();i++){
	numbers[i].selected=(i==realNumber);
	}
	selectNumber(realNumber,false);
	}
	}
	}else if(section==1){
	//Loop through levelpacks and update GUI
	levelpacks->value+=x;

	if(levelpacks->value<0){
	levelpacks->value=levelpacks->item.size()-1;
	}else if(levelpacks->value>(int)levelpacks->item.size()-1){
	levelpacks->value=0;
	}

	GUIEventCallback_OnEvent("cmdLvlPack",static_cast<GUIObject*>(levelpacks),0);

	//If up is pressed, change section
	if(y==1){
	section=2;
	selectNumber(0,false);
	numbers[0].selected=true;
	}
	}else{
	section=clamp(section+y,0,2);
	}
	}

	void LevelSelect::handleEvents(){
	//Check for an SDL_QUIT event.
	if(event.type==SDL_QUIT){
	setNextState(STATE_EXIT);
	}

	//Check for a mouse click.
	if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT){
	checkMouse();
	}

	//Check focus movement
	if(inputMgr.isKeyDownEvent(INPUTMGR_RIGHT)){
	selectNumberKeyboard(1,0);
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_LEFT)){
	selectNumberKeyboard(-1,0);
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_UP)){
	selectNumberKeyboard(0,-1);
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_DOWN)){
	selectNumberKeyboard(0,1);
	}

	//Check if enter is pressed
	if(section==2 && inputMgr.isKeyUpEvent(INPUTMGR_SELECT)){
	selectNumber(selectedNumber->getNumber(),true);
	}

	//Check if escape is pressed.
	if(inputMgr.isKeyUpEvent(INPUTMGR_ESCAPE)){
	setNextState(STATE_MENU);
	}

	//Check for scrolling down and up.
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELDOWN && levelScrollBar){
	if(levelScrollBar->value<levelScrollBar->maxValue) levelScrollBar->value++;
	return;
	}else if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELUP && levelScrollBar){
	if(levelScrollBar->value>0) levelScrollBar->value--;
	return;
	}
	}

	void LevelSelect::checkMouse(){
	int x,y,dy=0,m=numbers.size();

	//Get the current mouse location.
	SDL_GetMouseState(&x,&y);

	//Check if there's a scrollbar, if so get the value.
	if(levelScrollBar)
	dy=levelScrollBar->value;
	//Upper bound of levels we'd like to display.
	if(m>dy*LEVELS_PER_ROW+LEVELS_DISPLAYED_IN_SCREEN)
	m=dy*LEVELS_PER_ROW+LEVELS_DISPLAYED_IN_SCREEN;
	y+=dy*64;

	SDL_Rect mouse={x,y,0,0};

	for(int n=dy*LEVELS_PER_ROW; n<m; n++){
	if(!numbers[n].getLocked()){
	if(checkCollision(mouse,numbers[n].box)==true){
	if(numbers[n].selected){
	selectNumber(n,true);
	}else{
	//Select current level
	for(int i=0;i<levels->getLevelCount();i++){
	numbers[i].selected=(i==n);
	}
	selectNumber(n,false);
	}
	section=2;
	break;
	}
	}
	}
	}

	void LevelSelect::logic(){}

	void LevelSelect::render(){
	int x,y,dy=0,m=numbers.size();
	int idx=-1;

	//Get the current mouse location.
	SDL_GetMouseState(&x,&y);

	if(levelScrollBar)
	dy=levelScrollBar->value;
	//Upper bound of levels we'd like to display.
	if(m>dy*LEVELS_PER_ROW+LEVELS_DISPLAYED_IN_SCREEN)
	m=dy*LEVELS_PER_ROW+LEVELS_DISPLAYED_IN_SCREEN;
	y+=dy*64;

	SDL_Rect mouse={x,y,0,0};

	//Draw background.
	objThemes.getBackground(true)->draw(screen);
	objThemes.getBackground(true)->updateAnimation();
	//Draw the title.
	applySurface((SCREEN_WIDTH-title->w)/2,40-TITLE_FONT_RAISE,title,screen,NULL);

	//Loop through the level blocks and draw them.
	for(int n=dy*LEVELS_PER_ROW;n<m;n++){
	numbers[n].show(dy*64);
	- if(numbers[n].getLocked()==false && checkCollision(mouse,numbers[n].box)==true)
	+ if(numbers[n].getLocked()==false && checkCollision(mouse,numbers[n].box)==true){
	idx=n;
	+ currentCursor=CURSOR_POINT;
	+ }
	}

	//Show the tool tip text.
	if(idx>=0){
	renderTooltip(idx,dy);
	}
	}

	void LevelSelect::resize(){
	calcRows();
	refresh(false);

	//NOTE: We don't need to recreate the listbox and the back button, only resize the list.
	levelpacks->left=(SCREEN_WIDTH-500)/2;
	levelpackDescription->width = SCREEN_WIDTH;
	}

	void LevelSelect::GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	if(name=="cmdLvlPack"){
	getSettings()->setValue("lastlevelpack",static_cast<GUISingleLineListBox*>(obj)->item[obj->value]);
	}else if(name=="cmdBack"){
	setNextState(STATE_MENU);
	return;
	}else{
	return;
	}

	//new: reset the level list scroll bar
	if(levelScrollBar)
	levelScrollBar->value=0;

	string s1=getUserPath(USER_DATA)+"progress/"+static_cast<GUISingleLineListBox*>(obj)->item[obj->value]+".progress";
	levels=getLevelPackManager()->getLevelPack(static_cast<GUISingleLineListBox*>(obj)->item[obj->value]);
	//Load the progress file.
	levels->loadProgress(s1);

	//And refresh the numbers.
	refresh();
	}
	diff --git a/src/Main.cpp b/src/Main.cpp
	index a5413b1..28b789d 100644
	--- a/src/Main.cpp
	+++ b/src/Main.cpp
	@@ -1,240 +1,244 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "Functions.h"
	#include "Timer.h"
	#include "Objects.h"
	#include "Globals.h"
	#include "TitleMenu.h"
	#include "GUIObject.h"
	#include "InputManager.h"
	#include "MD5.h"
	#include "StatisticsManager.h"
	#include <SDL/SDL.h>
	#include <stdlib.h>
	#include <time.h>
	#include <stdio.h>
	#include <string.h>

	#ifdef HARDWARE_ACCELERATION
	#include <GL/gl.h>
	#include <GL/glu.h>
	#endif

	//Variables for recording.
	//To enable picture recording uncomment the next line:
	//#define RECORD_PICUTRE_SEQUENCE
	#ifdef RECORD_PICUTRE_SEQUENCE
	bool recordPictureSequence=false;
	int recordPictureIndex=0;
	#endif
	#ifdef __APPLE__
	int SDL_main(int argc, char** argv) {
	#else
	int main(int argc, char** argv) {
	#endif
	#ifdef _MSC_VER
	//Fix the non-latin file name bug under Visual Studio
	setlocale(LC_ALL,"");
	#endif

	//First parse the comand line arguments.
	int s=parseArguments(argc,argv);
	if(s==-1){
	printf("Usage: %s [OPTIONS] ...\n",argv[0]);
	printf("%s","Available options:\n");
	printf(" %-5s%-30s %s\n","","--data-dir <dir>","Specifies the data directory.");
	printf(" %-5s%-30s %s\n","","--user-dir <dir>","Specifies the user preferences directory.");
	printf(" %-5s%-30s %s\n","-f,","--fullscreen","Run the game fullscreen.");
	printf(" %-5s%-30s %s\n","-w,","--windowed","Run the game windowed.");
	printf(" %-5s%-30s %s\n","-mv,","--music <volume>","Set the music volume.");
	printf(" %-5s%-30s %s\n","-sv,","--sound <volume>","Set the sound volume.");
	printf(" %-5s%-30s %s\n","-s,","--set <setting> <value>","Change a setting to a given value.");
	printf(" %-5s%-30s %s\n","-v,","--version","Display the version and quit.");
	printf(" %-5s%-30s %s\n","-h,","--help","Display this help message.");
	return 0;
	}else if(s==0){
	return 0;
	}

	//Try to configure the dataPath, userPath, etc...
	if(configurePaths()==false){
	fprintf(stderr,"FATAL ERROR: Failed to configure paths.\n");
	return 1;
	}
	//Load the settings.
	if(loadSettings()==false){
	fprintf(stderr,"FATAL ERROR: Failed to load config file.\n");
	return 1;
	}
	//Initialise some stuff like SDL, the window, SDL_Mixer.
	if(init()==false) {
	fprintf(stderr,"FATAL ERROR: Failed to initalize game.\n");
	return 1;
	}
	//Load some important files like the background music, default theme.
	if(loadFiles()==false){
	fprintf(stderr,"FATAL ERROR: Failed to load necessary files.\n");
	return 1;
	}

	//Seed random.
	srand((unsigned)time(NULL));

	//Set the currentState id to the main menu and create it.
	stateID=STATE_MENU;
	currentState=new Menu();

	//Set the fadeIn value to zero.
	int fadeIn=0;

	//Keep the last resize event, this is to only process one.
	SDL_Event lastResize={};

	//Start the game loop.
	while(stateID!=STATE_EXIT){
	//We start the timer.
	timer.start();

	//Loop the SDL events.
	while(SDL_PollEvent(&event)){
	//Check if user resizes the window.
	if(event.type==SDL_VIDEORESIZE){
	lastResize=event;

	//Don't let other objects process this event (?)
	continue;
	}

	//Check if the fullscreen toggle shortcut is pressed (Alt+Enter).
	if(event.type==SDL_KEYUP && event.key.keysym.sym==SDLK_RETURN && (event.key.keysym.mod & KMOD_ALT)){
	getSettings()->setValue("fullscreen",getSettings()->getBoolValue("fullscreen")?"0":"1");

	//We need to create a new screen.
	if(!createScreen()){
	//Screen creation failed so set to safe settings.
	getSettings()->setValue("fullscreen","0");
	getSettings()->setValue("width","800");
	getSettings()->setValue("height","600");

	//Try it with the safe settings.
	if(!createScreen()){
	//Everything fails so quit.
	setNextState(STATE_EXIT);
	cerr<<"ERROR: Unable to create screen."<<endl;
	}
	}

	//The screen is created, now load the (menu) theme.
	if(!loadTheme("")){
	//Loading the theme failed so quit.
	setNextState(STATE_EXIT);
	cerr<<"ERROR: Unable to load theme after toggling fullscreen."<<endl;
	}

	//Don't let other objects process this event.
	continue;
	}

	#ifdef RECORD_PICUTRE_SEQUENCE
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_F10){
	recordPictureSequence=!recordPictureSequence;
	printf("Record Picture Sequence %s\n",recordPictureSequence?"ON":"OFF");
	}
	#endif
	+ if(currentCursor!=CURSOR_REMOVE)
	+ currentCursor=CURSOR_NORMAL;
	//Let the input manager handle the events.
	inputMgr.updateState(true);
	//Let the currentState handle the events.
	currentState->handleEvents();
	//Also pass the events to the GUI.
	GUIObjectHandleEvents();
	}

	//Process the resize event.
	if(lastResize.type==SDL_VIDEORESIZE){
	event=lastResize;
	onVideoResize();

	//After resize we erase the event type
	lastResize.type=SDL_NOEVENT;
	}

	//maybe we should add a check here (??) to fix some bugs (ticket #47)
	if(nextState!=STATE_NULL){
	fadeIn=17;
	changeState();
	}
	if(stateID==STATE_EXIT) break;

	//update input state (??)
	inputMgr.updateState(false);
	//Now it's time for the state to do his logic.
	currentState->logic();
	-
	+
	currentState->render();
	//TODO: Shouldn't the gamestate take care of rendering the GUI?
	if(GUIObjectRoot) GUIObjectRoot->render();

	//draw new achievements (if any)
	statsMgr.render();

	//draw fading effect
	if(fadeIn>0&&fadeIn<255){
	SDL_BlitSurface(screen,NULL,tempSurface,NULL);
	SDL_FillRect(screen,NULL,0);
	SDL_SetAlpha(tempSurface, SDL_SRCALPHA, fadeIn);
	SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	fadeIn+=17;
	}

	#ifdef RECORD_PICUTRE_SEQUENCE
	if(recordPictureSequence){
	char s[64];
	recordPictureIndex++;
	sprintf(s,"pic%08d.bmp",recordPictureIndex);
	printf("Save screen to %s\n",s);
	SDL_SaveBMP(screen,(getUserPath(USER_CACHE)+s).c_str());
	}
	#endif
	+ SDL_SetCursor(cursors[currentCursor]);
	+
	//And draw the screen surface to the actual screen.
	flipScreen();

	//Check if nextState is set, meaning we should fade in and change state.
	if(nextState!=STATE_NULL){
	fadeIn=17;
	changeState();
	}

	//Now calcualte how long we need to wait to keep a constant framerate.
	int t=timer.getTicks();
	t=(1000/FPS)-t;
	if(t>0){
	SDL_Delay(t);
	}
	}

	//The game has ended, save the settings just to be sure.
	saveSettings();

	//Clean everything up.
	clean();

	//End of program.
	return 0;
	}
	diff --git a/src/Player.cpp b/src/Player.cpp
	index e629553..65dfb6f 100644
	--- a/src/Player.cpp
	+++ b/src/Player.cpp
	@@ -1,1528 +1,1529 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "Player.h"
	#include "Game.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "Objects.h"
	#include "InputManager.h"
	#include "StatisticsManager.h"
	#include "MD5.h"
	#include <iostream>
	#include <fstream>
	#include <SDL/SDL.h>
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	#include <SDL/SDL_mixer.h>
	#include <SDL/SDL_ttf.h>
	#endif
	using namespace std;

	#ifdef RECORD_FILE_DEBUG
	string recordKeyPressLog,recordKeyPressLog_saved;
	vector<SDL_Rect> recordPlayerPosition,recordPlayerPosition_saved;
	#endif

	Player::Player(Game* objParent):xVelBase(0),yVelBase(0),objParent(objParent),recordSaved(false),
	inAirSaved(false),isJumpSaved(false),onGroundSaved(false),canMoveSaved(false),holdingOtherSaved(false){
	//Set the dimensions of the player.
	//The size of the player is 21x40.
	box.x=0;
	box.y=0;
	box.w=21;
	box.h=40;

	//Set his velocity to zero.
	xVel=0;
	yVel=0;

	//Set the start position.
	fx=0;
	fy=0;

	//Set some default values.
	inAir=true;
	isJump=false;
	onGround=true;
	shadowCall=false;
	shadow=false;
	canMove=true;
	holdingOther=false;
	dead=false;
	record=false;
	downKeyPressed=false;
	spaceKeyPressed=false;
	recordIndex=-1;
	#ifdef RECORD_FILE_DEBUG
	recordKeyPressLog.clear();
	recordKeyPressLog_saved.clear();
	recordPlayerPosition.clear();
	recordPlayerPosition_saved.clear();
	#endif
	objNotificationBlock=NULL;

	//Some default values for animation variables.
	direction=0;
	jumpTime=0;

	state=stateSaved=0;

	//xVelSaved is used to store if there's a state saved or not.
	xVelSaved=yVelSaved=0x80000000;

	objCurrentStand=objLastStand=objLastTeleport=objShadowBlock=NULL;
	}

	Player::~Player(){
	//Do nothing here
	}

	bool Player::isPlayFromRecord(){
	return recordIndex>=0; // && recordIndex<(int)recordButton.size();
	}

	//get the game record object.
	std::vector<int>* Player::getRecord(){
	return &recordButton;
	}

	#ifdef RECORD_FILE_DEBUG
	string& Player::keyPressLog(){
	return recordKeyPressLog;
	}
	vector<SDL_Rect>& Player::playerPosition(){
	return recordPlayerPosition;
	}
	#endif

	//play the record.
	void Player::playRecord(){
	//TODO:
	recordIndex=0;
	}

	void Player::spaceKeyDown(class Shadow* shadow){
	//Start recording or stop, depending on the recording state.
	if(record==false){
	//We start recording.
	if(shadow->called==true){
	//The shadow is still busy so first stop him before we can start recording.
	shadowCall=false;
	shadow->called=false;
	shadow->playerButton.clear();
	}else if(!dead){
	//The shadow isn't moving and we aren't dead so start recording.
	record=true;

	//We start a recording meaning we need to increase recordings by one.
	objParent->recordings++;

	//Update statistics.
	if(!dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	statsMgr.recordTimes++;

	if(statsMgr.recordTimes==100) statsMgr.newAchievement("record100");
	if(statsMgr.recordTimes==1000) statsMgr.newAchievement("record1k");
	}
	}
	}else{
	//The player is recording so stop recording and call the shadow.
	record=false;
	shadowCall=true;
	}
	}

	void Player::handleInput(class Shadow* shadow){
	//Check if we should read the input from record file.
	//Actually, we read input from record file in
	//another function shadowSetState.
	bool readFromRecord=false;
	if(recordIndex>=0 && recordIndex<(int)recordButton.size()) readFromRecord=true;

	if(!readFromRecord){
	//Reset horizontal velocity.
	xVel=0;
	if(inputMgr.isKeyDown(INPUTMGR_RIGHT)){
	//Walking to the right.
	xVel+=7;
	}
	if(inputMgr.isKeyDown(INPUTMGR_LEFT)){
	//Walking to the left.
	if(xVel!=0 && !dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	//Horizontal confusion achievement :)
	statsMgr.newAchievement("horizontal");
	}
	xVel-=7;
	}

	//Check if a key has been released.
	if(/event.type==SDL_KEYUP \|\| /!inputMgr.isKeyDown(INPUTMGR_ACTION)){
	//It has so downKeyPressed can't be true.
	downKeyPressed=false;
	}
	/*
	//Don't reset spaceKeyPressed or when you press the space key
	//and release another key then the bug occurs. (ticket #44)
	if(event.type==SDL_KEYUP \|\| !inputMgr.isKeyDown(INPUTMGR_SPACE)){
	spaceKeyPressed=false;
	}*/
	}

	//Check if a key is pressed (down).
	if(inputMgr.isKeyDownEvent(INPUTMGR_JUMP) && !readFromRecord){
	//The up key, if we aren't in the air we start jumping.
	//Fixed a potential bug
	if(!inAir && !isJump){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Jump key pressed\n",objParent->time);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	isJump=true;
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_SPACE) && !readFromRecord){
	//Fixed a potential bug
	if(!spaceKeyPressed){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Space key pressed\n",objParent->time);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	spaceKeyDown(shadow);
	spaceKeyPressed=true;
	}
	}else if(inputMgr.isKeyUpEvent(INPUTMGR_SPACE) && !readFromRecord){
	if(record && getSettings()->getBoolValue("quickrecord")){
	spaceKeyDown(shadow);
	spaceKeyPressed=true;
	}
	}else if(record && !readFromRecord && inputMgr.isKeyDownEvent(INPUTMGR_CANCELRECORDING)){
	//Cancel current recording

	//Search the recorded button and clear the last space key press
	int i=recordButton.size()-1;
	for(;i>=0;i--){
	if(recordButton[i] & PlayerButtonSpace){
	recordButton[i] &= ~PlayerButtonSpace;
	break;
	}
	}

	if(i>=0){
	//Clear the recording at the player's side.
	playerButton.clear();
	line.clear();

	//reset the record flag
	record=false;

	//decrese the record count
	objParent->recordings--;
	}else{
	cout<<"Failed to find last recording"<<endl;
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_ACTION)){
	//Downkey is pressed.
	//Fixed a potential bug
	if(!downKeyPressed){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Action key pressed\n",objParent->time);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	downKeyPressed=true;
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_SAVE)){
	//F2 only works in the level editor.
	if(!(dead \|\| shadow->dead) && stateID==STATE_LEVEL_EDITOR){
	//Save the state. (delayed)
	if(objParent)
	objParent->saveStateNextTime=true;
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_LOAD) && !readFromRecord){
	//F3 is used to load the last state.
	if(objParent)
	objParent->loadStateNextTime=true;
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_SWAP)){
	//F4 will swap the player and the shadow, but only in the level editor.
	if(!(dead \|\| shadow->dead) && stateID==STATE_LEVEL_EDITOR){
	swapState(shadow);
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_TELEPORT)){
	//F5 will revive and teleoprt the player to the cursor. Only works in the level editor.
	//Shift+F5 teleports the shadow.
	if(stateID==STATE_LEVEL_EDITOR){
	//get the position of the cursor.
	int x,y;
	SDL_GetMouseState(&x,&y);
	x+=camera.x;
	y+=camera.y;

	if(inputMgr.isKeyDown(INPUTMGR_SHIFT)){
	//teleports the shadow.
	shadow->dead=false;
	shadow->box.x=x;
	shadow->box.y=y;
	}else{
	//teleports the player.
	dead=false;
	box.x=x;
	box.y=y;
	}

	//play sound?
	if(getSettings()->getBoolValue("sound")){
	Mix_PlayChannel(-1,swapSound,0);
	}
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_SUICIDE)){
	//F12 is suicide and only works in the leveleditor.
	if(stateID==STATE_LEVEL_EDITOR){
	die();
	shadow->die();
	}
	}
	}

	void Player::setPosition(int x,int y){
	box.x=x;
	box.y=y;
	}

	void Player::move(vector<GameObject*> &levelObjects){
	//Pointer to a checkpoint.
	GameObject* objCheckPoint=NULL;
	//Pointer to a swap.
	GameObject* objSwap=NULL;

	//Set the objShadowBlock to NULL.
	//Only for swapping to prevent the shadow from swapping in a shadow block.
	objShadowBlock=NULL;

	//Set the objNotificationBlock to NULL.
	objNotificationBlock=NULL;

	//Set the object the player is currently standing to NULL.
	objCurrentStand=NULL;

	//Check if the player is still alive.
	if(dead==false){
	//Add gravity acceleration to the vertical velocity.
	//NOTE: The x velocity is already set during the input handling, so is the jumping.
	if(inAir==true){
	yVel+=1;

	//Cap fall speed to 13.
	if(yVel>13){
	yVel=13;
	}
	}

	//An array that will hold all the GameObjects that are involved in the collision/movement.
	vector<GameObject*> objects;

	//Determine the collision frame.
	SDL_Rect frame={box.x,box.y,box.w,box.h};
	//Keep the horizontal movement of the player in mind.
	if(xVel+xVelBase>=0) {
	frame.w+=(xVel+xVelBase);
	}else{
	frame.x+=(xVel+xVelBase);
	frame.w-=(xVel+xVelBase);
	}
	//And the vertical movement.
	if(yVel+yVelBase>=0) {
	frame.h+=(yVel+yVelBase);
	}else{
	frame.y+=(yVel+yVelBase);
	frame.h-=(yVel+yVelBase);
	}

	//Loop through the game objects.
	for(unsigned int o=0; o<levelObjects.size(); o++){
	//Check if the player can collide with this game object.
	if(!levelObjects[o]->queryProperties(GameObjectProperty_PlayerCanWalkOn,this))
	continue;

	//Check if the block is inside the frame.
	if(checkCollision(frame,levelObjects[o]->getBox())){
	objects.push_back(levelObjects[o]);
	continue;
	}

	//Additional checks need to be made for moving blocks.
	if(levelObjects[o]->type==TYPE_MOVING_BLOCK \|\| levelObjects[o]->type==TYPE_MOVING_SHADOW_BLOCK \|\| levelObjects[o]->type==TYPE_MOVING_SPIKES) {
	//Check the movement of these blocks to see if they will collide.
	SDL_Rect v=levelObjects[o]->getBox(BoxType_Velocity);
	SDL_Rect r=levelObjects[o]->getBox();
	r.x+=v.x;
	r.y+=v.y;
	if(checkCollision(frame,r)) {
	objects.push_back(levelObjects[o]);
	}
	}
	}

	//Boolean if the player is moved, used for squash detection.
	bool playerMoved=false;
	//Indicates player or shadow is traveling, we should add it to traveling distance
	bool isTraveling=true;
	//The current location of the player, used to set the player back if he's squashed to prevent displacement.
	int lastX=box.x;
	int lastY=box.y;

	//Check if the player can move.
	if(canMove==true){
	//Move the player.
	box.x+=xVel;

	//Loop through the objects related to the (horizontal) collision/movement.
	for(unsigned int o=0; o<objects.size(); o++){
	//Get the collision box of the levelobject.
	SDL_Rect r=objects[o]->getBox();

	//Check collision with the player.
	//NOTE: Although the object is inside the collision frame we need to check if it collides with the player box (xVel applied).
	if(checkCollision(box,r)){
	//We have collision, get the velocity of the box.
	SDL_Rect v=objects[o]->getBox(BoxType_Delta);

	//Check on which side of the box the player is.
	if(box.x + box.w/2 <= r.x + r.w/2){
	//The left side of the block.
	if(xVel+xVelBase>v.x){
	if(box.x>r.x-box.w){
	playerMoved=true;

	//In case of a pushable block we give it velocity.
	if(objects[o]->type==TYPE_PUSHABLE){
	(dynamic_cast<Block*>(objects[o]))->xVel=(xVel+xVelBase)/2;
	}
	box.x=r.x-box.w;
	}
	}
	}else{
	//The right side of the block.
	if(xVel+xVelBase<v.x){
	if(box.x<r.x+r.w){
	playerMoved=true;

	//In case of a pushable block we give it velocity.
	if(objects[o]->type==TYPE_PUSHABLE){
	(dynamic_cast<Block*>(objects[o]))->xVel=(xVel+xVelBase)/2;
	}
	box.x=r.x+r.w;
	}
	}
	}
	}
	}
	}

	//Now apply the yVel. (gravity, jumping, etc..)
	box.y+=yVel;

	//Pointer to the object the player standed on.
	GameObject* lastStand=NULL;

	//Assume we are in air and are able to move unless proven otherwise (???).
	inAir=true;
	canMove=true;

	//Boolean if the player can teleport.
	bool canTeleport=true;

	//Loop through all the objects related to the (vertical) collision/movement.
	for(unsigned int o=0; o<objects.size(); o++){
	//Get the collision box of the levelobject.
	SDL_Rect r=objects[o]->getBox();

	//NOTE: Although the object is inside the collision frame we need to check if it collides with the player box (yVel applied).
	if(checkCollision(box,r)){
	//Get the velocity of the gameobject.
	SDL_Rect v=objects[o]->getBox(BoxType_Delta);

	//Check which side of the object the player is.
	if(box.y+box.h/2<=r.y+r.h/2){
	if(yVel>=v.y \|\| yVel>=0){
	inAir=false;
	//NOTE: We don't set the new position here, since that is done later for proper lastStand.
	yVel=1;

	//Check if there's already a lastStand.
	if(lastStand){
	//There is one, so check 'how much' the player is on the blocks.
	SDL_Rect r=objects[o]->getBox();
	int w=0;
	if(box.x+box.w>r.x+r.w){
	w=(r.x+r.w)-box.x;
	}else{
	w=(box.x+box.w)-r.x;
	}

	//Do the same for the other box.
	r=lastStand->getBox();
	int w2=0;
	if(box.x+box.w>r.x+r.w){
	w2=(r.x+r.w)-box.x;
	}else{
	w2=(box.x+box.w)-r.x;
	}

	//NOTE: It doesn't matter which block the player is on if they are both stationary.
	SDL_Rect v=objects[o]->getBox(BoxType_Velocity);
	SDL_Rect v2=lastStand->getBox(BoxType_Velocity);
	bool s=(v.x==0 && v.y==0);
	bool s2=(v2.x==0 && v2.y==0);

	//Check if both are stationary.
	if(s && s2){
	//NOTE: We could ignore on which the player is standing, but for 'future proofness' (e.g. scripting) we calculate it.
	if(w>w2)
	lastStand=objects[o];
	}else{
	//At least one of them is moving, check upwards movement.
	//NOTE: No matter how far the player is on the moving block, if it moves upwards, take him with him.
	if(!s && v.y>v2.y){
	lastStand=objects[o];
	}else{
	//Now check for horizontal movement.
	if(w>w2)
	lastStand=objects[o];
	else if(w==w2 && s2)
	lastStand=objects[o];
	}
	}
	}else{
	lastStand=objects[o];
	}
	objects[o]->onEvent(GameObjectEvent_PlayerIsOn);

	//The player is moved, if it's a moving block check for squating.
	if(v.y!=0){
	playerMoved=true;
	}
	}
	}else{
	//FIXME: The player can have a yVel of 0 and get squashed if he is standing on the other.
	bool holding=objParent->shadow.holdingOther;
	if(shadow)
	holding=objParent->player.holdingOther;
	if(yVel<=v.y+1 \|\| holding){
	yVel=v.y>0?v.y:0;
	if(box.y<r.y+r.h){
	if(!holding)
	box.y=r.y+r.h;

	//The player is moved, if it's a moving block check for squating.
	if(v.y!=0){
	playerMoved=true;
	}
	}
	}
	}
	}
	}

	//Now handle the previously skipped lastStand correction.
	if(lastStand)
	box.y=lastStand->getBox().y-box.h;

	//Check if the player was moved, if so check if the player is squashed.
	if(playerMoved){
	for(unsigned int o=0;o<levelObjects.size();o++){
	SDL_Rect r2=levelObjects[o]->getBox();
	if(levelObjects[o]->queryProperties(GameObjectProperty_PlayerCanWalkOn,this) && checkCollision(box,r2)){
	//The player is squashed so first move him back.
	box.x=lastX;
	box.y=lastY;

	//Update statistics.
	if(!dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	if(shadow) statsMgr.shadowSquashed++;
	else statsMgr.playerSquashed++;

	switch(statsMgr.playerSquashed+statsMgr.shadowSquashed){
	case 1:
	statsMgr.newAchievement("squash1");
	break;
	case 50:
	statsMgr.newAchievement("squash50");
	break;
	}
	}

	//Now call the die method.
	die();
	}
	}
	}

	//Check if the player fell of the level, if so let him die but without animation.
	if(box.y>LEVEL_HEIGHT)
	die(false);

	//Check if the player changed blocks, meaning stepped onto a block.
	objCurrentStand=lastStand;
	if(lastStand!=objLastStand){
	objLastStand=lastStand;
	if(lastStand){
	//Call the walk on event of the laststand.
	lastStand->onEvent(GameObjectEvent_PlayerWalkOn);

	//Bugfix for Fragile blocks.
	if(lastStand->type==TYPE_FRAGILE && !lastStand->queryProperties(GameObjectProperty_PlayerCanWalkOn,this)){
	inAir=true;
	onGround=false;
	isJump=false;
	}
	}
	}

	//Now check the functional blocks.
	for(unsigned int o=0;o<levelObjects.size();o++){
	//Check for collision.
	if(checkCollision(box,levelObjects[o]->getBox())){
	//Now switch the type.
	switch(levelObjects[o]->type){
	case TYPE_CHECKPOINT:
	{
	//If we're not the shadow set the gameTip to Checkpoint.
	if(!shadow && objParent!=NULL)
	objParent->gameTipIndex=TYPE_CHECKPOINT;

	//And let objCheckPoint point to this object.
	objCheckPoint=levelObjects[o];
	break;
	}
	case TYPE_SWAP:
	{
	//If we're not the shadow set the gameTip to swap.
	if(!shadow && objParent!=NULL)
	objParent->gameTipIndex=TYPE_SWAP;

	//And let objSwap point to this object.
	objSwap=levelObjects[o];
	break;
	}
	case TYPE_EXIT:
	{
	//Make sure we're not in the leveleditor.
	if(stateID==STATE_LEVEL_EDITOR)
	break;

	//Check to see if we have enough keys to finish the level
	if(objParent->currentCollectables>=objParent->totalCollectables){
	//We can't just handle the winning here (in the middle of the update cycle)/
	//So set won in Game true.
	objParent->won=true;
	}
	break;
	}
	case TYPE_PORTAL:
	{
	//Check if the teleport id isn't empty.
	if((dynamic_cast<Block*>(levelObjects[o]))->id.empty()){
	cerr<<"Warning: Invalid teleport id!"<<endl;
	canTeleport=false;
	}

	//If we're not the shadow set the gameTip to portal.
	if(!shadow && objParent!=NULL)
	objParent->gameTipIndex=TYPE_PORTAL;

	//Check if we can teleport and should (downkey -or- auto).
	if(canTeleport && (downKeyPressed \|\| (levelObjects[o]->queryProperties(GameObjectProperty_Flags,this)&1))){
	canTeleport=false;
	if(downKeyPressed \|\| levelObjects[o]!=objLastTeleport){
	downKeyPressed=false;

	//Loop the levelobjects again to find the destination.
	for(unsigned int oo=o+1;;){
	//We started at our index+1.
	//Meaning that if we reach the end of the vector then we need to start at the beginning.
	if(oo>=levelObjects.size())
	oo-=(int)levelObjects.size();
	//It also means that if we reach the same index we need to stop.
	//If the for loop breaks this way then we have no succes.
	if(oo==o){
	//Couldn't teleport so play the error sound.
	if(getSettings()->getBoolValue("sound")){
	Mix_PlayChannel(-1,errorSound,0);
	}
	break;
	}

	//Check if the second (oo) object is a portal.
	if(levelObjects[oo]->type==TYPE_PORTAL){
	//Check the id against the destination of the first portal.
	if((dynamic_cast<Block>(levelObjects[o]))->destination==(dynamic_cast<Block>(levelObjects[oo]))->id){
	//Call the event.
	levelObjects[o]->onEvent(GameObjectEvent_OnToggle);
	objLastTeleport=levelObjects[oo];

	//Get the destination location and teleport the player.
	SDL_Rect r=levelObjects[oo]->getBox();
	box.x=r.x+5;
	box.y=r.y+2;

	//We don't count it to traveling distance.
	isTraveling=false;

	//Check if music/sound is enabled.
	if(getSettings()->getBoolValue("sound")){
	Mix_PlayChannel(-1,swapSound,0);
	}
	break;
	}
	}

	//Increase oo.
	oo++;
	}
	}
	}
	break;
	}
	case TYPE_SWITCH:
	{
	//If we're not the shadow set the gameTip to switch.
	if(!shadow && objParent!=NULL)
	objParent->gameTipIndex=TYPE_SWITCH;

	//If the down key is pressed then invoke an event.
	if(downKeyPressed){
	//Play the animation.
	levelObjects[o]->playAnimation(1);

	//Check if sound is enabled, if so play the toggle sound.
	if(getSettings()->getBoolValue("sound")==true){
	Mix_PlayChannel(-1,toggleSound,0);
	}

	//Update statistics.
	if(!dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	statsMgr.switchTimes++;
	//TODO: achievements
	}

	if(objParent!=NULL){
	//Make sure that the id isn't emtpy.
	if(!(dynamic_cast<Block*>(levelObjects[o]))->id.empty()){
	objParent->broadcastObjectEvent(0x10000 \| (levelObjects[o]->queryProperties(GameObjectProperty_Flags,this)&3),
	-1,(dynamic_cast<Block*>(levelObjects[o]))->id.c_str());
	}else{
	cerr<<"Warning: invalid switch id!"<<endl;
	}
	}
	}
	break;
	}
	case TYPE_SHADOW_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	{
	//This only applies to the player.
	if(!shadow)
	objShadowBlock=levelObjects[o];
	break;
	}
	case TYPE_NOTIFICATION_BLOCK:
	{
	//This only applies to the player.
	if(!shadow)
	objNotificationBlock=levelObjects[o];
	break;
	}
	case TYPE_COLLECTABLE:
	{
	//Check if collectable is active (if it's not it's equal to 1(inactive))
	if(levelObjects[o]->queryProperties(GameObjectProperty_Flags, this)==0) {
	//Toggle an event
	levelObjects[o]->onEvent(GameObjectEvent_OnToggle);
	//Increase the current number of collectables
	objParent->currentCollectables++;
	if(getSettings()->getBoolValue("sound"))
	Mix_PlayChannel(-1,collectSound,0);
	//Open exit(s)
	if(objParent->currentCollectables>=objParent->totalCollectables){
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(levelObjects[i]->type==TYPE_EXIT){
	Block obj=dynamic_cast<Block>(levelObjects[i]);
	if(obj!=NULL){
	levelObjects[i]->onEvent(GameObjectEvent_OnSwitchOn);
	}
	}
	}
	}
	}
	break;
	}
	}

	//Now check for the spike property.
	if(levelObjects[o]->queryProperties(GameObjectProperty_IsSpikes,this)){
	//It is so get the collision box.
	SDL_Rect r=levelObjects[o]->getBox();

	//TODO: pixel-accuracy hit test.
	//For now we shrink the box.
	r.x+=2;
	r.y+=2;
	r.w-=4;
	r.h-=4;

	//Check collision, if the player collides then let him die.
	if(checkCollision(box,r)){
	die();
	}
	}
	}
	}

	//Check if the player can teleport.
	if(canTeleport)
	objLastTeleport=NULL;

	//Check the checkpoint pointer only if the downkey is pressed.
	//new: don't save the game if playing game record
	if(objParent!=NULL && downKeyPressed && objCheckPoint!=NULL && !isPlayFromRecord()){
	//Checkpoint thus save the state.
	if(objParent->canSaveState()){
	objParent->saveStateNextTime=true;
	objParent->objLastCheckPoint=objCheckPoint;
	}
	}
	//Check the swap pointer only if the down key is pressed.
	if(objSwap!=NULL && downKeyPressed && objParent!=NULL){
	//Now check if the shadow we're the shadow or not.
	if(shadow){
	if(!(dead \|\| objParent->player.dead)){
	//Check if the player isn't in front of a shadow block.
	if(!objParent->player.objShadowBlock){
	objParent->player.swapState(this);
	objSwap->playAnimation(1);
	//We don't count it to traveling distance.
	isTraveling=false;
	//Note: Statistics updated in swapState() function.
	}else{
	//We can't swap so play the error sound.
	if(getSettings()->getBoolValue("sound")==true){
	Mix_PlayChannel(-1,errorSound,0);
	}
	}
	}
	}else{
	if(!(dead \|\| objParent->shadow.dead)){
	//Check if the player isn't in front of a shadow block.
	if(!objShadowBlock){
	swapState(&objParent->shadow);
	objSwap->playAnimation(1);
	//We don't count it to traveling distance.
	isTraveling=false;
	//Note: Statistics updated in swapState() function.
	}else{
	//We can't swap so play the error sound.
	if(getSettings()->getBoolValue("sound")==true){
	Mix_PlayChannel(-1,errorSound,0);
	}
	}
	}
	}
	}

	//Determine the correct theme state.
	if(!dead){
	//Set the direction depending on the velocity.
	if(xVel>0)
	direction=0;
	else if(xVel<0)
	direction=1;

	//Check if the player is in the air.
	if(!inAir){
	//On the ground so check the direction and movement.
	if(xVel>0){
	if(appearance.currentStateName!="walkright"){
	appearance.changeState("walkright");
	}
	}else if(xVel<0){
	if(appearance.currentStateName!="walkleft"){
	appearance.changeState("walkleft");
	}
	}else if(xVel==0){
	if(direction==1){
	appearance.changeState("standleft");
	}else{
	appearance.changeState("standright");
	}
	}
	}else{
	//Check for jump appearance (inAir).
	if(direction==1){
	if(yVel>0){
	if(appearance.currentStateName!="fallleft")
	appearance.changeState("fallleft");
	}else{
	if(appearance.currentStateName!="jumpleft")
	appearance.changeState("jumpleft");
	}
	}else{
	if(yVel>0){
	if(appearance.currentStateName!="fallright")
	appearance.changeState("fallright");
	}else{
	if(appearance.currentStateName!="jumpright")
	appearance.changeState("jumpright");
	}
	}
	}
	}


	+
	//Update traveling distance statistics.
	if(isTraveling && (lastX!=box.x \|\| lastY!=box.y) && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	float dx=float(lastX-box.x),dy=float(lastY-box.y);
	float d0=statsMgr.playerTravelingDistance+statsMgr.shadowTravelingDistance,
	d=sqrtf(dxdx+dydy)/50.0f;
	if(shadow) statsMgr.shadowTravelingDistance+=d;
	else statsMgr.playerTravelingDistance+=d;

	//Update achievement
	d+=d0;
	if(d0<=100.0f && d>=100.0f) statsMgr.newAchievement("travel100");
	if(d0<=1000.0f && d>=1000.0f) statsMgr.newAchievement("travel1k");
	if(d0<=10000.0f && d>=10000.0f) statsMgr.newAchievement("travel10k");
	if(d0<=42195.0f && d>=42195.0f) statsMgr.newAchievement("travel42k");
	}
	}

	//Finally we reset some stuff.
	downKeyPressed=false;
	xVelBase=0;
	yVelBase=0;
	}


	void Player::jump(){
	//Check if the player is dead or not.
	if(dead==true){
	//The player can't jump if he's dead.
	isJump=false;
	}

	//Check if the player can jump.
	if(isJump==true && inAir==false){
	//Set the jump velocity.
	yVel=-13;
	inAir=true;
	isJump=false;
	jumpTime++;

	//Update statistics
	if(!objParent->player.isPlayFromRecord() && !objParent->interlevel){
	if(shadow) statsMgr.shadowJumps++;
	else statsMgr.playerJumps++;

	if(statsMgr.playerJumps+statsMgr.shadowJumps==1000) statsMgr.newAchievement("frog");
	}

	//Check if sound is enabled, if so play the jump sound.
	if(getSettings()->getBoolValue("sound")==true){
	Mix_PlayChannel(-1,jumpSound,0);
	}
	}
	}

	void Player::show(){
	//Check if we should render the recorded line.
	//Only do this when we're recording and we're not the shadow.
	if(shadow==false && record==true){
	//FIXME: Adding an entry not in update but in render?
	line.push_back(SDL_Rect());
	line[line.size()-1].x=box.x+11;
	line[line.size()-1].y=box.y+20;

	//Loop through the line dots and draw them.
	for(int l=0; l<(signed)line.size(); l++){
	appearance.drawState("line",screen,line[l].x-camera.x,line[l].y-camera.y,NULL);
	}
	}

	//NOTE: We do logic here, because it's only needed by the appearance.
	appearance.updateAnimation();
	appearance.draw(screen, box.x-camera.x, box.y-camera.y, NULL);
	}

	void Player::shadowSetState(){
	int currentKey=0;

	/*//debug
	extern int block_test_count;
	extern bool block_test_only;
	if(SDL_GetKeyState(NULL)[SDLK_p]){
	block_test_count=recordButton.size();
	}
	if(block_test_count==(int)recordButton.size()){
	block_test_only=true;
	}*/

	//Check if we should read the input from record file.
	if(recordIndex>=0){ // && recordIndex<(int)recordButton.size()){
	//read the input from record file
	if(recordIndex<(int)recordButton.size()){
	currentKey=recordButton[recordIndex];
	recordIndex++;
	}

	//Reset horizontal velocity.
	xVel=0;
	if(currentKey&PlayerButtonRight){
	//Walking to the right.
	xVel+=7;
	}
	if(currentKey&PlayerButtonLeft){
	//Walking to the left.
	xVel-=7;
	}

	if(currentKey&PlayerButtonJump){
	//The up key, if we aren't in the air we start jumping.
	if(inAir==false){
	isJump=true;
	}else{
	//Shouldn't go here
	cout<<"Replay BUG"<<endl;
	}
	}

	//check the down key
	downKeyPressed=(currentKey&PlayerButtonDown)!=0;

	//check the space key
	if(currentKey&PlayerButtonSpace){
	spaceKeyDown(&objParent->shadow);
	}
	}else{
	//read the input from keyboard.
	recordIndex=-1;

	//Check for xvelocity.
	if(xVel>0)
	currentKey\|=PlayerButtonRight;
	if(xVel<0)
	currentKey\|=PlayerButtonLeft;

	//Check for jumping.
	if(isJump){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Jump key recorded\n",objParent->time-1);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	currentKey\|=PlayerButtonJump;
	}

	//Check if the downbutton is pressed.
	if(downKeyPressed){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Action key recorded\n",objParent->time-1);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	currentKey\|=PlayerButtonDown;
	}

	if(spaceKeyPressed){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Space key recorded\n",objParent->time-1);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	currentKey\|=PlayerButtonSpace;
	}

	//Record it.
	recordButton.push_back(currentKey);
	}

	#ifdef RECORD_FILE_DEBUG
	if(recordIndex>=0){
	if(recordIndex>0 && recordIndex<=int(recordPlayerPosition.size())/2){
	SDL_Rect &r1=recordPlayerPosition[recordIndex*2-2];
	SDL_Rect &r2=recordPlayerPosition[recordIndex*2-1];
	if(r1.x!=box.x \|\| r1.y!=box.y \|\| r2.x!=objParent->shadow.box.x \|\| r2.y!=objParent->shadow.box.y){
	char c[192];
	sprintf(c,"Replay ERROR [%05d] %d %d %d %d Expected: %d %d %d %d\n",
	objParent->time-1,box.x,box.y,objParent->shadow.box.x,objParent->shadow.box.y,r1.x,r1.y,r2.x,r2.y);
	cout<<c;
	}
	}
	}else{
	recordPlayerPosition.push_back(box);
	recordPlayerPosition.push_back(objParent->shadow.box);
	}
	#endif

	//reset spaceKeyPressed.
	spaceKeyPressed=false;

	//Only add an entry if the player is recording.
	if(record){
	//Add the action.
	if(!dead){
	playerButton.push_back(currentKey);

	//Change the state.
	state++;
	}
	}
	}

	void Player::shadowGiveState(Shadow* shadow){
	//Check if the player calls the shadow.
	if(shadowCall==true){
	//Clear any recording still with the shadow.
	shadow->playerButton.clear();

	//Loop the recorded moves and add them to the one of the shadow.
	for(unsigned int s=0;s<playerButton.size();s++){
	shadow->playerButton.push_back(playerButton[s]);
	}

	//Reset the state of both the player and the shadow.
	stateReset();
	shadow->stateReset();

	//Clear the recording at the player's side.
	playerButton.clear();
	line.clear();

	//Set shadowCall false
	shadowCall=false;
	//And let the shadow know that the player called him.
	shadow->meCall();
	}
	}

	void Player::stateReset(){
	//Reset the state by setting it to 0.
	state=0;
	}

	void Player::otherCheck(class Player* other){
	//First make sure the player isn't dead.
	//And check for velocity of the block the player is standing on.
	if(!dead){
	if(objCurrentStand!=NULL){
	//Now get the velocity of the object the player is standing on.
	SDL_Rect v=objCurrentStand->getBox(BoxType_Velocity);

	//Set the base velocity to the velocity of the object.
	xVelBase=v.x;
	yVelBase=v.y;

	//Already move the player box.
	box.x+=v.x;
	box.y+=v.y;
	}
	}
	//Now do the same for the shadow.
	if(!other->dead){
	if(other->objCurrentStand!=NULL){
	//Now get the velocity of the object the shadow is standing on.
	SDL_Rect v=other->objCurrentStand->getBox(BoxType_Velocity);

	//Set the base velocity to the velocity of the object.
	other->xVelBase=v.x;
	other->yVelBase=v.y;

	//Already move the shadow box.
	other->box.x+=v.x;
	other->box.y+=v.y;
	}
	}

	//Now check if the player is on the shadow.
	//First make sure they are both alive.
	if(!dead && !other->dead){
	//Get the box of the shadow.
	SDL_Rect boxShadow=other->getBox();

	//Check if the player is on top of the shadow.
	if(checkCollision(box,boxShadow)==true){
	//We have collision now check if the other is standing on top of you.
	if(box.y+box.h<=boxShadow.y+13 && !other->inAir){
	int yVelocity=yVel-1;
	if(yVelocity>0){
	box.y-=yVel;
	box.y+=boxShadow.y-(box.y+box.h);
	inAir=false;
	canMove=false;
	onGround=true;
	other->holdingOther=true;
	other->appearance.changeState("holding");

	//Change our own appearance to standing.
	if(direction==1){
	appearance.changeState("standleft");
	}else{
	appearance.changeState("standright");
	}

	//Apply the velocity the shadow has.
	box.x+=other->xVelBase;
	box.y+=other->yVelBase;
	}
	}else if(boxShadow.y+boxShadow.h<=box.y+13 && !inAir){
	int yVelocity=other->yVel-1;
	if(yVelocity>0){
	other->box.y-=other->yVel;
	other->box.y+=box.y-(other->box.y+other->box.h);
	other->inAir=false;
	other->canMove=false;
	other->onGround=true;
	holdingOther=true;
	appearance.changeState("holding");

	//Change our own appearance to standing.
	if(other->direction==1){
	other->appearance.changeState("standleft");
	}else{
	other->appearance.changeState("standright");
	}

	//Apply the velocity the shadow has.
	other->box.x+=xVelBase;
	other->box.y+=yVelBase;
	}
	}
	}else{
	holdingOther=false;
	other->holdingOther=false;
	}
	}

	//And set currentStand to null.
	objCurrentStand=NULL;
	other->objCurrentStand=NULL;
	}

	SDL_Rect Player::getBox(){
	return box;
	}

	void Player::setMyCamera(){
	//Only change the camera when the player isn't dead.
	if(dead)
	return;

	//Check if the level fit's horizontally inside the camera.
	if(camera.w>LEVEL_WIDTH){
	camera.x=-(camera.w-LEVEL_WIDTH)/2;
	}else{
	//Check if the player is halfway pass the halfright of the screen.
	if(box.x>camera.x+(SCREEN_WIDTH/2+50)){
	//It is so ease the camera to the right.
	camera.x+=(box.x-camera.x-(SCREEN_WIDTH/2))>>4;

	//Check if the camera isn't going too far.
	if(box.x<camera.x+(SCREEN_WIDTH/2+50)){
	camera.x=box.x-(SCREEN_WIDTH/2+50);
	}
	}

	//Check if the player is halfway pass the halfleft of the screen.
	if(box.x<camera.x+(SCREEN_WIDTH/2-50)){
	//It is so ease the camera to the left.
	camera.x+=(box.x-camera.x-(SCREEN_WIDTH/2))>>4;

	//Check if the camera isn't going too far.
	if(box.x>camera.x+(SCREEN_WIDTH/2-50)){
	camera.x=box.x-(SCREEN_WIDTH/2-50);
	}
	}

	//If the camera is too far to the left we set it to 0.
	if(camera.x<0){
	camera.x=0;
	}
	//If the camera is too far to the right we set it to the max right.
	if(camera.x+camera.w>LEVEL_WIDTH){
	camera.x=LEVEL_WIDTH-camera.w;
	}
	}

	//Check if the level fit's vertically inside the camera.
	if(camera.h>LEVEL_HEIGHT){
	//We don't centre vertical because the bottom line of the level (deadly) will be mid air.
	camera.y=-(camera.h-LEVEL_HEIGHT);
	}else{
	//Check if the player is halfway pass the lower half of the screen.
	if(box.y>camera.y+(SCREEN_HEIGHT/2+50)){
	//If is so ease the camera down.
	camera.y+=(box.y-camera.y-(SCREEN_HEIGHT/2))>>4;

	//Check if the camera isn't going too far.
	if(box.y<camera.y+(SCREEN_HEIGHT/2+50)){
	camera.y=box.y-(SCREEN_HEIGHT/2+50);
	}
	}

	//Check if the player is halfway pass the upper half of the screen.
	if(box.y<camera.y+(SCREEN_HEIGHT/2-50)){
	//It is so ease the camera up.
	camera.y+=(box.y-camera.y-(SCREEN_HEIGHT/2))>>4;

	//Check if the camera isn't going too far.
	if(box.y>camera.y+(SCREEN_HEIGHT/2-50)){
	camera.y=box.y-(SCREEN_HEIGHT/2-50);
	}
	}

	//If the camera is too far up we set it to 0.
	if(camera.y<0){
	camera.y=0;
	}
	//If the camera is too far down we set it to the max down.
	if(camera.y+camera.h>LEVEL_HEIGHT){
	camera.y=LEVEL_HEIGHT-camera.h;
	}
	}
	}

	void Player::reset(bool save){
	//Set the location of the player to it's initial state.
	box.x=fx;
	box.y=fy;

	//Reset back to default value.
	inAir=true;
	isJump=false;
	onGround=true;
	shadowCall=false;
	canMove=true;
	holdingOther=false;
	dead=false;
	record=false;
	downKeyPressed=false;
	spaceKeyPressed=false;

	//Some animation variables.
	appearance.resetAnimation(save);
	appearance.changeState("standright");
	direction=0;

	state=0;
	xVel=0; //??? fixed a strange bug in game replay
	yVel=0;

	objCurrentStand=NULL;
	objNotificationBlock=NULL;

	//Clear the recording.
	line.clear();
	playerButton.clear();
	recordButton.clear();
	recordIndex=-1;
	#ifdef RECORD_FILE_DEBUG
	recordKeyPressLog.clear();
	recordPlayerPosition.clear();
	#endif

	//xVelSaved is used to indicate if there's a state saved or not.
	if(save){
	xVelSaved=0x80000000;
	}
	}

	void Player::saveState(){
	//We can only save the state when the player isn't dead.
	if(!dead){
	boxSaved.x=box.x;
	boxSaved.y=box.y;
	xVelSaved=xVel;
	yVelSaved=yVel;
	inAirSaved=inAir;
	isJumpSaved=isJump;
	onGroundSaved=onGround;
	canMoveSaved=canMove;
	holdingOtherSaved=holdingOther;
	stateSaved=state;

	//Let the appearance save.
	appearance.saveAnimation();

	//Save any recording stuff.
	recordSaved=record;
	playerButtonSaved=playerButton;
	lineSaved=line;

	//Save the record
	savedRecordButton=recordButton;
	#ifdef RECORD_FILE_DEBUG
	recordKeyPressLog_saved=recordKeyPressLog;
	recordPlayerPosition_saved=recordPlayerPosition;
	#endif

	//Only play the sound when it's enabled.
	if(getSettings()->getBoolValue("sound")==true){
	//To prevent playing the sound twice, only the player can cause the sound.
	if(!shadow)
	Mix_PlayChannel(-1,saveSound,0);
	}
	}
	}

	void Player::loadState(){
	//Check with xVelSaved if there's a saved state.
	if(xVelSaved==int(0x80000000)){
	//There isn't so reset the game to load the first initial state.
	//NOTE: There's no need in removing the saved state since there is none.
	reset(false);
	return;
	}

	//Restore the saved values.
	box.x=boxSaved.x;
	box.y=boxSaved.y;
	//xVel is set to 0 since it's saved counterpart is used to indicate a saved state.
	xVel=0;
	yVel=yVelSaved;

	//Restore the saved values.
	inAir=inAirSaved;
	isJump=isJumpSaved;
	onGround=onGroundSaved;
	canMove=canMoveSaved;
	holdingOther=holdingOtherSaved;
	dead=false;
	record=false;
	shadowCall=false;
	state=stateSaved;

	//Restore the appearance.
	appearance.loadAnimation();

	//Restore any recorded stuff.
	record=recordSaved;
	playerButton=playerButtonSaved;
	line=lineSaved;

	//Load the previously saved record
	recordButton=savedRecordButton;
	#ifdef RECORD_FILE_DEBUG
	recordKeyPressLog=recordKeyPressLog_saved;
	recordPlayerPosition=recordPlayerPosition_saved;
	#endif
	}

	void Player::swapState(Player* other){
	//We need to swap the values of the player with the ones of the given player.
	swap(box.x,other->box.x);
	swap(box.y,other->box.y);
	//NOTE: xVel isn't there since it's used for something else.
	swap(yVel,other->yVel);
	swap(inAir,other->inAir);
	swap(isJump,other->isJump);
	swap(onGround,other->onGround);
	swap(canMove,other->canMove);
	swap(holdingOther,other->holdingOther);
	swap(dead,other->dead);

	//Also reset the state of the other.
	other->stateReset();

	//Play the swap sound.
	if(getSettings()->getBoolValue("sound")==true){
	Mix_PlayChannel(-1,swapSound,0);
	}

	//Update statistics.
	if(!dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	statsMgr.swapTimes++;
	//TODO: achievements
	}
	}

	bool Player::canSaveState(){
	//We can only save the state if the player isn't dead.
	return !dead;
	}

	bool Player::canLoadState(){
	//We use xVelSaved to indicate if a state is saved or not.
	return xVelSaved != int(0x80000000);
	}

	void Player::die(bool animation){
	//Make sure the player isn't already dead.
	if(!dead){
	dead=true;

	//If sound is enabled run the hit sound.
	if(getSettings()->getBoolValue("sound")==true){
	Mix_PlayChannel(-1,hitSound,0);
	}

	//Change the apearance to die (if animation is true).
	if(animation){
	if(direction==1){
	appearance.changeState("dieleft");
	}else{
	appearance.changeState("dieright");
	}
	}

	//Update statistics
	if(!objParent->player.isPlayFromRecord() && !objParent->interlevel){
	if(shadow) statsMgr.shadowDies++;
	else statsMgr.playerDies++;

	switch(statsMgr.playerDies+statsMgr.shadowDies){
	case 1:
	statsMgr.newAchievement("die1");
	break;
	case 50:
	statsMgr.newAchievement("die50");
	break;
	case 1000:
	statsMgr.newAchievement("die1000");
	break;
	}

	if(objParent->player.dead && objParent->shadow.dead) statsMgr.newAchievement("doubleKill");
	}
	}

	//We set the jumpTime to 120 when this is the shadow.
	//That's the countdown for the "Your shadow has died." message.
	if(shadow){
	jumpTime=80;
	}
	}
	diff --git a/src/TitleMenu.cpp b/src/TitleMenu.cpp
	index b69a00e..8844573 100644
	--- a/src/TitleMenu.cpp
	+++ b/src/TitleMenu.cpp
	@@ -1,896 +1,899 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. 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 "StatisticsManager.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"),themeTextColor);
	entries[1]=TTF_RenderUTF8_Blended(fontTitle,_("Options"),themeTextColor);
	entries[2]=TTF_RenderUTF8_Blended(fontTitle,_("Map Editor"),themeTextColor);
	entries[3]=TTF_RenderUTF8_Blended(fontTitle,_("Addons"),themeTextColor);
	entries[4]=TTF_RenderUTF8_Blended(fontTitle,_("Quit"),themeTextColor);
	entries[5]=TTF_RenderUTF8_Blended(fontTitle,">",themeTextColor);
	entries[6]=TTF_RenderUTF8_Blended(fontTitle,"<",themeTextColor);

	//Load the credits icon.
	statisticsIcon=loadImage(getDataPath()+"gfx/menu/statistics.png");
	creditsIcon=loadImage(getDataPath()+"gfx/menu/credits.png");
	}

	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){
	highlight=0;

	if(x>=200&&x<SCREEN_WIDTH-200&&y>=(SCREEN_HEIGHT-250)/2&&y<(SCREEN_HEIGHT-200)/2+320){
	highlight=(y-((SCREEN_HEIGHT-200)/2-64))/64;
	+ if(highlight>0) currentCursor=CURSOR_POINT;
	if(highlight>5) highlight=0;
	}

	//Also check the icons.
	if(y>=SCREEN_HEIGHT-56&&y<SCREEN_HEIGHT-8){
	if(x>=SCREEN_WIDTH-8){
	//do nothing
	}else if(x>=SCREEN_WIDTH-56){
	highlight=7;
	+ currentCursor=CURSOR_POINT;
	}else if(x>=SCREEN_WIDTH-104){
	highlight=6;
	+ currentCursor=CURSOR_POINT;
	}
	}
	}

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

	//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 addons state.
	setNextState(STATE_ADDONS);
	break;
	case 5:
	//We quit, so we enter the exit state.
	setNextState(STATE_EXIT);
	break;
	case 6:
	//Show the statistics screen.
	setNextState(STATE_STATISTICS);
	break;
	case 7:
	//Show the credits screen.
	setNextState(STATE_CREDITS);
	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(){
	//Draw background.
	objThemes.getBackground(true)->draw(screen);
	objThemes.getBackground(true)->updateAnimation();

	//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 && highlight<=5){
	//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);
	}

	//Check if an icon is selected/highlighted and draw tooltip
	if(highlight==6){
	SDL_Color fg={0,0,0};
	SDL_Surface *surface=TTF_RenderUTF8_Blended(fontText,_("Achievements and Statistics"),fg);
	drawGUIBox(SCREEN_WIDTH-64-surface->w-2,SCREEN_HEIGHT-56-surface->h-2,surface->w+4,surface->h+4,screen,0xFFFFFF00\|230);
	applySurface(SCREEN_WIDTH-64-surface->w,SCREEN_HEIGHT-56-surface->h,surface,screen,NULL);
	SDL_FreeSurface(surface);
	}
	if(highlight==7){
	SDL_Color fg={0,0,0};
	SDL_Surface *surface=TTF_RenderUTF8_Blended(fontText,_("Credits"),fg);
	drawGUIBox(SCREEN_WIDTH-16-surface->w-2,SCREEN_HEIGHT-56-surface->h-2,surface->w+4,surface->h+4,screen,0xFFFFFF00\|230);
	applySurface(SCREEN_WIDTH-16-surface->w,SCREEN_HEIGHT-56-surface->h,surface,screen,NULL);
	SDL_FreeSurface(surface);
	}

	//Draw the credits icon.
	applySurface(SCREEN_WIDTH-96,SCREEN_HEIGHT-48,statisticsIcon,screen,NULL);
	applySurface(SCREEN_WIDTH-48,SCREEN_HEIGHT-48,creditsIcon,screen,NULL);
	}

	void Menu::resize(){}


	/////////////////////////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> resolutionList;

	Options::Options(){
	//Render the title.
	title=TTF_RenderUTF8_Blended(fontTitle,_("Settings"),themeTextColor);

	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;

	//Now create the gui.
	createGUI();
	}

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

	//Free the title image.
	SDL_FreeSurface(title);
	}

	void Options::createGUI(){
	//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->addChild(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->addChild(musicSlider);

	obj=new GUIObject(x,190-liftY,240,36,GUIObjectLabel,_("Sound"));
	GUIObjectRoot->addChild(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->addChild(soundSlider);

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

	obj=new GUIObject(x,270-liftY,240,36,GUIObjectLabel,_("Resolution"));
	obj->name="lstResolution";
	GUIObjectRoot->addChild(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(resolutionList.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 predefinedResolutionList[] = {
	{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(predefinedResolutionList)/sizeof(_res);i++){
	resolutionList.push_back(predefinedResolutionList[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};
	resolutionList.push_back(res);
	}
	}
	reverse(resolutionList.begin(),resolutionList.end());
	}
	}

	//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)resolutionList.size();i++){
	//Create a string from width and height and then add it to list
	ostringstream out;
	out << resolutionList[i].w << "x" << resolutionList[i].h;
	resolutions->item.push_back(out.str());

	//Check if current resolution matches, select it
	if (resolutionList[i].w==currentRes.w && resolutionList[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->addChild(resolutions);

	obj=new GUIObject(x,310-liftY,240,36,GUIObjectLabel,_("Language"));
	obj->name="lstResolution";
	GUIObjectRoot->addChild(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->addChild(langs);

	obj=new GUIObject(x,350-liftY,240,36,GUIObjectLabel,_("Theme"));
	obj->name="theme";
	GUIObjectRoot->addChild(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->addChild(theme);

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

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

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

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

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

	b1->render(0,0,false);
	b2->render(0,0,false);
	if(b2->left-b2->gravityX < b1->left+b1->width-b1->gravityX){
	b1->smallFont=true;
	b1->width=-1;
	b2->smallFont=true;
	b2->width=-1;
	}

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

	b2=new GUIObject(SCREEN_WIDTH*0.7,SCREEN_HEIGHT-60,-1,36,GUIObjectButton,_("Save Changes"),0,true,true,GUIGravityCenter);
	b2->name="cmdSave";
	b2->eventCallback=this;
	GUIObjectRoot->addChild(b2);

	b1->render(0,0,false);
	b2->render(0,0,false);
	if(b2->left-b2->gravityX < b1->left+b1->width-b1->gravityX){
	b1->smallFont=true;
	b1->width=-1;
	b2->smallFont=true;
	b2->width=-1;
	}
	}

	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);
	loadTheme(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)resolutionList.size()){
	getSettings()->setValue("width",convertInt(resolutionList[resolutions->value].w));
	getSettings()->setValue("height",convertInt(resolutionList[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(resolutionList[lastRes].w));
	getSettings()->setValue("height",convertInt(resolutionList[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)));
	getLevelPackManager()->updateLanguage();

	//And reload the font.
	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
	//Resets statistics.
	statsMgr.reloadCompletedLevelsAndAchievements();
	}
	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(){
	//Draw background.
	objThemes.getBackground(true)->draw(screen);
	objThemes.getBackground(true)->updateAnimation();
	//Now render the title.
	applySurface((SCREEN_WIDTH-title->w)/2,40-TITLE_FONT_RAISE,title,screen,NULL);

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

	void Options::resize(){
	//Recreate the gui to fit the new resolution.
	createGUI();
	}

	/////////////////////////CREDITS_MENU//////////////////////////////////

	Credits::Credits(){
	//Render the title.
	title=TTF_RenderUTF8_Blended(fontTitle,_("Credits"),themeTextColor);

	//Vector that will hold every line of the credits.
	vector<string> credits;

	//Open the AUTHORS file and read every line.
	{
	ifstream fin((getDataPath()+"/../AUTHORS").c_str());
	if(!fin.is_open()) {
	cerr<<"ERROR: Unable to open the AUTHORS file."<<endl;
	credits.push_back("ERROR: Unable to open the AUTHORS file.");
	credits.push_back("");
	}

	//Loop the lines of the file.
	string line;
	while(getline(fin,line)){
	credits.push_back(line);
	}
	}

	//Enter a new line between the two files.
	credits.push_back("");

	//Open the Credits.text file and read every line.
	{
	ifstream fin((getDataPath()+"/Credits.txt").c_str());
	if(!fin.is_open()) {
	cerr<<"ERROR: Unable to open the Credits.txt file."<<endl;
	credits.push_back("ERROR: Unable to open the Credits.txt file.");
	credits.push_back("");
	}

	//Loop the lines of the file.
	string line;
	while(getline(fin,line)){
	credits.push_back(line);

	//NOTE: Some sections point to other credits files.
	if(line=="music/") {
	vector<string> musicCredits=getMusicManager()->createCredits();
	credits.insert(credits.end(),musicCredits.begin(),musicCredits.end());
	}
	}
	}

	//Now determine the number of lines and calculate the height of the resulting credits surface.
	int lines=credits.size();
	int fontHeight=TTF_FontLineSkip(fontText);
	int maxW=0;

	//Find out the width of the longest line
	for(int i=0;i<lines;i++){
	if(credits[i][0]!='\0'){
	int w;
	TTF_SizeUTF8(fontText,credits[i].c_str(),&w,NULL);

	if(w>maxW)
	maxW=w;
	}
	}

	//Finally create the surface and draw every line of text there
	creditsText=SDL_CreateRGBSurface(SDL_SWSURFACE,maxW,lines*fontHeight,32,RMASK,GMASK,BMASK,AMASK);

	for(int i=0;i<lines;i++){
	if(credits[i][0]!='\0'){
	SDL_Surface* lineSurf=TTF_RenderUTF8_Blended(fontText,credits[i].c_str(),themeTextColor);

	SDL_SetAlpha(lineSurf,0,0xFF);
	SDL_SetAlpha(creditsText,SDL_SRCALPHA,SDL_ALPHA_TRANSPARENT);

	applySurface(0,fontHeight*i,lineSurf,creditsText,NULL);

	SDL_FreeSurface(lineSurf);
	}
	}

	//Create GUI
	createGUI();
	}

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

	//Free images
	SDL_FreeSurface(title);
	SDL_FreeSurface(creditsText);
	}

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

	//Create back button.
	GUIObject* obj=new GUIObject(SCREEN_WIDTH*0.5,SCREEN_HEIGHT-60,-1,36,GUIObjectButton,_("Back"),0,true,true,GUIGravityCenter);
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->addChild(obj);

	//Create vertical scrollbar.
	scrollbarV=new GUIScrollBar(SCREEN_WIDTH-64-16,128,16,SCREEN_HEIGHT-128-92,1,0,0,creditsText->h/8-(SCREEN_HEIGHT-128-92)/8);
	GUIObjectRoot->addChild(scrollbarV);

	//If text is too long, create horizontal scrollbar.
	if(creditsText->w>SCREEN_WIDTH-128){
	scrollbarH=new GUIScrollBar(64,SCREEN_HEIGHT-92,SCREEN_WIDTH-128-16,16,0,0,0,creditsText->w/8-(SCREEN_WIDTH-64-92)/8);
	GUIObjectRoot->addChild(scrollbarH);
	}else{
	scrollbarH=NULL;
	}
	}

	void Credits::GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	//Check what type of event it was.
	if(eventType==GUIEventClick){
	if(name=="cmdBack"){
	//Goto the main menu.
	setNextState(STATE_MENU);
	}
	}
	}

	void Credits::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);
	}

	//Check for scrolling down and up with mouse scroll wheel.
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELDOWN && scrollbarV){
	if(scrollbarV->value<scrollbarV->maxValue)
	scrollbarV->value+=scrollbarV->smallChange;
	if(scrollbarV->value>scrollbarV->maxValue)
	scrollbarV->value=scrollbarV->maxValue;
	return;
	}else if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELUP && scrollbarV){
	if(scrollbarV->value>0)
	scrollbarV->value-=scrollbarV->smallChange;
	if(scrollbarV->value<0)
	scrollbarV->value=0;
	return;
	}
	}

	void Credits::logic(){

	}

	void Credits::render(){
	//Draw background.
	objThemes.getBackground(true)->draw(screen);
	objThemes.getBackground(true)->updateAnimation();
	//Now render the title.
	applySurface((SCREEN_WIDTH-title->w)/2,40-TITLE_FONT_RAISE,title,screen,NULL);

	//Clip and draw text accoring to scrollbars' values.
	SDL_Rect r;
	if(scrollbarH)
	r.x = scrollbarH->value*8;
	else
	r.x = 0;
	r.y = scrollbarV->value*8;
	r.w = SCREEN_WIDTH-128-16;
	r.h = SCREEN_HEIGHT-128-92;
	applySurface(64,128,creditsText,screen,&r);

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

	void Credits::resize(){
	//Recreate the gui to fit the new resolution.
	createGUI();
	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, May 15, 6:26 PM (3 h, 4 m ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 63949
Default Alt Text: (322 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions