No OneTemporary
Actions

Authored By

Unknown

Size

384 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/CMakeLists.txt b/CMakeLists.txt
	index 92b84f7..18c1154 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,141 +1,149 @@
	Project (meandmyshadow)
	-CMake_Minimum_Required (VERSION 2.8)
	+CMake_Minimum_Required (VERSION 3.1)
	Set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")

	#Option if the game should be compiled with hardware acceleration.
	#Option (HARDWARE_ACCELERATION "Use openGL as rendering backend" OFF)
	Set (HARDWARE_ACCELERATION OFF)
	Option (DEBUG_MODE "Compile the game with debug mode enabled" OFF)

	#Find the required libraries.
	Find_Package (SDL2 REQUIRED)
	Find_Package (SDL2_image REQUIRED)
	Find_Package (SDL2_ttf REQUIRED)
	Find_Package (SDL2_mixer REQUIRED)
	Find_Package (CURL REQUIRED)
	Find_Package (LibArchive REQUIRED)
	Find_Package (Lua REQUIRED)

	if("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
	#Find xlib for limiting window.
	Include (FindX11)
	if (HARDWARE_ACCELERATION AND NOT OPENGL_FOUND)
	message (FATAL_ERROR "OpenGL library could not be found!")
	elseif (NOT HARDWARE_ACCELERATION AND NOT X11_FOUND)
	message (FATAL_ERROR "X11 library could not be found!")
	endif (HARDWARE_ACCELERATION AND NOT OPENGL_FOUND)
	endif ()

	if (NOT SDL2_FOUND)
	message (FATAL_ERROR "SDL2 library could not be found!")
	endif (NOT SDL2_FOUND)

	if (NOT SDL2_IMAGE_FOUND)
	message (FATAL_ERROR "SDL2_image library could not be found!")
	endif (NOT SDL2_IMAGE_FOUND)

	if (NOT SDL2_TTF_FOUND)
	message (FATAL_ERROR "SDL2_ttf library could not be found!")
	endif (NOT SDL2_TTF_FOUND)

	if (NOT SDL2_MIXER_FOUND)
	message (FATAL_ERROR "SDL2_mixer library could not be found!")
	endif (NOT SDL2_MIXER_FOUND)

	if (NOT CURL_FOUND)
	message(FATAL_ERROR "CURL library could not be found!")
	endif (NOT CURL_FOUND)

	if (NOT LibArchive_FOUND)
	message (FATAL_ERROR "LibArchive library could not be found!")
	endif (NOT LibArchive_FOUND)

	if (NOT LUA_FOUND)
	message (FATAL_ERROR "Lua library could not be found!")
	endif (NOT LUA_FOUND)

	##Although Lua is found it could be the wrong version.
	##Try to find the header file and extract the Lua version, if we don't find the header file carry on.
	#if (LUA_INCLUDE_DIR AND EXISTS "${LUA_INCLUDE_DIR}/lua.h")
	# #Open the file and extract the version define lines.
	# file (STRINGS "${LUA_INCLUDE_DIR}/lua.h" lua_version_str REGEX "^#define[ \t]+LUA_VERSION_M(AJ\|IN)OR[ \t]")
	# #Extract only the numbers from the files.
	# string (REGEX MATCHALL "[0-9]" LUA_VERSION_STRING "${lua_version_str}")
	# string (COMPARE EQUAL "${LUA_VERSION_STRING}" "5;2" LUA_VERSION_MATCH)

	# if (NOT LUA_VERSION_MATCH)
	# message (FATAL_ERROR "Incorrect Lua version ${LUA_VERSION_STRING}, expected 5.2!")
	# endif (NOT LUA_VERSION_MATCH)

	# #Finally unset the unneeded variables.
	# unset (lua_version_str)
	# unset (LUA_VERSION_STRING)
	# unset (LUA_VERSION_MATCH)
	#endif()
	if (LUA_VERSION_STRING VERSION_LESS "5.2")
	message (FATAL_ERROR "Lua version too old ${LUA_VERSION_STRING}, expected at least 5.2!")
	endif ()

	#Parse the configure file.
	Configure_File (
	"${PROJECT_SOURCE_DIR}/src/config.h.in"
	"${PROJECT_BINARY_DIR}/config.h"
	)

	+if(WIN32)
	+ add_definitions(-DHAVE_SDL)
	+ include_directories(${PROJECT_SOURCE_DIR}/src/libs/dirent)
	+endif(WIN32)
	+
	#Add the include directories of the (found) libraries.
	Include_Directories(
	${PROJECT_BINARY_DIR}
	${X11_X11_INCLUDE_PATH}
	${OPENGL_gl_INCLUDE_DIR}
	${SDL2_INCLUDE_DIR}
	${SDL2_IMAGE_INCLUDE_DIR}
	${SDL2_TTF_INCLUDE_DIR}
	${SDL2_MIXER_INCLUDE_DIR}
	${CURL_INCLUDE_DIR}
	${LibArchive_INCLUDE_DIR}
	${LUA_INCLUDE_DIR}
	${PROJECT_SOURCE_DIR}/src/libs
	)

	#Set the output path and the source path.
	Set (EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR})
	Set (SRC_DIR ${PROJECT_SOURCE_DIR}/src)

	#List the source files.
	File (GLOB SOURCES ${SRC_DIR}/*.cpp)
	File (GLOB TINYGETTEXT ${SRC_DIR}/libs/tinygettext/*.cpp)
	File (GLOB FINDLOCALE ${SRC_DIR}/libs/findlocale/*.cpp)

	Add_Executable (meandmyshadow ${SOURCES} ${TINYGETTEXT} ${FINDLOCALE})

	+set_property(TARGET meandmyshadow PROPERTY CXX_STANDARD 11)
	+
	Target_Link_Libraries (
	meandmyshadow
	${OPENGL_gl_LIBRARY}
	${X11_X11_LIB}
	- ${SDL2_LIBRARY}
	- ${SDL2_IMAGE_LIBRARY}
	- ${SDL2_TTF_LIBRARY}
	- ${SDL2_MIXER_LIBRARY}
	+ ${SDL2_LIBRARY}
	+ ${SDL2_IMAGE_LIBRARY}
	+ ${SDL2_TTF_LIBRARY}
	+ ${SDL2_MIXER_LIBRARY}
	+ ${SDL2MAIN_LIBRARY}
	${CURL_LIBRARY}
	${LibArchive_LIBRARY}
	${LUA_LIBRARIES}
	)

	#Path options
	Set (BINDIR "bin" CACHE STRING "Where to install binaries")
	Set (DATAROOTDIR "${CMAKE_INSTALL_PREFIX}/share" CACHE STRING "Sets the root of data directories to a non-default location")
	Set (ICONDIR "${DATAROOTDIR}/icons" CACHE STRING "Sets the icon directory for desktop entry to a non-default location.")
	Set (DESKTOPDIR "${DATAROOTDIR}/applications" CACHE STRING "Sets the desktop file directory for desktop entry to a non-default location.")

	#Install locations
	Install (DIRECTORY ${PROJECT_SOURCE_DIR}/data DESTINATION ${DATAROOTDIR}/meandmyshadow/)
	Install (FILES AUTHORS DESTINATION ${DATAROOTDIR}/meandmyshadow/)
	Install (TARGETS meandmyshadow RUNTIME DESTINATION ${BINDIR})

	if ("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
	Install (FILES meandmyshadow.desktop DESTINATION ${DESKTOPDIR})
	Install (FILES icons/16x16/meandmyshadow.png DESTINATION ${ICONDIR}/hicolor/16x16/apps/)
	Install (FILES icons/32x32/meandmyshadow.png DESTINATION ${ICONDIR}/hicolor/32x32/apps/)
	Install (FILES icons/48x48/meandmyshadow.png DESTINATION ${ICONDIR}/hicolor/48x48/apps/)
	Install (FILES icons/64x64/meandmyshadow.png DESTINATION ${ICONDIR}/hicolor/64x64/apps/)
	endif ("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
	diff --git a/src/AchievementList.h b/src/AchievementList.h
	index aeacfd6..28a1159 100644
	--- a/src/AchievementList.h
	+++ b/src/AchievementList.h
	@@ -1,104 +1,105 @@
	/*
	* 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/>.
	*/

	// NOTE: This is an internal file for all avaliable achievements.
	// Don't include it in other files!

	// Format: {id, name, file, pos, description, [type]}
	// id: Identifier of achievement. Should not change once the new achievement is added,
	// otherwise the old statistics will be lost.
	// name: Name of achievement. Translatable.
	// file: The icon file. NULL for no icon.
	// pos: Specifies which part of the icon will be displayed (left, top, width, height).
	// description: Description of achievement. Translatable. Can be multi-line text.
	// type [optional]: Specifies the display type of achievement.
	// ACHIEVEMENT_HIDDEN [default]: Show "Unknown achievement" when unfinished.
	// ACHIEVEMENT_TITLE: Only show icon and title when unfinished.
	// ACHIEVEMENT_ALL: Always show icon, title and description.
	// ACHIEVEMENT_PROGRESS: Show icon, title and description and a progress bar.
	// StatisticsManager::getAchievementProgress() function should return the progress (between 0 and 1).
	+// NOTE: WARNING: All arguments should now be specified, as surface being nullptr is being relied upon.

	AchievementInfo achievementList[]={
	- {"newbie",__("Newbie"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Complete a level."),ACHIEVEMENT_ALL},
	- {"experienced",__("Experienced player"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Complete 50 levels."),ACHIEVEMENT_PROGRESS},
	- {"goodjob",__("Good job!"),"gfx/medals.png",{60,0,30,30},__("Receive a gold medal."),ACHIEVEMENT_ALL},
	- {"expert",__("Expert"),"gfx/medals.png",{60,0,30,30},__("Earn 50 gold medal."),ACHIEVEMENT_PROGRESS},
	+ {"newbie",__("Newbie"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Complete a level."),ACHIEVEMENT_ALL,nullptr},
	+ {"experienced",__("Experienced player"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Complete 50 levels."),ACHIEVEMENT_PROGRESS,nullptr},
	+ {"goodjob",__("Good job!"),"gfx/medals.png",{60,0,30,30},__("Receive a gold medal."),ACHIEVEMENT_ALL,nullptr},
	+ {"expert",__("Expert"),"gfx/medals.png",{60,0,30,30},__("Earn 50 gold medal."),ACHIEVEMENT_PROGRESS,nullptr},

	- {"tutorial",__("Graduate"),"gfx/medals.png",{60,0,30,30},__("Complete the tutorial level pack."),ACHIEVEMENT_PROGRESS},
	- {"tutorialGold",__("Outstanding graduate"),"gfx/medals.png",{60,0,30,30},__("Complete the tutorial level pack with gold for all levels."),ACHIEVEMENT_PROGRESS},
	+ {"tutorial",__("Graduate"),"gfx/medals.png",{60,0,30,30},__("Complete the tutorial level pack."),ACHIEVEMENT_PROGRESS,nullptr},
	+ {"tutorialGold",__("Outstanding graduate"),"gfx/medals.png",{60,0,30,30},__("Complete the tutorial level pack with gold for all levels."),ACHIEVEMENT_PROGRESS,nullptr},

	- {"addicted",__("Hooked"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Play Me and My Shadow for more than 2 hours.")},
	- {"loyalFan",__("Loyal fan of Me and My Shadow"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Play Me and My Shadow for more than 24 hours.")},
	+ {"addicted",__("Hooked"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Play Me and My Shadow for more than 2 hours."),ACHIEVEMENT_HIDDEN,nullptr},
	+ {"loyalFan",__("Loyal fan of Me and My Shadow"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Play Me and My Shadow for more than 24 hours."),ACHIEVEMENT_HIDDEN,nullptr},

	- {"constructor",__("Constructor"),"gfx/gui.png",{112,16,16,16},__("Use the level editor for more than 2 hours.")},
	- {"constructor2",__("The creator"),"gfx/gui.png",{112,16,16,16},__("Use the level editor for more than 24 hours.")},
	+ {"constructor",__("Constructor"),"gfx/gui.png",{112,16,16,16},__("Use the level editor for more than 2 hours."),ACHIEVEMENT_HIDDEN,nullptr},
	+ {"constructor2",__("The creator"),"gfx/gui.png",{112,16,16,16},__("Use the level editor for more than 24 hours."),ACHIEVEMENT_HIDDEN,nullptr},

	- {"create1",__("Look, cute level!"),"gfx/gui.png",{112,16,16,16},__("Create a level for the first time."),ACHIEVEMENT_ALL},
	- {"create50",__("The level museum"),"gfx/gui.png",{112,16,16,16},__("Create 50 levels."),ACHIEVEMENT_PROGRESS},
	+ {"create1",__("Look, cute level!"),"gfx/gui.png",{112,16,16,16},__("Create a level for the first time."),ACHIEVEMENT_ALL,nullptr},
	+ {"create50",__("The level museum"),"gfx/gui.png",{112,16,16,16},__("Create 50 levels."),ACHIEVEMENT_PROGRESS,nullptr},

	- {"frog",__("Frog"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Jump 1000 times."),ACHIEVEMENT_PROGRESS},
	+ {"frog",__("Frog"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Jump 1000 times."),ACHIEVEMENT_PROGRESS,nullptr},

	- {"travel100",__("Wanderer"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Travel 100 meters."),ACHIEVEMENT_PROGRESS},
	- {"travel1k",__("Runner"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Travel 1 kilometer."),ACHIEVEMENT_PROGRESS},
	- {"travel10k",__("Long distance runner"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Travel 10 kilometers."),ACHIEVEMENT_PROGRESS},
	- {"travel42k",__("Marathon runner"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Travel 42,195 meters."),ACHIEVEMENT_PROGRESS},
	+ {"travel100",__("Wanderer"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Travel 100 meters."),ACHIEVEMENT_PROGRESS,nullptr},
	+ {"travel1k",__("Runner"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Travel 1 kilometer."),ACHIEVEMENT_PROGRESS,nullptr},
	+ {"travel10k",__("Long distance runner"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Travel 10 kilometers."),ACHIEVEMENT_PROGRESS,nullptr},
	+ {"travel42k",__("Marathon runner"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Travel 42,195 meters."),ACHIEVEMENT_PROGRESS,nullptr},

	- {"die1",__("Be careful!"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Die for the first time."),ACHIEVEMENT_ALL},
	- {"die50",__("It doesn't matter..."),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Die 50 times.")},
	- {"die1000",__("Expert of trial and error"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Die 1000 times.")},
	+ {"die1",__("Be careful!"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Die for the first time."),ACHIEVEMENT_ALL,nullptr},
	+ {"die50",__("It doesn't matter..."),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Die 50 times."),ACHIEVEMENT_HIDDEN,nullptr},
	+ {"die1000",__("Expert of trial and error"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Die 1000 times."),ACHIEVEMENT_HIDDEN,nullptr},

	- {"squash1",__("Keep an eye for moving blocks!"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Get squashed for the first time.")},
	- {"squash50",__("Potato masher"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Get squashed 50 times.")},
	+ {"squash1",__("Keep an eye for moving blocks!"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Get squashed for the first time."),ACHIEVEMENT_HIDDEN,nullptr},
	+ {"squash50",__("Potato masher"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Get squashed 50 times."),ACHIEVEMENT_HIDDEN,nullptr},

	- {"doubleKill",__("Double kill"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Get both the player and the shadow dead.")},
	+ {"doubleKill",__("Double kill"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Get both the player and the shadow dead."),ACHIEVEMENT_HIDDEN,nullptr},

	- {"die5in5",__("Bad luck"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Die 5 times in under 5 seconds.")},
	- {"die10in5",__("This level is too dangerous"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Die 10 times in under 5 seconds.")},
	+ {"die5in5",__("Bad luck"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Die 5 times in under 5 seconds."),ACHIEVEMENT_HIDDEN,nullptr},
	+ {"die10in5",__("This level is too dangerous"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Die 10 times in under 5 seconds."),ACHIEVEMENT_HIDDEN,nullptr},

	- {"forget",__("You forgot your friend"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Finish the level with the player or the shadow dead.")},
	- {"jit",__("Just in time"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Reach the exit with the player and the shadow simultaneously.")},
	+ {"forget",__("You forgot your friend"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Finish the level with the player or the shadow dead."),ACHIEVEMENT_HIDDEN,nullptr},
	+ {"jit",__("Just in time"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Reach the exit with the player and the shadow simultaneously."),ACHIEVEMENT_HIDDEN,nullptr},

	- {"record100",__("Recorder"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Record 100 times."),ACHIEVEMENT_PROGRESS},
	- {"record1k",__("Shadowmaster"),"themes/Cloudscape/characters/shadow.png",{0,0,23,40},__("Record 1000 times."),ACHIEVEMENT_PROGRESS},
	+ {"record100",__("Recorder"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Record 100 times."),ACHIEVEMENT_PROGRESS,nullptr},
	+ {"record1k",__("Shadowmaster"),"themes/Cloudscape/characters/shadow.png",{0,0,23,40},__("Record 1000 times."),ACHIEVEMENT_PROGRESS,nullptr},

	- {"switch100",__("Switch puller"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Pull the switch 100 times."),ACHIEVEMENT_PROGRESS},
	- {"switch1k",__("The switch is broken!"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Pull the switch 1000 times.")},
	+ {"switch100",__("Switch puller"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Pull the switch 100 times."),ACHIEVEMENT_PROGRESS,nullptr},
	+ {"switch1k",__("The switch is broken!"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Pull the switch 1000 times."),ACHIEVEMENT_HIDDEN,nullptr},

	- {"swap100",__("Swapper"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Swap 100 times."),ACHIEVEMENT_PROGRESS},
	- {"swap1k",__("Player to shadow to player to shadow..."),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Swap 1000 times.")},
	+ {"swap100",__("Swapper"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Swap 100 times."),ACHIEVEMENT_PROGRESS,nullptr},
	+ {"swap1k",__("Player to shadow to player to shadow..."),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Swap 1000 times."),ACHIEVEMENT_HIDDEN,nullptr},

	- {"save1k",__("Play it save"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Save 1000 times.")},
	- {"load1k",__("This game is too hard"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Load the game 1000 times.")},
	+ {"save1k",__("Play it save"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Save 1000 times."),ACHIEVEMENT_HIDDEN,nullptr},
	+ {"load1k",__("This game is too hard"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Load the game 1000 times."),ACHIEVEMENT_HIDDEN,nullptr},

	- {"panicSave",__("Panic save"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Save twice in 1 second.")},
	- {"panicLoad",__("Panic load"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Load twice in 1 second.")},
	+ {"panicSave",__("Panic save"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Save twice in 1 second."),ACHIEVEMENT_HIDDEN,nullptr},
	+ {"panicLoad",__("Panic load"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Load twice in 1 second."),ACHIEVEMENT_HIDDEN,nullptr},

	- {"loadAndDie",__("Bad saving position"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Load the game and die within 1 second.")},
	- {"loadAndDie100",__("This level is too hard"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Load the same save and die 100 times.")},
	+ {"loadAndDie",__("Bad saving position"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Load the game and die within 1 second."),ACHIEVEMENT_HIDDEN,nullptr},
	+ {"loadAndDie100",__("This level is too hard"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Load the same save and die 100 times."),ACHIEVEMENT_HIDDEN,nullptr},

	- {"quickswap",__("Quick swap"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Swap twice in under a second.")},
	+ {"quickswap",__("Quick swap"),"themes/Cloudscape/characters/player.png",{0,0,23,40},__("Swap twice in under a second."),ACHIEVEMENT_HIDDEN,nullptr},

	//ripped from Achievements Unlocked
	- {"horizontal",__("Horizontal confusion"),"gfx/emotions.png",{0,0,23,40},__("Press left and right simultaneously.")},
	+ {"horizontal",__("Horizontal confusion"),"gfx/emotions.png",{0,0,23,40},__("Press left and right simultaneously."),ACHIEVEMENT_HIDDEN,nullptr},

	- {"programmer",__("Programmer"),"gfx/gui.png",{112,16,16,16},__("Play the development version of Me and My Shadow."),ACHIEVEMENT_TITLE},
	+ {"programmer",__("Programmer"),"gfx/gui.png",{112,16,16,16},__("Play the development version of Me and My Shadow."),ACHIEVEMENT_TITLE,nullptr},

	//end of achievements
	{}
	};
	diff --git a/src/Addons.h b/src/Addons.h
	index 6a9089b..fee701b 100644
	--- a/src/Addons.h
	+++ b/src/Addons.h
	@@ -1,159 +1,160 @@
	/*
	* Copyright (C) 2011-2013 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 ADDONS_H
	#define ADDONS_H

	#include "GameState.h"
	#include "GameObjects.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "Render.h"

	+#include <array>
	#include <vector>
	#include <string>

	//The addons menu.
	class Addons: public GameState,public GUIEventCallback{
	private:
	//The minimum addon version that is supported.
	static const int MIN_VERSION=2;
	//The maximum addon version that is supported.
	static const int MAX_VERSION=2;

	//An addon entry.
	struct Addon{
	//The name of the addon.
	string name;
	//The type of addon. (Level, Levelpack, Theme)
	string type;
	//The link to the addon file.
	string file;
	//The name of the author.
	string author;

	//The description of the addon.
	string description;

	//Icon for the addon.
	SharedTexture icon;
	//Screenshot for the addon.
	SharedTexture screenshot;

	//The latest version of the addon.
	int version;
	//The version that the user has installed, if installed.
	int installedVersion;

	//Boolean if the addon is installed.
	bool installed;
	//Boolean if the addon is upToDate. (installedVersion==version)
	bool upToDate;

	//Map that contains the content of the addon.
	//NOTE: This is only filled if the addon is installed.
	std::vector<std::pair<std::string,std::string> > content;
	//Array that holds the name of the addons it's dependent on.
	//NOTE: This is only filled if the addon is installed.
	std::vector<std::pair<std::string,std::string> > dependencies;
	};

	//The title.
	TexturePtr title;

	//Placeholder icons for addons in case they don't provide custom icons.
	std::array<SharedTexture, 3> addonIcon;

	//Placeholder screenshot for addons in case they don't provide one.
	SharedTexture screenshot;

	//Map containing a vector of Addons for each addon category.
	std::vector<Addon> addons;

	//File pointing to the addon file in the userpath.
	FILE* addon;

	//String that should contain the error when something fails.
	string error;

	//The type of addon that is currently selected.
	string type;
	//Pointer to the addon that is selected.
	Addon* selected;

	//The list used for the selecting of the category.
	GUISingleLineListBox* categoryList;
	//The list used for listing the addons.
	GUIListBox* list;
	public:
	//Constructor.
	Addons(SDL_Renderer& renderer, ImageManager& imageManager);
	//Destructor.
	~Addons();

	//Method that will create the GUI.
	void createGUI(SDL_Renderer &renderer, ImageManager &imageManager);

	//Method that loads that downloads the addons list.
	//file: Pointer to the file to download the list to.
	//Returns: True if the file is downloaded successfuly.
	bool getAddonsList(FILE* file, SDL_Renderer& renderer, ImageManager& imageManager);
	//
	void fillAddonList(TreeStorageNode &objAddons,TreeStorageNode &objInstalledAddons,SDL_Renderer& renderer, ImageManager& imageManager);
	//Put all the addons of a given type in a vector.
	//type: The type the addons must be.
	//Returns: Vector containing the addons.
	void addonsToList(const string &type, SDL_Renderer &renderer, ImageManager &);

	//Method that will save the installed addons to the installed_addons file.
	//Returns: True if the file is saved successfuly.
	bool saveInstalledAddons();

	//Method for loading a cached image and downloading if it isn't cached.
	//url: The url to the image.
	//md5sum: The md5sum used for caching.
	//Returns: Shared pointer to the loaded image.
	SharedTexture loadCachedImage(const char* url,const char* md5sum, SDL_Renderer& renderer, ImageManager& imageManager);

	//Method that will open a GUIOverlay with the an overview of the selected addon.
	void showAddon(ImageManager& imageManager,SDL_Renderer& renderer);

	//Inherited from GameState.
	void handleEvents(ImageManager&, SDL_Renderer&) override;
	void logic(ImageManager&, SDL_Renderer&) override;
	void render(ImageManager&, SDL_Renderer& renderer) override;
	void resize(ImageManager &imageManager, SDL_Renderer& renderer) override;

	//Method used for GUI event handling.
	//name: The name of the callback.
	//obj: Pointer to the GUIObject that caused the event.
	//eventType: The type of event: click, change, etc..
	void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType);

	//This method will remove the addon based on the content vector.
	//NOTE It doesn't check if the addon is installed or not.
	//addon: The addon to remove.
	void removeAddon(ImageManager& imageManager,SDL_Renderer &renderer, Addon* addon);
	//This method will install the addon by downloading,extracting and reading.
	//NOTE It doesn't check if the addon is installed or not.
	//addon: The addon to install.
	void installAddon(ImageManager& imageManager, SDL_Renderer &renderer, Addon* addon);

	};
	#endif
	diff --git a/src/FileManager.cpp b/src/FileManager.cpp
	index 5415d01..7dd2050 100644
	--- a/src/FileManager.cpp
	+++ b/src/FileManager.cpp
	@@ -1,828 +1,833 @@
	/*
	* 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 <iostream>
	#include <string>
	#include <vector>
	+#include "config.h"
	#include "FileManager.h"
	#include "Functions.h"
	#ifdef __APPLE__
	#include "archive.h"
	#include "archive_entry.h"
	#else
	#include <archive.h>
	#include <archive_entry.h>
	#endif
	using namespace std;

	#ifdef WIN32
	#include <windows.h>
	#include <shlobj.h>
	#include <shlwapi.h>
	#include <direct.h>
	#pragma comment(lib,"shlwapi.lib")
	#else
	#include <strings.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include <dirent.h>
	#endif
	+
	//Included for the downloadFile method.
	#include <curl/curl.h>

	//Under Windows there's just one userpath.
	#ifdef WIN32
	string userPath,dataPath,appPath,exeName;
	#else
	//But on other platforms we make a difference between the userPath (config files) and the userDataPath (data files).
	//Finally there's the path for cache data userCachePath.
	string userPath,userDataPath,userCachePath,dataPath,appPath,exeName;
	#endif

	bool configurePaths() {
	//Get the appPath and the exeName.
	{
	char s[4096];
	int i,m;
	#ifdef WIN32
	m=GetModuleFileNameA(NULL,s,sizeof(s));
	#elif defined(ANDROID)
	//FIXME: Oops. There are no any executable files in Android.
	strcpy(s,"./meandmyshadow");
	m=strlen(s);
	#else
	m=readlink("/proc/self/exe",s,sizeof(s));
	#endif
	s[m]=0;
	- for(i=m-1;i>=0;i--){
	+ for(i=m-1;i>=0&&i<4096;i--){
	if(s[i]=='/'\|\|s[i]=='\\'){
	s[i]=0;
	break;
	}
	}
	appPath=s;
	exeName=s+i+1;
	}

	//TODO: Check if the userpath is empty before setting userPath???
	//Check if the userPath is empty.
	if(getUserPath().empty()){
	#ifdef WIN32
	//Get the userPath.
	char s[1024];
	SHGetSpecialFolderPathA(NULL,s,CSIDL_PERSONAL,1);
	userPath=s;
	userPath+="\\My Games\\meandmyshadow\\";
	#elif defined(ANDROID)
	//FIXME: These paths are relative to SDL Android data path.
	userPath="./";
	userDataPath="./";
	userCachePath="./";
	#else
	//Temp variable that is used to prevent NULL assignement.
	char* env;

	//First get the $XDG_CONFIG_HOME env var.
	env=getenv("XDG_CONFIG_HOME");
	//If it's null set userPath to $HOME/.config/.
	if(env!=NULL){
	userPath=env;
	}else{
	userPath=getenv("HOME");
	userPath+="/.config";
	}
	//And add meandmyshadow to it.
	userPath+="/meandmyshadow/";

	//Now get the $XDG_DATA_HOME env var.
	env=getenv("XDG_DATA_HOME");
	//If it's null set userDataPath to $HOME/.local/share.

	if(env!=NULL){
	userDataPath=env;
	}else{
	userDataPath=getenv("HOME");
	userDataPath+="/.local/share";
	}
	//And add meandmyshadow to it.
	userDataPath+="/meandmyshadow/";

	//Now get the $XDG_CACHE_HOME env var.
	env=getenv("XDG_CACHE_HOME");
	//If it's null set userCachePath to $HOME/.cache.
	if(env!=NULL){
	userCachePath=env;
	}else{
	userCachePath=getenv("HOME");
	userCachePath+="/.cache";
	}
	//And add meandmyshadow to it.
	userCachePath+="/meandmyshadow/";

	//Set env null.
	env=NULL;
	#endif

	//Print the userPath.
	cout<<"User preferences will be fetched from: "<<userPath<<endl;
	#ifndef WIN32
	//In case of a non-Windows computer show the user data path.
	cout<<"User data will be fetched from: "<<userDataPath<<endl;
	#endif
	}

	#ifdef WIN32
	//Create the userPath folder and other subfolders.
	createDirectory(userPath.c_str());
	createDirectory((userPath+"levels").c_str());
	createDirectory((userPath+"levelpacks").c_str());
	createDirectory((userPath+"themes").c_str());
	createDirectory((userPath+"music").c_str());
	//The progress folder and subfolders.
	createDirectory((userPath+"progress").c_str());
	createDirectory((userPath+"progress\\main").c_str());
	createDirectory((userPath+"progress\\addon").c_str());
	createDirectory((userPath+"progress\\custom").c_str());
	createDirectory((userPath+"tmp").c_str());
	createDirectory((userPath+"images").c_str());
	//The records folder for recordings.
	createDirectory((userPath+"records").c_str());
	createDirectory((userPath+"records\\autosave").c_str());
	//And the custom folder inside the userpath.
	createDirectory((userPath+"custom").c_str());
	createDirectory((userPath+"custom\\levels").c_str());
	createDirectory((userPath+"custom\\levelpacks").c_str());
	#else
	//Create the userPath.
	createDirectory(userPath.c_str());
	createDirectory(userDataPath.c_str());
	createDirectory(userCachePath.c_str());
	//Also create other folders in the userpath.
	createDirectory((userDataPath+"/levels").c_str());
	createDirectory((userDataPath+"/levelpacks").c_str());
	createDirectory((userDataPath+"/themes").c_str());
	createDirectory((userDataPath+"/music").c_str());
	//The progress folder and subfolders.
	createDirectory((userDataPath+"/progress").c_str());
	createDirectory((userDataPath+"/progress/main").c_str());
	createDirectory((userDataPath+"/progress/addon").c_str());
	createDirectory((userDataPath+"/progress/custom").c_str());
	createDirectory((userCachePath+"/tmp").c_str());
	createDirectory((userCachePath+"/images").c_str());
	//The records folder for recordings.
	createDirectory((userDataPath+"/records").c_str());
	createDirectory((userDataPath+"/records/autosave").c_str());
	//And the custom folder inside the userpath.
	createDirectory((userDataPath+"/custom").c_str());
	createDirectory((userDataPath+"/custom/levels").c_str());
	createDirectory((userDataPath+"/custom/levelpacks").c_str());
	#endif

	//Get the dataPath by trying multiple relative locations.
	{
	FILE *f;
	string s;
	while(true){
	//try existing one
	if(!dataPath.empty()){
	s=dataPath+"font/knewave.ttf";
	if((f=fopen(s.c_str(),"rb"))!=NULL){
	fclose(f);
	break;
	}
	}
	//try "./"
	dataPath="./data/";
	s=dataPath+"font/knewave.ttf";
	if((f=fopen(s.c_str(),"rb"))!=NULL){
	fclose(f);
	break;
	}
	//try "../"
	dataPath="../data/";
	s=dataPath+"font/knewave.ttf";
	if((f=fopen(s.c_str(),"rb"))!=NULL){
	fclose(f);
	break;
	}
	//try App.Path
	dataPath=getAppPath()+"/data/";
	s=dataPath+"font/knewave.ttf";
	if((f=fopen(s.c_str(),"rb"))!=NULL){
	fclose(f);
	break;
	}
	//try App.Path+"/../"
	dataPath=getAppPath()+"/../data/";
	s=dataPath+"font/knewave.ttf";
	if((f=fopen(s.c_str(),"rb"))!=NULL){
	fclose(f);
	break;
	}
	//try DATA_PATH
	#ifdef DATA_PATH
	dataPath=DATA_PATH;
	+ std::cout << "trying: " << dataPath << std::endl;
	s=dataPath+"font/knewave.ttf";
	if((f=fopen(s.c_str(),"rb"))!=NULL){
	fclose(f);
	break;
	}
	#endif
	#ifdef __APPLE__
	extern std::string get_data_path();
	dataPath = get_data_path();
	dataPath=get_data_path();
	s=dataPath+"font/knewave.ttf";
	if((f=fopen(s.c_str(),"rb"))!=NULL){
	fclose(f);
	break;
	}

	#endif
	+ SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error! Faild to find game data!",
	+ "The game data files could not be found!", NULL);
	//error: can't find file
	return false;
	}
	//Print the dataPath.
	cout<<"Data files will be fetched from: "<<dataPath<<endl;
	}
	return true;
	}

	std::vector<std::string> enumAllFiles(std::string path,const char* extension,bool containsPath){
	vector<string> v;
	#ifdef WIN32
	string s1;
	WIN32_FIND_DATAA f;
	if(!path.empty()){
	char c=path[path.size()-1];
	if(c!='/'&&c!='\\') path+="\\";
	}
	s1=path;
	if(extension!=NULL && *extension){
	s1+="*.";
	s1+=extension;
	}else{
	s1+="*";
	}
	HANDLE h=FindFirstFileA(s1.c_str(),&f);
	if(h==NULL\|\|h==INVALID_HANDLE_VALUE) return v;
	do{
	if(!(f.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)){
	if(containsPath){
	v.push_back(path+f.cFileName);
	}else{
	v.push_back(f.cFileName);
	}
	}
	}while(FindNextFileA(h,&f));
	FindClose(h);
	return v;
	#else
	int len=0;
	if(extension!=NULL && *extension) len=strlen(extension);
	if(!path.empty()){
	char c=path[path.size()-1];
	if(c!='/'&&c!='\\') path+="/";
	}
	DIR *pDir;
	struct dirent *pDirent;
	pDir=opendir(path.c_str());
	if(pDir==NULL) return v;
	while((pDirent=readdir(pDir))!=NULL){
	if(pDirent->d_name[0]=='.'){
	if(pDirent->d_name[1]==0\|\|
	(pDirent->d_name[1]=='.'&&pDirent->d_name[2]==0)) continue;
	}
	string s1=path+pDirent->d_name;
	struct stat S_stat;
	lstat(s1.c_str(),&S_stat);
	if(!S_ISDIR(S_stat.st_mode)){
	if(len>0){
	if((int)s1.size()<len+1) continue;
	if(s1[s1.size()-len-1]!='.') continue;
	if(strcasecmp(&s1[s1.size()-len],extension)) continue;
	}

	if(containsPath){
	v.push_back(s1);
	}else{
	v.push_back(string(pDirent->d_name));
	}
	}
	}
	closedir(pDir);
	return v;
	#endif
	}

	std::vector<std::string> enumAllDirs(std::string path,bool containsPath){
	vector<string> v;
	#ifdef WIN32
	string s1;
	WIN32_FIND_DATAA f;
	if(!path.empty()){
	char c=path[path.size()-1];
	if(c!='/'&&c!='\\') path+="\\";
	}
	s1=path+"*";
	HANDLE h=FindFirstFileA(s1.c_str(),&f);
	if(h==NULL\|\|h==INVALID_HANDLE_VALUE) return v;
	do{
	// skip '.' and '..' and hidden folders
	if(f.cFileName[0]=='.'){
	/*if(f.cFileName[1]==0\|\|
	(f.cFileName[1]=='.'&&f.cFileName[2]==0))*/ continue;
	}
	if(f.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY){
	if(containsPath){
	v.push_back(path+f.cFileName);
	}else{
	v.push_back(f.cFileName);
	}
	}
	}while(FindNextFileA(h,&f));
	FindClose(h);
	return v;
	#else
	if(!path.empty()){
	char c=path[path.size()-1];
	if(c!='/'&&c!='\\') path+="/";
	}
	DIR *pDir;
	struct dirent *pDirent;
	pDir=opendir(path.c_str());
	if(pDir==NULL) return v;
	while((pDirent=readdir(pDir))!=NULL){
	if(pDirent->d_name[0]=='.'){
	if(pDirent->d_name[1]==0\|\|
	(pDirent->d_name[1]=='.'&&pDirent->d_name[2]==0)) continue;
	}
	string s1=path+pDirent->d_name;
	struct stat S_stat;
	lstat(s1.c_str(),&S_stat);
	if(S_ISDIR(S_stat.st_mode)){
	//Skip hidden folders.
	s1=string(pDirent->d_name);
	if(s1.find('.')==0) continue;

	//Add result to vector.
	if(containsPath){
	v.push_back(path+pDirent->d_name);
	}else{
	v.push_back(s1);
	}
	}
	}
	closedir(pDir);
	return v;
	#endif
	}

	std::string processFileName(const std::string& s){
	string prefix=dataPath;

	//FIXME: Do we still need those last three?
	//REMARK: maybe 'return prefix+s;' is not needed (?)
	// it causes some bugs such as can't save level progress
	if(s.compare(0,6,"%DATA%")==0){
	if(s.size()>6 && (s[6]=='/' \|\| s[6]=='\\')){
	return dataPath+s.substr(7);
	}else{
	return dataPath+s.substr(6);
	}
	}else if(s.compare(0,6,"%USER%")==0){
	if(s.size()>6 && (s[6]=='/' \|\| s[6]=='\\')){
	return getUserPath(USER_DATA)+s.substr(7);
	}else{
	return getUserPath(USER_DATA)+s.substr(6);
	}
	}else if(s.compare(0,9,"%LVLPACK%")==0){
	if(s.size()>9 && (s[9]=='/' \|\| s[9]=='\\')){
	return prefix+"levelpacks/"+s.substr(10);
	}else{
	return prefix+"levelpacks/"+s.substr(9);
	}
	}else if(s.compare(0,5,"%LVL%")==0){
	if(s.size()>5 && (s[5]=='/' \|\| s[5]=='\\')){
	return prefix+"levels/"+s.substr(6);
	}else{
	return prefix+"levels/"+s.substr(5);
	}
	}else if(s.compare(0,8,"%THEMES%")==0){
	if(s.size()>8 && (s[8]=='/' \|\| s[8]=='\\')){
	return prefix+"themes/"+s.substr(9);
	}else{
	return prefix+"themes/"+s.substr(8);
	}
	}else if(s.size()>0 && (s[0]=='/' \|\| s[0]=='\\')){
	return s;
	#ifdef WIN32
	// Another fix for Windows :(
	}else if(s.size()>1 && (s[1]==':')){
	return s;
	#endif
	}else{
	#if defined(ANDROID)
	//REMARK: maybe 'return prefix+s;' is not needed (?)
	// it causes some bugs such as can't save level progress in Android.
	return s;
	#else
	return prefix+s;
	#endif
	}
	}

	std::string compressFileName(const std::string& s){
	//FIXME: Do we need the other ones from processFileName?

	//Check if the data path is at the start.
	size_t pos=s.find(getDataPath());
	if(pos!=string::npos){
	pos+=getDataPath().size();
	return "%DATA%/"+s.substr(pos);
	}
	pos=s.find(getUserPath(USER_DATA));
	if(pos!=string::npos){
	pos+=getUserPath(USER_DATA).size();
	return "%USER%/"+s.substr(pos);
	}

	return s;
	}

	std::string fileNameFromPath(const std::string &path, const bool webURL){
	std::string filename;
	size_t pos;
	#ifdef WIN32
	// NOTE: '/' in string should be '/' not '\/',
	// we don't need to escape it
	if(webURL){
	pos = path.find_last_of("/");
	}else{
	// NOTE: sometimes path separator in Windows can be '/',
	// so we must check botn '\' and '/'
	pos = path.find_last_of("\\/");
	}
	#else
	// NOTE: '/' in string should be '/' not '\/',
	// we don't need to escape it
	pos = path.find_last_of("/");
	#endif
	if(pos != std::string::npos)
	filename.assign(path.begin() + pos + 1, path.end());
	else
	filename=path;

	return filename;
	}

	std::string pathFromFileName(const std::string &filename){
	std::string path;
	// NOTE: '/' in string should be '/' not '\/',
	// we don't need to escape it
	#ifdef WIN32
	// NOTE: sometimes path separator in Windows can be '/',
	// so we must check botn '\' and '/'
	size_t pos = filename.find_last_of("\\/");
	#else
	size_t pos = filename.find_last_of("/");
	#endif
	if(pos != std::string::npos)
	path.assign(filename.begin(), filename.begin() + pos +1);
	else
	path=filename;

	return path;
	}

	bool downloadFile(const string &path, const string &destination) {
	string filename=fileNameFromPath(path,true);

	FILE* file = fopen((destination+filename).c_str(), "wb");
	bool status=downloadFile(path,file);
	fclose(file);

	//And return the status.
	return status;
	}

	bool downloadFile(const string &path, FILE* destination) {
	CURL* curl=curl_easy_init();

	// proxy test (test only)
	string internetProxy = getSettings()->getValue("internet-proxy");
	size_t pos = internetProxy.find_first_of(":");
	if(pos!=string::npos){
	curl_easy_setopt(curl,CURLOPT_PROXYPORT,atoi(internetProxy.substr(pos+1).c_str()));
	internetProxy = internetProxy.substr(0,pos);
	curl_easy_setopt(curl,CURLOPT_PROXY,internetProxy.c_str());
	}

	curl_easy_setopt(curl,CURLOPT_URL,path.c_str());
	curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,writeData);
	curl_easy_setopt(curl,CURLOPT_WRITEDATA,destination);
	CURLcode res = curl_easy_perform(curl);
	curl_easy_cleanup(curl);

	return (res==0);
	}

	size_t writeData(void ptr, size_t size, size_t nmemb, void stream){
	return fwrite(ptr, size, nmemb, (FILE *)stream);
	}


	bool extractFile(const string &fileName, const string &destination) {
	//Create the archive we're going to extract.
	archive* file;
	//Create the destination we're going to extract to.
	archive* dest;

	file=archive_read_new();
	dest=archive_write_disk_new();
	archive_write_disk_set_options(dest, ARCHIVE_EXTRACT_TIME);

	archive_read_support_format_zip(file);

	//Now read the archive.
	if(archive_read_open_filename(file,fileName.c_str(),10240)) {
	cerr<<"ERROR: An error occurred while reading archive "+fileName<<endl;
	return false;
	}

	//Now write every entry to disk.
	int status;
	archive_entry* entry=NULL;
	while(true) {
	status=archive_read_next_header(file,&entry);
	if(status==ARCHIVE_EOF){
	break;
	}
	if(status!=ARCHIVE_OK){
	cerr<<"ERROR: An error occurred while reading archive "+fileName<<endl;
	return false;
	}
	archive_entry_copy_pathname(entry,(destination+archive_entry_pathname(entry)).c_str());

	status=archive_write_header(dest,entry);
	if(status!=ARCHIVE_OK){
	cerr<<"ERROR: An error occurred while extracting archive "+fileName<<endl;
	return false;
	}else{
	copyData(file, dest);
	status=archive_write_finish_entry(dest);
	if(status!=ARCHIVE_OK){
	cerr<<"ERROR: An error occurred while extracting archive "+fileName<<endl;
	return false;
	}

	}
	}

	//Finally close the archive.
	archive_read_close(file);
	archive_read_free(file);
	return true;
	}

	bool dirExists(const char* dir){
	#ifdef __linux__
	struct stat sb;
	if(stat(dir,&sb) == 0 && S_ISDIR(sb.st_mode)){
	return true;
	}
	return false;
	#elif defined(WIN32)
	DWORD attr=GetFileAttributesA(dir);
	if(attr==INVALID_FILE_ATTRIBUTES) return false;
	return (attr & FILE_ATTRIBUTE_DIRECTORY)!=0;
	#else
	#error dirExists is not implemented for this system! Add the code for your system here.
	#endif
	}

	bool createDirectory(const char* path){
	#ifdef WIN32
	char s0[1024],s[1024];

	GetCurrentDirectoryA(sizeof(s0),s0);
	PathCombineA(s,s0,path);

	for(unsigned int i=0;i<sizeof(s);i++){
	if(s[i]=='\0') break;
	else if(s[i]=='/') s[i]='\\';
	}

	//printf("createDirectory:%s\n",s);
	return SHCreateDirectoryExA(NULL,s,NULL)!=0;
	#else
	return mkdir(path,0777)==0;
	#endif
	}

	bool removeDirectory(const char *path){
	#ifdef WIN32
	WIN32_FIND_DATAA f;
	HANDLE h = FindFirstFileA((string(path)+"\\*").c_str(),&f);
	#else
	//Open the directory that needs to be removed.
	DIR* d=opendir(path);
	#endif
	//Get the path length
	size_t path_len = strlen(path);
	//Boolean if the directory is emptied.
	//True: succes False: failure
	//Default is true because if the directory is empty it will never enter the while loop, but we still have success.
	bool r = true;

	#ifdef WIN32
	if(h!=NULL && h!=INVALID_HANDLE_VALUE) {
	#else
	//Check if the directory exists.
	if(d) {
	//Pointer to an entry of the directory.
	struct dirent* p;
	#endif

	#ifdef WIN32
	do{
	#else
	//Loop the entries of the directory that needs to be removed as long as there's no error.
	while(r && (p=readdir(d))) {
	#endif

	/* Skip the names "." and ".." as we don't want to recurse on them. */
	#ifdef WIN32
	if (!strcmp(f.cFileName, ".") \|\| !strcmp(f.cFileName, "..")) {
	#else
	if (!strcmp(p->d_name, ".") \|\| !strcmp(p->d_name, "..")) {
	#endif
	//The filename is . or .. so we continue to the next entry.
	continue;
	} else {
	//r2 tells if the entry is deleted.
	//True: succes False: failure
	//Default is false.
	bool r2 = false;
	char* buf;
	size_t len;

	#ifdef WIN32
	//Get the length of the path + the directory entry name.
	len = path_len + strlen(f.cFileName) + 2;
	#else
	//Get the length of the path + the directory entry name.
	len = path_len + strlen(p->d_name) + 2;
	#endif
	buf = (char*) malloc(len);

	if(buf) {
	#ifdef WIN32
	_snprintf(buf, len, "%s\\%s", path, f.cFileName);

	if(f.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY){
	r2 = removeDirectory(buf);
	}else{
	r2 = unlink(buf)==0;
	}
	#else
	struct stat statbuf;
	snprintf(buf, len, "%s/%s", path, p->d_name);

	if(!stat(buf, &statbuf)){
	//Check if the entry is a directory or a file.
	if (S_ISDIR(statbuf.st_mode)){
	//We call ourself(removeDirectory) recursively.
	//We return true on success.
	r2 = removeDirectory(buf);
	}else{
	//unlink() returns zero on succes so we set r2 to the unlink(buf)==0.
	r2 = unlink(buf)==0;
	}
	}
	#endif
	//Free the buf.
	free(buf);
	}
	//We set r to r2 since r2 contains the status of the latest deletion.
	r = r2;
	}
	#ifdef WIN32
	}while(r && FindNextFileA(h,&f));
	FindClose(h);
	#else
	}
	//Close the directory.
	closedir(d);
	#endif
	}

	//The while loop has ended, meaning we (tried) cleared the directory.
	//If r is true, meaning no errors we can delete the directory.
	if(r){
	//The return value of rmdir is 0 when it succeeded.
	r = rmdir(path)==0;
	}

	//Return the status.
	return r;
	}

	bool renameDirectory(const char* oldPath,const char* newPath){
	return rename(oldPath,newPath)==0;
	}


	void copyData(archive* file, archive* dest) {
	int status;
	const void* buff;
	size_t size;
	#if ARCHIVE_VERSION_NUMBER < 3000000
	off_t offset;
	#else
	int64_t offset;
	#endif


	while(true) {
	status=archive_read_data_block(file, &buff, &size, &offset);
	if(status==ARCHIVE_EOF){
	return;
	}
	if(status!=ARCHIVE_OK){
	cerr<<"ERROR: An error occurred while writing data to disk."<<endl;
	return;
	}
	status=archive_write_data_block(dest, buff, size, offset);
	if(status!=ARCHIVE_OK) {
	cerr<<"ERROR: An error occurred while writing data to disk."<<endl;
	return;
	}
	}
	}

	bool copyFile(const char* source,const char* dest){
	//Open the source file.
	ifstream fin(source,fstream::binary);
	if(!fin)
	return false;

	//Open the dest file.
	ofstream fout(dest,fstream::trunc\|fstream::binary);
	if(!fout)
	return false;

	//Copy.
	fout<<fin.rdbuf();
	return true;
	}

	bool removeFile(const char* file){
	return remove(file)==0;
	}

	bool fileExists(const char* file){
	#ifdef WIN32
	bool ret=false;
	HANDLE h=CreateFileA(file,0,FILE_SHARE_READ \| FILE_SHARE_WRITE \| FILE_SHARE_DELETE,NULL,OPEN_EXISTING,0,NULL);
	if(h!=INVALID_HANDLE_VALUE){
	ret=true;
	CloseHandle(h);
	}
	return ret;
	#else
	return (access(file,F_OK)==0);
	#endif
	}

	bool createFile(const char* file){
	//Open the file with write permission.
	FILE* f=fopen(file,"wb");

	//Check if there are no problems.
	if(f){
	//Close the file.
	fclose(f);
	return true;
	}else{
	return false;
	}
	}
	diff --git a/src/Functions.cpp b/src/Functions.cpp
	index 1975037..b48c8ff 100644
	--- a/src/Functions.cpp
	+++ b/src/Functions.cpp
	@@ -1,1749 +1,1749 @@
	/*
	* Copyright (C) 2011-2013 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 <locale.h>
	#include <algorithm>
	#include <SDL.h>
	#include <SDL_mixer.h>
	#include <SDL_syswm.h>
	#include <SDL_ttf.h>
	#include <string>
	#include "Globals.h"
	#include "Functions.h"
	#include "FileManager.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 "SoundManager.h"
	#include "ScriptExecutor.h"
	#include "LevelPackManager.h"
	#include "ThemeManager.h"
	#include "GUIListBox.h"
	#include "GUIOverlay.h"
	#include "StatisticsManager.h"
	#include "StatisticsScreen.h"
	#include "Cursors.h"
	#include "ScriptAPI.h"

	#include "libs/tinyformat/tinyformat.h"
	#include "libs/tinygettext/tinygettext.hpp"
	#include "libs/tinygettext/log.hpp"
	#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.
	#if defined(__linux__) && !defined(ANDROID)
	#include<X11/Xlib.h>
	#include<X11/Xutil.h>
	#define __X11_INCLUDED__
	#endif

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

	//Initialise the soundManager.
	//The SoundManager is used to keep track of the sfx in the game.
	SoundManager soundManager;

	//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=nullptr;

	SDL_Renderer* sdlRenderer=nullptr;

	#ifdef HARDWARE_ACCELERATION
	GLuint screenTexture;
	#endif

	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_Renderer& renderer,Uint32 color){
	//NOTE: We let SDL_gfx render it.
	SDL_SetRenderDrawColor(&renderer,color >> 24,color >> 16,color >> 8,255);
	//rectangleRGBA(&renderer,x,y,x+w,y+h,color >> 24,color >> 16,color >> 8,255);
	const SDL_Rect r{x,y,w,h};
	SDL_RenderDrawRect(&renderer,&r);
	}

	//Draw a box with anti-aliased borders using SDL_gfx.
	void drawGUIBox(int x,int y,int w,int h,SDL_Renderer& renderer,Uint32 color){
	SDL_Renderer* rd = &renderer;
	//FIXME, this may get the wrong color on system with different endianness.
	//Fill content's background color from function parameter
	SDL_SetRenderDrawColor(rd,color >> 24,color >> 16,color >> 8,color >> 0);
	{
	const SDL_Rect r{x+1,y+1,w-2,h-2};
	SDL_RenderFillRect(rd, &r);
	}
	SDL_SetRenderDrawColor(rd,0,0,0,255);
	//Draw first black borders around content and leave 1 pixel in every corner
	SDL_RenderDrawLine(rd,x+1,y,x+w-2,y);
	SDL_RenderDrawLine(rd,x+1,y+h-1,x+w-2,y+h-1);
	SDL_RenderDrawLine(rd,x,y+1,x,y+h-2);
	SDL_RenderDrawLine(rd,x+w-1,y+1,x+w-1,y+h-2);

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

	//Draw second lighter border around content
	SDL_SetRenderDrawColor(rd,0,0,0,64);
	{
	const SDL_Rect r{x+1,y+1,w-2,h-2};
	SDL_RenderDrawRect(rd,&r);
	}

	SDL_SetRenderDrawColor(rd,0,0,0,50);

	//Create anti-aliasing in corners of second border
	SDL_RenderDrawPoint(rd,x+1,y+1);
	SDL_RenderDrawPoint(rd,x+1,y+h-2);
	SDL_RenderDrawPoint(rd,x+w-2,y+1);
	SDL_RenderDrawPoint(rd,x+w-2,y+h-2);
	}

	void drawLine(int x1,int y1,int x2,int y2,SDL_Renderer& renderer,Uint32 color){
	SDL_SetRenderDrawColor(&renderer,color >> 24,color >> 16,color >> 8,255);
	//NOTE: We let SDL_gfx render it.
	//lineRGBA(&renderer,x1,y1,x2,y2,color >> 24,color >> 16,color >> 8,255);
	SDL_RenderDrawLine(&renderer,x1,y1,x2,y2);
	}

	void drawLineWithArrow(int x1,int y1,int x2,int y2,SDL_Renderer& renderer,Uint32 color,int spacing,int offset,int xsize,int ysize){
	//Draw line first
	drawLine(x1,y1,x2,y2,renderer,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),renderer,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),renderer,color);
	}
	}

	ScreenData creationFailed() {
	- return ScreenData();
	+ return ScreenData{ nullptr };
	}

	ScreenData 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;

	//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;
	}

	//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.
	fprintf(stderr,"FATAL ERROR: Unable to use hardware acceleration (compiled without).\n");
	return creationFailed();
	#endif
	}else{
	//Set the flags.
	// Uint32 flags=SCREEN_FLAGS;
	//Flags are not used in SDL2.
	Uint32 flags = 0;
	//#if !defined(ANDROID)
	// flags \|= SDL_DOUBLEBUF;
	//#endif
	if(settings->getBoolValue("fullscreen"))
	flags\|=SDL_WINDOW_FULLSCREEN; //TODO with SDL2 we can also do SDL_WINDOW_FULLSCREEN_DESKTOP
	else if(settings->getBoolValue("resizable"))
	flags\|=SDL_WINDOW_RESIZABLE;

	//Create the window and renderer if they don't exist and check if there weren't any errors.
	if (!sdlWindow && !sdlRenderer) {
	// screen=SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,flags);
	SDL_CreateWindowAndRenderer(SCREEN_WIDTH, SCREEN_HEIGHT, flags, &sdlWindow, &sdlRenderer);
	if(!sdlWindow \|\| !sdlRenderer){
	std::cerr << "FATAL ERROR: SDL_CreateWindowAndRenderer failed.\nError: " << SDL_GetError() << std::endl;
	return creationFailed();
	}

	SDL_SetRenderDrawBlendMode(sdlRenderer, SDL_BlendMode::SDL_BLENDMODE_BLEND);

	// White background so we see the menu on failure.
	SDL_SetRenderDrawColor(sdlRenderer, 255, 255, 255, 255);
	}
	}

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

	//Set the the window caption.
	SDL_SetWindowTitle(sdlWindow, ("Me and My Shadow "+version).c_str());
	//FIXME Seems to be obsolete
	// SDL_EnableUNICODE(1);

	//Nothing went wrong so return true.
	return ScreenData{sdlRenderer};
	}

	//Workaround for the resizing below 800x600 for Windows.
	#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

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

	//Enumerate available 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\|SCREEN_FLAGS\|SDL_ANYFORMAT);
	//NOTe - currently only using the first display (0)
	int numDisplayModes = SDL_GetNumDisplayModes(0);

	if(numDisplayModes < 1){
	cerr<<"ERROR: Can't enumerate available 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(int i=0;i < numDisplayModes; ++i){
	SDL_DisplayMode mode;
	int error = SDL_GetDisplayMode(0, i, &mode);
	if(error < 0) {
	//We failed to get a display mode. Should we crash here?
	std::cerr << "ERROR: Failed to get display mode " << i << " " << std::endl;
	}
	//Check if the resolution is higher than the minimum (800x600).
	if(mode.w >= 800 && mode.h >= 600){
	_res res={mode.w, mode.h};
	resolutionList.push_back(res);
	}
	}
	//Reverse it so that we begin with the lowest resolution.
	reverse(resolutionList.begin(),resolutionList.end());
	}
	}

	//Return the resolution list.
	return resolutionList;
	}

	void pickFullscreenResolution(){
	//Get the resolution list.
	vector<_res> resolutionList=getResolutionList();

	//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);
	}

	#ifdef __X11_INCLUDED__
	int handleXError(Display* disp,XErrorEvent* event){
	//NOTE: This is UNTESTED code, there are still some things that should be tested/changed.
	//NOTE: It checks against hardcoded opcodes, this should be based on included defines from the xf86vid headers instead.
	//NOTE: This code assumes Xlib is in use, just like the resize restriction code for Linux.

	//Print out the error message as normal.
	char output[256];
	XGetErrorText(disp,event->error_code,output,256);
	cerr<<output<<endl;

	//Check if the game is fullscreen.
	if(getSettings()->getBoolValue("fullscreen")){
	//Check for the exact error we want to handle differently.
	if(event->error_code==BadValue && event->minor_code==10/X_XF86VidModeSwitchToMode/){
	//The cause of this problem has likely something to do with fullscreen mode, so fallback to windowed.
	cerr<<"ERROR: Xlib error code "<<event->error_code<<", request code "<<event->request_code<<"."<<endl;
	cerr<<"ERROR: Falling back to windowed mode!"<<endl;

	getSettings()->setValue("fullscreen","false");
	createScreen();
	return 0;
	}
	}

	//Do the normal Xlib behaviour.
	exit(1);
	return 0;
	}
	#endif

	void configureWindow(){
	//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_GetWindowWMInfo(sdlWindow, &wmInfo);

	#ifdef __X11_INCLUDED__
	//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())){
	std::cerr<<"ERROR: Unable to allocate memory for XSizeHints."<<endl;
	return;
	}

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

	//Set the normal hints of the window.
	//TODO: Lock func no longer exists in SDL2, is using
	//XLockDisplay is correct?
	//(void)wmInfo.info.x11.lock_func;
	XLockDisplay(wmInfo.info.x11.display);
	XSetWMNormalHints(wmInfo.info.x11.display,wmInfo.info.x11.window,sizeHints);
	XUnlockDisplay(wmInfo.info.x11.display);
	//(void)wmInfo.info.x11.unlock_func;

	//Free size hint structure
	XFree(sizeHints);

	}else{
	//No X11 so an unsupported window manager.
	std::cerr<<"WARNING: Untested windowing system!"<<endl;
	}
	#elif defined(WIN32)
	//We overwrite the window proc of SDL
	- WNDPROC wndproc=(WNDPROC)GetWindowLong(wmInfo.win.window,GWL_WNDPROC);
	+ WNDPROC wndproc=(WNDPROC)GetWindowLong(wmInfo.info.win.window,GWL_WNDPROC);
	if(wndproc!=NULL && wndproc!=(WNDPROC)WindowProc){
	m_OldWindowProc=wndproc;
	- SetWindowLong(wmInfo.win.window,GWL_WNDPROC,(LONG)(WNDPROC)WindowProc);
	+ SetWindowLong(wmInfo.info.win.window,GWL_WNDPROC,(LONG)(WNDPROC)WindowProc);
	}
	#endif
	}

	void onVideoResize(ImageManager& imageManager, SDL_Renderer &renderer){
	//Check if the resize event isn't malformed.
	if(event.window.data1<=0 \|\| event.window.data2<=0)
	return;

	//Check the size limit.
	//TODO: SDL2 porting note: This may break on systems non-X11 or Windows systems as the window size won't be limited
	//there.
	if(event.window.data1<800)
	event.window.data1=800;
	if(event.window.data2<600)
	event.window.data2=600;

	//Check if it really resizes.
	if(SCREEN_WIDTH==event.window.data1 && SCREEN_HEIGHT==event.window.data2)
	return;

	char s[32];

	//Set the new width and height.
	snprintf(s,32,"%d",event.window.data1);
	getSettings()->setValue("width",s);
	snprintf(s,32,"%d",event.window.data2);
	getSettings()->setValue("height",s);
	//FIXME: THIS doesn't work properly.
	//Do resizing.
	if(!createScreen())
	return;

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

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

	ScreenData init(){
	//Initialze SDL.
	if(SDL_Init(SDL_INIT_EVERYTHING)==-1) {
	std::cerr << "FATAL ERROR: SDL_Init failed\nError: " << SDL_GetError() << std::endl;
	return creationFailed();
	}

	//Initialze SDL_mixer (audio).
	//Note for SDL2 port: Changed frequency from 22050 to 44100.
	//22050 caused some sound artifacts on my system, and I'm not sure
	//why one would use it in this day and age anyhow.
	//unless it's for compatability with some legacy system.
	if(Mix_OpenAudio(44100,MIX_DEFAULT_FORMAT,2,512)==-1){
	std::cerr << "FATAL ERROR: Mix_OpenAudio failed\nError: " << Mix_GetError() << std::endl;
	return creationFailed();
	}
	//Set the volume.
	Mix_Volume(-1,atoi(settings->getValue("sound").c_str()));

	//Initialze SDL_ttf (fonts).
	if(TTF_Init()==-1){
	std::cerr << "FATAL ERROR: TTF_Init failed\nError: " << TTF_GetError() << std::endl;
	return creationFailed();
	}

	#ifdef __X11_INCLUDED__
	//Before creating the screen set the XErrorHandler in case of X11.
	XSetErrorHandler(handleXError);
	#endif

	//Create the screen.
	ScreenData screenData(createScreen());
	if(!screenData) {
	return creationFailed();
	}

	//Load key config. Then initialize 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);

	//Set time format to the user-preference of the system.
	setlocale(LC_TIME,"");

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

	//Structure that holds the event type/name pair.
	struct EventTypeName{
	int type;
	const char* name;
	};
	//Create the types of game object event types.
	{
	const EventTypeName types[]={
	{GameObjectEvent_PlayerWalkOn,"playerWalkOn"},
	{GameObjectEvent_PlayerIsOn,"playerIsOn"},
	{GameObjectEvent_PlayerLeave,"playerLeave"},
	{GameObjectEvent_OnCreate,"onCreate"},
	{GameObjectEvent_OnEnterFrame,"onEnterFrame"},
	{GameObjectEvent_OnToggle,"onToggle"},
	{GameObjectEvent_OnSwitchOn,"onSwitchOn"},
	{GameObjectEvent_OnSwitchOff,"onSwitchOff"},
	{0,NULL}
	};
	for(int i=0;types[i].name;i++){
	Game::gameObjectEventNameMap[types[i].name]=types[i].type;
	Game::gameObjectEventTypeMap[types[i].type]=types[i].name;
	}
	}
	//Create the types of level event types.
	{
	const EventTypeName types[]={
	{LevelEvent_OnCreate,"onCreate"},
	{LevelEvent_OnSave,"onSave"},
	{LevelEvent_OnLoad,"onLoad"},
	{LevelEvent_OnReset,"onReset"},
	{0,NULL}
	};
	for(int i=0;types[i].name;i++){
	Game::levelEventNameMap[types[i].name]=types[i].type;
	Game::levelEventTypeMap[types[i].type]=types[i].name;
	}
	}

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

	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{
	#if defined(ANDROID)
	//Android has built-in DroidSansFallback.ttf. (?)
	return TTF_OpenFont("/system/fonts/DroidSansFallback.ttf",size);
	#else
	return TTF_OpenFont((getDataPath()+"font/DroidSansFallback.ttf").c_str(),size);
	#endif
	}
	}

	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);
	if(fontMono)
	TTF_CloseFont(fontMono);

	/// 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);
	fontMono=loadFont("VeraMono",12);
	if(fontTitle==NULL \|\| fontGUI==NULL \|\| fontGUISmall==NULL \|\| fontText==NULL \|\| fontMono==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(SDL_Renderer& renderer){
	TTF_Font* fontArrow=loadFont(_("knewave"),18);

	arrowLeft1=textureFromText(renderer,*fontArrow,"<",themeTextColor);
	arrowRight1=textureFromText(renderer,*fontArrow,">",themeTextColor);
	arrowLeft2=textureFromText(renderer,*fontArrow,"<",themeTextColorDialog);
	arrowRight2=textureFromText(renderer,*fontArrow,">",themeTextColorDialog);

	TTF_CloseFont(fontArrow);
	}

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

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

	generateArrows(renderer);

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

	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{
	++i;
	data[i]=mask[i]=0;
	}
	switch(image[4+row][col]){
	case '+':
	data[i] \|= 0x01;
	mask[i] \|= 0x01;
	break;
	case '.':
	mask[i] \|= 0x01;
	break;
	default:
	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);
	}

	bool loadFiles(ImageManager& imageManager, SDL_Renderer& renderer){
	//Load the fonts.
	if(!loadFonts())
	return false;

	//Show a loading screen
	{
	int w = 0,h = 0;
	SDL_GetRendererOutputSize(&renderer, &w, &h);
	SDL_Color fg={255,255,255,0};
	TexturePtr loadingTexture = textureFromText(renderer, *fontTitle, _("Loading..."),fg);
	SDL_Rect loadingRect = rectFromTexture(*loadingTexture);
	loadingRect.x = (w-loadingRect.w)/2;
	loadingRect.y = (h-loadingRect.h)/2;
	SDL_RenderCopy(sdlRenderer, loadingTexture.get(), NULL, &loadingRect);
	SDL_RenderPresent(sdlRenderer);
	SDL_RenderClear(sdlRenderer);
	}

	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);

	//Load all the music lists from the data and user data path.
	{
	vector<string> musicLists=enumAllFiles((getDataPath()+"music/"),"list",true);
	for(unsigned int i=0;i<musicLists.size();i++)
	getMusicManager()->loadMusicList(musicLists[i]);
	musicLists=enumAllFiles((getUserPath(USER_DATA)+"music/"),"list",true);
	for(unsigned int i=0;i<musicLists.size();i++)
	getMusicManager()->loadMusicList(musicLists[i]);
	}
	//Set the list to the configured one.
	getMusicManager()->setMusicList(getSettings()->getValue("musiclist"));

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

	//Load the sound effects
	soundManager.loadSound((getDataPath()+"sfx/jump.wav").c_str(),"jump");
	soundManager.loadSound((getDataPath()+"sfx/hit.wav").c_str(),"hit");
	soundManager.loadSound((getDataPath()+"sfx/checkpoint.wav").c_str(),"checkpoint");
	soundManager.loadSound((getDataPath()+"sfx/swap.wav").c_str(),"swap");
	soundManager.loadSound((getDataPath()+"sfx/toggle.wav").c_str(),"toggle");
	soundManager.loadSound((getDataPath()+"sfx/error.wav").c_str(),"error");
	soundManager.loadSound((getDataPath()+"sfx/collect.wav").c_str(),"collect");
	soundManager.loadSound((getDataPath()+"sfx/achievement.ogg").c_str(),"achievement");

	//Load the cursor images from the Cursor.h file.
	cursors[CURSOR_POINTER]=loadCursor(pointer);
	cursors[CURSOR_CARROT]=loadCursor(ibeam);
	cursors[CURSOR_DRAG]=loadCursor(closedhand);
	cursors[CURSOR_SIZE_HOR]=loadCursor(size_hor);
	cursors[CURSOR_SIZE_VER]=loadCursor(size_ver);
	cursors[CURSOR_SIZE_FDIAG]=loadCursor(size_fdiag);
	cursors[CURSOR_SIZE_BDIAG]=loadCursor(size_bdiag);
	cursors[CURSOR_REMOVE]=loadCursor(remove_cursor);
	//Set the default cursor right now.
	SDL_SetCursor(cursors[CURSOR_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";
	levelsPack->levelpackPath="Levels/";
	//NOTE: Set the type of 'levels' to main so it won't be added to the custom packs, even though it contains non-main levels.
	levelsPack->type=COLLECTION;
	LevelPack* customLevelsPack=new LevelPack;
	customLevelsPack->levelpackName="Custom Levels";
	customLevelsPack->levelpackPath="Custom Levels/";
	customLevelsPack->type=COLLECTION;

	//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(renderer, imageManager);
	statsMgr.registerAchievements(imageManager);
	statsMgr.loadFile(getUserPath(USER_CONFIG)+"statistics");

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

	//Load the theme, both menu and default.
	//NOTE: Loading theme may fail and returning false would stop everything, default theme will be used instead.
	if (!loadTheme(imageManager,renderer,getSettings()->getValue("theme"))){
	getSettings()->setValue("theme","%DATA%/themes/Cloudscape");
	saveSettings();
	}

	//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(){
	return settings->save();
	}

	Settings* getSettings(){
	return settings;
	}

	MusicManager* getMusicManager(){
	return &musicManager;
	}

	SoundManager* getSoundManager(){
	return &soundManager;
	}

	LevelPackManager* getLevelPackManager(){
	return &levelPackManager;
	}

	ScriptExecutor* getScriptExecutor(){
	return &scriptExecutor;
	}

	void flipScreen(SDL_Renderer& renderer){
	// Render the data from the back buffer.
	SDL_RenderPresent(&renderer);
	}

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

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

	//Delete dictionaryManager.
	delete dictionaryManager;

	//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;
	}

	//These calls to destroy makes sure stuff is
	//deleted before SDL is uninitialised (as these managers are stack allocated
	//globals.)

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

	//Destroy all sounds
	soundManager.destroy();

	//Destroy the cursors.
	for(int i=0;i<CURSOR_MAX;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_CloseFont(fontMono);
	TTF_Quit();

	//Remove the temp surface.
	SDL_DestroyRenderer(sdlRenderer);
	SDL_DestroyWindow(sdlWindow);
	arrowLeft1.reset(nullptr);
	arrowLeft2.reset(nullptr);
	arrowRight1.reset(nullptr);
	arrowRight2.reset(nullptr);

	//Stop audio.and quit
	Mix_CloseAudio();
	//SDL2 porting note. Not sure why this was only done on apple.
	//#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(ImageManager& imageManager, SDL_Renderer& renderer){

	//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=NULL;
	Game* game=new Game(renderer, imageManager);
	currentState=game;
	//Check if we should load record file or a level.
	if(!Game::recordFile.empty()){
	game->loadRecord(imageManager,renderer,Game::recordFile.c_str());
	Game::recordFile.clear();
	}else{
	game->loadLevel(imageManager,renderer,levels->getLevelFile());
	levels->saveLevelProgress();
	}
	}
	break;
	case STATE_MENU:
	currentState=new Menu(imageManager, renderer);
	break;
	case STATE_LEVEL_SELECT:
	currentState=new LevelPlaySelect(imageManager, renderer);
	break;
	case STATE_LEVEL_EDIT_SELECT:
	currentState=new LevelEditSelect(imageManager, renderer);
	break;
	case STATE_LEVEL_EDITOR:
	{
	currentState=NULL;
	LevelEditor* levelEditor=new LevelEditor(renderer, imageManager);
	currentState=levelEditor;
	//Load the selected level.
	levelEditor->loadLevel(imageManager,renderer,levels->getLevelFile());
	}
	break;
	case STATE_OPTIONS:
	currentState=new Options(imageManager, renderer);
	break;
	case STATE_ADDONS:
	currentState=new Addons(renderer, imageManager);
	break;
	case STATE_CREDITS:
	currentState=new Credits(imageManager,renderer);
	break;
	case STATE_STATISTICS:
	currentState=new StatisticsScreen(imageManager,renderer);
	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, if fading is enabled.
	int fade=0;
	if(settings->getBoolValue("fading"))
	fade=255;
	while(fade>0){
	// FIXME: Disabled for now
	fade-=17;
	if(fade<0)
	fade=0;
	dimScreen(renderer, static_cast<Uint8>(255-fade));
	flipScreen(renderer);
	SDL_Delay(25);
	}
	}
	}

	void musicStoppedHook(){
	//We just call the musicStopped method of the MusicManager.
	musicManager.musicStopped();
	}

	void channelFinishedHook(int channel){
	soundManager.channelFinished(channel);
	}

	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;
	}

	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(ImageManager& imageManager, SDL_Renderer& renderer, 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(ImageManager& imageManager,SDL_Renderer& renderer, 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 GUIFrame(imageManager,renderer,(SCREEN_WIDTH-600)/2,200,600,200,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 GUILabel(imageManager,renderer,0,y,root->width,25,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 GUIButton(imageManager,renderer,root->width*places[i],y,-1,36,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(renderer,root);
	overlay->enterLoop(imageManager,renderer, 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(ImageManager& imageManager, SDL_Renderer& renderer,std::string name,GUIObject* obj,int /eventType/) override {
	//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(imageManager,renderer);

	//Prompt the user with a Yes or No question.
	/// TRANSLATORS: Filename is coming before this text
	if(msgBox(imageManager,renderer, 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(imageManager,renderer);

	//The file can't be opened so tell the user.
	msgBox(imageManager,renderer, 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(imageManager,renderer);

	//Unable to open file so tell the user.
	msgBox(imageManager,renderer, 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;
	}
	}
	}
	};

	//SDL2 port note: Commented this out since it was unused.
	/*
	bool fileDialog(ImageManager& imageManager,SDL_Renderer& renderer, 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 GUIFrame(100,100-base_y/2,600,400+base_y,title?title:(isSave?_("Save File"):_("Load File")));

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

	//Add the FileName label and textfield.
	root->addChild(new GUILabel(8,20+base_y,184,36,_("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 GUITextBox(160,20+base_y,432,36,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 GUIButton(200,360+base_y,192,36,_("OK"));
	obj->name="cmdOK";
	obj->eventCallback=&objHandler;
	root->addChild(obj);
	obj=new GUIButton(400,360+base_y,192,36,_("Cancel"));
	obj->name="cmdCancel";
	obj->eventCallback=&objHandler;
	root->addChild(obj);

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

	//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 e2f4ac8..7ecdedd 100644
	--- a/src/Functions.h
	+++ b/src/Functions.h
	@@ -1,274 +1,274 @@
	/*
	* Copyright (C) 2011-2013 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 "Globals.h"

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

	class MusicManager;
	class SoundManager;

	//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
	//NOTE: "_C" is conflict to some Android macros so we change its name.
	//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 _CC(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)

	class ImageManager;
	-class SDL_Texture;
	+struct SDL_Texture;
	class LevelPackManager;
	class ScriptExecutor;

	//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_Renderer &renderer, 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.
	//renderer: The SDL_Renderer to render on..
	//color: The color of the rectangle background to draw.
	void drawGUIBox(int x,int y,int w,int h,SDL_Renderer& renderer,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_Renderer &renderer,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_Renderer &renderer, 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(ImageManager& imageManager, SDL_Renderer& renderer, std::string name);

	struct ScreenData{
	- SDL_Renderer* renderer=nullptr;
	+ SDL_Renderer* renderer;
	explicit operator bool() const {
	return renderer!=nullptr;
	}
	};

	//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.
	ScreenData createScreen();


	//A very simple structure for resolutions.
	struct _res{
	int w,h;
	};

	//Method for retrieving a list of resolutions.
	std::vector<_res> getResolutionList();
	//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.
	void configureWindow();

	//Call this method when receive SDL_VIDEORESIZE event.
	void onVideoResize(ImageManager &imageManager, SDL_Renderer& renderer);

	//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.
	ScreenData init();
	//Loads some important files, like the background music and the default theme.
	//Returns: True if everything goes well.
	bool loadFiles(ImageManager &imageManager, SDL_Renderer &renderer);

	//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 SoundManager object.
	//Returns: A pointer to the SoundManager object.
	SoundManager* getSoundManager();

	//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(SDL_Renderer& renderer);

	//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(ImageManager &imageManager, SDL_Renderer &renderer);

	//This method is called when music is stopped.
	//NOTE: This method is outside the MusicManager because it can't be called otherwise by SDL_Mixer.
	//Do not call this method anywhere in the code!
	void musicStoppedHook();

	//This method is called when a sfx finished playing.
	//NOTE: This method is outside the SoundManager because it can't be called otherwise by SDL_Mixer.
	//Do not call this method anywhere in the code!
	//channel: The number of the channel that is finished.
	void channelFinishedHook(int channel);

	//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);

	//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(ImageManager& imageManager,SDL_Renderer& renderer, 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(ImageManager& imageManager, SDL_Renderer& renderer, 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/GUIObject.cpp b/src/GUIObject.cpp
	index fed8d02..87a8870 100644
	--- a/src/GUIObject.cpp
	+++ b/src/GUIObject.cpp
	@@ -1,938 +1,939 @@
	/*
	* 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 "GUIObject.h"
	+#include <algorithm>
	#include <iostream>
	#include <list>
	#include <SDL_ttf.h>

	#include "Render.h"

	using namespace std;

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

	void GUIObjectHandleEvents(ImageManager& imageManager, SDL_Renderer& renderer, bool kill){
	//NOTE: This was already not doing anything so commenting it for now.
	/*
	//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(renderer);

	//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(imageManager,renderer,e.name,e.obj,e.eventType);
	}
	}
	//We empty the event queue just to be sure.
	GUIEventQueue.clear();
	}

	GUIObject::~GUIObject(){
	//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(SDL_Renderer& renderer,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 its parent are enabled.
	enabled=enabled && this->enabled;
	//The GUIObject is only enabled when its parent are enabled.
	visible=visible && this->visible;

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

	//Also let the children handle their events.
	for(unsigned int i=0;i<childControls.size();i++){
	bool b1=childControls[i]->handleEvents(renderer,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 GUIObject::render(SDL_Renderer& renderer, int x,int y,bool draw){
	//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;

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

	void GUIObject::refreshCache(bool enabled) {
	//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){
	//TODO: Only change alpha if only enabled changes.
	//Free the cache.
	cacheTex.reset(nullptr);

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

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

	//////////////GUIButton///////////////////////////////////////////////////////////////////

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

	//The widget is only enabled when its parent are enabled.
	enabled=enabled && this->enabled;
	//The widget is only enabled when its parent are enabled.
	visible=visible && this->visible;

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

	//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 widget.
	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;

	//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;
	}
	}
	}

	//Also let the children handle their events.
	for(unsigned int i=0;i<childControls.size();i++){
	bool b1=childControls[i]->handleEvents(renderer,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 GUIButton::render(SDL_Renderer& renderer, int x,int y,bool draw){
	//There's no need drawing the widget when it's invisible.
	if(!visible)
	return;

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

	refreshCache(enabled);

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

	if(!smallFont) {
	cacheTex = textureFromText(renderer, *fontGUI, lp, color);
	} else {
	cacheTex = textureFromText(renderer, *fontGUISmall, lp, color);
	}
	//Make the widget transparent if it's disabled.
	if(!enabled) {
	SDL_SetTextureAlphaMod(cacheTex.get(), 128);
	}
	//Calculate proper size for the widget.
	if(width<=0){
	width=textureWidth(*cacheTex)+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.
	const SDL_Rect size = rectFromTexture(*cacheTex);
	const int drawX=x-gravityX+(width-size.w)/2;
	const int drawY=y+(height-size.h)/2-GUI_FONT_RAISE;

	//Check if the arrows don't fall of.
	if(size.w+32<=width){
	if(state==1){
	if(inDialog){
	applyTexture(x-gravityX+(width-size.w)/2+4+size.w+5,y+2,*arrowLeft2,renderer);
	applyTexture(x-gravityX+(width-size.w)/2-25,y+2,*arrowRight2,renderer);
	}else{
	applyTexture(x-gravityX+(width-size.w)/2+4+size.w+5,y+2,*arrowLeft1,renderer);
	applyTexture(x-gravityX+(width-size.w)/2-25,y+2,*arrowRight1,renderer);
	}
	}else if(state==2){
	if(inDialog){
	applyTexture(x-gravityX+(width-size.w)/2+4+size.w,y+2,*arrowLeft2,renderer);
	applyTexture(x-gravityX+(width-size.w)/2-20,y+2,*arrowRight2,renderer);
	}else{
	applyTexture(x-gravityX+(width-size.w)/2+4+size.w,y+2,*arrowLeft1,renderer);
	applyTexture(x-gravityX+(width-size.w)/2-20,y+2,arrowRight1,renderer);
	}
	}
	}

	//Draw the text.
	applyTexture(drawX, drawY, *cacheTex, renderer);
	}
	}
	}

	//////////////GUICheckBox///////////////////////////////////////////////////////////////////

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

	//The widget is only enabled when its parent are enabled.
	enabled=enabled && this->enabled;
	//The widget is only enabled when its parent are enabled.
	visible=visible && this->visible;

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

	//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 widget.
	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;

	//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;
	}
	}
	}

	return b;
	}

	void GUICheckBox::render(SDL_Renderer& renderer, int x,int y,bool draw){
	//There's no need drawing the widget when it's invisible.
	if(!visible)
	return;

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

	refreshCache(enabled);

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

	cacheTex=textureFromText(renderer,*fontText,lp,color);
	}

	if(draw){
	//Calculate the location, center it vertically.
	const int drawX=x;
	const int drawY=y+(height - textureHeight(*cacheTex))/2;

	//Draw the text
	applyTexture(drawX, drawY, *cacheTex, renderer);
	}
	}

	if(draw){
	//Draw the check (or not).
	//value*16 determines where in the gui textures we draw from.
	//if(value==1\|\|value==2)
	// r1.x=value*16;
	const SDL_Rect srcRect={value*16,0,16,16};
	const SDL_Rect dstRect={x+width-20, y+(height-16)/2, 16, 16};
	//Get the right image depending on the state of the object.
	SDL_RenderCopy(&renderer, bmGuiTex.get(), &srcRect, &dstRect);
	}
	}

	//////////////GUILabel///////////////////////////////////////////////////////////////////

	bool GUILabel::handleEvents(SDL_Renderer&,int ,int ,bool ,bool ,bool processed){
	return processed;
	}

	void GUILabel::render(SDL_Renderer& renderer, int x,int y,bool draw){
	//There's no need drawing the widget when it's invisible.
	if(!visible)
	return;

	//Check if the enabled state changed or the caption, if so we need to clear the (old) cache.
	refreshCache(enabled);

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

	//Rectangle the size of the widget.
	SDL_Rect r;
	r.x=x;
	r.y=y;
	r.w=width;
	r.h=height;

	//Get the caption and make sure it isn't empty.
	const char* lp=caption.c_str();
	if(lp!=NULL && lp[0]){
	//Update cache if needed.
	if(!cacheTex){
	SDL_Color color;
	if(inDialog)
	color=themeTextColorDialog;
	else
	color=themeTextColor;

	cacheTex=textureFromText(renderer, *fontText, lp, color);
	if(width<=0)
	width=textureWidth(*cacheTex);
	}

	//Align the text properly and draw it.
	if(draw){
	const SDL_Rect size = rectFromTexture(*cacheTex);
	if(gravity==GUIGravityCenter)
	gravityX=(width-size.w)/2;
	else if(gravity==GUIGravityRight)
	gravityX=width-size.w;
	else
	gravityX=0;

	r.y=y+(height - size.h)/2;
	r.x+=gravityX;
	applyTexture(r.x, r.y, cacheTex, renderer);
	}
	}
	}

	//////////////GUITextBox///////////////////////////////////////////////////////////////////

	void GUITextBox::backspaceChar(){
	//We need to remove a character so first make sure that there is text.
	if(caption.length()>0){
	if(highlightStart==highlightEnd&&highlightStart>0){
	int advance;
	TTF_GlyphMetrics(fontText,caption[highlightEnd-1],NULL,NULL,NULL,NULL,&advance);
	highlightEndX=highlightStartX=highlightEndX-advance;

	highlightEnd=highlightStart=highlightEnd-1;
	caption.erase((size_t)highlightEnd,1);
	}else if(highlightStart<highlightEnd){
	caption.erase(highlightStart,highlightEnd-highlightStart);
	highlightEnd=highlightStart;
	highlightEndX=highlightStartX;
	}else{
	caption.erase(highlightEnd,highlightStart-highlightEnd);
	highlightStart=highlightEnd;
	highlightStartX=highlightEndX;
	}

	//If there is an event callback then call it.
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventChange};
	GUIEventQueue.push_back(e);
	}
	}
	}

	void GUITextBox::deleteChar(){
	//We need to remove a character so first make sure that there is text.
	if(caption.length()>0){
	if(highlightStart==highlightEnd){
	caption.erase((size_t)highlightEnd,1);

	highlightStart=highlightEnd;
	highlightStartX=highlightEndX;
	}else if(highlightStart<highlightEnd){
	caption.erase(highlightStart,highlightEnd-highlightStart);

	highlightEnd=highlightStart;
	highlightEndX=highlightStartX;
	}else{
	caption.erase(highlightEnd,highlightStart-highlightEnd);

	highlightStart=highlightEnd;
	highlightStartX=highlightEndX;
	}

	//If there is an event callback then call it.
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventChange};
	GUIEventQueue.push_back(e);
	}
	}
	}

	void GUITextBox::moveCarrotLeft(){
	if(highlightEnd>0){
	highlightEnd--;
	int advance;
	TTF_GlyphMetrics(fontText,caption.at(highlightEnd),NULL,NULL,NULL,NULL,&advance);
	if(SDL_GetModState() & KMOD_SHIFT){
	highlightEndX-=advance;
	}else{
	highlightStart=highlightEnd;
	highlightStartX=highlightEndX=highlightEndX-advance;
	}
	}else{
	if((SDL_GetModState() & KMOD_SHIFT)==0){
	highlightStart=highlightEnd;
	highlightStartX=highlightEndX;
	}
	}
	tick=15;
	}

	void GUITextBox::moveCarrotRight(){
	if(highlightEnd<caption.length()){
	int advance;
	TTF_GlyphMetrics(fontText,caption.at(highlightEnd),NULL,NULL,NULL,NULL,&advance);
	if(SDL_GetModState() & KMOD_SHIFT){
	highlightEndX+=advance;
	highlightEnd++;
	}else{
	highlightStartX=highlightEndX=highlightEndX+advance;
	highlightEnd=highlightStart=highlightEnd+1;
	}
	}else{
	if((SDL_GetModState() & KMOD_SHIFT)==0){
	highlightStart=highlightEnd;
	highlightStartX=highlightEndX;
	}
	}
	tick=15;
	}

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

	//The widget is only enabled when its parent are enabled.
	enabled=enabled && this->enabled;
	//The widget is only enabled when its parent are enabled.
	visible=visible && this->visible;

	//Get the absolute position.
	x+=left-gravityX;
	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 there's a key press and the event hasn't been already processed.
	if(state==2 && event.type==SDL_KEYDOWN && !b){
	//Get the keycode.
	SDL_Keycode key=event.key.keysym.sym;

	//Check if the key is supported.
	if(key>=32&&key<=126){
	if(highlightStart==highlightEnd){
	caption.insert((size_t)highlightStart,1,static_cast<char>(key));
	highlightStart++;
	highlightEnd=highlightStart;
	}else if(highlightStart<highlightEnd){
	caption.erase(highlightStart,highlightEnd-highlightStart);
	caption.insert((size_t)highlightStart,1,static_cast<char>(key));
	highlightStart++;
	highlightEnd=highlightStart;
	highlightEndX=highlightStartX;
	}else{
	caption.erase(highlightEnd,highlightStart-highlightEnd);
	caption.insert((size_t)highlightEnd,1,static_cast<char>(key));
	highlightEnd++;
	highlightStart=highlightEnd;
	highlightStartX=highlightEndX;
	}
	int advance;
	TTF_GlyphMetrics(fontText,static_cast<char>(key),NULL,NULL,NULL,NULL,&advance);
	highlightStartX=highlightEndX=highlightStartX+advance;

	//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){
	//Set the key values correctly.
	this->key=SDLK_BACKSPACE;
	keyHoldTime=0;
	keyTime=5;

	//Delete one character direct to prevent a lag.
	backspaceChar();
	}else if(event.key.keysym.sym==SDLK_DELETE){
	//Set the key values correctly.
	this->key=SDLK_DELETE;
	keyHoldTime=0;
	keyTime=5;

	//Delete one character direct to prevent a lag.
	deleteChar();
	}else if(event.key.keysym.sym==SDLK_RIGHT){
	//Set the key values correctly.
	this->key=SDLK_RIGHT;
	keyHoldTime=0;
	keyTime=5;

	//Move directly to prevent a lag.
	moveCarrotRight();
	}else if(event.key.keysym.sym==SDLK_LEFT){
	//Set the key values correctly.
	this->key=SDLK_LEFT;
	keyHoldTime=0;
	keyTime=5;

	//Move directly to prevent a lag.
	moveCarrotLeft();
	}

	//The event has been processed.
	b=true;
	}else if(state==2 && event.type==SDL_KEYUP && !b){
	//Check if released key is the same as the holded key.
	if(event.key.keysym.sym==key){
	//It is so stop the key.
	key=-1;
	}
	}

	//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 widget.
	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;
	}

	//Also update the cursor type.
	currentCursor=CURSOR_CARROT;

	//Move carrot and highlightning according to mouse input.
	int clickX=i-x-2;

	int finalPos=0;
	int finalX=0;

	if(cacheTex&&!caption.empty()){
	finalPos=caption.length();
	for(unsigned int i=0;i<caption.length();i++){
	int advance;
	TTF_GlyphMetrics(fontText,caption[i],NULL,NULL,NULL,NULL,&advance);
	finalX+=advance;

	if(clickX<finalX-advance/2){
	finalPos=i;
	finalX-=advance;
	break;
	}
	}
	}

	if(event.type==SDL_MOUSEBUTTONUP){
	state=2;
	highlightEnd=finalPos;
	highlightEndX=finalX;
	}else if(event.type==SDL_MOUSEBUTTONDOWN){
	state=2;
	highlightStart=highlightEnd=finalPos;
	highlightStartX=highlightEndX=finalX;
	}else if(event.type==SDL_MOUSEMOTION&&(k&SDL_BUTTON(1))){
	state=2;
	highlightEnd=finalPos;
	highlightEndX=finalX;
	}
	}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;
	}
	}
	}

	return b;
	}

	void GUITextBox::render(SDL_Renderer& renderer, int x,int y,bool draw){
	//There's no need drawing the widget 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.
	refreshCache(enabled);

	//FIXME: Logic in the render method since that is update constant.
	if(key!=-1){
	//Increase the key time.
	keyHoldTime++;
	//Make sure the deletionTime isn't to short.
	if(keyHoldTime>=keyTime){
	keyHoldTime=0;
	keyTime--;
	if(keyTime<1)
	keyTime=1;

	//Now check the which key it was.
	switch(key){
	case SDLK_BACKSPACE:
	backspaceChar();
	break;
	case SDLK_DELETE:
	deleteChar();
	break;
	case SDLK_LEFT:
	moveCarrotLeft();
	break;
	case SDLK_RIGHT:
	moveCarrotRight();
	break;
	}
	}
	}

	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,renderer,color);
	}

	//Rectangle used for drawing.
	SDL_Rect r{0,0,0,0};

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

	if(draw){
	//Only draw the carrot and highlight when focus.
	if(state==2){
	//Place the highlighted area.
	r.x=x+4;
	r.y=y+3;
	r.h=height-6;

	if(highlightStart<highlightEnd){
	r.x+=highlightStartX;
	r.w=highlightEndX-highlightStartX;
	}else{
	r.x+=highlightEndX;
	r.w=highlightStartX-highlightEndX;
	}

	//Draw the area.
	//SDL_FillRect(screen,&r,SDL_MapRGB(screen->format,128,128,128));
	SDL_SetRenderDrawColor(&renderer, 128,128,128,255);
	SDL_RenderFillRect(&renderer, &r);

	//Ticking carrot.
	if(tick<16){
	//Show carrot: 15->0.
	r.x=x+highlightEndX+2;
	r.y=y+3;
	r.h=height-6;
	r.w=2;
	//SDL_FillRect(screen,&r,SDL_MapRGB(screen->format,0,0,0));
	SDL_SetRenderDrawColor(&renderer,0,0,0,255);
	SDL_RenderFillRect(&renderer, &r);

	//Reset: 32 or count down.
	if(tick<=0)
	tick=32;
	else
	tick--;
	}else{
	//Hide carrot: 32->16.
	tick--;
	}
	}

	//Calculate the location, center it vertically.
	SDL_Rect dstRect=rectFromTexture(*cacheTex);
	dstRect.x=x+4;
	dstRect.y=y+(height-dstRect.h)/2;
	dstRect.w=std::min(width-2, dstRect.w);
	//Draw the text.
	const SDL_Rect srcRect={0,0,width-2,25};
	SDL_RenderCopy(&renderer, cacheTex.get(), &srcRect, &dstRect);
	}
	}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_SetRenderDrawColor(&renderer, 0,0,0,0);
	SDL_RenderFillRect(&renderer, &r);
	}
	}
	}

	//////////////GUIFrame///////////////////////////////////////////////////////////////////

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

	//The widget is only enabled when its parent are enabled.
	enabled=enabled && this->enabled;
	//The widget is only enabled when its parent are enabled.
	visible=visible && this->visible;

	//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(renderer,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 GUIFrame::render(SDL_Renderer& renderer, int x,int y,bool draw){
	//There's no need drawing this widget 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.
	cacheTex.reset(nullptr);

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

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

	//Draw fill and borders.
	if(draw){
	Uint32 color=0xDDDDDDFF;
	drawGUIBox(x,y,width,height,renderer,color);
	}

	//Get the title text and make sure it isn't empty.
	const char* lp=caption.c_str();
	if(lp!=NULL && lp[0]){
	//Update cache if needed.
	if(!cacheTex) {
	cacheTex = textureFromText(renderer, *fontGUI, lp, themeTextColorDialog);
	}
	//Draw the text.
	if(draw) {
	applyTexture(x+(width-textureWidth(cacheTex))/2, y+6-GUI_FONT_RAISE, cacheTex, renderer);
	}
	}
	//We now need to draw all the children.
	for(unsigned int i=0;i<childControls.size();i++){
	childControls[i]->render(renderer,x,y,draw);
	}
	}

	//////////////GUIImage///////////////////////////////////////////////////////////////////

	GUIImage::~GUIImage(){
	}

	bool GUIImage::handleEvents(SDL_Renderer&,int ,int ,bool ,bool ,bool processed){
	return processed;
	}

	void GUIImage::fitToImage(){
	const SDL_Rect imageSize = rectFromTexture(*image);

	//Increase or decrease the width and height to fully show the image.
	if(clip.w!=0) {
	width=clip.w;
	} else {
	width=imageSize.w;
	}
	if(clip.h!=0) {
	height=clip.h;
	} else {
	height=imageSize.h;
	}
	}

	void GUIImage::render(SDL_Renderer& renderer, int x,int y,bool draw){
	//There's no need drawing the widget when it's invisible.
	//Also make sure the image isn't null.
	if(!visible \|\| !image)
	return;

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

	//Create a clip rectangle.
	SDL_Rect r{clip};
	//The width and height are capped by the GUIImage itself.
	if(r.w>width \|\| r.w==0) {
	r.w=width;
	}
	if(r.h>height \|\| r.h==0) {
	r.h=height;
	}

	const SDL_Rect dstRect{x,y,r.w,r.h};
	SDL_RenderCopy(&renderer, image.get(), &r, &dstRect);
	}
	diff --git a/src/GUIObject.h b/src/GUIObject.h
	index 14454a9..06c610c 100644
	--- a/src/GUIObject.h
	+++ b/src/GUIObject.h
	@@ -1,397 +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/>.
	*/

	#ifndef GUIOBJECT_H
	#define GUIOBJECT_H

	#include "FileManager.h"
	#include "ImageManager.h"
	#include "Render.h"
	#include <string>
	#include <vector>
	#include <list>

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

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


	-class SDL_Renderer;
	+struct SDL_Renderer;
	class GUIObject;

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

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

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

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

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

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

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

	//Widget's gravity to centering
	int gravity;
	int gravityX;
	bool autoWidth;

	//Is the parent widget a dialog?
	bool inDialog;
	protected:
	//The state of the GUIObject.
	//It depends on the type of GUIObject where it's used for.
	int state;

	//Texture containing different gui images.
	SharedTexture bmGuiTex;

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

	if(width<=0)
	autoWidth=true;
	else
	autoWidth=false;

	inDialog=false;

	//Load the gui images.
	bmGuiTex=imageManager.loadTexture(getDataPath()+"gfx/gui.png", renderer);
	}
	//Destructor.
	virtual ~GUIObject();

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

	void addChild(GUIObject* obj){
	//Add widget add a child
	childControls.push_back(obj);

	//Copy inDialog boolean from parent.
	obj->inDialog=inDialog;
	}

	//Method for getting a child from a GUIObject.
	//NOTE: This method doesn't search recursively.
	//name: The name of the child to return.
	//Returns: Pointer to the requested child, NULL otherwise.
	GUIObject* getChild(std::string name){
	//Look for a child with the name.
	for(unsigned int i=0;i<childControls.size();i++)
	if(childControls[i]->name==name)
	return childControls[i];

	//Not found so return NULL.
	return NULL;
	}

	//Check if the caption or status has changed, or if the width is <0 and
	//recreate the cached texture if so.
	void refreshCache(bool enabled);
	};

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

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

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

	class GUIButton:public GUIObject{
	public:
	GUIButton(ImageManager& imageManager, SDL_Renderer& renderer,int left=0,int top=0,int width=0,int height=0,
	const char* caption=NULL,int value=0,
	bool enabled=true,bool visible=true,int gravity=0):
	GUIObject(imageManager,renderer,left,top,width,height,caption,value,enabled,visible,gravity),
	smallFont(false){ }
	//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(SDL_Renderer&renderer, int x=0, int y=0, bool enabled=true, bool visible=true, bool processed=false);
	//Method that will render the GUIScrollBar.
	//x: The x location to draw the GUIObject. (x+left)
	//y: The y location to draw the GUIObject. (y+top)
	//draw: Whether displey the widget or not.
	virtual void render(SDL_Renderer& renderer, int x=0,int y=0,bool draw=true);

	//Boolean if small font is used.
	bool smallFont;
	};

	class GUICheckBox:public GUIObject{
	public:
	GUICheckBox(ImageManager& imageManager, SDL_Renderer& renderer,int left=0,int top=0,int width=0,int height=0,
	const char* caption=NULL,int value=0,
	bool enabled=true,bool visible=true,int gravity=0):
	GUIObject(imageManager,renderer,left,top,width,height,caption,value,enabled,visible,gravity){}
	//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(SDL_Renderer&,int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	//Method that will render the GUIScrollBar.
	//x: The x location to draw the GUIObject. (x+left)
	//y: The y location to draw the GUIObject. (y+top)
	//draw: Whether displey the widget or not.
	virtual void render(SDL_Renderer &renderer, int x=0, int y=0, bool draw=true);
	};

	class GUILabel:public GUIObject{
	public:
	GUILabel(ImageManager& imageManager, SDL_Renderer& renderer,int left=0,int top=0,int width=0,int height=0,
	const char* caption=NULL,int value=0,
	bool enabled=true,bool visible=true,int gravity=0):
	GUIObject(imageManager,renderer,left,top,width,height,caption,value,enabled,visible,gravity){}
	//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(SDL_Renderer&,int =0, int =0, bool =true, bool =true, bool processed=false);
	//Method that will render the GUIScrollBar.
	//x: The x location to draw the GUIObject. (x+left)
	//y: The y location to draw the GUIObject. (y+top)
	//draw: Whether displey the widget or not.
	virtual void render(SDL_Renderer &renderer, int x=0, int y=0, bool draw=true);
	};

	class GUITextBox:public GUIObject{
	public:
	GUITextBox(ImageManager& imageManager, SDL_Renderer& renderer,int left=0,int top=0,int width=0,int height=0,
	const char* caption=NULL,int value=0,
	bool enabled=true,bool visible=true,int gravity=0):
	GUIObject(imageManager,renderer,left,top,width,height,caption,value,enabled,visible,gravity),
	highlightStart(0),highlightEnd(0),tick(15),key(-1),keyHoldTime(0),keyTime(0){}
	//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(SDL_Renderer&,int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	//Method that will render the GUIScrollBar.
	//x: The x location to draw the GUIObject. (x+left)
	//y: The y location to draw the GUIObject. (y+top)
	//draw: Whether displey the widget or not.
	virtual void render(SDL_Renderer& renderer, int x=0,int y=0,bool draw=true);
	private:
	//Text highlights.
	int highlightStart;
	int highlightEnd;

	int highlightStartX;
	int highlightEndX;

	//Carrot ticking.
	int tick;

	//Integer containing the key that is holded.
	int key;

	//Integer containing the time the key is pressed.
	int keyHoldTime;
	//The time it takes to invoke the key action again.
	int keyTime;

	//Functions for modifying the text.
	void backspaceChar();
	void deleteChar();

	//Functions for moving the carrot.
	void moveCarrotLeft();
	void moveCarrotRight();
	};

	class GUIFrame:public GUIObject{
	public:
	GUIFrame(ImageManager& imageManager, SDL_Renderer& renderer,int left=0,int top=0,int width=0,int height=0,
	const char* caption=NULL,int value=0,
	bool enabled=true,bool visible=true,int gravity=0):
	GUIObject(imageManager,renderer,left,top,width,height,caption,value,enabled,visible,gravity){
	inDialog=true;
	}
	//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(SDL_Renderer&renderer, int x=0, int y=0, bool enabled=true, bool visible=true, bool processed=false);
	//Method that will render the GUIScrollBar.
	//x: The x location to draw the GUIObject. (x+left)
	//y: The y location to draw the GUIObject. (y+top)
	//draw: Whether displey the widget or not.
	virtual void render(SDL_Renderer &renderer, int x=0, int y=0, bool draw=true);
	};

	//A GUIObject that holds an shared_ptr to a Texture for rendering.
	class GUIImage:public GUIObject{
	public:
	GUIImage(ImageManager& imageManager, SDL_Renderer& renderer,int left=0,int top=0,int width=0,int height=0,
	SharedTexture image=nullptr,SDL_Rect clip=SDL_Rect(),
	bool enabled=true,bool visible=true):
	GUIObject(imageManager,renderer,left,top,width,height,NULL,0,enabled,visible,0),
	image(image),clip(clip){ }
	//Destructor.
	~GUIImage();
	//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(SDL_Renderer&,int =0, int =0, bool =true, bool =true, bool processed=false);
	//Method that will render the GUIScrollBar.
	//x: The x location to draw the GUIObject. (x+left)
	//y: The y location to draw the GUIObject. (y+top)
	//draw: Whether display the widget or not.
	virtual void render(SDL_Renderer &renderer, int x=0, int y=0, bool draw=true);

	//Method that will change the dimensions of the GUIImage so that the full image is shown.
	//OR in case of a clip rect that the selected section of the image is shown.
	void fitToImage();

	//Method for setting the image of the widget.
	//image: SharedTexture containing the image.
	void setImage(SharedTexture texture){
	image=texture;
	}

	//Method for setting the clip rectangle for the GUIImager.
	//rect: The new clip rectangle.
	void setClipRect(SDL_Rect rect){
	clip=rect;
	}
	private:
	//Pointer to the SDL_Texture to draw.
	//MAY BE NULL!!
	SharedTexture image;
	//Optional rectangle for defining the section of the texture that should be drawn.
	//NOTE: This doesn't have to correspond with the dimensions of the GUIObject.
	SDL_Rect clip;
	};

	#endif
	diff --git a/src/GUISpinBox.cpp b/src/GUISpinBox.cpp
	index 62dd888..e243c07 100644
	--- a/src/GUISpinBox.cpp
	+++ b/src/GUISpinBox.cpp
	@@ -1,393 +1,394 @@
	/*
	* 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 "GUISpinBox.h"

	+#include <algorithm>
	#include <SDL_ttf.h>

	bool GUISpinBox::handleEvents(SDL_Renderer&,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;

	//Reset "key" to stop contant update of "number" in render().
	//If the mouse is still on the button, the "key" will be reassigned later.
	key=-1;

	//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.
	SDL_Keycode key=event.key.keysym.sym;

	//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);

	this->key=SDLK_BACKSPACE;
	keyHoldTime=0;
	keyTime=5;

	//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);

	this->key=SDLK_DELETE;
	keyHoldTime=0;
	keyTime=5;

	//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());

	this->key=SDLK_RIGHT;
	keyHoldTime=0;
	keyTime=5;
	}else if(event.key.keysym.sym==SDLK_LEFT){
	value=clamp(value-1,0,caption.length());

	this->key=SDLK_LEFT;
	keyHoldTime=0;
	keyTime=5;
	}

	//The event has been processed.
	b=true;
	}else if(state==2 && event.type==SDL_KEYUP && !b){
	//Check if released key is the same as the holded key.
	if(event.key.keysym.sym==key){
	//It is so stop the key.
	key=-1;
	}
	}

	//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;
	}

	//Also update the cursor type.
	if(i<x+width-16)
	currentCursor=CURSOR_CARROT;

	//Check for a mouse button press.
	if(k&SDL_BUTTON(1)){
	//We have focus.
	state=2;

	//Handle buttons.
	if(i>x+width-16){
	if(j<y+17){
	//Set the key values correct.
	this->key=SDLK_UP;
	keyHoldTime=0;
	keyTime=5;

	//Update once to prevent a lag.
	updateValue(true);
	}else{
	//Set the key values correct.
	this->key=SDLK_DOWN;
	keyHoldTime=0;
	keyTime=5;

	//Update once to prevent a lag.
	updateValue(false);
	}
	}else{
	//Move caret to the place clicked
	int click=i-x;

	if(!cacheTex){
	value=0;
	}else if(click>textureWidth(*cacheTex)){
	value=caption.length();
	}else{
	unsigned int wid=0;
	for(unsigned int i=0;i<caption.length();i++){
	int advance;
	TTF_GlyphMetrics(fontText,caption[i],NULL,NULL,NULL,NULL,&advance);
	wid+=advance;

	if(click<(int)wid-(int)advance/2){
	value=i;
	break;
	}
	}
	}
	}
	}

	//Allow mouse wheel to change value.
	if(event.type==SDL_MOUSEWHEEL){
	if(event.wheel.y > 0){
	updateValue(true);
	}else if(event.wheel.y < 0){
	updateValue(false);
	}
	}
	}else{
	//The mouse is outside the TextBox.
	//If we don't have focus but only hover we lose it.
	if(state==1){
	state=0;
	update();
	}

	//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;
	update();
	}
	}
	}

	return b;
	}

	void GUISpinBox::render(SDL_Renderer &renderer, int x, int y, bool draw){
	//FIXME: Logic in the render method since that is update constant.
	if(key!=-1){
	//Increase the key time.
	keyHoldTime++;
	//Make sure the deletionTime isn't to short.
	if(keyHoldTime>=keyTime){
	keyHoldTime=0;
	keyTime--;
	if(keyTime<1)
	keyTime=1;

	//Now check the which key it was.
	switch(key){
	case SDLK_UP:
	{
	updateValue(true);
	break;
	}
	case SDLK_DOWN:
	{
	updateValue(false);
	break;
	}
	case SDLK_BACKSPACE:
	{
	//Remove the character before the carrot.
	value=clamp(value-1,0,caption.length());
	caption.erase((size_t)value,1);
	break;
	}
	case SDLK_DELETE:
	{
	//Remove the character after the carrot.
	value=clamp(value,0,caption.length());
	caption.erase((size_t)value,1);
	break;
	}
	case SDLK_LEFT:
	{
	value=clamp(value-1,0,caption.length());
	break;
	}
	case SDLK_RIGHT:
	{
	value=clamp(value+1,0,caption.length());
	break;
	}
	}
	}
	}

	//There's no need drawing 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.
	cacheTex.reset(nullptr);

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

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

	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 a background box.
	const Uint32 color=0xFFFFFF00\|clr;
	drawGUIBox(x,y,width,height,renderer,color);

	SDL_Rect srcRect={80,0,16,16};
	//Draw arrow buttons.
	SDL_Rect dstRect = {x+width-18, y+1, srcRect.w, srcRect.h};
	SDL_RenderCopy(&renderer, bmGuiTex.get(), &srcRect, &dstRect);

	srcRect.x=96;
	dstRect.y+=16;
	SDL_RenderCopy(&renderer, bmGuiTex.get(), &srcRect, &dstRect);
	}

	if(!caption.empty()){
	//Update graphic cache if empty.
	if(!cacheTex){
	SDL_Color black={0,0,0,255};
	cacheTex=textureFromText(renderer,*fontText,caption.c_str(),black);
	}

	//Cache the render color
	Uint8 r,g,b,a;
	SDL_GetRenderDrawColor(&renderer, &r,&g,&b,&a);
	//Set it to black for drawing the caret.
	SDL_SetRenderDrawColor(&renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);

	if(draw){
	const SDL_Rect srcRect={0,0,width-2,25};
	SDL_Rect dstRect = rectFromTexture(x+2,
	y+(height-textureHeight(*cacheTex))/2,
	*cacheTex);
	dstRect.w = std::min(dstRect.w, width - 4);
	SDL_RenderCopy(&renderer, cacheTex.get(), &srcRect, &dstRect);

	//Only draw the caret when focus.
	if(state==2){
	SDL_Rect caretRect{x, y+4, 2, height-8};

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

	//Make sure that the carrot is inside the textbox.
	if(caretRect.x<x+width) {
	//Draw a box representing the caret.
	SDL_RenderFillRect(&renderer, &caretRect);
	}
	}

	}else{
	//Only draw the caret when focus.
	if(state==2&&draw){
	const SDL_Rect caretRect{x+4, y+4, 2, height-8};
	SDL_RenderFillRect(&renderer, &caretRect);
	}
	}
	//Reset the render color.
	SDL_SetRenderDrawColor(&renderer, r, g, b, a);
	}
	}

	void GUISpinBox::update(){
	//Read number from the caption string.
	float number=(float)atof(caption.c_str());

	//Stay in the limits.
	if(number>limitMax){
	number=limitMax;
	}else if(number<limitMin){
	number=limitMin;
	}

	//Write the number to the caption string.
	char str[32];
	sprintf(str,format,number);
	caption=str;
	}

	void GUISpinBox::updateValue(bool positive){
	//Read number from the caption string.
	float number=(float)atof(caption.c_str());

	//Apply change.
	if(positive)
	number+=change;
	else
	number-=change;

	//Stay in the limits.
	if(number>limitMax){
	number=limitMax;
	}else if(number<limitMin){
	number=limitMin;
	}

	//Write the number to the caption string.
	char str[32];
	sprintf(str,format,number);
	caption=str;
	}
	diff --git a/src/GUITextArea.cpp b/src/GUITextArea.cpp
	index 2cbe804..ce88f6c 100644
	--- a/src/GUITextArea.cpp
	+++ b/src/GUITextArea.cpp
	@@ -1,870 +1,871 @@
	/*
	* 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 "GUITextArea.h"
	#include <cmath>
	+#include <algorithm>
	#include <ctype.h>
	#include <SDL_ttf.h>

	using namespace std;

	GUITextArea::GUITextArea(ImageManager& imageManager, SDL_Renderer& renderer,int left,int top,int width,int height,bool enabled,bool visible):
	GUIObject(imageManager,renderer,left,top,width,height,NULL,-1,enabled,visible),editable(true){

	key=-1;
	keyHoldTime=keyTime=0;

	//Set some default values.
	state=0;
	setFont(fontText);

	highlightLineStart=highlightLineEnd=0;
	highlightStartX=highlightEndX=0;
	highlightStart=highlightEnd=0;

	//Add empty text.
	lines.push_back("");
	linesCache.push_back(nullptr);

	//Create scrollbar widget.
	scrollBar=new GUIScrollBar(imageManager,renderer,width-16,0,16,height,1,0,0,0);
	childControls.push_back(scrollBar);

	scrollBarH=new GUIScrollBar(imageManager,renderer,0,height-16,width-16,16,0,0,0,0,100,500,true,false);
	childControls.push_back(scrollBarH);
	}

	void GUITextArea::setFont(TTF_Font* font){
	//NOTE: This fuction shouldn't be called after adding items, so no need to update the whole cache.
	widgetFont=font;
	fontHeight=TTF_FontHeight(font)+1;
	}

	bool GUITextArea::handleEvents(SDL_Renderer& renderer,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;

	//Update the vertical scrollbar.
	b=b\|\|scrollBar->handleEvents(renderer,x,y,enabled,visible,b);
	if(!editable)
	highlightLineStart=scrollBar->value;

	//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 && editable){
	//Get the keycode.
	SDL_Keycode key=event.key.keysym.sym;

	//Check if the key is supported.
	if(key>=32&&key<=126){
	removeHighlight(renderer);
	string* str=&lines.at(highlightLineStart);
	str->insert((size_t)highlightEnd,1,static_cast<char>(key));
	highlightEnd++;
	highlightStart=highlightEnd;
	int advance;
	TTF_GlyphMetrics(widgetFont,static_cast<char>(key),NULL,NULL,NULL,NULL,&advance);
	highlightStartX=highlightEndX=highlightStartX+advance;

	//Update cache.
	linesCache.at(highlightLineStart) =
	textureFromText(renderer, *widgetFont, str->c_str(), BLACK);

	//Update view if needed.
	adjustView();

	//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){
	//Set the key values correct.
	this->key=SDLK_BACKSPACE;
	keyHoldTime=0;
	keyTime=5;

	//Delete one character direct to prevent a lag.
	backspaceChar(renderer);
	}else if(event.key.keysym.sym==SDLK_DELETE){
	//Set the key values correct.
	this->key=SDLK_DELETE;
	keyHoldTime=0;
	keyTime=5;

	//Delete one character direct to prevent a lag.
	deleteChar(renderer);
	}else if(event.key.keysym.sym==SDLK_RETURN){
	removeHighlight(renderer);
	//Split the current line and update.
	string str2=lines.at(highlightLineEnd).substr(highlightStart);
	lines.at(highlightLineStart)=lines.at(highlightLineStart).substr(0,highlightStart);

	linesCache.at(highlightLineStart) =
	textureFromText(renderer,*widgetFont,lines.at(highlightLineStart).c_str(),BLACK);

	//Calculate indentation.
	int indent=0;
	for (int i=0; i<lines.at(highlightLineStart).length(); i++){
	if (isspace(lines.at(highlightLineStart)[i]))
	indent++;
	else
	break;
	}
	str2.insert(0,indent,' ');

	//Add the rest in a new line.
	highlightLineStart++;
	highlightStart=indent;
	highlightEnd=highlightStart;
	highlightLineEnd++;

	highlightStartX=0;
	for(int i=0; i<indent; i++){
	int advance;
	TTF_GlyphMetrics(widgetFont,str2.at(i),NULL,NULL,NULL,NULL,&advance);
	highlightStartX+=advance;
	}
	highlightEndX=highlightStartX;

	lines.insert(lines.begin()+highlightLineStart,str2);

	auto tex = textureFromText(renderer,*widgetFont,str2.c_str(),BLACK);
	linesCache.insert(linesCache.begin()+highlightLineStart,std::move(tex));


	adjustView();

	//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_TAB){
	removeHighlight(renderer);
	//Add a tabulator or here just 2 spaces to the string.
	std::string& str=lines.at(highlightLineStart);
	str.insert((size_t)highlightStart,2,char(' '));

	int advance;
	TTF_GlyphMetrics(widgetFont,' ',NULL,NULL,NULL,NULL,&advance);
	highlightStart+=2;
	highlightStartX=advance*2;
	highlightEnd=highlightStart;
	highlightEndX=highlightStartX;

	//Update cache.
	linesCache.at(highlightLineStart) = textureFromText(renderer,*widgetFont,str.c_str(),BLACK);

	adjustView();
	}else if(event.key.keysym.sym==SDLK_RIGHT){
	//Set the key values correct.
	this->key=SDLK_RIGHT;
	keyHoldTime=0;
	keyTime=5;

	//Move the carrot once to prevent a lag.
	moveCarrotRight();
	}else if(event.key.keysym.sym==SDLK_LEFT){
	//Set the key values correct.
	this->key=SDLK_LEFT;
	keyHoldTime=0;
	keyTime=5;

	//Move the carrot once to prevent a lag.
	moveCarrotLeft();
	}else if(event.key.keysym.sym==SDLK_DOWN){
	//Set the key values correct.
	this->key=SDLK_DOWN;
	keyHoldTime=0;
	keyTime=5;

	//Move the carrot once to prevent a lag.
	moveCarrotDown();
	}else if(event.key.keysym.sym==SDLK_UP){
	//Set the key values correct.
	this->key=SDLK_UP;
	keyHoldTime=0;
	keyTime=5;

	//Move the carrot once to prevent a lag.
	moveCarrotUp();
	}

	//The event has been processed.
	b=true;
	}else if(state==2 && event.type==SDL_KEYUP && !b){
	//Check if released key is the same as the holded key.
	if(event.key.keysym.sym==key){
	//It is so stop the key.
	key=-1;
	}
	}

	//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;
	}

	//Check for mouse wheel scrolling.
	//Scroll horizontally if mouse is over the horizontal scrollbar.
	//Otherwise scroll vertically.
	if(j>=y+height-16&&scrollBarH->visible){
	if(event.type==SDL_MOUSEWHEEL && event.wheel.y < 0){
	scrollBarH->value+=20;
	if(scrollBarH->value>scrollBarH->maxValue)
	scrollBarH->value=scrollBarH->maxValue;
	}else if(event.type==SDL_MOUSEBUTTONDOWN && event.wheel.y > 0){
	scrollBarH->value-=20;
	if(scrollBarH->value<0)
	scrollBarH->value=0;
	}
	}else{
	if(event.type==SDL_MOUSEWHEEL && event.wheel.y < 0){
	scrollBar->value++;
	if(scrollBar->value>scrollBar->maxValue)
	scrollBar->value=scrollBar->maxValue;
	}else if(event.type==SDL_MOUSEBUTTONDOWN && event.wheel.y > 0){
	scrollBar->value--;
	if(scrollBar->value<0)
	scrollBar->value=0;
	}
	}

	//When mouse is not over the scrollbar.
	if(i<x+width-16&&j<(scrollBarH->visible?y+height-16:y+height)&&editable){
	//Update the cursor type.
	currentCursor=CURSOR_CARROT;

	//Move carrot to the place clicked.
	int mouseLine=clamp((int)floor(float(j-y)/float(fontHeight))+scrollBar->value,0,lines.size()-1);
	string* str=&lines.at(mouseLine);
	value=str->length();

	int clickX=i-x+scrollBarH->value;
	int finalX=0;
	int finalPos=str->length();

	for(unsigned int i=0;i<str->length();i++){
	int advance;
	TTF_GlyphMetrics(widgetFont,str->at(i),NULL,NULL,NULL,NULL,&advance);
	finalX+=advance;

	if(clickX<finalX-advance/2){
	finalPos=i;
	finalX-=advance;
	break;
	}
	}
	//if(k&SDL_BUTTON(1)){
	if(event.type==SDL_MOUSEBUTTONUP){
	state=2;
	highlightEnd=finalPos;
	highlightEndX=finalX;
	highlightLineEnd=mouseLine;
	}else if(event.type==SDL_MOUSEBUTTONDOWN){
	state=2;
	highlightStart=highlightEnd=finalPos;
	highlightStartX=highlightEndX=finalX;
	highlightLineStart=mouseLine;
	}else if(event.type==SDL_MOUSEMOTION&&(k&SDL_BUTTON(1))){
	state=2;
	highlightEnd=finalPos;
	highlightEndX=finalX;
	highlightLineEnd=mouseLine;
	}
	//}
	}
	}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;
	}
	}
	}

	//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(renderer,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 GUITextArea::removeHighlight(SDL_Renderer& renderer){
	if (highlightLineStart==highlightLineEnd) {
	int start=highlightStart, end=highlightEnd, startx=highlightStartX;
	if(highlightStart>highlightEnd){
	start=highlightEnd;
	end=highlightStart;
	startx=highlightEndX;
	}
	std::string& str=lines.at(highlightLineStart);
	str.erase(start,end-start);

	highlightStart=highlightEnd=start;
	highlightStartX=highlightEndX=startx;

	// Update cache.
	linesCache.at(highlightLineStart) = textureFromText(renderer,*widgetFont,str.c_str(),BLACK);
	}else{
	int startLine=highlightLineStart, endLine=highlightLineEnd,
	start=highlightStart, end=highlightEnd, startx=highlightStartX;
	if(startLine>endLine){
	startLine=highlightLineEnd;
	endLine=highlightLineStart;
	start=highlightEnd;
	end=highlightStart;
	startx=highlightEndX;
	}
	string *str=&lines.at(startLine);

	str->erase(start,str->length()-start);

	if(endLine-startLine>=2){
	for(int i=startLine+1; i < endLine; i++){
	lines.erase(lines.begin()+i);
	linesCache.erase(linesCache.begin()+i);
	endLine--;
	i--;
	}
	}

	string *str2=&lines.at(endLine);

	str2->erase(0, end);
	str->append(*str2);

	lines.erase(lines.begin()+endLine);
	linesCache.erase(linesCache.begin()+endLine);

	highlightLineStart=highlightLineEnd=startLine;
	highlightStart=highlightEnd=start;
	highlightStartX=highlightEndX=startx;

	// Update cache.
	linesCache.at(startLine) = textureFromText(renderer,*widgetFont,str->c_str(),BLACK);
	}
	adjustView();
	}

	void GUITextArea::deleteChar(SDL_Renderer& renderer){
	if (highlightLineStart==highlightLineEnd && highlightStart==highlightEnd){
	highlightEnd++;
	if(highlightEnd>lines.at(highlightLineEnd).length()){
	if(highlightLineEnd==lines.size()-1){
	highlightEnd--;
	}else{
	highlightLineEnd++;
	highlightEnd=0;
	}
	}
	}
	removeHighlight(renderer);
	//If there is an event callback.
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventChange};
	GUIEventQueue.push_back(e);
	}
	}

	void GUITextArea::backspaceChar(SDL_Renderer& renderer){
	if(highlightLineStart==highlightLineEnd && highlightStart==highlightEnd){
	highlightStart--;
	if(highlightStart<0){
	if(highlightLineStart==0){
	highlightStart=0;
	}else{
	highlightLineStart--;
	highlightStart=lines.at(highlightLineStart).length();
	highlightStartX=0;
	TexturePtr& t = linesCache.at(highlightLineEnd);
	if(t) highlightStartX=textureWidth(*t);
	highlightEndX=highlightStartX;
	}
	}else{
	int advance;
	TTF_GlyphMetrics(widgetFont,lines.at(highlightLineStart).at(highlightStart),NULL,NULL,NULL,NULL,&advance);
	highlightStartX-=advance;
	highlightEndX=highlightStartX;
	}
	}
	removeHighlight(renderer);

	//If there is an event callback.
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventChange};
	GUIEventQueue.push_back(e);
	}
	}

	void GUITextArea::moveCarrotRight(){
	highlightEnd++;
	if (highlightEnd>lines.at(highlightLineEnd).length()){
	if (highlightLineEnd==lines.size()-1){
	highlightEnd--;
	}else{
	highlightEnd=0;
	highlightEndX=0;
	highlightLineEnd++;
	}
	}else{
	int advance;
	TTF_GlyphMetrics(widgetFont,lines.at(highlightLineEnd).at(highlightEnd-1),NULL,NULL,NULL,NULL,&advance);
	highlightEndX+=advance;
	}
	if((SDL_GetModState()&KMOD_SHIFT)==0){
	highlightLineStart=highlightLineEnd;
	highlightStart=highlightEnd;
	highlightStartX=highlightEndX;
	}
	adjustView();
	}

	void GUITextArea::moveCarrotLeft(){
	highlightEnd--;
	if (highlightEnd<0){
	if (highlightLineEnd==0){
	highlightEnd++;
	}else{
	highlightLineEnd--;
	highlightEnd=lines.at(highlightLineEnd).length();
	highlightEndX=0;
	TexturePtr& t = linesCache.at(highlightLineEnd);
	if(t) highlightEndX=textureWidth(*t);
	}
	}else{
	int advance;
	TTF_GlyphMetrics(widgetFont,lines.at(highlightLineEnd).at(highlightEnd),NULL,NULL,NULL,NULL,&advance);
	highlightEndX-=advance;
	}
	if((SDL_GetModState()&KMOD_SHIFT)==0){
	highlightLineStart=highlightLineEnd;
	highlightStart=highlightEnd;
	highlightStartX=highlightEndX;
	}
	adjustView();
	}

	void GUITextArea::moveCarrotUp(){
	if(highlightLineEnd==0){
	highlightEnd=0;
	highlightEndX=0;
	}else{
	highlightLineEnd--;
	const std::string& str=lines.at(highlightLineEnd);

	//Find out closest match.
	int xPos=0;
	size_t i;
	for(i=0;i<str.length();i++){
	int advance;
	TTF_GlyphMetrics(widgetFont,str.at(i),NULL,NULL,NULL,NULL,&advance);
	xPos+=advance;

	if(highlightEndX<xPos-advance/2){
	highlightEnd=i;
	highlightEndX=xPos-advance;
	break;
	}
	}
	if(i==str.length()){
	highlightEnd=str.length();
	highlightEndX=0;
	TexturePtr& t = linesCache.at(highlightLineEnd);
	if(t) highlightEndX=textureWidth(*t);
	}
	}
	if((SDL_GetModState()&KMOD_SHIFT)==0){
	highlightStart=highlightEnd;
	highlightStartX=highlightEndX;
	highlightLineStart=highlightLineEnd;
	}
	adjustView();
	}

	void GUITextArea::moveCarrotDown(){
	if(highlightLineEnd==lines.size()-1){
	highlightEnd=lines.at(highlightLineEnd).length();
	highlightEndX=0;
	TexturePtr& t = linesCache.at(highlightLineEnd);
	if(t) highlightEndX=textureWidth(*t);
	}else{
	highlightLineEnd++;
	string* str=&lines.at(highlightLineEnd);

	//Find out closest match.
	int xPos=0;
	size_t i;
	for(i=0;i<str->length();i++){
	int advance;
	TTF_GlyphMetrics(widgetFont,str->at(i),NULL,NULL,NULL,NULL,&advance);
	xPos+=advance;

	if(highlightEndX<xPos-advance/2){
	highlightEnd=i;
	highlightEndX=xPos-advance;
	break;
	}
	}
	if(i==str->length()){
	highlightEnd=str->length();
	highlightEndX=0;
	TexturePtr& t = linesCache.at(highlightLineEnd);
	if(t) highlightEndX=textureWidth(*t);
	}
	}
	if((SDL_GetModState()&KMOD_SHIFT)==0){
	highlightStart=highlightEnd;
	highlightStartX=highlightEndX;
	highlightLineStart=highlightLineEnd;
	}
	adjustView();
	}

	void GUITextArea::adjustView(){
	//Adjust view to current line.
	if(fontHeight*(highlightLineEnd-scrollBar->value)+4>height-4)
	scrollBar->value=highlightLineEnd-3;
	else if(highlightLineEnd-scrollBar->value<0)
	scrollBar->value=highlightLineEnd;

	//Find out the lenght of the longest line.
	int maxWidth=0;
	for(const TexturePtr& tex: linesCache){
	if(tex) {
	const int texWidth = textureWidth(*tex.get());
	if(texWidth>width-16&&texWidth>maxWidth)
	maxWidth=texWidth;
	}
	}

	//We need the horizontal scrollbar if any line is too long.
	if(maxWidth>0){
	scrollBar->height=height-16;
	scrollBarH->visible=true;
	scrollBarH->maxValue=maxWidth-width+24;
	}else{
	scrollBar->height=height;
	scrollBarH->visible=false;
	scrollBarH->value=0;
	scrollBarH->maxValue=0;
	}

	//Adjust the horizontal view.
	int carrotX=0;
	for(int n=0;n<highlightEnd;n++){
	int advance;
	TTF_GlyphMetrics(widgetFont,lines.at(highlightLineEnd).at(n),NULL,NULL,NULL,NULL,&advance);
	carrotX+=advance;
	}
	if(carrotX>width-24)
	scrollBarH->value=scrollBarH->maxValue;
	else
	scrollBarH->value=0;

	//Update vertical scrollbar.
	int rh=height-(scrollBarH->visible?16:0);
	int m=lines.size(),n=(int)floor((float)rh/(float)fontHeight);
	if(m>n){
	scrollBar->maxValue=m-n;
	scrollBar->smallChange=1;
	scrollBar->largeChange=n;
	}else{
	scrollBar->value=0;
	scrollBar->maxValue=0;
	}
	}

	void GUITextArea::drawHighlight(SDL_Renderer& renderer, int x,int y,SDL_Rect r,SDL_Color color){
	if(r.x<x) {
	int tmp_w = r.w - x + r.x;
	if(tmp_w<0) return;
	r.w = tmp_w;
	r.x = left;
	}
	if(r.x+r.w > x+width){
	int tmp_w=width-r.x+x;
	if(tmp_w<=0) return;
	r.w=tmp_w;
	}
	if(r.y<y){
	int tmp_h=r.h - y + r.y;
	if(tmp_h<=0) return;
	r.h=tmp_h;
	}
	if(r.y+r.h > y+height){
	int tmp_h=height-r.y+y;
	if(tmp_h<=0) return;
	r.h=tmp_h;
	}
	SDL_SetRenderDrawColor(&renderer, color.r, color.g, color.b, color.a);
	SDL_RenderFillRect(&renderer, &r);
	}

	void GUITextArea::render(SDL_Renderer& renderer, int x,int y,bool draw){
	//FIXME: Logic in the render method since that is update constant.
	if(key!=-1){
	//Increase the key time.
	keyHoldTime++;
	//Make sure the deletionTime isn't to short.
	if(keyHoldTime>=keyTime){
	keyHoldTime=0;
	keyTime--;
	if(keyTime<1)
	keyTime=1;

	//Now check the which key it was.
	switch(key){
	case SDLK_BACKSPACE:
	backspaceChar(renderer);
	break;
	case SDLK_DELETE:
	deleteChar(renderer);
	break;
	case SDLK_LEFT:
	moveCarrotLeft();
	break;
	case SDLK_RIGHT:
	moveCarrotRight();
	break;
	case SDLK_UP:
	moveCarrotUp();
	break;
	case SDLK_DOWN:
	moveCarrotDown();
	break;
	}
	}
	}

	//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 box.
	const Uint32 color=0xFFFFFFFF;
	drawGUIBox(x,y,width,height,renderer,color);
	}

	//Place the highlighted area.
	SDL_Rect r;
	const SDL_Color color{128,128,128,255};
	if(highlightLineStart==highlightLineEnd){
	r.x=x-scrollBarH->value;
	r.y=y+((highlightLineStart-scrollBar->value)*fontHeight);
	r.h=fontHeight;
	if(highlightStart<highlightEnd){
	r.x+=highlightStartX;
	r.w=highlightEndX-highlightStartX;
	}else{
	r.x+=highlightEndX;
	r.w=highlightStartX-highlightEndX;
	}
	drawHighlight(renderer, x,y,r,color);
	}else if(highlightLineStart<highlightLineEnd){
	int lnc=highlightLineEnd-highlightLineStart;
	for(int i=0;i<=lnc;i++){
	r.x=x-scrollBarH->value;
	r.y=y+((i+highlightLineStart-scrollBar->value)*fontHeight);
	r.w=width+scrollBarH->maxValue;
	r.h=fontHeight;
	if(i==0){
	r.x+=highlightStartX;
	r.w-=highlightStartX;
	}else if(i==lnc){
	r.w=highlightEndX;
	}
	if(lines.at(i+highlightLineStart).empty()){
	r.w=fontHeight/4;
	}
	drawHighlight(renderer,x,y,r,color);
	}
	}else{
	int lnc=highlightLineStart-highlightLineEnd;
	for(int i=0;i<=lnc;i++){
	r.x=x-scrollBarH->value;
	r.y=y+((i+highlightLineEnd-scrollBar->value)*fontHeight);
	r.w=width+scrollBarH->maxValue;
	r.h=fontHeight;
	if(i==0){
	r.x+=highlightEndX;
	r.w-=highlightEndX;
	}else if(i==lnc){
	r.w=highlightStartX;
	}
	if(lines.at(i+highlightLineEnd).empty()){
	r.w=fontHeight/4;
	}
	drawHighlight(renderer,x,y,r,color);
	}
	}

	//Draw text.
	int lineY=0;
	for(auto it = linesCache.begin()+scrollBar->value;it!=linesCache.end();++it){
	if(*it){
	if(lineY<height){
	SDL_Rect r={scrollBarH->value,0,width-17,textureHeight(*it->get())};
	int over=-height+lineY+fontHeight;
	if(over>0) r.h-=over;
	const SDL_Rect dstRect={x+1,y+1+lineY,std::min(r.w, textureWidth((it))),r.h};
	SDL_RenderCopy(&renderer,it->get(),&r,&dstRect);
	}else{
	break;
	}
	}
	lineY+=fontHeight;
	}

	//Only draw the carrot when focus.
	if(state==2&&editable){
	r.x=x-scrollBarH->value+highlightEndX;
	r.y=y+4+fontHeight*(highlightLineEnd-scrollBar->value);
	r.w=2;
	r.h=fontHeight-4;

	//Make sure that the carrot is inside the textbox.
	if((r.y<y+height-4)&&(r.y>y)&&(r.x>x-1)&&(r.x<x+width-16)){
	drawHighlight(renderer,x,y,r,SDL_Color{0,0,0,127});
	}
	}

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

	void GUITextArea::setString(SDL_Renderer& renderer, std::string input){
	//Clear previous content if any.
	//Delete every line.
	lines.clear();
	linesCache.clear();

	size_t linePos=0,lineLen=0;

	//Loop through the input string.
	for(size_t i=0;i<input.length();++i){
	//Check when we come in end of a line.
	if(input.at(i)=='\n'){
	//Check if the line is empty.
	if(lineLen==0){
	lines.push_back("");
	linesCache.push_back(nullptr);
	}else{
	//Read the whole line.
	string line=input.substr(linePos,lineLen);
	lines.push_back(line);

	//Render and cache text.
	linesCache.push_back(
	textureFromText(renderer,*widgetFont,line.c_str(),BLACK));
	}
	//Skip '\n' in end of the line.
	linePos=i+1;
	lineLen=0;
	}else{
	lineLen++;
	}
	}

	//The string might not end with a newline.
	//That's why we're going to add end rest of the string as one line.
	string line=input.substr(linePos);
	lines.push_back(line);

	//bm=TTF_RenderUTF8_Blended(widgetFont,line.c_str(),black);
	TexturePtr tex = textureFromText(renderer,*widgetFont,line.c_str(),BLACK);
	linesCache.push_back(std::move(tex));

	adjustView();
	}

	void GUITextArea::setStringArray(SDL_Renderer& renderer, std::vector<std::string> input){
	//Free cached images.
	linesCache.clear();

	//Copy values.
	lines=input;

	for(const std::string& s: lines) {
	linesCache.push_back(textureFromText(renderer,*widgetFont,s.c_str(),BLACK));
	}

	adjustView();
	}

	string GUITextArea::getString(){
	string tmp;
	for(vector<string>::iterator it=lines.begin();it!=lines.end();++it){
	//Append a newline only if not the first line.
	if(it!=lines.begin())
	tmp.append(1,'\n');
	//Append the line.
	tmp.append(*it);
	}
	return tmp;
	}

	void GUITextArea::resize(){
	scrollBar->left=width-16;
	scrollBar->height=height;

	if(scrollBarH->visible)
	scrollBar->height-=16;

	scrollBarH->top=height-16;
	scrollBarH->width=width-16;

	adjustView();
	}
	diff --git a/src/GameState.h b/src/GameState.h
	index b3f9b6e..4fc1f83 100644
	--- a/src/GameState.h
	+++ b/src/GameState.h
	@@ -1,45 +1,45 @@
	/*
	* 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 GAMESTATE_H
	#define GAMESTATE_H

	-class SDL_Renderer;
	+struct SDL_Renderer;
	class ImageManager;

	class GameState{
	public:
	//Destructor.
	virtual ~GameState(){}

	//In this method all the key and mouse events should be handled.
	//NOTE: The GUIEvents won't be handled here.
	virtual void handleEvents(ImageManager& imageManager, SDL_Renderer& renderer)=0;

	//All the logic that needs to be done should go in this method.
	virtual void logic(ImageManager& imageManager, SDL_Renderer& renderer)=0;

	//This method handles all the rendering.
	virtual void render(ImageManager& imageManager,SDL_Renderer& renderer)=0;

	//Method that will be called when the screen size has been changed in runtime.
	virtual void resize(ImageManager& imageManager, SDL_Renderer& renderer)=0;
	};

	#endif
	diff --git a/src/LevelEditor.cpp b/src/LevelEditor.cpp
	index e0f258f..3e6e2a9 100644
	--- a/src/LevelEditor.cpp
	+++ b/src/LevelEditor.cpp
	@@ -1,3532 +1,3533 @@
	/*
	* Copyright (C) 2011-2013 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 "Block.h"
	#include "GameState.h"
	#include "Functions.h"
	#include "GameObjects.h"
	#include "ThemeManager.h"
	#include "LevelPack.h"
	#include "LevelEditor.h"
	#include "TreeStorageNode.h"
	#include "POASerializer.h"
	#include "GUIListBox.h"
	#include "GUITextArea.h"
	#include "GUIWindow.h"
	#include "GUISpinBox.h"
	#include "MusicManager.h"
	#include "InputManager.h"
	#include "StatisticsManager.h"
	#include <fstream>
	#include <iostream>
	#include <vector>
	#include <algorithm>
	#include <string.h>
	-#include <stdlib.h>
	#include <stdio.h>
	#include <sstream>
	#ifdef WIN32
	+//Avoid issues with std::max
	+#define NOMINMAX
	#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 <SDL_ttf.h>

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

	static int levelTime,levelRecordings;

	//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"),__("Pushable")
	};

	static const std::array<const char*,static_cast<size_t>(ToolTips::TooltipMax)> tooltipNames={
	"Select","Add","Delete","Play","","Level settings","Save level","Back to menu","Configure"
	};


	//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
	};

	/////////////////LevelEditorActionsPopup/////////////////

	class LevelEditorActionsPopup:private GUIEventCallback{
	private:
	//The parent object.
	LevelEditor* parent;

	//The position and size of window.
	SDL_Rect rect;

	//Array containing the actions in this popup.
	GUIListBox* actions;

	//GUI image.
	SDL_Surface* bmGUI;

	//Pointer to the object the actions apply to.
	GameObject* target;

	//The behaviour names.
	vector<string> behaviour;
	//The fragile block states.
	vector<string> states;

	public:
	SDL_Rect getRect(){
	return rect;
	}
	void dismiss(){
	//Remove the actionsPopup from the parent.
	if(parent!=NULL && parent->actionsPopup==this){
	parent->actionsPopup=NULL;
	}

	//And delete ourself.
	delete this;
	}
	SharedTexture createItem(SDL_Renderer& renderer,const char* caption,int icon){
	//FIXME: Add some sort of caching?
	//We draw using surfaces and convert to a texture in the end for now.
	SDL_Color fg={0,0,0};
	SurfacePtr tip(TTF_RenderUTF8_Blended(fontText,caption,fg));
	SDL_SetSurfaceAlphaMod(tip.get(), 0xFF);
	//Create the surface, we add 16px to the width for an icon,
	//plus 8px for the border to make it looks better.
	SurfacePtr item(SDL_CreateRGBSurface(SDL_SWSURFACE,tip->w+16+8,24,32,RMASK,GMASK,BMASK,AMASK));
	SDL_Rect itemRect={0,0,item->w,item->h};
	SDL_FillRect(item.get(),&itemRect,0x00FFFFFF);
	//Not sure why there is this extra highlight.
	itemRect.y=3;
	itemRect.h=16;
	SDL_FillRect(item.get(),&itemRect,0xFFFFFFFF);
	//Draw the text on the item surface.
	applySurface(16+8,0,tip.get(),item.get(),NULL);

	//Check if we should draw an icon.
	if(icon>0){
	//Draw the check (or not).
	SDL_Rect r={0,0,16,16};
	r.x=((icon-1)%8)*16;
	r.y=((icon-1)/8)*16;
	applySurface(4,3,bmGUI,item.get(),&r);
	}

	//Update the height.
	rect.h+=24;
	//Check if we should update the width., 8px extra on the width is for four pixels spacing on either side.
	if(item->w+8>rect.w) {
	rect.w=item->w+8;
	}

	return textureFromSurface(renderer, std::move(item));
	}
	void updateItem(SDL_Renderer& renderer,int index,const char* action,const char* caption,int icon=0){
	auto item=createItem(renderer,caption,icon);
	actions->updateItem(renderer, index,action,item);
	}
	void addItem(SDL_Renderer& renderer,const char* action,const char* caption,int icon=0){
	auto item=createItem(renderer,caption,icon);
	actions->addItem(renderer,action,item);
	}
	LevelEditorActionsPopup(ImageManager& imageManager,SDL_Renderer& renderer,LevelEditor* parent, GameObject* target, int x=0, int y=0){
	this->parent=parent;
	this->target=target;
	//NOTE: The size gets set in the addItem method, height is already four to prevent a scrollbar.
	rect.w=0;
	rect.h=4;

	//Load the gui images.
	bmGUI=imageManager.loadImage(getDataPath()+"gfx/gui.png");

	//Create the behaviour vector.
	behaviour.push_back(_("On"));
	behaviour.push_back(_("Off"));
	behaviour.push_back(_("Toggle"));

	//Create the states list.
	states.push_back(_("Complete"));
	states.push_back(_("One step"));
	states.push_back(_("Two steps"));
	states.push_back(_("Gone"));
	//TODO: The width should be based on the longest option.

	//Create default actions.
	//NOTE: Width and height are determined later on when the options are rendered.
	actions=new GUIListBox(imageManager,renderer,0,0,0,0);
	actions->eventCallback=this;

	//Check if it's a block or not.
	if(target!=NULL)
	addBlockItems(renderer);
	else
	addLevelItems(renderer);

	//Now set the size of the GUIListBox.
	actions->width=rect.w;
	actions->height=rect.h;

	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 addBlockItems(SDL_Renderer& renderer){
	//Get the type of the target.
	int type=target->type;

	//Check if the block is selected or not.
	std::vector<GameObject*>::iterator it;
	it=find(parent->selection.begin(),parent->selection.end(),target);
	if(it!=parent->selection.end())
	addItem(renderer,"Deselect",_("Deselect"));
	else
	addItem(renderer,"Select",_("Select"));
	addItem(renderer,"Delete",_("Delete"),8);
	//Determine what to do depending on the type.
	if(isLinkable[type]){
	//Check if it's a moving block type or trigger.
	if(type==TYPE_BUTTON \|\| type==TYPE_SWITCH \|\| type==TYPE_PORTAL){
	addItem(renderer,"Link",_("Link"),8*3);
	addItem(renderer,"Remove Links",_("Remove Links"));

	//Check if it's a portal, which contains a automatic option, and triggers a behaviour one.
	if(type==TYPE_PORTAL){
	addItem(renderer,"Automatic",_("Automatic"),(target->getEditorProperty("automatic")=="1")?2:1);
	}else{
	//Get the current behaviour.
	int currentBehaviour=2;
	if(target->getEditorProperty("behaviour")=="on"){
	currentBehaviour=0;
	}else if(target->getEditorProperty("behaviour")=="off"){
	currentBehaviour=1;
	}

	addItem(renderer,"Behaviour",behaviour[currentBehaviour].c_str());
	}
	}else{
	addItem(renderer,"Path",_("Path"));
	addItem(renderer,"Remove Path",_("Remove Path"));

	//FIXME: We use hardcoded indeces, if the order changes we have a problem.
	addItem(renderer,"Activated",_("Activated"),(target->getEditorProperty("activated")=="1")?2:1);
	addItem(renderer,"Looping",_("Looping"),(target->getEditorProperty("loop")=="1")?2:1);
	}
	}
	//Check for a conveyor belt.
	if(type==TYPE_CONVEYOR_BELT \|\| type==TYPE_SHADOW_CONVEYOR_BELT){
	addItem(renderer,"Activated",_("Activated"),(target->getEditorProperty("activated")=="1")?2:1);
	addItem(renderer,"Speed",_("Speed"));
	}
	//Check if it's a fragile block.
	if(type==TYPE_FRAGILE){
	//Get the current state.
	int currentState=atoi(target->getEditorProperty("state").c_str());
	addItem(renderer,"State",states[currentState].c_str());
	}
	//Check if it's a notification block.
	if(type==TYPE_NOTIFICATION_BLOCK)
	addItem(renderer,"Message",_("Message"));
	//Finally add scripting to the bottom.
	addItem(renderer,"Scripting",_("Scripting"),8*2+1);
	}

	void addLevelItems(SDL_Renderer& renderer){
	addItem(renderer,"LevelSettings",_("Settings"),8*2);
	addItem(renderer,"LevelScripting",_("Scripting"),8*2+1);
	}

	virtual ~LevelEditorActionsPopup(){
	//bmGui is freed by imageManager.
	if(actions)
	delete actions;
	}

	void render(SDL_Renderer& renderer){
	//Draw the actions.
	actions->render(renderer,rect.x,rect.y);
	}
	void handleEvents(SDL_Renderer& renderer){
	//Check if a mouse is pressed outside the popup.
	int x,y;
	SDL_GetMouseState(&x,&y);
	SDL_Rect mouse={x,y,0,0};
	if(event.type==SDL_MOUSEBUTTONDOWN && !checkCollision(mouse,rect)){
	dismiss();
	return;
	}
	//Let the listbox handle its events.
	actions->handleEvents(renderer,rect.x,rect.y);
	}
	void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//NOTE: There should only be one GUIObject, so we know what event is fired.
	//Get the selected entry.
	std::string action=actions->item[actions->value];
	if(action=="Select"){
	//Add the target to the selection.
	parent->selection.push_back(target);
	dismiss();
	return;
	}else if(action=="Deselect"){
	//Check if the block is in the selection.
	std::vector<GameObject*>::iterator it;
	it=find(parent->selection.begin(),parent->selection.end(),target);
	if(it!=parent->selection.end()){
	//Remove the object from the selection.
	parent->selection.erase(it);
	}

	dismiss();
	return;
	}else if(action=="Delete"){
	parent->removeObject(target);
	dismiss();
	return;
	}else if(action=="Link"){
	parent->linking=true;
	parent->linkingTrigger=dynamic_cast<Block*>(target);
	parent->tool=LevelEditor::SELECT;
	dismiss();
	return;
	}else if(action=="Remove Links"){
	//Remove all the
	std::map<Block,vector<GameObject> >::iterator it;
	it=parent->triggers.find(dynamic_cast<Block*>(target));
	if(it!=parent->triggers.end()){
	//Remove the targets.
	(*it).second.clear();
	}

	//In case of a portal remove its destination field.
	if(target->type==TYPE_PORTAL){
	target->setEditorProperty("destination","");
	}else{
	//We give the trigger a new id to prevent activating unlinked targets.
	char s[64];
	sprintf(s,"%u",parent->currentId);
	parent->currentId++;
	target->setEditorProperty("id",s);
	}
	dismiss();
	return;
	}else if(action=="Path"){
	parent->moving=true;
	parent->movingBlock=dynamic_cast<Block*>(target);
	parent->tool=LevelEditor::SELECT;
	dismiss();
	return;
	}else if(action=="Remove Path"){
	//Set the number of moving positions to zero.
	target->setEditorProperty("MovingPosCount","0");

	std::map<Block*,vector<MovingPosition> >::iterator it;
	it=parent->movingBlocks.find(dynamic_cast<Block*>(target));
	if(it!=parent->movingBlocks.end()){
	(*it).second.clear();
	}
	dismiss();
	return;
	}else if(action=="Message"){
	//Create the GUI.
	GUIWindow* root=new GUIWindow(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-250)/2,600,250,true,true,_("Notification block"));
	root->name="notificationBlockWindow";
	root->eventCallback=parent;
	GUIObject* obj;

	obj=new GUILabel(imageManager,renderer,40,50,240,36,_("Enter message here:"));
	root->addChild(obj);
	GUITextArea* textarea=new GUITextArea(imageManager,renderer,50,90,500,100);
	//Set the name of the text area, which is used to identify the object later on.
	textarea->name="message";
	string tmp=target->getEditorProperty("message");
	//Change \n with the characters '\n'.
	while(tmp.find("\\n")!=string::npos){
	tmp=tmp.replace(tmp.find("\\n"),2,"\n");
	}
	textarea->setString(renderer, tmp);
	root->addChild(textarea);

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

	//Add the window to the GUIObjectRoot and the objectWindows map.
	GUIObjectRoot->addChild(root);
	parent->objectWindows[root]=target;

	//And dismiss this popup.
	dismiss();
	return;
	}else if(action=="Activated"){
	//Get the previous state.
	bool enabled=(target->getEditorProperty("activated")=="1");

	//Switch the state.
	enabled=!enabled;

	target->setEditorProperty("activated",enabled?"1":"0");

	updateItem(renderer,actions->value,"Enabled",_("Enabled"),enabled?2:1);
	actions->value=-1;
	return;
	}else if(action=="Looping"){
	//Get the previous state.
	bool loop=(target->getEditorProperty("loop")=="1");

	//Switch the state.
	loop=!loop;
	target->setEditorProperty("loop",loop?"1":"0");

	updateItem(renderer,actions->value,"Looping",_("Looping"),loop?2:1);
	actions->value=-1;
	return;
	}else if(action=="Automatic"){
	//Get the previous state.
	bool automatic=(target->getEditorProperty("automatic")=="1");

	//Switch the state.
	automatic=!automatic;
	target->setEditorProperty("automatic",automatic?"1":"0");

	updateItem(renderer,actions->value,"Automatic",_("Automatic"),automatic?2:1);
	actions->value=-1;
	return;
	}else if(action=="Behaviour"){
	//Get the current behaviour.
	int currentBehaviour=2;
	string behave=target->getEditorProperty("behaviour");
	if(behave=="on"){
	currentBehaviour=0;
	}else if(behave=="off"){
	currentBehaviour=1;
	}

	//Increase the behaviour.
	currentBehaviour++;
	if(currentBehaviour>2)
	currentBehaviour=0;

	//Update the data of the block.
	target->setEditorProperty("behaviour",behaviour[currentBehaviour]);

	//And update the item.
	updateItem(renderer,actions->value,"Behaviour",behaviour[currentBehaviour].c_str());
	actions->value=-1;
	return;
	}else if(action=="State"){
	//Get the current state.
	int currentState=atoi(target->getEditorProperty("state").c_str());

	//Increase the state.
	currentState++;
	if(currentState>3)
	currentState=0;

	//Update the data of the block.
	char s[64];
	sprintf(s,"%d",currentState);
	target->setEditorProperty("state",s);

	//And update the item.
	updateItem(renderer,actions->value,"State",states[currentState].c_str());
	actions->value=-1;
	return;
	}else if(action=="Speed"){
	//Create the GUI.
	GUIWindow* root=new GUIWindow(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-250)/2,600,250,true,true,_("Conveyor belt speed"));
	root->name="conveyorBlockWindow";
	root->eventCallback=parent;
	GUIObject* obj;

	obj=new GUILabel(imageManager,renderer,40,100,240,36,_("Enter speed here:"));
	root->addChild(obj);
	GUISpinBox* obj2=new GUISpinBox(imageManager,renderer,240,100,320,36);
	//Set the name of the text area, which is used to identify the object later on.
	obj2->name="speed";
	obj2->caption=target->getEditorProperty("speed");
	obj2->update();
	root->addChild(obj2);

	obj=new GUIButton(imageManager,renderer,root->width*0.3,250-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgConveyorBlockOK";
	obj->eventCallback=root;
	root->addChild(obj);
	obj=new GUIButton(imageManager,renderer,root->width*0.7,250-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgCancel";
	obj->eventCallback=root;
	root->addChild(obj);

	//Add the window to the GUIObjectRoot and the objectWindows map.
	GUIObjectRoot->addChild(root);
	parent->objectWindows[root]=target;

	//And dismiss this popup.
	dismiss();
	return;
	}else if(action=="Scripting"){
	//Create the GUI.
	GUIWindow* root=new GUIWindow(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-500)/2,600,500,true,true,_("Scripting"));
	root->name="scriptingWindow";
	root->eventCallback=parent;
	GUIObject* obj;

	obj=new GUILabel(imageManager,renderer,50,60,240,36,_("Id:"));
	root->addChild(obj);

	obj=new GUITextBox(imageManager,renderer,100,60,240,36,dynamic_cast<Block*>(target)->id.c_str());
	obj->name="id";
	root->addChild(obj);

	GUISingleLineListBox* list=new GUISingleLineListBox(imageManager,renderer,50,100,500,36);
	std::map<std::string,int>::iterator it;
	for(it=Game::gameObjectEventNameMap.begin();it!=Game::gameObjectEventNameMap.end();++it)
	list->addItem(it->first);
	list->name="cfgScriptingEventType";
	list->value=0;
	list->eventCallback=root;
	root->addChild(list);

	//Add a text area for each event type.
	Block* block=dynamic_cast<Block*>(target);
	for(unsigned int i=0;i<list->item.size();i++){
	GUITextArea* text=new GUITextArea(imageManager,renderer,50,140,500,300);
	text->name=list->item[i].first;
	text->setFont(fontMono);
	//Only set the first one visible and enabled.
	text->visible=(i==0);
	text->enabled=(i==0);

	map<int,string>::iterator it=block->scripts.find(Game::gameObjectEventNameMap[list->item[i].first]);
	if(it!=block->scripts.end())
	text->setString(renderer, it->second);

	root->addChild(text);
	}


	obj=new GUIButton(imageManager,renderer,root->width*0.3,500-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgScriptingOK";
	obj->eventCallback=root;
	root->addChild(obj);
	obj=new GUIButton(imageManager,renderer,root->width*0.7,500-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgCancel";
	obj->eventCallback=root;
	root->addChild(obj);

	//Add the window to the GUIObjectRoot and the objectWindows map.
	GUIObjectRoot->addChild(root);
	parent->objectWindows[root]=target;

	//And dismiss this popup.
	dismiss();
	return;
	}else if(action=="LevelSettings"){
	//Open the levelSettings window.
	parent->levelSettings(imageManager,renderer);

	//And dismiss this popup.
	dismiss();
	return;
	}else if(action=="LevelScripting"){
	//Create the GUI.
	GUIWindow* root=new GUIWindow(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-500)/2,600,500,true,true,_("Level Scripting"));
	root->name="levelScriptingWindow";
	root->eventCallback=parent;
	GUIObject* obj;

	GUISingleLineListBox* list=new GUISingleLineListBox(imageManager,renderer,50,60,500,36);
	std::map<std::string,int>::iterator it;
	for(it=Game::levelEventNameMap.begin();it!=Game::levelEventNameMap.end();++it)
	list->addItem(it->first);
	list->name="cfgLevelScriptingEventType";
	list->value=0;
	list->eventCallback=root;
	root->addChild(list);

	//Add a text area for each event type.
	for(unsigned int i=0;i<list->item.size();i++){
	GUITextArea* text=new GUITextArea(imageManager,renderer,50,100,500,340);
	text->name=list->item[i].first;
	text->setFont(fontMono);
	//Only set the first one visible and enabled.
	text->visible=(i==0);
	text->enabled=(i==0);

	map<int,string>::iterator it=parent->scripts.find(Game::levelEventNameMap[list->item[i].first]);
	if(it!=parent->scripts.end())
	text->setString(renderer, it->second);

	root->addChild(text);
	}


	obj=new GUIButton(imageManager,renderer,root->width*0.3,500-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgLevelScriptingOK";
	obj->eventCallback=root;
	root->addChild(obj);
	obj=new GUIButton(imageManager,renderer,root->width*0.7,500-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgCancel";
	obj->eventCallback=root;
	root->addChild(obj);

	//Add the window to the GUIObjectRoot and the objectWindows map.
	GUIObjectRoot->addChild(root);
	parent->objectWindows[root]=target;

	//And dismiss this popup.
	dismiss();
	return;
	}
	}
	};


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

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

	//The position of window.
	SDL_Rect rect;

	//GUI image.
	SharedTexture bmGUI;

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

	//The scrollbar.
	GUIScrollBar* scrollBar;

	//Highlighted object.
	GameObject* highlightedObj;

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

	//If selection is dirty
	bool dirty;

	public:
	SDL_Rect getRect(){
	return rect;
	}
	int width(){
	return rect.w;
	}
	int height(){
	return rect.h;
	}
	void updateScrollBar(ImageManager& imageManager, SDL_Renderer& renderer){
	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(imageManager,renderer,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(ImageManager& imageManager, SDL_Renderer& renderer){
	if(parent!=NULL){
	std::vector<Block*>& 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(imageManager,renderer);
	}
	}
	void dismiss(){
	if(parent!=NULL && parent->selectionPopup==this){
	parent->selectionPopup=NULL;
	}
	delete this;
	}
	LevelEditorSelectionPopup(LevelEditor* parent, ImageManager& imageManager, SDL_Renderer& renderer, std::vector<GameObject*>& selection, int x=0, int y=0){
	this->parent=parent;
	this->selection=selection;

	dirty=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(imageManager,renderer);

	//Load the gui images.
	bmGUI=imageManager.loadTexture(getDataPath()+"gfx/gui.png",renderer);
	}
	virtual ~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(ImageManager& imageManager, SDL_Renderer& renderer){
	//Check dirty
	if(dirty){
	updateSelection(imageManager,renderer);
	if(selection.empty()){
	dismiss();
	return;
	}
	dirty=false;
	}

	//background
	drawGUIBox(rect.x,rect.y,rect.w,rect.h,renderer,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;

	ToolTips toolTip = ToolTips::TooltipMax;

	//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];
	//0xCCCCCC
	SDL_SetRenderDrawColor(&renderer,0x00,0xCC,0xCC,0xCC);
	SDL_RenderFillRect(&renderer,&r);
	}

	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);
	obj->editorPicture.draw(renderer,r.x+7,r.y+7);
	}

	if(parent!=NULL){
	//draw name
	TexturePtr& tex=parent->typeTextTextures.at(type);
	if(tex) {
	applyTexture(r.x+64,r.y+(64-textureHeight(tex))/2,tex,renderer);
	}

	//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-72,r.y+20,24,24};
	if(checkCollision(mouse,r2)){
	drawGUIBox(r2.x,r2.y,r2.w,r2.h,renderer,0x999999FFU);
	tooltipRect=r2;
	//tooltip=_("Select");
	highlightedBtn=1;
	toolTip=ToolTips::Select;
	}
	r2.x+=4;
	r2.y+=4;
	r2.w=r1.w;
	r2.h=r1.h;
	SDL_RenderCopy(&renderer, bmGUI.get(),&r1,&r2);
	}

	//draw delete
	{
	SDL_Rect r1={112,0,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,renderer,0x999999FFU);
	tooltipRect=r2;
	//tooltip=_("Delete");
	highlightedBtn=2;
	toolTip=ToolTips::Delete;
	}
	r2.x+=4;
	r2.y+=4;
	r2.w=r1.w;
	r2.h=r1.h;
	SDL_RenderCopy(&renderer, bmGUI.get(),&r1,&r2);
	}

	//draw configure
	{
	SDL_Rect r1={112,16,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,renderer,0x999999FFU);
	tooltipRect=r2;
	//tooltip=_("Configure");
	toolTip=ToolTips::Configure;
	highlightedBtn=3;
	}
	r2.x+=4;
	r2.y+=4;
	r2.w=r1.w;
	r2.h=r1.h;
	SDL_RenderCopy(&renderer, bmGUI.get(),&r1,&r2);
	}
	}
	}

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

	//draw tooltip
	if(parent && int(toolTip) < parent->tooltipTextures.size()){
	//Tool specific text.
	TexturePtr& tip=parent->tooltipTextures.at(size_t(toolTip));

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

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

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

	//Draw tooltip's text
	applyTexture(tooltipRect.x,tooltipRect.y,tip,renderer);
	}
	}
	}
	void handleEvents(ImageManager& imageManager,SDL_Renderer& renderer){
	//Check dirty
	if(dirty){
	updateSelection(imageManager,renderer);
	if(selection.empty()){
	dismiss();
	return;
	}
	dirty=false;
	}

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

	if(event.type==SDL_MOUSEBUTTONDOWN){
	if(event.button.button==SDL_BUTTON_LEFT){
	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<Block*>& 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->removeObject(highlightedObj);
	break;
	case 3:
	if(parent->actionsPopup)
	delete parent->actionsPopup;
	parent->actionsPopup=new LevelEditorActionsPopup(imageManager,renderer,parent,highlightedObj,mouse.x,mouse.y);
	break;
	}
	}
	}
	}
	}
	else if(event.type == SDL_MOUSEWHEEL) {
	//check mousewheel
	if(event.wheel.y < 0){
	startRow-=2;
	updateScrollBar(imageManager,renderer);
	return;
	} else {
	startRow+=2;
	updateScrollBar(imageManager,renderer);
	return;
	}
	}
	}
	};

	/////////////////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(SDL_Renderer& renderer, ImageManager& imageManager):Game(renderer, imageManager){
	//Get the target time and recordings.
	levelTime=levels->getLevel()->targetTime;
	levelRecordings=levels->getLevel()->targetRecordings;

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

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

	//Load the toolbar.
	toolbar=imageManager.loadTexture(getDataPath()+"gfx/menu/toolbar.png",renderer);
	toolbarRect={(SCREEN_WIDTH-410)/2,SCREEN_HEIGHT-50,410,50};

	selectionPopup=NULL;
	actionsPopup=NULL;

	movingSpeedWidth=-1;

	//Load the selectionMark.
	selectionMark=imageManager.loadTexture(getDataPath()+"gfx/menu/selection.png",renderer);

	//Load the movingMark.
	movingMark=imageManager.loadTexture(getDataPath()+"gfx/menu/moving.png",renderer);

	//Load the gui images.
	bmGUI=imageManager.loadTexture(getDataPath()+"gfx/gui.png",renderer);
	toolboxText=textureFromText(renderer,*fontText,_("Toolbox"),SDL_Color{0,0,0,0});

	for(auto i = 0;i < typeTextTextures.size();++i) {
	typeTextTextures[i] =
	textureFromText(renderer,
	*fontText,
	_(blockNames[i]),
	BLACK);
	}

	for(auto i = 0;i < tooltipTextures.size();++i) {
	if(i != size_t(ToolTips::NoTooltip)) {
	tooltipTextures[i] =
	textureFromText(renderer,
	*fontText,
	_(tooltipNames[i]),
	BLACK);
	}
	}

	//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();

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

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

	//Delete the popup
	if(actionsPopup){
	delete actionsPopup;
	actionsPopup=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;
	toolboxVisible=false;
	toolboxRect.x=-1;
	toolboxRect.y=-1;
	toolboxRect.w=0;
	toolboxRect.h=0;
	toolboxIndex=0;
	pressedShift=false;
	pressedLeftMouse=false;
	dragging=false;
	selectionDrag=false;
	dragCenter=NULL;
	cameraXvel=0;
	cameraYvel=0;
	linking=false;
	linkingTrigger=NULL;
	currentId=0;
	movingBlock=NULL;
	moving=false;
	movingSpeed=10;
	tooltip=-1;

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

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

	//Delete any gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	//Clear the GUIWindow object map.
	objectWindows.clear();
	}

	void LevelEditor::loadLevelFromNode(ImageManager& imageManager, SDL_Renderer& renderer,TreeStorageNode* obj, const std::string& fileName){
	//call the method of base class.
	Game::loadLevelFromNode(imageManager,renderer,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());
	}

	//NOTE: We set the camera here since we know the dimensions of the level.
	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;

	//The level is loaded, so call postLoad.
	postLoad();
	}

	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);

	//Update the target time the levelpack.
	levels->getLevel()->targetTime=levelTime;
	}
	if(levelRecordings>=0){
	sprintf(c,"%d",levelRecordings);
	node.attributes["recordings"].push_back(c);

	//Update the target recordings the levelpack.
	levels->getLevel()->targetRecordings=levelRecordings;
	}
	}

	//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.
	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 and size in the storageNode.
	sprintf(s,"%d",box.x);
	obj1->value.push_back(s);
	sprintf(s,"%d",box.y);
	obj1->value.push_back(s);
	sprintf(s,"%d",box.w);
	obj1->value.push_back(s);
	sprintf(s,"%d",box.h);
	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);
	}
	}

	//Loop through the scripts and add them to the storage node of the game object.
	map<int,string>::iterator it;
	Block* object=(dynamic_cast<Block*>(levelObjects[o]));
	for(it=object->scripts.begin();it!=object->scripts.end();++it){
	//Make sure the script isn't an empty string.
	if(it->second.empty())
	continue;

	TreeStorageNode* script=new TreeStorageNode;
	obj1->subNodes.push_back(script);

	script->name="script";
	script->value.push_back(gameObjectEventTypeMap[it->first]);

	script->attributes["script"].push_back(it->second);
	}
	}
	}

	//Loop through the level scripts and save them.
	map<int,string>::iterator it;
	for(it=scripts.begin();it!=scripts.end();++it){
	//Make sure the script isn't an empty string.
	if(it->second.empty())
	continue;

	TreeStorageNode* script=new TreeStorageNode;
	node.subNodes.push_back(script);

	script->name="script";
	script->value.push_back(levelEventTypeMap[it->first]);

	script->attributes["script"].push_back(it->second);
	}

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


	///////////////EVENT///////////////////
	void LevelEditor::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//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(imageManager,renderer);

	//Also check if we should exit the playMode.
	if(inputMgr.isKeyDownEvent(INPUTMGR_ESCAPE)){
	//Reset the game and disable playMode.
	Game::reset(true);
	playMode=false;
	GUIObjectRoot->visible=true;
	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(imageManager,renderer,_("Are you sure you want to quit?"),MsgBoxYesNo,_("Quit prompt"))==MsgBoxYes){
	//We exit the level editor.
	setNextState(STATE_LEVEL_EDIT_SELECT);

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

	//No need for handling other events, so return.
	return;
	}
	}

	//Check if we should redirect the event to the actions popup
	if(actionsPopup!=NULL){
	actionsPopup->handleEvents(renderer);
	return;
	}
	//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(imageManager,renderer);
	return;
	}
	}
	//TODO: Don't handle any Events when GUIWindows process them.
	{
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	//Create the rectangle.
	SDL_Rect mouse={x,y,0,0};
	for(unsigned int i=0;i<GUIObjectRoot->childControls.size();i++){
	SDL_Rect box={0,0,0,0};
	box.x=GUIObjectRoot->childControls[i]->left;
	box.y=GUIObjectRoot->childControls[i]->top;
	box.w=GUIObjectRoot->childControls[i]->width;
	box.h=GUIObjectRoot->childControls[i]->height;
	if(checkCollision(mouse,box))
	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;
	}else{
	//The selected button isn't a tool.
	//Now check which button it is.
	if(t==NUMBER_TOOLS){
	enterPlayMode();
	}
	if(t==NUMBER_TOOLS+2){
	//Open up level settings dialog
	levelSettings(imageManager,renderer);
	}
	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(imageManager,renderer,tfm::format(_("Level \"%s\" saved"),fileNameFromPath(levelFile)),MsgBoxOKOnly,_("Saved"));
	else
	msgBox(imageManager,renderer,tfm::format(_("Level \"%s\" saved"),levelName),MsgBoxOKOnly,_("Saved"));
	}
	}

	return;
	}

	//Check if tool box is clicked.
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_LEFT && toolboxRect.w>0){
	if(toolboxVisible){
	if(event.button.y<64){
	//Check if we need to hide it
	if(event.button.x>=SCREEN_WIDTH-24 && event.button.x<SCREEN_WIDTH && event.button.y<20){
	toolboxVisible=false;
	return;
	}

	//Check if a block is clicked.
	if(event.button.x>=24 && event.button.x<SCREEN_WIDTH-24){
	int m=(SCREEN_WIDTH-48)/64;
	int i=(event.button.x-24)/64;
	if(i<m && i+toolboxIndex<EDITOR_ORDER_MAX){
	currentType=i+toolboxIndex;
	}
	}

	//TODO: Move left and move right button.

	return;
	}
	}else if(event.button.x>=toolboxRect.x && event.button.x<toolboxRect.x+toolboxRect.w
	&& event.button.y>=toolboxRect.y && event.button.y<toolboxRect.y+toolboxRect.h)
	{
	toolboxVisible=true;
	return;
	}
	}

	//Check if shift is pressed.
	pressedShift=inputMgr.isKeyDown(INPUTMGR_SHIFT);

	//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(this,0,0,50,50,atoi(clipboard[o]["type"].c_str()));
	block->setBaseLocation(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())){
	//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);
	}
	}
	}

	//Update cursor.
	if(dragging){
	if(tool==REMOVE)
	currentCursor=CURSOR_REMOVE;
	else
	currentCursor=CURSOR_DRAG;
	}

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

	//Check if we scroll up, meaning the currentType++;
	if((event.type==SDL_MOUSEWHEEL && event.wheel.y > 0) \|\| inputMgr.isKeyDownEvent(INPUTMGR_NEXT)){
	switch(tool){
	case ADD:
	//Check if mouse is in tool box.
	if(toolboxVisible && toolboxRect.w>0){
	int x,y;
	SDL_GetMouseState(&x,&y);
	if(y<64){
	toolboxIndex-=2;
	if(toolboxIndex<0) toolboxIndex=0;
	break;
	}
	}
	//Only change the current type when using the add tool.
	currentType++;
	if(currentType>=EDITOR_ORDER_MAX){
	currentType=0;
	}
	break;
	case SELECT:
	//When configuring moving blocks.
	if(moving){
	movingSpeed++;
	//The movingspeed is capped at 100.
	if(movingSpeed>100){
	movingSpeed=100;
	}
	break;
	}
	//Fall through.
	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_MOUSEWHEEL && event.wheel.y < 0) \|\| inputMgr.isKeyDownEvent(INPUTMGR_PREVIOUS)){
	switch(tool){
	case ADD:
	//Check if mouse is in tool box.
	if(toolboxVisible && toolboxRect.w>0){
	int x,y;
	SDL_GetMouseState(&x,&y);
	if(y<64){
	int m=EDITOR_ORDER_MAX-(SCREEN_WIDTH-48)/64;
	toolboxIndex+=2;
	if(toolboxIndex>m) toolboxIndex=m;
	if(toolboxIndex<0) toolboxIndex=0;
	break;
	}
	}
	//Only change the current type when using the add tool.
	currentType--;
	if(currentType<0){
	currentType=EDITOR_ORDER_MAX-1;
	}
	break;
	case SELECT:
	//When configuring moving blocks.
	if(moving){
	movingSpeed--;
	if(movingSpeed<=0){
	movingSpeed=1;
	}
	break;
	}
	//Fall through.
	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){
	enterPlayMode();
	}
	//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;
	}

	//Check for certain events.

	//First make sure the mouse isn't above the toolbar.
	if(!checkCollision(mouse,toolbarRect) && !checkCollision(mouse,toolboxRect)){
	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_MOUSEBUTTONDOWN){
	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]);
	}
	}

	//Check if there are multiple objects above eachother or just one.
	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(imageManager,renderer,clickObjects[0],isSelected);
	}
	}else if(clickObjects.size()>=1){
	//There are more than one object under the mouse
	//SDL2 port (never managed to trigger this without changing the parameters.
	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());

	//Only show the selection popup when right clicking.
	if(event.button.button==SDL_BUTTON_LEFT){
	onClickObject(clickObjects[0],isSelected);
	}else if(event.button.button==SDL_BUTTON_RIGHT){
	//Remove the selection popup if there's one.
	if(selectionPopup!=NULL)
	delete selectionPopup;

	//Get the mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	selectionPopup=new LevelEditorSelectionPopup(this,imageManager,renderer,clickObjects,x,y);
	}
	}
	}

	//If event is false then we clicked on void.
	if(!clickEvent){
	if(event.type==SDL_MOUSEBUTTONDOWN){
	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==SELECT/){
	//Stop linking.
	if(linking){
	linking=false;
	linkingTrigger=NULL;
	//NOTE: We shouldn't be able to be linking AND moving so return to prevent actions popup.
	return;
	}

	//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,"%u",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;
	return;
	}

	//No return so far so call onRightClickVoid.
	onRightClickVoid(imageManager,renderer,mouse.x,mouse.y);
	}
	}
	}
	}

	//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(imageManager,renderer);
	}

	//NOTE: Do we even need Ctrl+n?
	//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).
	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(imageManager,renderer,tfm::format(_("Level \"%s\" saved"),fileNameFromPath(levelFile)),MsgBoxOKOnly,_("Saved"));
	else
	msgBox(imageManager,renderer,tfm::format(_("Level \"%s\" saved"),levelName),MsgBoxOKOnly,_("Saved"));
	}
	}
	}

	void LevelEditor::enterPlayMode(){
	//Check if we are already in play mode.
	if(playMode) return;

	//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,"%u",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;
	}

	//Change mode.
	playMode=true;
	GUIObjectRoot->visible=false;
	cameraSave.x=camera.x;
	cameraSave.y=camera.y;

	//Compile and run script.
	//NOTE: The scriptExecutor should have been reset because we called Game::reset() before.
	compileScript();
	}

	void LevelEditor::levelSettings(ImageManager& imageManager,SDL_Renderer& renderer){
	//It isn't so open a popup asking for a name.
	GUIWindow* root=new GUIWindow(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-300)/2,600,300,true,true,_("Level settings"));
	root->name="lvlSettingsWindow";
	root->eventCallback=this;
	GUIObject* obj;

	//Create the two textboxes with a label.
	obj=new GUILabel(imageManager,renderer,40,50,240,36,_("Name:"));
	root->addChild(obj);
	obj=new GUITextBox(imageManager,renderer,140,50,410,36,levelName.c_str());
	obj->name="name";
	root->addChild(obj);

	obj=new GUILabel(imageManager,renderer,40,100,240,36,_("Theme:"));
	root->addChild(obj);
	obj=new GUITextBox(imageManager,renderer,140,100,410,36,levelTheme.c_str());
	obj->name="theme";
	root->addChild(obj);

	//target time and recordings.
	{
	obj=new GUILabel(imageManager,renderer,40,150,240,36,_("Target time (s):"));
	root->addChild(obj);
	GUISpinBox* obj2=new GUISpinBox(imageManager,renderer,290,150,260,36);
	obj2->name="time";

	ostringstream ss;
	ss << levelTime/40.0f;
	obj2->caption=ss.str();
	obj2->update();

	obj2->limitMin=0.0f;
	obj2->change=0.1f;
	root->addChild(obj2);

	obj=new GUILabel(imageManager,renderer,40,200,240,36,_("Target recordings:"));
	root->addChild(obj);
	obj2=new GUISpinBox(imageManager,renderer,290,200,260,36);

	ostringstream ss2;
	ss2 << levelRecordings;
	obj2->caption=ss2.str();

	obj2->limitMin=0.0f;
	obj2->format="%1.0f";
	obj2->name="recordings";
	obj2->update();
	root->addChild(obj2);
	}


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

	GUIObjectRoot->addChild(root);
	}

	void LevelEditor::postLoad(){
	//We need to find the triggers.
	for(unsigned int o=0;o<levelObjects.size();o++){
	//Check for the highest id.
	unsigned int id=atoi(levelObjects[o]->getEditorProperty("id").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:
	{
	//Get the editor data.
	vector<pair<string,string> > objMap;
	levelObjects[o]->getEditorData(objMap);

	//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;
	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::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_GetMouseFocus() == sdlWindow)){
	//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 tool box is visible and we need to calc screen size correctly.
	int y0=50;
	if(toolboxVisible && toolboxRect.w>0) y0+=64;

	//Check if the mouse is near the top edge of the screen.
	//Else check if the mouse is near the bottom edge.
	if(y<y0){
	//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;
	}
	}
	}

	void LevelEditor::onClickObject(GameObject* obj,bool selected){
	switch(tool){
	case SELECT:
	{
	//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.
	char s[64];
	sprintf(s,"%d",atoi(obj->getEditorProperty("id").c_str()));
	linkingTrigger->setEditorProperty("destination",s);
	}else{
	//Give the object the same id as the trigger.
	char s[64];
	sprintf(s,"%d",atoi(linkingTrigger->getEditorProperty("id").c_str()));
	obj->setEditorProperty("id",s);
	}

	//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;
	}
	}
	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(ImageManager& imageManager,SDL_Renderer& renderer,GameObject* obj,bool){
	//Create an actions popup for the game object.
	if(actionsPopup==NULL){
	//Get the mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	actionsPopup=new LevelEditorActionsPopup(imageManager,renderer,this,obj,x,y);
	return;
	}
	}

	void LevelEditor::onClickVoid(int x,int y){
	switch(tool){
	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(this,x,y,50,50,editorTileOrder[currentType]));
	break;
	}
	case SELECT:
	{
	//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::onRightClickVoid(ImageManager& imageManager,SDL_Renderer& renderer,int,int){
	//Create an actions popup for the game object.
	if(actionsPopup==NULL){
	//Get the mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	actionsPopup=new LevelEditorActionsPopup(imageManager,renderer,this,NULL,x,y);
	return;
	}
	}

	void LevelEditor::onDragStart(int x,int y){
	switch(tool){
	case SELECT:
	case ADD:
	{
	//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};

	currentCursor=CURSOR_REMOVE;

	//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:
	{
	//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){
	//NOTE: Function isn't used anymore.
	}

	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.
	Block* block=dynamic_cast<Block*>(obj);
	//Make sure it's a block.
	if(!block)
	return;
	levelObjects.push_back(block);

	//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[block]=linked;

	//Give it it's own id.
	char s[64];
	sprintf(s,"%u",currentId);
	currentId++;
	block->setEditorProperty("id",s);
	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[block]=positions;

	//Get the editor data.
	vector<pair<string,string> > objMap;
	block->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[block].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,"%u",currentId);
	currentId++;
	editorData["id"]=s;
	block->setEditorData(editorData);
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::moveObject(GameObject* obj,int x,int y){
	//Set the obj at it's new position.
	obj->setBaseLocation(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;

	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.setLocation(player.getBox().x+diffx,player.getBox().y+diffy);
	shadow.setLocation(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+(obj->getBox().w-player.getBox().w)/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+(obj->getBox().w-shadow.getBox().h)/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<Block,vector<GameObject> >::iterator mapIt;

	//Make sure we don't access the removed object through
	//moving/linking.
	if(obj==movingBlock){
	movingBlock=nullptr;
	}
	if(obj==linkingTrigger){
	linkingTrigger=nullptr;
	}
	moving=false;
	linking=false;

	//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(dynamic_cast<Block*>(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<Block*,vector<MovingPosition> >::iterator movIt;
	movIt=movingBlocks.find(dynamic_cast<Block*>(obj));
	if(movIt!=movingBlocks.end()){
	//It is so we remove it.
	movingBlocks.erase(movIt);
	}

	//Check if the block isn't being configured with a window one way or another.
	std::map<GUIObject,GameObject>::iterator confIt;
	for(confIt=objectWindows.begin();confIt!=objectWindows.end();++confIt){
	if((*confIt).second==obj){
	destroyWindow((*confIt).first);
	}
	}

	//Now we remove the object from the levelObjects.
	{
	std::vector<Block*>::iterator it;
	it=find(levelObjects.begin(),levelObjects.end(),dynamic_cast<Block*>(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(ImageManager&, SDL_Renderer&, std::string name,GUIObject* obj,int eventType){
	//Check if one of the windows is closed.
	if(eventType==GUIEventClick && (name=="lvlSettingsWindow" \|\| name=="notificationBlockWindow" \|\| name=="conveyorBlockWindow" \|\| name=="scriptingWindow" \|\| name=="levelScriptingWindow")){
	destroyWindow(obj);
	return;
	}
	//TODO: Add resize code for each GUIWindow.
	if(name=="lvlSettingsWindow"){
	return;
	}
	if(name=="notificationBlockWindow"){
	return;
	}
	if(name=="conveyorBlockWindow"){
	return;
	}
	if(name=="scriptingWindow"){
	return;
	}
	if(name=="levelScriptingWindow"){
	return;
	}

	//Check for GUI events.
	//Notification block configure events.
	if(name=="cfgNotificationBlockOK"){
	//Get the configuredObject.
	GameObject* configuredObject=objectWindows[obj];
	if(configuredObject){
	//Get the message textbox from the GUIWindow.
	GUITextArea* message=(GUITextArea*)obj->getChild("message");

	if(message){
	//Set the message of the notification block.
	configuredObject->setEditorProperty("message",message->getString());
	}
	}
	}
	//Conveyor belt block configure events.
	if(name=="cfgConveyorBlockOK"){
	//Get the configuredObject.
	GameObject* configuredObject=objectWindows[obj];
	if(configuredObject){
	//Get the speed textbox from the GUIWindow.
	GUISpinBox* speed=(GUISpinBox*)obj->getChild("speed");

	if(speed){
	//Set the speed of the conveyor belt.
	configuredObject->setEditorProperty("speed",speed->caption);
	}
	}
	}
	//LevelSetting events.
	if(name=="lvlSettingsOK"){
	GUIObject* object=obj->getChild("name");
	if(object)
	levelName=object->caption;
	object=obj->getChild("theme");
	if(object)
	levelTheme=object->caption;

	//target time and recordings.
	GUISpinBox* object2=(GUISpinBox*)obj->getChild("time");
	if(object2){
	float number=atof(object2->caption.c_str());
	if(number<=0){
	levelTime=-1;
	}else{
	levelTime=int(number*40.0+0.5);
	}
	}

	object2=(GUISpinBox*)obj->getChild("recordings");
	if(object){
	float number=atof(object2->caption.c_str());
	if(number<=0){
	levelRecordings=-1;
	}else{
	levelRecordings=int(number);
	}
	}
	}
	//Level scripting window events.
	if(name=="cfgLevelScriptingEventType"){
	//Get the script textbox from the GUIWindow.
	GUISingleLineListBox* list=(GUISingleLineListBox*)obj->getChild("cfgLevelScriptingEventType");

	if(list){
	//Loop through the scripts.
	for(unsigned int i=0;i<list->item.size();i++){
	GUIObject* script=obj->getChild(list->item[i].first);
	if(script){
	script->visible=(script->name==list->item[list->value].first);
	script->enabled=(script->name==list->item[list->value].first);
	}
	}
	}
	return;
	}
	if(name=="cfgLevelScriptingOK"){
	//Get the script textbox from the GUIWindow.
	GUISingleLineListBox* list=(GUISingleLineListBox*)obj->getChild("cfgLevelScriptingEventType");

	if(list){
	//Loop through the scripts.
	for(unsigned int i=0;i<list->item.size();i++){
	//Get the GUITextArea.
	GUITextArea* script=dynamic_cast<GUITextArea*>(obj->getChild(list->item[i].first));
	if(script){
	//Set the script for the target block.
	string str=script->getString();
	if(str.empty())
	scripts.erase(levelEventNameMap[script->name]);
	else
	scripts[levelEventNameMap[script->name]]=str;
	}
	}
	}
	}
	//Scripting window events.
	if(name=="cfgScriptingEventType"){
	//TODO: Save any unsaved scripts? (Or keep track of all scripts and save upon cfgScriptingOK?)
	//Get the configuredObject.
	Block* configuredObject=dynamic_cast<Block*>(objectWindows[obj]);
	if(configuredObject){
	//Get the script textbox from the GUIWindow.
	GUISingleLineListBox* list=(GUISingleLineListBox*)obj->getChild("cfgScriptingEventType");

	if(list){
	//Loop through the scripts.
	for(unsigned int i=0;i<list->item.size();i++){
	GUIObject* script=obj->getChild(list->item[i].first);
	if(script){
	script->visible=script->enabled=(script->name==list->item[list->value].first);
	}
	}
	}
	}
	return;
	}
	if(name=="cfgScriptingOK"){
	//Get the configuredObject.
	GameObject* configuredObject=objectWindows[obj];
	if(configuredObject){
	//Get the script textbox from the GUIWindow.
	GUISingleLineListBox* list=(GUISingleLineListBox*)obj->getChild("cfgScriptingEventType");
	GUIObject* id=obj->getChild("id");

	Block* block=dynamic_cast<Block*>(configuredObject);
	if(block){
	if(list){
	//Loop through the scripts.
	for(unsigned int i=0;i<list->item.size();i++){
	//Get the GUITextArea.
	GUITextArea* script=dynamic_cast<GUITextArea*>(obj->getChild(list->item[i].first));
	if(script){
	//Set the script for the target block.
	string str=script->getString();
	if(str.empty())
	block->scripts.erase(gameObjectEventNameMap[script->name]);
	else
	block->scripts[gameObjectEventNameMap[script->name]]=str;
	}
	}
	}
	if(id){
	//Set the new id for the target block.
	//TODO: Check for trigger links etc...
	(dynamic_cast<Block*>(configuredObject))->id=id->caption;
	}
	}
	}
	}

	//NOTE: We assume every event came from a window so remove it.
	destroyWindow(obj);
	}

	void LevelEditor::destroyWindow(GUIObject* window){
	//Make sure the given pointer isn't null.
	if(!window)
	return;

	//Remove the window from the GUIObject root.
	if(GUIObjectRoot){
	vector<GUIObject*>::iterator it;
	it=find(GUIObjectRoot->childControls.begin(),GUIObjectRoot->childControls.end(),window);
	if(it!=GUIObjectRoot->childControls.end()){
	GUIObjectRoot->childControls.erase(it);
	}
	}

	//Also remove the window from the objectWindows map.
	map<GUIObject,GameObject>::iterator it;
	it=objectWindows.find(window);
	if(it!=objectWindows.end()){
	objectWindows.erase(it);
	}

	//And delete the GUIWindow.
	delete window;
	}

	////////////////LOGIC////////////////////
	void LevelEditor::logic(ImageManager& imageManager, SDL_Renderer& renderer){
	if(playMode){
	//PlayMode so let the game do it's logic.
	Game::logic(imageManager,renderer);
	}else{
	//In case of a selection or actions popup prevent the camera from moving.
	if(selectionPopup \|\| actionsPopup)
	return;

	//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.
	//Get the mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	SDL_Rect mouse={x,y,0,0};
	{
	//Check if the mouse isn't above a GUIObject (window).
	bool inside=false;
	for(unsigned int i=0;i<GUIObjectRoot->childControls.size();i++){
	SDL_Rect box={0,0,0,0};
	box.x=GUIObjectRoot->childControls[i]->left;
	box.y=GUIObjectRoot->childControls[i]->top;
	box.w=GUIObjectRoot->childControls[i]->width;
	box.h=GUIObjectRoot->childControls[i]->height;
	if(checkCollision(mouse,box))
	inside=true;
	}

	if(!inside){
	SDL_Rect r[3]={toolbarRect,toolboxRect};
	int m=2;
	//TODO: Also call onCameraMove when moving using the mouse.
	setCamera(r,m);
	}
	}

	//It isn't playMode so the mouse should be checked.
	tooltip=-1;

	//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-410)/2+(t40)+((t+1)10),SCREEN_HEIGHT-45,40,40};

	//Check for collision.
	if(checkCollision(mouse,toolRect)==true){
	//Set the tooltip tool.
	tooltip=t;
	}
	}
	}
	}

	/////////////////RENDER//////////////////////
	void LevelEditor::render(ImageManager& imageManager,SDL_Renderer& renderer){
	//Always let the game render the game.
	Game::render(imageManager,renderer);

	//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;

	drawGUIBox(r.x,r.y,r.w,r.h,renderer,0xFFFFFF33);

	//Draw the selectionMarks.
	applyTexture(r.x,r.y,selectionMark,renderer);
	applyTexture(r.x+r.w-5,r.y,selectionMark,renderer);
	applyTexture(r.x,r.y+r.h-5,selectionMark,renderer);
	applyTexture(r.x+r.w-5,r.y+r.h-5,selectionMark,renderer);
	}

	//Set the color for the borders.
	SDL_SetRenderDrawColor(&renderer,themeTextColor.r,themeTextColor.g,themeTextColor.b,115);

	int leftWidth=0;
	int rightWidth=0;

	//Draw the dark areas marking the outside of the level.
	SDL_Rect r{0,0,0,0};
	if(camera.x<0){
	//Draw left side.
	r.x=0;
	r.y=0;
	r.w=0-camera.x;
	leftWidth=r.w;
	r.h=SCREEN_HEIGHT;
	SDL_RenderFillRect(&renderer, &r);
	}
	if(camera.y<0){
	//Draw the top.
	r.x=leftWidth;
	r.y=0;
	r.w=SCREEN_WIDTH;
	r.h=0-camera.y;
	SDL_RenderFillRect(&renderer, &r);
	} else {
	r.h=0;
	}
	if(camera.x>LEVEL_WIDTH-SCREEN_WIDTH){
	//Draw right side.
	r.x=LEVEL_WIDTH-camera.x;
	r.y=std::max(r.y+r.h,0);
	r.w=SCREEN_WIDTH-(LEVEL_WIDTH-camera.x);
	rightWidth=r.w;
	r.h=SCREEN_HEIGHT;
	SDL_RenderFillRect(&renderer, &r);
	}
	if(camera.y>LEVEL_HEIGHT-SCREEN_HEIGHT){
	//Draw the bottom.
	r.x=leftWidth;
	r.y=LEVEL_HEIGHT-camera.y;
	r.w=SCREEN_WIDTH-rightWidth-leftWidth;
	r.h=SCREEN_HEIGHT-(LEVEL_HEIGHT-camera.y);
	SDL_RenderFillRect(&renderer, &r);
	}

	//Check if we should draw on stuff.
	showConfigure(renderer);
	if(selectionDrag){
	showSelectionDrag(renderer);
	}else{
	if(tool==ADD){
	showCurrentObject(renderer);
	}
	}

	//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};

	//Find a block where the mouse is hovering on.
	for(unsigned int o=0; o<levelObjects.size(); o++){
	SDL_Rect rect=levelObjects[o]->getBox();
	if(checkCollision(rect,mouse)==true){
	if(tool==REMOVE){
	drawGUIBox(rect.x-camera.x,rect.y-camera.y,rect.w,rect.h,renderer,0xFF000055);
	currentCursor=CURSOR_REMOVE;
	}else{
	drawGUIBox(rect.x-camera.x,rect.y-camera.y,rect.w,rect.h,renderer,0xFFFFFF33);
	}
	}
	}

	//Draw the level borders.
	drawRect(-camera.x,-camera.y,LEVEL_WIDTH,LEVEL_HEIGHT,renderer);

	//Render the hud layer.
	renderHUD(renderer);

	//Render selection popup (if any).
	if(selectionPopup!=NULL){
	if(linking \|\| moving){
	//If we switch to linking mode then delete it
	//FIXME: Logic in the render method.
	delete selectionPopup;
	selectionPopup=NULL;
	}else{
	selectionPopup->render(imageManager,renderer);
	}
	}

	//Render actions popup (if any).
	if(actionsPopup!=NULL){
	actionsPopup->render(renderer);
	}
	}
	}

	void LevelEditor::renderHUD(SDL_Renderer& renderer){
	//If moving show the moving speed in the top right corner.
	if(moving){
	if(movementSpeedTexture.needsUpdate(movingSpeed)) {
	//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.
	movementSpeedTexture.update(movingSpeed,
	textureFromText(renderer,
	*fontText,
	tfm::format(_("Movespeed: %s"),movingSpeed).c_str(),
	BLACK));
	}
	auto& tex = movementSpeedTexture.getTexture();
	//Draw the text in the box.
	drawGUIBox(SCREEN_WIDTH-movingSpeedWidth-2,-2,movingSpeedWidth+8,
	textureHeight(tex)+6,renderer,0xFFFFFFFF);
	applyTexture(SCREEN_WIDTH-movingSpeedWidth,2,tex,renderer,NULL);
	}

	//On top of all render the toolbar.
	drawGUIBox(toolbarRect.x,toolbarRect.y,8*50+10,52,renderer,0xEDEDEDFF);
	//Draw the first four options.
	SDL_Rect srcRect={0,0,200,50};
	SDL_Rect dstRect={toolbarRect.x+5, toolbarRect.y, srcRect.w, srcRect.h};
	SDL_RenderCopy(&renderer, toolbar.get(), &srcRect, &dstRect);
	//And the last three.
	srcRect.x=200;
	srcRect.w=150;
	dstRect.x=toolbarRect.x+255;
	dstRect.w=srcRect.w;
	SDL_RenderCopy(&renderer, toolbar.get(), &srcRect, &dstRect);

	//Now render a tooltip.
	if(tooltip>=0 && static_cast<std::size_t>(tooltip)<tooltipTextures.size()) {
	TexturePtr& tex = tooltipTextures.at(tooltip);
	if(tex) {
	const SDL_Rect texSize = rectFromTexture(*tex.get());
	SDL_Rect r={(SCREEN_WIDTH-390)/2+(tooltip40)+(tooltip10),SCREEN_HEIGHT-45,40,40};
	r.y=SCREEN_HEIGHT-50-texSize.h;
	if(r.x+texSize.w>SCREEN_WIDTH-50)
	r.x=SCREEN_WIDTH-50-texSize.w;

	//Draw borders around text
	Uint32 color=0xFFFFFF00\|230;
	drawGUIBox(r.x-2,r.y-2,texSize.w+4,texSize.h+4,renderer,color);
	applyTexture(r.x, r.y, tex, renderer);
	}
	}

	//Render the tool box.
	if(!playMode && !moving && tool==ADD && selectionPopup==NULL && actionsPopup==NULL && objectWindows.empty()){
	if(toolboxVisible){
	toolboxRect.x=0;
	toolboxRect.y=0;
	toolboxRect.w=SCREEN_WIDTH;
	toolboxRect.h=64;

	drawGUIBox(-2,-2,SCREEN_WIDTH+4,66,renderer,0xFFFFFF00\|230);

	//Draw the hide icon.
	SDL_Rect r={SCREEN_WIDTH-20,2,16,16};
	SDL_Rect r2={80,0,r.w,r.h};
	r.x=SCREEN_WIDTH-20;
	SDL_RenderCopy(&renderer, bmGUI.get(), &r2, &r);

	//Calculate the maximal number of blocks can be displayed.
	int m=(SCREEN_WIDTH-48)/64;
	if(toolboxIndex>=EDITOR_ORDER_MAX-m){
	toolboxIndex=EDITOR_ORDER_MAX-m;
	}else{
	//Draw an icon.
	r.x=SCREEN_WIDTH-20;
	r.y=24;
	r2.x=96;
	r2.y=16;
	SDL_RenderCopy(&renderer, bmGUI.get(),&r2,&r);
	}
	if(toolboxIndex<=0){
	toolboxIndex=0;
	}else{
	//Draw an icon.
	r.x=4;
	r.y=24;
	r2.x=80;
	r2.y=16;
	SDL_RenderCopy(&renderer, bmGUI.get(),&r2,&r);
	}

	//Draw available blocks.
	for(int i=0;i<m;i++){
	if(i+toolboxIndex>=EDITOR_ORDER_MAX) break;

	//Draw a rectangle around the current tool.
	if(i+toolboxIndex==currentType){
	drawGUIBox(i*64+24,3,64,58,renderer,0xDDDDDDFF);
	}

	ThemeBlock* obj=objThemes.getBlock(editorTileOrder[i+toolboxIndex]);
	if(obj){
	obj->editorPicture.draw(renderer,i*64+24+7,7);
	}
	}

	//Draw a tool tip.
	int x,y;
	SDL_GetMouseState(&x,&y);
	if(y<64 && x>=24 && x<24+m*64){
	int i=(x-24)/64;
	if(i+toolboxIndex<EDITOR_ORDER_MAX){
	TexturePtr& tip=typeTextTextures.at(editorTileOrder[i+toolboxIndex]);
	const SDL_Rect tipSize=rectFromTexture(*tip);

	SDL_Rect r={24+i*64,64,40,40};
	if(r.x+tipSize.w>SCREEN_WIDTH-50)
	r.x=SCREEN_WIDTH-50-tipSize.w;

	//Draw borders around text
	Uint32 color=0xFFFFFF00\|230;
	drawGUIBox(r.x-2,r.y-2,tipSize.w+4,tipSize.h+4,renderer,color);

	//Draw tooltip's text
	applyTexture(r.x, r.y, tip, renderer);
	}
	}
	}else{
	const SDL_Rect tbtSize = rectFromTexture(*toolboxText);

	toolboxRect.x=SCREEN_WIDTH-tbtSize.w-28;
	toolboxRect.y=0;
	toolboxRect.w=tbtSize.w+28;
	toolboxRect.h=tbtSize.h+4;

	SDL_Rect r={SCREEN_WIDTH-tbtSize.w-24,2,16,16};
	drawGUIBox(r.x-4,-2,tbtSize.w+32,tbtSize.h+6,renderer,0xFFFFFFFF);

	//Draw "Toolbox" text.
	applyTexture(r.x, r.y, toolboxText, renderer);

	const SDL_Rect r2={96,0,16,16};
	r.x=SCREEN_WIDTH-20;
	r.w=r2.w;
	r.h=r2.h;
	//Draw arrow.
	SDL_RenderCopy(&renderer, bmGUI.get(),&r2,&r);
	}
	}else{
	toolboxRect.x=-1;
	toolboxRect.y=-1;
	toolboxRect.w=0;
	toolboxRect.h=0;
	}

	//Draw a rectangle around the current tool.
	Uint32 color=0xFFFFFF00;
	drawGUIBox((SCREEN_WIDTH-390)/2+(tool40)+(tool10),SCREEN_HEIGHT-46,42,42,renderer,color);
	}

	void LevelEditor::showCurrentObject(SDL_Renderer& renderer){
	//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(renderer,x-camera.x,y-camera.y);
	}
	}
	}

	void LevelEditor::showSelectionDrag(SDL_Renderer& renderer){
	//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.
	const 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){
	const SDL_Rect r1=selection[o]->getBox();
	obj->editorPicture.draw(renderer,(r1.x-r.x)+x-camera.x,(r1.y-r.y)+y-camera.y);
	}
	}
	}

	void LevelEditor::showConfigure(SDL_Renderer& renderer){
	//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<Block,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,renderer,color,32,arrowAnimation%32);

	//Also draw two selection marks.
	applyTexture(r.x-camera.x+25-2,r.y-camera.y+25-2,selectionMark,renderer);
	applyTexture(r1.x-camera.x+25-2,r1.y-camera.y+25-2,selectionMark,renderer);
	}
	}
	}

	//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,renderer,color,32,arrowAnimation%32);
	}
	}

	//Draw the moving positions.
	map<Block*,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,renderer,color,32,offset);
	}else{
	//time==0 ???? so don't draw arrow at all
	drawLine(r.x,r.y,x,y,renderer);
	}
	}

	//And draw a marker at the end.
	applyTexture(x-13,y-13,movingMark,renderer);

	//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,renderer,color,32,offset);
	applyTexture(x+12,y+12,movingMark,renderer);
	}

	}

	void LevelEditor::resize(ImageManager &imageManager, SDL_Renderer &renderer){
	//Call the resize method of the Game.
	Game::resize(imageManager, renderer);

	//Move the toolbar's position rect used for collision.
	toolbarRect.x=(SCREEN_WIDTH-410)/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/ScriptExecutor.cpp b/src/ScriptExecutor.cpp
	index 301dbac..0bbf1ff 100644
	--- a/src/ScriptExecutor.cpp
	+++ b/src/ScriptExecutor.cpp
	@@ -1,134 +1,137 @@
	/*
	* 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 "ScriptExecutor.h"
	#include "ScriptAPI.h"
	#include <iostream>
	using namespace std;

	ScriptExecutor::ScriptExecutor():state(NULL){
	//NOTE: If a state is going to use the scriptExecutor it is his task to reset it.
	}

	ScriptExecutor::~ScriptExecutor(){
	//Make sure there is a state to close.
	if(state)
	lua_close(state);
	}

	void ScriptExecutor::reset(){
	//Close the lua_state, if any.
	if(state)
	lua_close(state);

	//Create a new state.
	state=luaL_newstate();

	//Now load the lua libraries.
	//FIXME: Only allow safe libraries/functions.
	luaopen_base(state);
	luaL_requiref(state,"table",luaopen_table,1);
	- luaL_requiref(state,"bit32",luaopen_bit32,1);
	+ //SDL2 porting note. This library seems to have been deprecated.
	+ //If this is used, it's possible to compile lua 5.3 in compatability mode
	+ //that includes it.
	+ //luaL_requiref(state,"bit32",luaopen_bit32,1);
	luaL_requiref(state,"string",luaopen_string,1);
	luaL_requiref(state,"math",luaopen_math,1);

	//Load our own libraries.
	luaL_requiref(state,"block",luaopen_block,1);
	luaL_requiref(state,"playershadow",luaopen_player,1);
	luaL_requiref(state,"level",luaopen_level,1);
	luaL_requiref(state,"camera",luaopen_camera,1);
	luaL_requiref(state,"audio",luaopen_audio,1);
	}

	void ScriptExecutor::registerFunction(std::string name,lua_CFunction function){
	lua_register(state,name.c_str(),function);
	}

	int ScriptExecutor::compileScript(std::string script){
	//First make sure the stack is empty.
	lua_settop(state,0);

	//Compile the script.
	if(luaL_loadstring(state,script.c_str())!=LUA_OK){
	cerr<<"LUA ERROR: "<<lua_tostring(state,-1)<<endl;
	return LUA_REFNIL;
	}

	//Save it to LUA_REGISTRYINDEX and return values.
	return luaL_ref(state,LUA_REGISTRYINDEX);
	}

	int ScriptExecutor::executeScript(std::string script,Block* origin){
	//First make sure the stack is empty.
	lua_settop(state,0);

	//Compile the script.
	if(luaL_loadstring(state,script.c_str())!=LUA_OK){
	cerr<<"LUA ERROR: "<<lua_tostring(state,-1)<<endl;
	return 0;
	}

	//Now execute the script.
	return executeScriptInternal(origin);
	}

	int ScriptExecutor::executeScript(int scriptIndex,Block* origin){
	//Check if reference is empty.
	if(scriptIndex==LUA_REFNIL) return 0;

	//Make sure the stack is empty.
	lua_settop(state,0);

	//Get the function
	lua_rawgeti(state,LUA_REGISTRYINDEX,scriptIndex);

	//Check if it's function and run.
	if(lua_isfunction(state,-1)){
	return executeScriptInternal(origin);
	}else{
	cerr<<"LUA ERROR: Not a function"<<endl;
	return 0;
	}
	}

	int ScriptExecutor::executeScriptInternal(Block* origin){
	//If the origin isn't null set it in the global scope.
	if(origin){
	origin->createUserData(state,"block");
	lua_setglobal(state,"this");
	}

	//Now execute the script on the top of Lua stack.
	int ret=lua_pcall(state,0,1,0);

	//If we set an origin set it back to nothing.
	if(origin){
	lua_pushnil(state);
	lua_setglobal(state,"this");
	}

	//Check if there's an error.
	if(ret!=LUA_OK){
	cerr<<"LUA ERROR: "<<lua_tostring(state,-1)<<endl;
	return 0;
	}

	//Get the return value.
	return lua_tonumber(state,-1);
	}
	diff --git a/src/ScriptUserData.h b/src/ScriptUserData.h
	index fb3e61c..853f165 100644
	--- a/src/ScriptUserData.h
	+++ b/src/ScriptUserData.h
	@@ -1,194 +1,196 @@
	/*
	* 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 SCRIPTUSERDATA_H
	#define SCRIPTUSERDATA_H

	extern "C" {
	#include "lua.h"
	#include "lualib.h"
	#include "lauxlib.h"
	}
	#include <string>

	#ifdef _DEBUG
	#include <assert.h>
	#endif

	+#if defined(_DEBUG) && defined(DISABLED_DEBUG_STUFF)
	//Some debug functions
	void scriptUserClassDebugCreate(char sig1,char sig2,char sig3,char sig4,const void* p1,const void* p2);
	void scriptUserClassDebugInvalidate(char sig1,char sig2,char sig3,char sig4,const void* p1,const void* p2);
	void scriptUserClassDebugUnlink(char sig1,char sig2,char sig3,char sig4,const void* p1,const void* p2);
	+#endif

	//A struct represents the Lua user data.
	struct ScriptUserData{
	char sig1,sig2,sig3,sig4;
	void* data;
	ScriptUserData* prev;
	ScriptUserData* next;
	};

	//A helper class to bind C++ class to Lua user data.
	template<char sig1,char sig2,char sig3,char sig4,class T>
	class ScriptUserClass{
	public:
	ScriptUserClass():scriptUserDataHead(NULL){
	}

	ScriptUserClass(const ScriptUserClass& other):scriptUserDataHead(NULL){
	}

	ScriptUserClass& operator=(const ScriptUserClass& other){
	//do nothing
	}

	//Create a Lua user data pointed to this object. (-0,+1,e)
	//state: Lua state.
	//metatableName: Metatable name.
	void createUserData(lua_State* state,const char* metatableName){
	//Convert this object to T.
	T* obj=dynamic_cast<T*>(this);
	#ifdef _DEBUG
	//It should not be NULL unless there is a bug in code
	assert(obj!=NULL);
	#endif

	//Create user data.
	ScriptUserData* ud=(ScriptUserData*)lua_newuserdata(state,sizeof(ScriptUserData));

	ud->sig1=sig1;
	ud->sig2=sig2;
	ud->sig3=sig3;
	ud->sig4=sig4;
	ud->data=obj;

	//Add it to the linked list.
	ud->next=scriptUserDataHead;
	ud->prev=NULL;
	if(scriptUserDataHead) scriptUserDataHead->prev=ud;
	scriptUserDataHead=ud;

	//Set matatable and we are done.
	luaL_getmetatable(state,metatableName);
	lua_setmetatable(state,-2);

	-#ifdef _DEBUG
	+#if defined(_DEBUG) && defined(DISABLED_DEBUG_STUFF)
	scriptUserClassDebugCreate(sig1,sig2,sig3,sig4,this,ud);
	#endif
	}

	//Destroys all Lua user data associated to this object.
	void destroyUserData(){
	while(scriptUserDataHead){
	-#ifdef _DEBUG
	+#if defined(_DEBUG) && defined(DISABLED_DEBUG_STUFF)
	scriptUserClassDebugInvalidate(sig1,sig2,sig3,sig4,this,scriptUserDataHead);
	#endif
	scriptUserDataHead->data=NULL;
	scriptUserDataHead=scriptUserDataHead->next;
	}
	}

	//Convert a Lua user data in Lua stack to object. (-0,+0,e)
	//state: Lua state.
	//idx: Index.
	//Returns: The object. NULL if this user data is invalid.
	//NOTE: This data should be a user data.
	static T* getObjectFromUserData(lua_State* state,int idx){
	ScriptUserData* ud=(ScriptUserData*)lua_touserdata(state,idx);

	if(ud && ud->sig1==sig1 && ud->sig2==sig2 && ud->sig3==sig3 && ud->sig4==sig4)
	return reinterpret_cast<T*>(ud->data);
	return NULL;
	}

	//Register __gc, __eq to given table. (-0,+0,e)
	//state: Lua state.
	//idx: Index.
	static void registerMetatableFunctions(lua_State *state,int idx){
	lua_pushstring(state,"__gc");
	lua_pushcfunction(state,&garbageCollectorFunction);
	lua_rawset(state,idx);
	lua_pushstring(state,"__eq");
	lua_pushcfunction(state,&checkEqualFunction);
	lua_rawset(state,idx);
	}

	virtual ~ScriptUserClass(){
	destroyUserData();
	}
	private:
	ScriptUserData* scriptUserDataHead;

	//The garbage collector (__gc) function.
	static int garbageCollectorFunction(lua_State* state){
	//Check if it's a user data. It can be a table (the library itself)
	if(!lua_isuserdata(state,1)) return 0;

	ScriptUserData* ud=(ScriptUserData*)lua_touserdata(state,1);

	if(ud){
	if(ud->data){
	-#ifdef _DEBUG
	+#if defined(_DEBUG) && defined(DISABLED_DEBUG_STUFF)
	//It should be impossible unless there is a bug in code
	assert(ud->sig1==sig1 && ud->sig2==sig2 && ud->sig3==sig3 && ud->sig4==sig4);
	#endif
	//Unlink it
	if(ud->next) ud->next->prev=ud->prev;
	if(ud->prev) ud->prev->next=ud->next;
	else{
	ScriptUserClass* owner=static_cast<ScriptUserClass>(reinterpret_cast<T>(ud->data));
	owner->scriptUserDataHead=ud->next;
	}
	-#ifdef _DEBUG
	+#if defined(_DEBUG) && defined(DISABLED_DEBUG_STUFF)
	scriptUserClassDebugUnlink(sig1,sig2,sig3,sig4,
	static_cast<ScriptUserClass>(reinterpret_cast<T>(ud->data)),ud);
	#endif
	}

	ud->data=NULL;
	ud->next=NULL;
	ud->prev=NULL;
	}

	return 0;
	}

	//The 'operator==' (__eq) function.
	static int checkEqualFunction(lua_State* state){
	//Check if it's a user data. It can be a table (the library itself)
	if(!lua_isuserdata(state,1) \|\| !lua_isuserdata(state,2)) return 0;

	ScriptUserData* ud1=(ScriptUserData*)lua_touserdata(state,1);
	ScriptUserData* ud2=(ScriptUserData*)lua_touserdata(state,2);

	if(ud1!=NULL && ud2!=NULL){
	#ifdef _DEBUG
	//It should be impossible unless there is a bug in code
	assert(ud1->sig1==sig1 && ud1->sig2==sig2 && ud1->sig3==sig3 && ud1->sig4==sig4);
	assert(ud2->sig1==sig1 && ud2->sig2==sig2 && ud2->sig3==sig3 && ud2->sig4==sig4);
	#endif
	lua_pushboolean(state,ud1->data==ud2->data);
	return 1;
	}

	return 0;
	}
	};

	#endif
	diff --git a/src/StatisticsManager.h b/src/StatisticsManager.h
	index 51768ea..f7974e8 100644
	--- a/src/StatisticsManager.h
	+++ b/src/StatisticsManager.h
	@@ -1,184 +1,184 @@
	/*
	* 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 STATISTICSMANAGER_H
	#define STATISTICSMANAGER_H

	#include <SDL.h>
	#include <string>
	#include <vector>
	#include <map>
	#include <time.h>

	#include "Render.h"

	enum AchievementDisplayStyle{
	ACHIEVEMENT_HIDDEN,
	ACHIEVEMENT_TITLE,
	ACHIEVEMENT_ALL,
	ACHIEVEMENT_PROGRESS,
	};

	//internal struct for achievement info
	struct AchievementInfo{
	//achievement id for save to statistics file
	const char* id;
	//achievement name for display
	const char* name;
	//achievement image. NULL for no image. will be loaded at getDataPath()+imageFile
	const char* imageFile;
	//image offset and size.
	SDL_Rect r;
	//achievement description. supports multi-line text
	const char* description;
	//display style
	AchievementDisplayStyle displayStyle;

	//SDL_Surface of achievement image.
	- SDL_Surface* imageSurface = nullptr;
	+ SDL_Surface* imageSurface;
	};

	struct OwnedAchievement{
	time_t achievedTime;
	AchievementInfo* info;
	};

	class StatisticsScreen;

	class StatisticsManager{
	friend class StatisticsScreen;
	public:
	//Player and shadow traveling distance (m), 1 block = 1 meter
	float playerTravelingDistance,shadowTravelingDistance;
	//Player and shadow jumps
	int playerJumps,shadowJumps;
	//Player and shadow dies
	int playerDies,shadowDies;
	//Player and shadow squashed
	int playerSquashed,shadowSquashed;
	//Completed levels. NOTE: this is dynamically calculated, and doesn't save to file.
	int completedLevels,silverLevels,goldLevels;
	//Record times
	int recordTimes;
	//number of switched pulled
	int switchTimes;
	//swap times
	int swapTimes;
	//save and load times
	int saveTimes,loadTimes;
	//play time (s)
	int playTime;
	//level edit time (s)
	int levelEditTime;
	//created levels
	int createdLevels;
	private:
	//current achievement displayed time
	int achievementTime;
	//some picture
	SharedTexture bmDropShadow;
	SDL_Surface* bmQuestionMark;
	//SDL_Surface for current achievement (excluding drop shadow)
	//SDL_Surface *bmAchievement;
	SharedTexture bmAchievement;
	//currently owned achievements
	std::map<std::string,OwnedAchievement> achievements;
	//queued achievements for display
	std::vector<AchievementInfo*> queuedAchievements;
	//currently displayed achievement
	int currentAchievement;
	//starting time
	time_t startTime;
	//level edit starting time
	time_t levelEditStartTime;
	//statistics for tutorial level pack
	int tutorialLevels,tutorialCompleted,tutorialGold;
	public:
	StatisticsManager();

	//clear the statistics and achievements.
	void clear();
	//load needed picture
	void loadPicture(SDL_Renderer &renderer, ImageManager &imageManager);
	//register avaliable achievements
	static void registerAchievements(ImageManager& imageManager);
	//load statistics file.
	void loadFile(const std::string& fileName);
	//save statistics file.
	void saveFile(const std::string& fileName);
	//add or display a new achievement.
	//name: the achievement id. if can't find it in avaliable achievement, nothing happens.
	//save: if true then save to currently owned achievements. if it already exists in
	//currently owned achievements, nothing happens.
	//if false then just added it to queue, including duplicated achievements.
	void newAchievement(const std::string& id,bool save=true);
	//if there are new achievements, draw it on the screen,
	//otherwise do nothing.
	void render(ImageManager&,SDL_Renderer& renderer);

	//Call this function to update completed levels.
	//NOTE: Level progress files are reloaded, so it's slow.
	void reloadCompletedLevelsAndAchievements();

	//Call this function to update other achievements at game startup.
	void reloadOtherAchievements();

	//Update level specified achievements.
	//Make sure the completed level count is correct.
	void updateLevelAchievements();

	//Update tutorial specified achievements.
	//Make sure the level progress of tutorial is correct.
	void updateTutorialAchievements();

	//Call when level edit is start
	void startLevelEdit();

	//Call when level edit is end
	void endLevelEdit();

	//update in-game time
	void updatePlayTime();

	//create a SharedTexture contains specified achievements or draw to existing surface.
	//renderer: renderer to create the texture on.
	//info: achievement info.
	//(surface: specifies SDL_Surface to draw on. if NULL then new surface will be created.)
	//NOTE: Removed this arg for sdl2 port as it was not used anyway.
	//rect [in, out, optional]: specifies position and optionally width to draw on. height will be returned.
	// if NULL then will be drawn on top-left corner. if surface is NULL then rect->x and rect->y are ignored.
	//showTip: shows "New achievement" tip
	//achievedTime: if we should show achieved time (and progress bar if AchievementInfo specifies) and when is it.
	// NOTE: if showTip=true then this argument does nothing.
	//return value: A texture that contains the specified achievements or NULL if any error occured.
	SharedTexture createAchievementSurface(SDL_Renderer& renderer, AchievementInfo* info,SDL_Rect* rect=NULL,bool showTip=true,const time_t *achievedTime=NULL);
	private:
	//internal function
	//flags: a bit-field value indicates which achievements we have.
	void updateTutorialAchievementsInternal(int flags);
	//internal function. alpha should be 1-5, 5 means fully opaque (not really)
	void drawAchievement(SDL_Renderer& renderer, int alpha);
	//internal function for get progress (in percent, 0-100)
	float getAchievementProgress(AchievementInfo* info);
	};

	extern StatisticsManager statsMgr;
	extern AchievementInfo achievementList[];

	#endif
	diff --git a/src/StatisticsScreen.cpp b/src/StatisticsScreen.cpp
	index ed1f166..7698be3 100644
	--- a/src/StatisticsScreen.cpp
	+++ b/src/StatisticsScreen.cpp
	@@ -1,350 +1,351 @@
	/*
	* 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 <stdio.h>
	#include <string>
	#include <vector>
	#include <map>
	#include "StatisticsManager.h"
	#include "StatisticsScreen.h"
	#include "Globals.h"
	#include "Functions.h"
	#include "ThemeManager.h"
	#include "InputManager.h"
	#include "GUIListBox.h"
	#include "GUIScrollBar.h"
	#include <SDL_ttf.h>
	+#include <array>

	using namespace std;

	//GUI events are handled here.
	//name: The name of the element that invoked the event.
	//obj: Pointer to the object that invoked the event.
	//eventType: Integer containing the type of event.
	void StatisticsScreen::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, 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);
	}
	}
	}

	//Constructor.
	StatisticsScreen::StatisticsScreen(ImageManager& imageManager, SDL_Renderer& renderer){
	//Update in-game time.
	statsMgr.updatePlayTime();

	//Render the title.
	//title=TTF_RenderUTF8_Blended(fontTitle,_("Achievements and Statistics"),themeTextColor);
	title = textureFromText(renderer, *fontTitle,_("Achievements and Statistics"),themeTextColor);


	//Create GUI.
	createGUI(imageManager, renderer);
	}

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

	//we are so lazy that we just use height of the first text, ignore the others
	#define DRAW_PLAYER_STATISTICS(name,var,fmt) { \
	SurfacePtr surface(TTF_RenderUTF8_Blended(fontGUISmall,name,themeTextColor)); \
	SurfacePtr stats = createSurface(w,surface->h); \
	SDL_FillRect(stats.get(),NULL,-1); \
	applySurface(4,0,surface.get(),stats.get(),NULL); \
	y=surface->h; \
	snprintf(formatString.data(),formatString.size(),fmt,statsMgr.player##var+statsMgr.shadow##var); \
	surface.reset(TTF_RenderUTF8_Blended(fontText,formatString.data(),themeTextColor)); \
	applySurface(w-260-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL); \
	snprintf(formatString.data(),formatString.size(),fmt,statsMgr.player##var); \
	surface.reset(TTF_RenderUTF8_Blended(fontText,formatString.data(),themeTextColor)); \
	applySurface(w-140-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL); \
	snprintf(formatString.data(),formatString.size(),fmt,statsMgr.shadow##var); \
	surface.reset(TTF_RenderUTF8_Blended(fontText,formatString.data(),themeTextColor)); \
	applySurface(w-20-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL); \
	list->addItem(renderer,"",textureFromSurface(renderer, std::move(stats))); /* add it to list box */ \
	}

	//Add an item to the listbox, that displays "name1", and "var1" formatted with "format"
	//we are so lazy that we just use height of the first text, ignore the others
	template <class T1>
	static void drawMiscStatistics1(SDL_Renderer& renderer, int w,GUIListBox list,const char name1,const T1 var1,const char* format1){
	//create new surface
	SurfacePtr nameSurface(TTF_RenderUTF8_Blended(fontGUISmall,name1,themeTextColor));

	SurfacePtr stats=createSurface(w, nameSurface->h);
	SDL_FillRect(stats.get(),NULL,-1);

	applySurface(4,0,nameSurface.get(),stats.get(),NULL);
	const int x=nameSurface->w+8;
	const int y=nameSurface->h;

	//draw value
	//char s[1024];
	std::array<char, 1024> s;
	snprintf(s.data(),s.size(),format1,var1);
	SurfacePtr formatSurface(TTF_RenderUTF8_Blended(fontText,s.data(),themeTextColor));
	//NOTE: SDL2 port. Not halving the y value here as this ends up looking better.
	applySurface(x,y-formatSurface->h,formatSurface.get(),stats.get(),NULL);

	//add it to list box
	list->addItem(renderer, "",textureFromSurface(renderer, std::move(stats)));

	//over
	//return stats;
	}

	//NOTE: Disabled this for the SDL2 port for now. It looks a bit off anyhow.
	//Might want to make a more general method that draws as many "cells" as there is space.
	//Draws two stats on one line if there is space.
	//we are so lazy that we just use height of the first text, ignore the others
	/*template <class T1,class T2>
	static void drawMiscStatistics2(int w,GUIListBox list,const char name1,const T1 var1,const char* format1,const char* name2,const T2 var2,const char* format2){
	SDL_Surface* stats=drawMiscStatistics1(w,list,name1,var1,format1);

	//Check if the width is enough
	if(w>=800){
	//draw name
	SDL_Surface* surface=TTF_RenderUTF8_Blended(fontGUISmall,name2,themeTextColor);
	applySurface(w/2-8,stats->h-surface->h,surface,stats,NULL);
	int x=surface->w+w/2;
	SDL_FreeSurface(surface);

	//draw value
	char s[1024];
	sprintf(s,format2,var2);
	surface=TTF_RenderUTF8_Blended(fontText,s,themeTextColor);
	applySurface(x,(stats->h-surface->h)/2,surface,stats,NULL);
	SDL_FreeSurface(surface);
	}else{
	//Split into two rows
	drawMiscStatistics1(w,list,name2,var2,format2);
	}
	}*/

	//Method that will create the GUI.
	void StatisticsScreen::createGUI(ImageManager& imageManager, SDL_Renderer &renderer){
	//Create the root element of the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	GUIObjectRoot=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

	//Create back button.
	GUIObject* obj=new GUIButton(imageManager,renderer,SCREEN_WIDTH*0.5,SCREEN_HEIGHT-60,-1,36,_("Back"),0,true,true,GUIGravityCenter);
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->addChild(obj);

	//Create list box.
	listBox=new GUISingleLineListBox(imageManager,renderer,(SCREEN_WIDTH-500)/2,104,500,32);
	listBox->addItem(_("Achievements"));
	listBox->addItem(_("Statistics"));
	listBox->value=0;
	GUIObjectRoot->addChild(listBox);

	//Create list box for achievements.
	GUIListBox *list=new GUIListBox(imageManager,renderer,64,150,SCREEN_WIDTH-128,SCREEN_HEIGHT-150-72);
	list->selectable=false;
	GUIObjectRoot->addChild(list);
	lists.clear();
	lists.push_back(list);

	for(int idx=0;achievementList[idx].id!=NULL;++idx){
	time_t *lpt=NULL;

	map<string,OwnedAchievement>::iterator it=statsMgr.achievements.find(achievementList[idx].id);
	if(it!=statsMgr.achievements.end()){
	lpt=&it->second.achievedTime;
	}

	SDL_Rect r;
	r.x=r.y=0;
	r.w=list->width-16;
	auto surface= statsMgr.createAchievementSurface(renderer, &achievementList[idx],&r,false,lpt);

	if(surface){
	//FIXME - this is broken with SDL2 as the function now operates on a renderer, not sure how best to fix it
	/* hlineRGBA(surface,0,surface->w,0,0,0,0,32);
	hlineRGBA(surface,0,surface->w,surface->h-1,0,0,0,128);
	hlineRGBA(surface,0,surface->w,surface->h-2,0,0,0,32);*/
	list->addItem(renderer, "",surface);
	}
	}

	//Now create list box for statistics.
	list=new GUIListBox(imageManager,renderer,64,150,SCREEN_WIDTH-128,SCREEN_HEIGHT-150-72,true,false);
	list->selectable=false;
	GUIObjectRoot->addChild(list);
	lists.push_back(list);

	//Load needed pictures.
	//FIXME: hard-coded image path
	//TODO: Might want to consider not caching these as most other stuff use textures now.
	SDL_Surface* bmPlayer=imageManager.loadImage(getDataPath()+"themes/Cloudscape/characters/player.png");
	SDL_Surface* bmShadow=imageManager.loadImage(getDataPath()+"themes/Cloudscape/characters/shadow.png");
	SDL_Surface* bmMedal=imageManager.loadImage(getDataPath()+"gfx/medals.png");

	//Render stats.
	//char s[64],s2[64];
	std::array<char, 64> formatString;

	SDL_Rect r;
	int x,y,w=SCREEN_WIDTH-128;
	SharedTexture h_bar = [&](){
	//The horizontal bar.
	SurfacePtr h_bar(createSurface(w,2));
	Uint32 clr=SDL_MapRGB(h_bar->format,themeTextColor.r,themeTextColor.g,themeTextColor.b);
	SDL_FillRect(h_bar.get(),NULL,clr);
	return textureFromSurface(renderer, std::move(h_bar));
	}();

	//Player and shadow specific statistics
	//The header.
	{
	SurfacePtr stats = createSurface(w, 44);
	SDL_FillRect(stats.get(),NULL,-1);

	SurfacePtr surface(TTF_RenderUTF8_Blended(fontGUISmall,_("Total"),themeTextColor));
	applySurface(w-260-surface->w,stats->h-surface->h,surface.get(),stats.get(),NULL);
	//FIXME: hard-coded player and shadow images
	r.x=0;r.y=0;r.w=23;r.h=40;
	applySurface(w-140-r.w,stats.get()->h-40,bmPlayer,stats.get(),&r);
	applySurface(w-20-r.w,stats.get()->h-40,bmShadow,stats.get(),&r);

	list->addItem(renderer, "",textureFromSurface(renderer, std::move(stats)));
	}

	//Each items.
	{
	DRAW_PLAYER_STATISTICS(_("Traveling distance (m)"),TravelingDistance,"%0.1f");
	DRAW_PLAYER_STATISTICS(_("Jump times"),Jumps,"%d");
	DRAW_PLAYER_STATISTICS(_("Die times"),Dies,"%d");
	DRAW_PLAYER_STATISTICS(_("Squashed times"),Squashed,"%d");
	}

	//Game specific statistics.
	list->addItem(renderer, "",h_bar);

	auto drawMiscStats = [&](const char* name1,const int var1,const char* format1) {
	drawMiscStatistics1(renderer, w, list, name1, var1, format1);
	};

	drawMiscStats(_("Recordings:"),statsMgr.recordTimes,"%d");
	drawMiscStats(_("Switch pulled times:"),statsMgr.switchTimes,"%d");
	drawMiscStats(_("Swap times:"),statsMgr.swapTimes,"%d");
	drawMiscStats(_("Save times:"),statsMgr.saveTimes,"%d");
	drawMiscStats(_("Load times:"),statsMgr.loadTimes,"%d");

	//Level specific statistics
	list->addItem(renderer, "",h_bar);
	{
	SurfacePtr surface(TTF_RenderUTF8_Blended(fontGUISmall,_("Completed levels:"),themeTextColor));
	SurfacePtr stats = createSurface(w, surface->h);
	SDL_FillRect(stats.get(),NULL,-1);

	applySurface(4,0,surface.get(),stats.get(),NULL);
	x=surface->w+8;
	y=surface->h;

	snprintf(formatString.data(), formatString.size(),"%d",statsMgr.completedLevels);
	surface.reset(TTF_RenderUTF8_Blended(fontText,formatString.data(),themeTextColor));

	applySurface(x,(y-surface->h),surface.get(),stats.get(),NULL);

	snprintf(formatString.data(), formatString.size(),"%d",statsMgr.completedLevels-statsMgr.goldLevels-statsMgr.silverLevels);
	surface.reset(TTF_RenderUTF8_Blended(fontText,formatString.data(),themeTextColor));
	applySurface(w-260-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL);
	r.x=0;r.y=0;r.w=30;r.h=30;
	applySurface(w-260-surface->w-30,(y-30)/2,bmMedal,stats.get(),&r);

	snprintf(formatString.data(), formatString.size(),"%d",statsMgr.silverLevels);
	surface.reset(TTF_RenderUTF8_Blended(fontText,formatString.data(),themeTextColor));
	applySurface(w-140-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL);
	r.x+=30;
	applySurface(w-140-surface->w-30,(y-30)/2,bmMedal,stats.get(),&r);

	snprintf(formatString.data(), formatString.size(),"%d",statsMgr.goldLevels);
	surface.reset(TTF_RenderUTF8_Blended(fontText,formatString.data(),themeTextColor));
	applySurface(w-20-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL);
	r.x+=30;
	applySurface(w-20-surface->w-30,(y-30)/2,bmMedal,stats.get(),&r);

	list->addItem(renderer,"",textureFromSurface(renderer, std::move(stats)));
	}

	//Other statistics.
	list->addItem(renderer, "",h_bar);

	snprintf(formatString.data(), formatString.size(),"%02d:%02d:%02d",statsMgr.playTime/3600,(statsMgr.playTime/60)%60,statsMgr.playTime%60);
	drawMiscStatistics1(renderer,w,list,_("In-game time:"),formatString.data(),"%s");
	snprintf(formatString.data(), formatString.size(),"%02d:%02d:%02d",statsMgr.levelEditTime/3600,(statsMgr.levelEditTime/60)%60,statsMgr.levelEditTime%60);
	drawMiscStatistics1(renderer,w,list,_("Level editing time:"),formatString.data(),"%s");

	drawMiscStats(_("Created levels:"),statsMgr.createdLevels,"%d");
	}

	//In this method all the key and mouse events should be handled.
	//NOTE: The GUIEvents won't be handled here.
	void StatisticsScreen::handleEvents(ImageManager&, SDL_Renderer&){
	//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);
	}
	}

	//All the logic that needs to be done should go in this method.
	void StatisticsScreen::logic(ImageManager&, SDL_Renderer&){
	}

	//This method handles all the rendering.
	void StatisticsScreen::render(ImageManager&, SDL_Renderer& renderer){
	//Draw background.
	objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();

	//Draw title.
	drawTitleTexture(SCREEN_WIDTH, *title, renderer);

	//Draw statistics.
	int value=listBox->value;
	for(unsigned int i=0;i<lists.size();i++){
	lists[i]->visible=(i==value);
	}
	}

	//Method that will be called when the screen size has been changed in runtime.
	void StatisticsScreen::resize(ImageManager &imageManager, SDL_Renderer &renderer){
	//Recreate the gui to fit the new resolution.
	createGUI(imageManager, renderer);
	}
	diff --git a/src/TitleMenu.cpp b/src/TitleMenu.cpp
	index 71098fa..177c449 100644
	--- a/src/TitleMenu.cpp
	+++ b/src/TitleMenu.cpp
	@@ -1,874 +1,874 @@
	/*
	* Copyright (C) 2011-2013 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 "TitleMenu.h"
	#include "ThemeManager.h"
	#include "GUIListBox.h"
	#include "GUITextArea.h"
	#include "InputManager.h"
	#include "LevelPackManager.h"
	#include "StatisticsManager.h"
	#include "MusicManager.h"
	#include "SoundManager.h"
	#include <iostream>
	#include <algorithm>
	#include <sstream>

	#include "libs/tinygettext/tinygettext.hpp"

	template<typename T>
	T sat_sub(T lhs, T rhs) {
	if (lhs > rhs) {
	return lhs - rhs;
	} else {
	return 0;
	}
	}

	using namespace std;

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

	Menu::Menu(ImageManager &imageManager, SDL_Renderer& renderer){
	animation=highlight=0;

	//Load the title image.
	titleTexture=imageManager.loadTexture(getDataPath()+"gfx/menu/title.png",renderer);


	auto tft = [&](const char* text){
	return textureFromText(renderer, *fontTitle, text, themeTextColor);
	};

	//Now render the five entries.
	entries[0]=tft(_("Play"));
	entries[1]=tft(_("Options"));
	entries[2]=tft(_("Map Editor"));
	entries[3]=tft(_("Addons"));
	entries[4]=tft(_("Quit"));
	entries[5]=tft(">");
	entries[6]=tft("<");

	//Load the textures for the credits and statistics buttons and their tooltips.
	const SDL_Color black{0,0,0,0};
	creditsIcon=imageManager.loadTexture(getDataPath()+"gfx/menu/credits.png", renderer);
	creditsTooltip=textureFromText(renderer, *fontText, _("Credits"), black);
	statisticsIcon=imageManager.loadTexture(getDataPath()+"gfx/menu/statistics.png", renderer);
	statisticsTooltip=textureFromText(renderer, *fontText, _("Achievements and Statistics"), black);

	// Check if textures were loaded.
	//TODO: Handle this better.
	if(!titleTexture \|\| !creditsIcon \|\| !statisticsIcon) {
	std::cerr << "Failed to load one or more images for the main menu, exiting. : " << SDL_GetError() << std::endl;
	std::terminate();
	}
	}

	Menu::~Menu(){
	}


	void Menu::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//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>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;
	}else if(x>=SCREEN_WIDTH-104){
	highlight=6;
	}
	}
	}

	//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(imageManager,renderer,_("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 credits screen.
	setNextState(STATE_CREDITS);
	break;
	case 7:
	//Show the statistics screen.
	setNextState(STATE_STATISTICS);
	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);
	}
	}

	void Menu::logic(ImageManager&, SDL_Renderer&){
	animation++;
	if(animation>10)
	animation=-10;
	}

	void Menu::render(ImageManager&, SDL_Renderer& renderer){
	//Draw background.
	objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();

	//Draw the title.
	{
	int titleWidth, titleHeight = 0;
	SDL_QueryTexture(titleTexture.get(), NULL, NULL, &titleWidth, &titleHeight);
	const SDL_Rect rect = SDL_Rect{(SCREEN_WIDTH-titleWidth)/2, 40, titleWidth, titleHeight};
	SDL_RenderCopy(&renderer, titleTexture.get(), NULL, &rect);
	}

	// Position where we start drawing the menu entries from.
	const int menuStartY = sat_sub(SCREEN_HEIGHT, 200) / 2;

	//Draw the menu entries.
	for(unsigned int i=0;i<5;i++){
	SDL_Rect dstRect = rectFromTexture(0, 0, *entries[i]);
	dstRect.x = sat_sub(SCREEN_WIDTH, dstRect.w) / 2;
	dstRect.y = menuStartY + 64*i+(64-dstRect.h) / 2;
	SDL_RenderCopy(&renderer, entries[i].get(), NULL, &dstRect);
	}

	//Check if an option is selected/highlighted.
	if(highlight>0 && highlight<=5){
	// Width of highlighted entry.
	const int highlightWidth = rectFromTexture(0, 0, *entries[highlight - 1]).w;
	const int leftOfHighlight = (SCREEN_WIDTH-highlightWidth)/2;
	const SDL_Rect leftSize = rectFromTexture(0, 0, *entries[5]);
	const int rightHeight = rectFromTexture(0, 0, *entries[6]).h;
	// How much to offset the arrows to create the animation.
	const int animationX = (25-abs(animation)/2);
	// The common value of both arrow's y positions.
	const int yCommon = menuStartY-64+64*highlight;

	//Draw the '>' sign, which is entry 5.
	int x=leftOfHighlight-animationX-leftSize.w;
	int y=yCommon+(64-leftSize.h)/2;
	applyTexture(x, y, *entries[5], renderer);

	//Draw the '<' sign, which is entry 6.
	x=leftOfHighlight+highlightWidth+animationX;
	y=yCommon+(64-rightHeight)/2;
	applyTexture(x, y, *entries[6], renderer);
	}

	//Check if an icon is selected/highlighted and draw tooltip
	if(highlight==6 \|\| highlight==7){
	SDL_Texture* texture;
	if(highlight==6) {
	texture = creditsTooltip.get();
	} else {
	texture = statisticsTooltip.get();
	}
	const SDL_Rect textureSize = rectFromTexture(*texture);
	drawGUIBox(-2,SCREEN_HEIGHT-textureSize.h-2,textureSize.w+4,textureSize.h+4,renderer,0xFFFFFFFF);
	applyTexture(0, SCREEN_HEIGHT - textureSize.h, *texture, renderer);
	}

	//Draw icons.
	applyTexture(SCREEN_WIDTH-96,SCREEN_HEIGHT-48,*creditsIcon,renderer);
	applyTexture(SCREEN_WIDTH-48,SCREEN_HEIGHT-48,*statisticsIcon,renderer);
	}

	void Menu::resize(ImageManager &, SDL_Renderer&){}


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

	//Some variables for the options.
	static bool fullscreen,leveltheme,internet,fade,quickrec;
	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(ImageManager& imageManager,SDL_Renderer& renderer){
	//Render the title.
	title=textureFromText(renderer, *fontTitle, _("Settings"), themeTextColor);

	//Initialize variables.
	lastJumpSound=0;
	clearIconHower=false;

	//Load icon image and tooltip text.
	clearIcon=imageManager.loadTexture(getDataPath()+"gfx/menu/clear-progress.png",renderer);
	/// TRANSLATORS: Used for button which clear any level progress like unlocked levels and highscores.
	clearTooltip=textureFromText(renderer, *fontText, _("Clear Progress"), SDL_Color{0,0,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();
	fade=getSettings()->getBoolValue("fading");
	quickrec=getSettings()->getBoolValue("quickrecord");

	//Set the restartFlag false.
	restartFlag=false;

	//Now create the gui.
	createGUI(imageManager,renderer);
	}

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

	void Options::createGUI(ImageManager& imageManager,SDL_Renderer& renderer){
	//Variables for positioning
	const int columnW=SCREEN_WIDTH*0.3;
	const int column1X=SCREEN_WIDTH*0.15;
	const int column2X=SCREEN_WIDTH*0.55;
	const int lineHeight=40;

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

	//Single line list for different tabs.
	GUISingleLineListBox* listBox=new GUISingleLineListBox(imageManager,renderer,(SCREEN_WIDTH-500)/2,104,500,32);
	listBox->addItem(_("General"));
	listBox->addItem(_("Controls"));
	listBox->value=0;
	listBox->name="lstTabs";
	listBox->eventCallback=this;
	GUIObjectRoot->addChild(listBox);

	//Create general tab.
	tabGeneral=new GUIObject(imageManager,renderer,0,150,SCREEN_WIDTH,SCREEN_HEIGHT);
	GUIObjectRoot->addChild(tabGeneral);

	//Now we create GUIObjects for every option.
	GUIObject* obj=new GUILabel(imageManager,renderer,column1X,0,columnW,36,_("Music"));
	tabGeneral->addChild(obj);

	musicSlider=new GUISlider(imageManager,renderer,column2X,0,columnW,36,atoi(getSettings()->getValue("music").c_str()),0,128,15);
	musicSlider->name="sldMusic";
	musicSlider->eventCallback=this;
	tabGeneral->addChild(musicSlider);

	obj=new GUILabel(imageManager,renderer,column1X,lineHeight,columnW,36,_("Sound"));
	tabGeneral->addChild(obj);

	soundSlider=new GUISlider(imageManager,renderer,column2X,lineHeight,columnW,36,atoi(getSettings()->getValue("sound").c_str()),0,128,15);
	soundSlider->name="sldSound";
	soundSlider->eventCallback=this;
	tabGeneral->addChild(soundSlider);

	obj=new GUILabel(imageManager,renderer,column1X,2*lineHeight,columnW,36,_("Resolution"));
	obj->name="lstResolution";
	tabGeneral->addChild(obj);

	//Create list with many different resolutions.
	resolutions = new GUISingleLineListBox(imageManager,renderer,column2X,2*lineHeight,columnW,36);
	resolutions->value=-1;

	//Only get the resolution list if it hasn't been done before.
	if(resolutionList.empty()){
	resolutionList=getResolutionList();
	}

	//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->addItem(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->addItem(out.str());
	resolutions->value=resolutions->item.size()-1;
	}
	lastRes=resolutions->value;

	tabGeneral->addChild(resolutions);

	obj=new GUILabel(imageManager,renderer,column1X,3*lineHeight,columnW,36,_("Language"));
	tabGeneral->addChild(obj);

	//Create GUI list with available languages.
	langs = new GUISingleLineListBox(imageManager,renderer,column2X,3*lineHeight,columnW,36);
	langs->name="lstLanguages";

	/// TRANSLATORS: as detect user's language automatically
	langs->addItem("",_("Auto-Detect"));
	langs->addItem("en","English");

	//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->addItem(s0->str(),s0->get_name());
	}

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

	langs->value=lastLang;
	tabGeneral->addChild(langs);

	obj=new GUILabel(imageManager,renderer,column1X,4*lineHeight,columnW,36,_("Theme"));
	obj->name="theme";
	tabGeneral->addChild(obj);

	//Create the theme option gui element.
	theme=new GUISingleLineListBox(imageManager,renderer,column2X,4*lineHeight,columnW,36);
	theme->name="lstTheme";

	//Vector containing the theme locations and names.
	vector<pair<string,string> > themes;
	vector<string> v=enumAllDirs(getUserPath(USER_DATA)+"themes/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	string location=getUserPath(USER_DATA)+"themes/"+*i;
	themes.push_back(pair<string,string>(location,*i));
	}
	vector<string> v2=enumAllDirs(getDataPath()+"themes/");
	for(vector<string>::iterator i=v2.begin(); i!=v2.end(); ++i){
	string location=getDataPath()+"themes/"+*i;
	themes.push_back(pair<string,string>(location,*i));
	}

	//Try to find the configured theme so we can display it.
	int value=-1;
	for(vector<pair<string,string> >::iterator i=themes.begin(); i!=themes.end(); ++i){
	if(i->first==themeName) {
	value=i-themes.begin();
	}
	}
	theme->addItems(themes);
	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(imageManager,renderer,"lstTheme",theme,GUIEventChange);
	theme->eventCallback=this;
	tabGeneral->addChild(theme);

	//Proxy settings.
	obj=new GUILabel(imageManager,renderer,column1X,5*lineHeight,columnW,36,_("Internet proxy"));
	obj->name="chkProxy";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);
	obj=new GUITextBox(imageManager,renderer,column2X,5*lineHeight,columnW,36,internetProxy.c_str());
	obj->name="txtProxy";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column1X,6*lineHeight,columnW,36,_("Fullscreen"),fullscreen?1:0);
	obj->name="chkFullscreen";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column1X,7*lineHeight,columnW,36,_("Level themes"),leveltheme?1:0);
	obj->name="chkLeveltheme";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column2X,6*lineHeight,columnW,36,_("Internet"),internet?1:0);
	obj->name="chkInternet";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column2X,7*lineHeight,columnW,36,_("Fade transition"),fade?1:0);
	obj->name="chkFade";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column1X,8*lineHeight,columnW,36,_("Quick record"),quickrec?1:0);
	obj->name="chkQuickRec";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	//Create the controls tab.
	tabControls=inputMgr.showConfig(imageManager,renderer,SCREEN_HEIGHT-210);
	tabControls->top=140;
	tabControls->visible=false;
	GUIObjectRoot->addChild(tabControls);

	//Save original keys.
	for(int i=0;i<INPUTMGR_MAX;i++){
	tmpKeys[i]=inputMgr.getKeyCode((InputManagerKeys)i,false);
	tmpAlternativeKeys[i]=inputMgr.getKeyCode((InputManagerKeys)i,true);
	}

	//Create buttons.
	GUIObjectb1=new GUIButton(imageManager,renderer,SCREEN_WIDTH0.3,SCREEN_HEIGHT-60,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	b1->name="cmdBack";
	b1->eventCallback=this;
	GUIObjectRoot->addChild(b1);

	GUIObject* b2=new GUIButton(imageManager,renderer,SCREEN_WIDTH*0.7,SCREEN_HEIGHT-60,-1,36,_("Save Changes"),0,true,true,GUIGravityCenter);
	b2->name="cmdSave";
	b2->eventCallback=this;
	GUIObjectRoot->addChild(b2);
	}

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

	void Options::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Check what type of event it was.
	if(eventType==GUIEventClick){
	if(name=="cmdBack"){
	//Reset the key changes.
	for(int i=0;i<INPUTMGR_MAX;i++){
	inputMgr.setKeyCode((InputManagerKeys)i,tmpKeys[i],false);
	inputMgr.setKeyCode((InputManagerKeys)i,tmpAlternativeKeys[i],true);
	}

	//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);
	getSettings()->setValue("fading",fade?"1":"0");
	getSettings()->setValue("quickrecord",quickrec?"1":"0");
	//Before loading the theme remove the previous one from the stack.
	objThemes.removeTheme();
	loadTheme(imageManager,renderer,themeName);
	if(!useProxy)
	internetProxy.clear();
	getSettings()->setValue("internet-proxy",internetProxy);
	getSettings()->setValue("lang",langs->getName());

	//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(imageManager,renderer,"")){
	//Loading the theme failed so quit.
	setNextState(STATE_EXIT);
	return;
	}
	}
	if(langs->value!=lastLang){
	//We set the language.
	language=langs->getName();
	dictionaryManager->set_language(tinygettext::Language::from_name(language));
	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=="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;
	}else if(name=="chkFade"){
	fade=obj->value?true:false;
	}else if(name=="chkQuickRec"){
	quickrec=obj->value?true:false;
	}
	}
	if(name=="lstTheme"){
	if(theme!=NULL && theme->value>=0 && theme->value<(int)theme->item.size()){
	//Convert the themeName to contain %DATA%, etc...
	themeName=compressFileName(theme->item[theme->value].first);
	}
	}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){
	getSoundManager()->playSound("jump");
	lastJumpSound=15;
	}
	}
	if(name=="lstTabs"){
	if(obj->value==0){
	tabGeneral->visible=true;
	tabControls->visible=false;
	}else{
	tabGeneral->visible=false;
	tabControls->visible=true;
	}
	}
	}

	void Options::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//Get the x and y location of the mouse.
	int x,y;
	SDL_GetMouseState(&x,&y);

	//Check icon.
	if(event.type==SDL_MOUSEMOTION \|\| event.type==SDL_MOUSEBUTTONDOWN){
	if(y>=SCREEN_HEIGHT-56&&y<SCREEN_HEIGHT-8&&x>=SCREEN_WIDTH-56)
	clearIconHower=true;
	else
	clearIconHower=false;
	}

	if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT && clearIconHower){
	if(msgBox(imageManager,renderer,_("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
	//Reset statistics.
	statsMgr.reloadCompletedLevelsAndAchievements();
	}
	}

	//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(ImageManager&, SDL_Renderer&){
	//Increase the lastJumpSound variable if needed.
	if(lastJumpSound!=0){
	lastJumpSound--;
	}
	}

	void Options::render(ImageManager&, SDL_Renderer& renderer){
	//Draw background.
	objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();

	//Now render the title.
	drawTitleTexture(SCREEN_WIDTH, *title, renderer);

	//Check if an icon is selected/highlighted and draw tooltip
	if(clearIconHower){
	const SDL_Rect texSize = rectFromTexture(*clearTooltip);
	drawGUIBox(-2,SCREEN_HEIGHT-texSize.h-2,texSize.w+4,texSize.h+4,renderer,0xFFFFFFFF);
	applyTexture(0,SCREEN_HEIGHT-texSize.h,clearTooltip,renderer);
	}

	//Draw icon.
	applyTexture(SCREEN_WIDTH-48,SCREEN_HEIGHT-48,*clearIcon,renderer);

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

	void Options::resize(ImageManager& imageManager, SDL_Renderer& renderer){
	//Recreate the gui to fit the new resolution.
	createGUI(imageManager,renderer);
	}

	/////////////////////////CREDITS_MENU//////////////////////////////////

	Credits::Credits(ImageManager& imageManager,SDL_Renderer& renderer){
	//Render the title.
	title=textureFromText(renderer, *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());
	}
	}
	}

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

	//Create back button.
	backButton=new GUIButton(imageManager,renderer,SCREEN_WIDTH*0.5,SCREEN_HEIGHT-60,-1,36,_("Back"),0,true,true,GUIGravityCenter);
	backButton->name="cmdBack";
	backButton->eventCallback=this;
	GUIObjectRoot->addChild(backButton);

	//Create a text area for credits.
	textArea=new GUITextArea(imageManager,renderer,SCREEN_WIDTH0.05,114,SCREEN_WIDTH0.9,SCREEN_HEIGHT-200);
	textArea->setFont(fontMono);
	textArea->setStringArray(renderer, std::move(credits));
	textArea->editable=false;
	GUIObjectRoot->addChild(textArea);
	}

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

	void Credits::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, 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(ImageManager&, SDL_Renderer&){
	//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 Credits::logic(ImageManager&, SDL_Renderer&){}

	void Credits::render(ImageManager&,SDL_Renderer &renderer){
	//Draw background.
	objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();

	//Now render the title.
	drawTitleTexture(SCREEN_WIDTH, *title, renderer);

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

	void Credits::resize(ImageManager&, SDL_Renderer&){
	//Resize and position widgets.
	GUIObjectRoot->width=SCREEN_WIDTH;
	GUIObjectRoot->height=SCREEN_HEIGHT;

	- backButton->left=SCREEN_WIDTH*0.5;
	+ backButton->left=SCREEN_WIDTH/2;
	backButton->top=SCREEN_HEIGHT-60;

	textArea->left=SCREEN_WIDTH*0.05;
	textArea->width=SCREEN_WIDTH*0.9;
	textArea->height=SCREEN_HEIGHT-200;
	textArea->resize();
	}
	diff --git a/src/config.h.in b/src/config.h.in
	index 94a0016..a162bd3 100644
	--- a/src/config.h.in
	+++ b/src/config.h.in
	@@ -1,13 +1,9 @@
	#ifndef CONFIG_H
	#define CONFIG_H

	-#if defined(WIN32)
	-//#define DATA_PATH
	-#else
	-#define DATA_PATH "@DATAROOTDIR@/meandmyshadow/data/"
	-#endif
	+#define DATA_PATH R"del(@DATAROOTDIR@/meandmyshadow/data/)del"

	#cmakedefine HARDWARE_ACCELERATION
	#cmakedefine DEBUG_MODE

	#endif
	diff --git a/src/libs/dirent/dirent.h b/src/libs/dirent/dirent.h
	new file mode 100644
	index 0000000..2de0704
	--- /dev/null
	+++ b/src/libs/dirent/dirent.h
	@@ -0,0 +1,917 @@
	+/*
	+ * Dirent interface for Microsoft Visual Studio
	+ * Version 1.21
	+ *
	+ * Copyright (C) 2006-2012 Toni Ronkko
	+ * This file is part of dirent. Dirent may be freely distributed
	+ * under the MIT license. For all details and documentation, see
	+ * https://github.com/tronkko/dirent
	+ */
	+#ifndef DIRENT_H
	+#define DIRENT_H
	+
	+/*
	+ * Define architecture flags so we don't need to include windows.h.
	+ * Avoiding windows.h makes it simpler to use windows sockets in conjunction
	+ * with dirent.h.
	+ */
	+#if !defined(_68K_) && !defined(_MPPC_) && !defined(_X86_) && !defined(_IA64_) && !defined(_AMD64_) && defined(_M_IX86)
	+# define _X86_
	+#endif
	+#if !defined(_68K_) && !defined(_MPPC_) && !defined(_X86_) && !defined(_IA64_) && !defined(_AMD64_) && defined(_M_AMD64)
	+#define _AMD64_
	+#endif
	+
	+#include <stdio.h>
	+#include <stdarg.h>
	+#include <windef.h>
	+#include <winbase.h>
	+#include <wchar.h>
	+#include <string.h>
	+#include <stdlib.h>
	+#include <malloc.h>
	+#include <sys/types.h>
	+#include <sys/stat.h>
	+#include <errno.h>
	+
	+/* Indicates that d_type field is available in dirent structure */
	+#define _DIRENT_HAVE_D_TYPE
	+
	+/* Indicates that d_namlen field is available in dirent structure */
	+#define _DIRENT_HAVE_D_NAMLEN
	+
	+/* Entries missing from MSVC 6.0 */
	+#if !defined(FILE_ATTRIBUTE_DEVICE)
	+# define FILE_ATTRIBUTE_DEVICE 0x40
	+#endif
	+
	+/* File type and permission flags for stat(), general mask */
	+#if !defined(S_IFMT)
	+# define S_IFMT _S_IFMT
	+#endif
	+
	+/* Directory bit */
	+#if !defined(S_IFDIR)
	+# define S_IFDIR _S_IFDIR
	+#endif
	+
	+/* Character device bit */
	+#if !defined(S_IFCHR)
	+# define S_IFCHR _S_IFCHR
	+#endif
	+
	+/* Pipe bit */
	+#if !defined(S_IFFIFO)
	+# define S_IFFIFO _S_IFFIFO
	+#endif
	+
	+/* Regular file bit */
	+#if !defined(S_IFREG)
	+# define S_IFREG _S_IFREG
	+#endif
	+
	+/* Read permission */
	+#if !defined(S_IREAD)
	+# define S_IREAD _S_IREAD
	+#endif
	+
	+/* Write permission */
	+#if !defined(S_IWRITE)
	+# define S_IWRITE _S_IWRITE
	+#endif
	+
	+/* Execute permission */
	+#if !defined(S_IEXEC)
	+# define S_IEXEC _S_IEXEC
	+#endif
	+
	+/* Pipe */
	+#if !defined(S_IFIFO)
	+# define S_IFIFO _S_IFIFO
	+#endif
	+
	+/* Block device */
	+#if !defined(S_IFBLK)
	+# define S_IFBLK 0
	+#endif
	+
	+/* Link */
	+#if !defined(S_IFLNK)
	+# define S_IFLNK 0
	+#endif
	+
	+/* Socket */
	+#if !defined(S_IFSOCK)
	+# define S_IFSOCK 0
	+#endif
	+
	+/* Read user permission */
	+#if !defined(S_IRUSR)
	+# define S_IRUSR S_IREAD
	+#endif
	+
	+/* Write user permission */
	+#if !defined(S_IWUSR)
	+# define S_IWUSR S_IWRITE
	+#endif
	+
	+/* Execute user permission */
	+#if !defined(S_IXUSR)
	+# define S_IXUSR 0
	+#endif
	+
	+/* Read group permission */
	+#if !defined(S_IRGRP)
	+# define S_IRGRP 0
	+#endif
	+
	+/* Write group permission */
	+#if !defined(S_IWGRP)
	+# define S_IWGRP 0
	+#endif
	+
	+/* Execute group permission */
	+#if !defined(S_IXGRP)
	+# define S_IXGRP 0
	+#endif
	+
	+/* Read others permission */
	+#if !defined(S_IROTH)
	+# define S_IROTH 0
	+#endif
	+
	+/* Write others permission */
	+#if !defined(S_IWOTH)
	+# define S_IWOTH 0
	+#endif
	+
	+/* Execute others permission */
	+#if !defined(S_IXOTH)
	+# define S_IXOTH 0
	+#endif
	+
	+/* Maximum length of file name */
	+#if !defined(PATH_MAX)
	+# define PATH_MAX MAX_PATH
	+#endif
	+#if !defined(FILENAME_MAX)
	+# define FILENAME_MAX MAX_PATH
	+#endif
	+#if !defined(NAME_MAX)
	+# define NAME_MAX FILENAME_MAX
	+#endif
	+
	+/* File type flags for d_type */
	+#define DT_UNKNOWN 0
	+#define DT_REG S_IFREG
	+#define DT_DIR S_IFDIR
	+#define DT_FIFO S_IFIFO
	+#define DT_SOCK S_IFSOCK
	+#define DT_CHR S_IFCHR
	+#define DT_BLK S_IFBLK
	+#define DT_LNK S_IFLNK
	+
	+/* Macros for converting between st_mode and d_type */
	+#define IFTODT(mode) ((mode) & S_IFMT)
	+#define DTTOIF(type) (type)
	+
	+/*
	+ * File type macros. Note that block devices, sockets and links cannot be
	+ * distinguished on Windows and the macros S_ISBLK, S_ISSOCK and S_ISLNK are
	+ * only defined for compatibility. These macros should always return false
	+ * on Windows.
	+ */
	+#if !defined(S_ISFIFO)
	+# define S_ISFIFO(mode) (((mode) & S_IFMT) == S_IFIFO)
	+#endif
	+#if !defined(S_ISDIR)
	+# define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
	+#endif
	+#if !defined(S_ISREG)
	+# define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG)
	+#endif
	+#if !defined(S_ISLNK)
	+# define S_ISLNK(mode) (((mode) & S_IFMT) == S_IFLNK)
	+#endif
	+#if !defined(S_ISSOCK)
	+# define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
	+#endif
	+#if !defined(S_ISCHR)
	+# define S_ISCHR(mode) (((mode) & S_IFMT) == S_IFCHR)
	+#endif
	+#if !defined(S_ISBLK)
	+# define S_ISBLK(mode) (((mode) & S_IFMT) == S_IFBLK)
	+#endif
	+
	+/* Return the exact length of d_namlen without zero terminator */
	+#define _D_EXACT_NAMLEN(p) ((p)->d_namlen)
	+
	+/* Return number of bytes needed to store d_namlen */
	+#define _D_ALLOC_NAMLEN(p) (PATH_MAX)
	+
	+
	+#ifdef __cplusplus
	+extern "C" {
	+#endif
	+
	+
	+/* Wide-character version */
	+struct _wdirent {
	+ /* Always zero */
	+ long d_ino;
	+
	+ /* Structure size */
	+ unsigned short d_reclen;
	+
	+ /* Length of name without \0 */
	+ size_t d_namlen;
	+
	+ /* File type */
	+ int d_type;
	+
	+ /* File name */
	+ wchar_t d_name[PATH_MAX];
	+};
	+typedef struct _wdirent _wdirent;
	+
	+struct _WDIR {
	+ /* Current directory entry */
	+ struct _wdirent ent;
	+
	+ /* Private file data */
	+ WIN32_FIND_DATAW data;
	+
	+ /* True if data is valid */
	+ int cached;
	+
	+ /* Win32 search handle */
	+ HANDLE handle;
	+
	+ /* Initial directory name */
	+ wchar_t *patt;
	+};
	+typedef struct _WDIR _WDIR;
	+
	+static _WDIR _wopendir (const wchar_t dirname);
	+static struct _wdirent _wreaddir (_WDIR dirp);
	+static int _wclosedir (_WDIR *dirp);
	+static void _wrewinddir (_WDIR* dirp);
	+
	+
	+/* For compatibility with Symbian */
	+#define wdirent _wdirent
	+#define WDIR _WDIR
	+#define wopendir _wopendir
	+#define wreaddir _wreaddir
	+#define wclosedir _wclosedir
	+#define wrewinddir _wrewinddir
	+
	+
	+/* Multi-byte character versions */
	+struct dirent {
	+ /* Always zero */
	+ long d_ino;
	+
	+ /* Structure size */
	+ unsigned short d_reclen;
	+
	+ /* Length of name without \0 */
	+ size_t d_namlen;
	+
	+ /* File type */
	+ int d_type;
	+
	+ /* File name */
	+ char d_name[PATH_MAX];
	+};
	+typedef struct dirent dirent;
	+
	+struct DIR {
	+ struct dirent ent;
	+ struct _WDIR *wdirp;
	+};
	+typedef struct DIR DIR;
	+
	+static DIR opendir (const char dirname);
	+static struct dirent readdir (DIR dirp);
	+static int closedir (DIR *dirp);
	+static void rewinddir (DIR* dirp);
	+
	+
	+/* Internal utility functions */
	+static WIN32_FIND_DATAW dirent_first (_WDIR dirp);
	+static WIN32_FIND_DATAW dirent_next (_WDIR dirp);
	+
	+static int dirent_mbstowcs_s(
	+ size_t *pReturnValue,
	+ wchar_t *wcstr,
	+ size_t sizeInWords,
	+ const char *mbstr,
	+ size_t count);
	+
	+static int dirent_wcstombs_s(
	+ size_t *pReturnValue,
	+ char *mbstr,
	+ size_t sizeInBytes,
	+ const wchar_t *wcstr,
	+ size_t count);
	+
	+static void dirent_set_errno (int error);
	+
	+/*
	+ * Open directory stream DIRNAME for read and return a pointer to the
	+ * internal working area that is used to retrieve individual directory
	+ * entries.
	+ */
	+static _WDIR*
	+_wopendir(
	+ const wchar_t *dirname)
	+{
	+ _WDIR *dirp = NULL;
	+ int error;
	+
	+ /* Must have directory name */
	+ if (dirname == NULL \|\| dirname[0] == '\0') {
	+ dirent_set_errno (ENOENT);
	+ return NULL;
	+ }
	+
	+ /* Allocate new _WDIR structure */
	+ dirp = (_WDIR*) malloc (sizeof (struct _WDIR));
	+ if (dirp != NULL) {
	+ DWORD n;
	+
	+ /* Reset _WDIR structure */
	+ dirp->handle = INVALID_HANDLE_VALUE;
	+ dirp->patt = NULL;
	+ dirp->cached = 0;
	+
	+ /* Compute the length of full path plus zero terminator */
	+ n = GetFullPathNameW (dirname, 0, NULL, NULL);
	+
	+ /* Allocate room for absolute directory name and search pattern */
	+ dirp->patt = (wchar_t) malloc (sizeof (wchar_t) n + 16);
	+ if (dirp->patt) {
	+
	+ /*
	+ * Convert relative directory name to an absolute one. This
	+ * allows rewinddir() to function correctly even when current
	+ * working directory is changed between opendir() and rewinddir().
	+ */
	+ n = GetFullPathNameW (dirname, n, dirp->patt, NULL);
	+ if (n > 0) {
	+ wchar_t *p;
	+
	+ /* Append search pattern \* to the directory name */
	+ p = dirp->patt + n;
	+ if (dirp->patt < p) {
	+ switch (p[-1]) {
	+ case '\\':
	+ case '/':
	+ case ':':
	+ /* Directory ends in path separator, e.g. c:\temp\ */
	+ /NOP/;
	+ break;
	+
	+ default:
	+ /* Directory name doesn't end in path separator */
	+ *p++ = '\\';
	+ }
	+ }
	+ p++ = '';
	+ *p = '\0';
	+
	+ /* Open directory stream and retrieve the first entry */
	+ if (dirent_first (dirp)) {
	+ /* Directory stream opened successfully */
	+ error = 0;
	+ } else {
	+ /* Cannot retrieve first entry */
	+ error = 1;
	+ dirent_set_errno (ENOENT);
	+ }
	+
	+ } else {
	+ /* Cannot retrieve full path name */
	+ dirent_set_errno (ENOENT);
	+ error = 1;
	+ }
	+
	+ } else {
	+ /* Cannot allocate memory for search pattern */
	+ error = 1;
	+ }
	+
	+ } else {
	+ /* Cannot allocate _WDIR structure */
	+ error = 1;
	+ }
	+
	+ /* Clean up in case of error */
	+ if (error && dirp) {
	+ _wclosedir (dirp);
	+ dirp = NULL;
	+ }
	+
	+ return dirp;
	+}
	+
	+/*
	+ * Read next directory entry. The directory entry is returned in dirent
	+ * structure in the d_name field. Individual directory entries returned by
	+ * this function include regular files, sub-directories, pseudo-directories
	+ * "." and ".." as well as volume labels, hidden files and system files.
	+ */
	+static struct _wdirent*
	+_wreaddir(
	+ _WDIR *dirp)
	+{
	+ WIN32_FIND_DATAW *datap;
	+ struct _wdirent *entp;
	+
	+ /* Read next directory entry */
	+ datap = dirent_next (dirp);
	+ if (datap) {
	+ size_t n;
	+ DWORD attr;
	+
	+ /* Pointer to directory entry to return */
	+ entp = &dirp->ent;
	+
	+ /*
	+ * Copy file name as wide-character string. If the file name is too
	+ * long to fit in to the destination buffer, then truncate file name
	+ * to PATH_MAX characters and zero-terminate the buffer.
	+ */
	+ n = 0;
	+ while (n + 1 < PATH_MAX && datap->cFileName[n] != 0) {
	+ entp->d_name[n] = datap->cFileName[n];
	+ n++;
	+ }
	+ dirp->ent.d_name[n] = 0;
	+
	+ /* Length of file name excluding zero terminator */
	+ entp->d_namlen = n;
	+
	+ /* File type */
	+ attr = datap->dwFileAttributes;
	+ if ((attr & FILE_ATTRIBUTE_DEVICE) != 0) {
	+ entp->d_type = DT_CHR;
	+ } else if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
	+ entp->d_type = DT_DIR;
	+ } else {
	+ entp->d_type = DT_REG;
	+ }
	+
	+ /* Reset dummy fields */
	+ entp->d_ino = 0;
	+ entp->d_reclen = sizeof (struct _wdirent);
	+
	+ } else {
	+
	+ /* Last directory entry read */
	+ entp = NULL;
	+
	+ }
	+
	+ return entp;
	+}
	+
	+/*
	+ * Close directory stream opened by opendir() function. This invalidates the
	+ * DIR structure as well as any directory entry read previously by
	+ * _wreaddir().
	+ */
	+static int
	+_wclosedir(
	+ _WDIR *dirp)
	+{
	+ int ok;
	+ if (dirp) {
	+
	+ /* Release search handle */
	+ if (dirp->handle != INVALID_HANDLE_VALUE) {
	+ FindClose (dirp->handle);
	+ dirp->handle = INVALID_HANDLE_VALUE;
	+ }
	+
	+ /* Release search pattern */
	+ if (dirp->patt) {
	+ free (dirp->patt);
	+ dirp->patt = NULL;
	+ }
	+
	+ /* Release directory structure */
	+ free (dirp);
	+ ok = /success/0;
	+
	+ } else {
	+ /* Invalid directory stream */
	+ dirent_set_errno (EBADF);
	+ ok = /failure/-1;
	+ }
	+ return ok;
	+}
	+
	+/*
	+ * Rewind directory stream such that _wreaddir() returns the very first
	+ * file name again.
	+ */
	+static void
	+_wrewinddir(
	+ _WDIR* dirp)
	+{
	+ if (dirp) {
	+ /* Release existing search handle */
	+ if (dirp->handle != INVALID_HANDLE_VALUE) {
	+ FindClose (dirp->handle);
	+ }
	+
	+ /* Open new search handle */
	+ dirent_first (dirp);
	+ }
	+}
	+
	+/* Get first directory entry (internal) */
	+static WIN32_FIND_DATAW*
	+dirent_first(
	+ _WDIR *dirp)
	+{
	+ WIN32_FIND_DATAW *datap;
	+
	+ /* Open directory and retrieve the first entry */
	+ dirp->handle = FindFirstFileW (dirp->patt, &dirp->data);
	+ if (dirp->handle != INVALID_HANDLE_VALUE) {
	+
	+ /* a directory entry is now waiting in memory */
	+ datap = &dirp->data;
	+ dirp->cached = 1;
	+
	+ } else {
	+
	+ /* Failed to re-open directory: no directory entry in memory */
	+ dirp->cached = 0;
	+ datap = NULL;
	+
	+ }
	+ return datap;
	+}
	+
	+/* Get next directory entry (internal) */
	+static WIN32_FIND_DATAW*
	+dirent_next(
	+ _WDIR *dirp)
	+{
	+ WIN32_FIND_DATAW *p;
	+
	+ /* Get next directory entry */
	+ if (dirp->cached != 0) {
	+
	+ /* A valid directory entry already in memory */
	+ p = &dirp->data;
	+ dirp->cached = 0;
	+
	+ } else if (dirp->handle != INVALID_HANDLE_VALUE) {
	+
	+ /* Get the next directory entry from stream */
	+ if (FindNextFileW (dirp->handle, &dirp->data) != FALSE) {
	+ /* Got a file */
	+ p = &dirp->data;
	+ } else {
	+ /* The very last entry has been processed or an error occured */
	+ FindClose (dirp->handle);
	+ dirp->handle = INVALID_HANDLE_VALUE;
	+ p = NULL;
	+ }
	+
	+ } else {
	+
	+ /* End of directory stream reached */
	+ p = NULL;
	+
	+ }
	+
	+ return p;
	+}
	+
	+/*
	+ * Open directory stream using plain old C-string.
	+ */
	+static DIR*
	+opendir(
	+ const char *dirname)
	+{
	+ struct DIR *dirp;
	+ int error;
	+
	+ /* Must have directory name */
	+ if (dirname == NULL \|\| dirname[0] == '\0') {
	+ dirent_set_errno (ENOENT);
	+ return NULL;
	+ }
	+
	+ /* Allocate memory for DIR structure */
	+ dirp = (DIR*) malloc (sizeof (struct DIR));
	+ if (dirp) {
	+ wchar_t wname[PATH_MAX];
	+ size_t n;
	+
	+ /* Convert directory name to wide-character string */
	+ error = dirent_mbstowcs_s (&n, wname, PATH_MAX, dirname, PATH_MAX);
	+ if (!error) {
	+
	+ /* Open directory stream using wide-character name */
	+ dirp->wdirp = _wopendir (wname);
	+ if (dirp->wdirp) {
	+ /* Directory stream opened */
	+ error = 0;
	+ } else {
	+ /* Failed to open directory stream */
	+ error = 1;
	+ }
	+
	+ } else {
	+ /*
	+ * Cannot convert file name to wide-character string. This
	+ * occurs if the string contains invalid multi-byte sequences or
	+ * the output buffer is too small to contain the resulting
	+ * string.
	+ */
	+ error = 1;
	+ }
	+
	+ } else {
	+ /* Cannot allocate DIR structure */
	+ error = 1;
	+ }
	+
	+ /* Clean up in case of error */
	+ if (error && dirp) {
	+ free (dirp);
	+ dirp = NULL;
	+ }
	+
	+ return dirp;
	+}
	+
	+/*
	+ * Read next directory entry.
	+ *
	+ * When working with text consoles, please note that file names returned by
	+ * readdir() are represented in the default ANSI code page while any output to
	+ * console is typically formatted on another code page. Thus, non-ASCII
	+ * characters in file names will not usually display correctly on console. The
	+ * problem can be fixed in two ways: (1) change the character set of console
	+ * to 1252 using chcp utility and use Lucida Console font, or (2) use
	+ * _cprintf function when writing to console. The _cprinf() will re-encode
	+ * ANSI strings to the console code page so many non-ASCII characters will
	+ * display correcly.
	+ */
	+static struct dirent*
	+readdir(
	+ DIR *dirp)
	+{
	+ WIN32_FIND_DATAW *datap;
	+ struct dirent *entp;
	+
	+ /* Read next directory entry */
	+ datap = dirent_next (dirp->wdirp);
	+ if (datap) {
	+ size_t n;
	+ int error;
	+
	+ /* Attempt to convert file name to multi-byte string */
	+ error = dirent_wcstombs_s(
	+ &n, dirp->ent.d_name, PATH_MAX, datap->cFileName, PATH_MAX);
	+
	+ /*
	+ * If the file name cannot be represented by a multi-byte string,
	+ * then attempt to use old 8+3 file name. This allows traditional
	+ * Unix-code to access some file names despite of unicode
	+ * characters, although file names may seem unfamiliar to the user.
	+ *
	+ * Be ware that the code below cannot come up with a short file
	+ * name unless the file system provides one. At least
	+ * VirtualBox shared folders fail to do this.
	+ */
	+ if (error && datap->cAlternateFileName[0] != '\0') {
	+ error = dirent_wcstombs_s(
	+ &n, dirp->ent.d_name, PATH_MAX,
	+ datap->cAlternateFileName, PATH_MAX);
	+ }
	+
	+ if (!error) {
	+ DWORD attr;
	+
	+ /* Initialize directory entry for return */
	+ entp = &dirp->ent;
	+
	+ /* Length of file name excluding zero terminator */
	+ entp->d_namlen = n - 1;
	+
	+ /* File attributes */
	+ attr = datap->dwFileAttributes;
	+ if ((attr & FILE_ATTRIBUTE_DEVICE) != 0) {
	+ entp->d_type = DT_CHR;
	+ } else if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
	+ entp->d_type = DT_DIR;
	+ } else {
	+ entp->d_type = DT_REG;
	+ }
	+
	+ /* Reset dummy fields */
	+ entp->d_ino = 0;
	+ entp->d_reclen = sizeof (struct dirent);
	+
	+ } else {
	+ /*
	+ * Cannot convert file name to multi-byte string so construct
	+ * an errornous directory entry and return that. Note that
	+ * we cannot return NULL as that would stop the processing
	+ * of directory entries completely.
	+ */
	+ entp = &dirp->ent;
	+ entp->d_name[0] = '?';
	+ entp->d_name[1] = '\0';
	+ entp->d_namlen = 1;
	+ entp->d_type = DT_UNKNOWN;
	+ entp->d_ino = 0;
	+ entp->d_reclen = 0;
	+ }
	+
	+ } else {
	+ /* No more directory entries */
	+ entp = NULL;
	+ }
	+
	+ return entp;
	+}
	+
	+/*
	+ * Close directory stream.
	+ */
	+static int
	+closedir(
	+ DIR *dirp)
	+{
	+ int ok;
	+ if (dirp) {
	+
	+ /* Close wide-character directory stream */
	+ ok = _wclosedir (dirp->wdirp);
	+ dirp->wdirp = NULL;
	+
	+ /* Release multi-byte character version */
	+ free (dirp);
	+
	+ } else {
	+
	+ /* Invalid directory stream */
	+ dirent_set_errno (EBADF);
	+ ok = /failure/-1;
	+
	+ }
	+ return ok;
	+}
	+
	+/*
	+ * Rewind directory stream to beginning.
	+ */
	+static void
	+rewinddir(
	+ DIR* dirp)
	+{
	+ /* Rewind wide-character string directory stream */
	+ _wrewinddir (dirp->wdirp);
	+}
	+
	+/* Convert multi-byte string to wide character string */
	+static int
	+dirent_mbstowcs_s(
	+ size_t *pReturnValue,
	+ wchar_t *wcstr,
	+ size_t sizeInWords,
	+ const char *mbstr,
	+ size_t count)
	+{
	+ int error;
	+
	+#if defined(_MSC_VER) && _MSC_VER >= 1400
	+
	+ /* Microsoft Visual Studio 2005 or later */
	+ error = mbstowcs_s (pReturnValue, wcstr, sizeInWords, mbstr, count);
	+
	+#else
	+
	+ /* Older Visual Studio or non-Microsoft compiler */
	+ size_t n;
	+
	+ /* Convert to wide-character string (or count characters) */
	+ n = mbstowcs (wcstr, mbstr, sizeInWords);
	+ if (!wcstr \|\| n < count) {
	+
	+ /* Zero-terminate output buffer */
	+ if (wcstr && sizeInWords) {
	+ if (n >= sizeInWords) {
	+ n = sizeInWords - 1;
	+ }
	+ wcstr[n] = 0;
	+ }
	+
	+ /* Length of resuting multi-byte string WITH zero terminator */
	+ if (pReturnValue) {
	+ *pReturnValue = n + 1;
	+ }
	+
	+ /* Success */
	+ error = 0;
	+
	+ } else {
	+
	+ /* Could not convert string */
	+ error = 1;
	+
	+ }
	+
	+#endif
	+
	+ return error;
	+}
	+
	+/* Convert wide-character string to multi-byte string */
	+static int
	+dirent_wcstombs_s(
	+ size_t *pReturnValue,
	+ char *mbstr,
	+ size_t sizeInBytes, /* max size of mbstr */
	+ const wchar_t *wcstr,
	+ size_t count)
	+{
	+ int error;
	+
	+#if defined(_MSC_VER) && _MSC_VER >= 1400
	+
	+ /* Microsoft Visual Studio 2005 or later */
	+ error = wcstombs_s (pReturnValue, mbstr, sizeInBytes, wcstr, count);
	+
	+#else
	+
	+ /* Older Visual Studio or non-Microsoft compiler */
	+ size_t n;
	+
	+ /* Convert to multi-byte string (or count the number of bytes needed) */
	+ n = wcstombs (mbstr, wcstr, sizeInBytes);
	+ if (!mbstr \|\| n < count) {
	+
	+ /* Zero-terminate output buffer */
	+ if (mbstr && sizeInBytes) {
	+ if (n >= sizeInBytes) {
	+ n = sizeInBytes - 1;
	+ }
	+ mbstr[n] = '\0';
	+ }
	+
	+ /* Lenght of resulting multi-bytes string WITH zero-terminator */
	+ if (pReturnValue) {
	+ *pReturnValue = n + 1;
	+ }
	+
	+ /* Success */
	+ error = 0;
	+
	+ } else {
	+
	+ /* Cannot convert string */
	+ error = 1;
	+
	+ }
	+
	+#endif
	+
	+ return error;
	+}
	+
	+/* Set errno variable */
	+static void
	+dirent_set_errno(
	+ int error)
	+{
	+#if defined(_MSC_VER) && _MSC_VER >= 1400
	+
	+ /* Microsoft Visual Studio 2005 and later */
	+ _set_errno (error);
	+
	+#else
	+
	+ /* Non-Microsoft compiler or older Microsoft compiler */
	+ errno = error;
	+
	+#endif
	+}
	+
	+
	+#ifdef __cplusplus
	+}
	+#endif
	+#endif /DIRENT_H/
	+

File Metadata

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

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions