No OneTemporary
Actions

Authored By

Unknown

Size

1017 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 c7d6694..520f91d 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,150 +1,154 @@
	Project (meandmyshadow)
	-CMake_Minimum_Required (VERSION 2.6)
	+CMake_Minimum_Required (VERSION 2.8)
	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" ON)
	+#Option (HARDWARE_ACCELERATION "Use openGL as rendering backend" OFF)
	+Set (HARDWARE_ACCELERATION OFF)
	Option (DEBUG_MODE "Compile the game with debug mode enabled" OFF)

	#Use openGL only when compiling with HARDWARE_ACCELERATION.
	#Otherwise we try to find XLib.
	if (HARDWARE_ACCELERATION)
	Find_Package (OpenGL REQUIRED)
	if ("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
	Find_Package (X11 REQUIRED)
	endif()
	else (HARDWARE_ACCELERATION)
	Include (FindX11)
	endif (HARDWARE_ACCELERATION)

	#Find the required libraries.
	-Find_Package (SDL REQUIRED)
	-Find_Package (SDL_gfx REQUIRED)
	-Find_Package (SDL_image REQUIRED)
	-Find_Package (SDL_ttf REQUIRED)
	-Find_Package (SDL_mixer REQUIRED)
	+Find_Package (SDL2 REQUIRED)
	+Find_Package (SDL2_gfx 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 (Lua51 REQUIRED)
	+Find_Package (Lua REQUIRED)

	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)

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

	-if (NOT SDLGFX_FOUND)
	- message (FATAL_ERROR "SDL_gfx library could not be found!")
	-endif (NOT SDLGFX_FOUND)
	+if (NOT SDL2_GFX_FOUND)
	+ message (FATAL_ERROR "SDL2_gfx library could not be found!")
	+endif (NOT SDL2_GFX_FOUND)

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

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

	-if (NOT SDLMIXER_FOUND)
	- message (FATAL_ERROR "SDL_mixer library could not be found!")
	-endif (NOT SDLMIXER_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 LUA51_FOUND)
	+if (NOT LUA_FOUND)
	message (FATAL_ERROR "Lua library could not be found!")
	-endif (NOT LUA51_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)
	+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 (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"
	)

	#Add the include directories of the (found) libraries.
	Include_Directories(
	${PROJECT_BINARY_DIR}
	${X11_X11_INCLUDE_PATH}
	${OPENGL_gl_INCLUDE_DIR}
	- ${SDL_INCLUDE_DIR}
	- ${SDLGFX_INCLUDE_DIR}
	- ${SDLIMAGE_INCLUDE_DIR}
	- ${SDLTTF_INCLUDE_DIR}
	- ${SDLMIXER_INCLUDE_DIR}
	+ ${SDL2_INCLUDE_DIR}
	+ ${SDL2_GFX_INCLUDE_DIR}
	+ ${SDL2_IMAGE_INCLUDE_DIR}
	+ ${SDL2_TTF_INCLUDE_DIR}
	+ ${SDL2_MIXER_INCLUDE_DIR}
	${CURL_INCLUDE_DIR}
	${LibArchive_INCLUDE_DIR}
	${LUA_INCLUDE_DIR}
	)

	#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})

	Target_Link_Libraries (
	meandmyshadow
	${OPENGL_gl_LIBRARY}
	${X11_X11_LIB}
	- ${SDL_LIBRARY}
	- ${SDLGFX_LIBRARY}
	- ${SDLIMAGE_LIBRARY}
	- ${SDLTTF_LIBRARY}
	- ${SDLMIXER_LIBRARY}
	+ ${SDL2_LIBRARY}
	+ ${SDL2_GFX_LIBRARY}
	+ ${SDL2_IMAGE_LIBRARY}
	+ ${SDL2_TTF_LIBRARY}
	+ ${SDL2_MIXER_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/cmake/Modules/FindSDL2.cmake b/cmake/Modules/FindSDL2.cmake
	new file mode 100644
	index 0000000..026dc34
	--- /dev/null
	+++ b/cmake/Modules/FindSDL2.cmake
	@@ -0,0 +1,169 @@
	+
	+# This module defines
	+# SDL2_LIBRARY, the name of the library to link against
	+# SDL2_FOUND, if false, do not try to link to SDL2
	+# SDL2_INCLUDE_DIR, where to find SDL.h
	+#
	+# This module responds to the the flag:
	+# SDL2_BUILDING_LIBRARY
	+# If this is defined, then no SDL2main will be linked in because
	+# only applications need main().
	+# Otherwise, it is assumed you are building an application and this
	+# module will attempt to locate and set the the proper link flags
	+# as part of the returned SDL2_LIBRARY variable.
	+#
	+# Don't forget to include SDLmain.h and SDLmain.m your project for the
	+# OS X framework based version. (Other versions link to -lSDL2main which
	+# this module will try to find on your behalf.) Also for OS X, this
	+# module will automatically add the -framework Cocoa on your behalf.
	+#
	+#
	+# Additional Note: If you see an empty SDL2_LIBRARY_TEMP in your configuration
	+# and no SDL2_LIBRARY, it means CMake did not find your SDL2 library
	+# (SDL2.dll, libsdl2.so, SDL2.framework, etc).
	+# Set SDL2_LIBRARY_TEMP to point to your SDL2 library, and configure again.
	+# Similarly, if you see an empty SDL2MAIN_LIBRARY, you should set this value
	+# as appropriate. These values are used to generate the final SDL2_LIBRARY
	+# variable, but when these values are unset, SDL2_LIBRARY does not get created.
	+#
	+#
	+# $SDL2DIR is an environment variable that would
	+# correspond to the ./configure --prefix=$SDL2DIR
	+# used in building SDL2.
	+# l.e.galup 9-20-02
	+#
	+# Modified by Eric Wing.
	+# Added code to assist with automated building by using environmental variables
	+# and providing a more controlled/consistent search behavior.
	+# Added new modifications to recognize OS X frameworks and
	+# additional Unix paths (FreeBSD, etc).
	+# Also corrected the header search path to follow "proper" SDL guidelines.
	+# Added a search for SDL2main which is needed by some platforms.
	+# Added a search for threads which is needed by some platforms.
	+# Added needed compile switches for MinGW.
	+#
	+# On OSX, this will prefer the Framework version (if found) over others.
	+# People will have to manually change the cache values of
	+# SDL2_LIBRARY to override this selection or set the CMake environment
	+# CMAKE_INCLUDE_PATH to modify the search paths.
	+#
	+# Note that the header path has changed from SDL2/SDL.h to just SDL.h
	+# This needed to change because "proper" SDL convention
	+# is #include "SDL.h", not <SDL2/SDL.h>. This is done for portability
	+# reasons because not all systems place things in SDL2/ (see FreeBSD).
	+
	+#=============================================================================
	+# Copyright 2003-2009 Kitware, Inc.
	+#
	+# Distributed under the OSI-approved BSD License (the "License");
	+# see accompanying file Copyright.txt for details.
	+#
	+# This software is distributed WITHOUT ANY WARRANTY; without even the
	+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	+# See the License for more information.
	+#=============================================================================
	+# (To distribute this file outside of CMake, substitute the full
	+# License text for the above reference.)
	+
	+message("<FindSDL2.cmake>")
	+
	+SET(SDL2_SEARCH_PATHS
	+ ~/Library/Frameworks
	+ /Library/Frameworks
	+ /usr/local
	+ /usr
	+ /sw # Fink
	+ /opt/local # DarwinPorts
	+ /opt/csw # Blastwave
	+ /opt
	+ ${SDL2_PATH}
	+)
	+
	+FIND_PATH(SDL2_INCLUDE_DIR SDL.h
	+ HINTS
	+ $ENV{SDL2DIR}
	+ PATH_SUFFIXES include/SDL2 include
	+ PATHS ${SDL2_SEARCH_PATHS}
	+)
	+
	+FIND_LIBRARY(SDL2_LIBRARY_TEMP
	+ NAMES SDL2
	+ HINTS
	+ $ENV{SDL2DIR}
	+ PATH_SUFFIXES lib64 lib
	+ PATHS ${SDL2_SEARCH_PATHS}
	+)
	+
	+IF(NOT SDL2_BUILDING_LIBRARY)
	+ IF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
	+ # Non-OS X framework versions expect you to also dynamically link to
	+ # SDL2main. This is mainly for Windows and OS X. Other (Unix) platforms
	+ # seem to provide SDL2main for compatibility even though they don't
	+ # necessarily need it.
	+ FIND_LIBRARY(SDL2MAIN_LIBRARY
	+ NAMES SDL2main
	+ HINTS
	+ $ENV{SDL2DIR}
	+ PATH_SUFFIXES lib64 lib
	+ PATHS ${SDL2_SEARCH_PATHS}
	+ )
	+ ENDIF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
	+ENDIF(NOT SDL2_BUILDING_LIBRARY)
	+
	+# SDL2 may require threads on your system.
	+# The Apple build may not need an explicit flag because one of the
	+# frameworks may already provide it.
	+# But for non-OSX systems, I will use the CMake Threads package.
	+IF(NOT APPLE)
	+ FIND_PACKAGE(Threads)
	+ENDIF(NOT APPLE)
	+
	+# MinGW needs an additional library, mwindows
	+# It's total link flags should look like -lmingw32 -lSDL2main -lSDL2 -lmwindows
	+# (Actually on second look, I think it only needs one of the m* libraries.)
	+IF(MINGW)
	+ SET(MINGW32_LIBRARY mingw32 CACHE STRING "mwindows for MinGW")
	+ENDIF(MINGW)
	+
	+IF(SDL2_LIBRARY_TEMP)
	+ # For SDL2main
	+ IF(NOT SDL2_BUILDING_LIBRARY)
	+ IF(SDL2MAIN_LIBRARY)
	+ SET(SDL2_LIBRARY_TEMP ${SDL2MAIN_LIBRARY} ${SDL2_LIBRARY_TEMP})
	+ ENDIF(SDL2MAIN_LIBRARY)
	+ ENDIF(NOT SDL2_BUILDING_LIBRARY)
	+
	+ # For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
	+ # CMake doesn't display the -framework Cocoa string in the UI even
	+ # though it actually is there if I modify a pre-used variable.
	+ # I think it has something to do with the CACHE STRING.
	+ # So I use a temporary variable until the end so I can set the
	+ # "real" variable in one-shot.
	+ IF(APPLE)
	+ SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} "-framework Cocoa")
	+ ENDIF(APPLE)
	+
	+ # For threads, as mentioned Apple doesn't need this.
	+ # In fact, there seems to be a problem if I used the Threads package
	+ # and try using this line, so I'm just skipping it entirely for OS X.
	+ IF(NOT APPLE)
	+ SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} ${CMAKE_THREAD_LIBS_INIT})
	+ ENDIF(NOT APPLE)
	+
	+ # For MinGW library
	+ IF(MINGW)
	+ SET(SDL2_LIBRARY_TEMP ${MINGW32_LIBRARY} ${SDL2_LIBRARY_TEMP})
	+ ENDIF(MINGW)
	+
	+ # Set the final string here so the GUI reflects the final state.
	+ SET(SDL2_LIBRARY ${SDL2_LIBRARY_TEMP} CACHE STRING "Where the SDL2 Library can be found")
	+ # Set the temp variable to INTERNAL so it is not seen in the CMake GUI
	+ SET(SDL2_LIBRARY_TEMP "${SDL2_LIBRARY_TEMP}" CACHE INTERNAL "")
	+ENDIF(SDL2_LIBRARY_TEMP)
	+
	+message("</FindSDL2.cmake>")
	+
	+INCLUDE(FindPackageHandleStandardArgs)
	+
	+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2 REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR)
	+
	diff --git a/cmake/Modules/FindSDL2_gfx.cmake b/cmake/Modules/FindSDL2_gfx.cmake
	new file mode 100644
	index 0000000..d306ba3
	--- /dev/null
	+++ b/cmake/Modules/FindSDL2_gfx.cmake
	@@ -0,0 +1,83 @@
	+# Locate SDL2_gfx library
	+#
	+# This module defines:
	+#
	+# ::
	+#
	+# SDL2_GFX_LIBRARIES, the name of the library to link against
	+# SDL2_GFX_INCLUDE_DIRS, where to find the headers
	+# SDL2_GFX_FOUND, if false, do not try to link against
	+# SDL2_GFX_VERSION_STRING - human-readable string containing the version of SDL2_gfx
	+#
	+#
	+#
	+# $SDL2DIR is an environment variable that would correspond to the
	+# ./configure --prefix=$SDL2DIR used in building SDL2.
	+#
	+# Created by Eric Wing. This was influenced by the FindSDL.cmake
	+# module, but with modifications to recognize OS X frameworks and
	+# additional Unix paths (FreeBSD, etc).
	+
	+#=============================================================================
	+# Copyright 2005-2009 Kitware, Inc.
	+# Copyright 2012 Benjamin Eikel
	+#
	+# Distributed under the OSI-approved BSD License (the "License");
	+# see accompanying file Copyright.txt for details.
	+#
	+# This software is distributed WITHOUT ANY WARRANTY; without even the
	+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	+# See the License for more information.
	+#=============================================================================
	+# (To distribute this file outside of CMake, substitute the full
	+# License text for the above reference.)
	+
	+find_path(SDL2_GFX_INCLUDE_DIR SDL2_gfxPrimitives.h
	+ HINTS
	+ ENV SDL2GFXDIR
	+ ENV SDL2DIR
	+ PATH_SUFFIXES SDL2
	+ # path suffixes to search inside ENV{SDL2DIR}
	+ include/SDL2 include
	+)
	+
	+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
	+ set(VC_LIB_PATH_SUFFIX lib/x64)
	+else()
	+ set(VC_LIB_PATH_SUFFIX lib/x86)
	+endif()
	+
	+find_library(SDL2_GFX_LIBRARY
	+ NAMES SDL2_gfx
	+ HINTS
	+ ENV SDL2GFXDIR
	+ ENV SDL2DIR
	+ PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX}
	+)
	+
	+if(SDL2_GFX_INCLUDE_DIR AND EXISTS "${SDL2_GFX_INCLUDE_DIR}/SDL2_gfxPrimitives.h")
	+ file(STRINGS "${SDL2_GFX_INCLUDE_DIR}/SDL2_gfxPrimitives.h" SDL2_GFX_VERSION_MAJOR_LINE REGEX "^#define[ \t]+SDL2_GFXPRIMITIVES_MAJOR[ \t]+[0-9]+$")
	+ file(STRINGS "${SDL2_GFX_INCLUDE_DIR}/SDL2_gfxPrimitives.h" SDL2_GFX_VERSION_MINOR_LINE REGEX "^#define[ \t]+SDL2_GFXPRIMITIVES_MINOR[ \t]+[0-9]+$")
	+ file(STRINGS "${SDL2_GFX_INCLUDE_DIR}/SDL2_gfxPrimitives.h" SDL2_GFX_VERSION_PATCH_LINE REGEX "^#define[ \t]+SDL2_GFXPRIMITIVES_MICRO[ \t]+[0-9]+$")
	+ string(REGEX REPLACE "^#define[ \t]+SDL2_GFXPRIMITIVES_MAJOR[ \t]+([0-9]+)$" "\\1" SDL2_GFX_VERSION_MAJOR "${SDL2_GFX_VERSION_MAJOR_LINE}")
	+ string(REGEX REPLACE "^#define[ \t]+SDL2_GFXPRIMITIVES_MINOR[ \t]+([0-9]+)$" "\\1" SDL2_GFX_VERSION_MINOR "${SDL2_GFX_VERSION_MINOR_LINE}")
	+ string(REGEX REPLACE "^#define[ \t]+SDL2_GFXPRIMITIVES_MICRO[ \t]+([0-9]+)$" "\\1" SDL2_GFX_VERSION_PATCH "${SDL2_GFX_VERSION_PATCH_LINE}")
	+ set(SDL2_GFX_VERSION_STRING ${SDL2_GFX_VERSION_MAJOR}.${SDL2_GFX_VERSION_MINOR}.${SDL2_GFX_VERSION_PATCH})
	+ unset(SDL2_GFX_VERSION_MAJOR_LINE)
	+ unset(SDL2_GFX_VERSION_MINOR_LINE)
	+ unset(SDL2_GFX_VERSION_PATCH_LINE)
	+ unset(SDL2_GFX_VERSION_MAJOR)
	+ unset(SDL2_GFX_VERSION_MINOR)
	+ unset(SDL2_GFX_VERSION_PATCH)
	+endif()
	+
	+set(SDL2_GFX_LIBRARIES ${SDL2_GFX_LIBRARY})
	+set(SDL2_GFX_INCLUDE_DIRS ${SDL2_GFX_INCLUDE_DIR})
	+
	+include(FindPackageHandleStandardArgs)
	+
	+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2_gfx
	+ REQUIRED_VARS SDL2_GFX_LIBRARIES SDL2_GFX_INCLUDE_DIRS
	+ VERSION_VAR SDL2_GFX_VERSION_STRING)
	+
	+mark_as_advanced(SDL2_GFX_LIBRARY SDL2_GFX_INCLUDE_DIR)
	diff --git a/cmake/Modules/FindSDL2_image.cmake b/cmake/Modules/FindSDL2_image.cmake
	new file mode 100644
	index 0000000..436ae90
	--- /dev/null
	+++ b/cmake/Modules/FindSDL2_image.cmake
	@@ -0,0 +1,100 @@
	+# Locate SDL_image library
	+#
	+# This module defines:
	+#
	+# ::
	+#
	+# SDL_IMAGE_LIBRARIES, the name of the library to link against
	+# SDL_IMAGE_INCLUDE_DIRS, where to find the headers
	+# SDL_IMAGE_FOUND, if false, do not try to link against
	+# SDL_IMAGE_VERSION_STRING - human-readable string containing the version of SDL_image
	+#
	+#
	+#
	+# For backward compatiblity the following variables are also set:
	+#
	+# ::
	+#
	+# SDLIMAGE_LIBRARY (same value as SDL_IMAGE_LIBRARIES)
	+# SDLIMAGE_INCLUDE_DIR (same value as SDL_IMAGE_INCLUDE_DIRS)
	+# SDLIMAGE_FOUND (same value as SDL_IMAGE_FOUND)
	+#
	+#
	+#
	+# $SDLDIR is an environment variable that would correspond to the
	+# ./configure --prefix=$SDLDIR used in building SDL.
	+#
	+# Created by Eric Wing. This was influenced by the FindSDL.cmake
	+# module, but with modifications to recognize OS X frameworks and
	+# additional Unix paths (FreeBSD, etc).
	+
	+#=============================================================================
	+# Copyright 2005-2009 Kitware, Inc.
	+# Copyright 2012 Benjamin Eikel
	+#
	+# Distributed under the OSI-approved BSD License (the "License");
	+# see accompanying file Copyright.txt for details.
	+#
	+# This software is distributed WITHOUT ANY WARRANTY; without even the
	+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	+# See the License for more information.
	+#=============================================================================
	+# (To distribute this file outside of CMake, substitute the full
	+# License text for the above reference.)
	+
	+find_path(SDL2_IMAGE_INCLUDE_DIR SDL_image.h
	+ HINTS
	+ ENV SDL2IMAGEDIR
	+ ENV SDL2DIR
	+ PATH_SUFFIXES SDL2
	+ # path suffixes to search inside ENV{SDLDIR}
	+ include/SDL2 include
	+ PATHS ${SDL2_PATH}
	+ )
	+
	+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
	+ set(VC_LIB_PATH_SUFFIX lib/x64)
	+else()
	+ set(VC_LIB_PATH_SUFFIX lib/x86)
	+endif()
	+
	+find_library(SDL2_IMAGE_LIBRARY
	+ NAMES SDL2_image
	+ HINTS
	+ ENV SDL2IMAGEDIR
	+ ENV SDL2DIR
	+ PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX}
	+ PATHS ${SDL2_PATH}
	+ )
	+
	+if(SDL2_IMAGE_INCLUDE_DIR AND EXISTS "${SDL2_IMAGE_INCLUDE_DIR}/SDL_image.h")
	+ file(STRINGS "${SDL2_IMAGE_INCLUDE_DIR}/SDL_image.h" SDL_IMAGE_VERSION_MAJOR_LINE REGEX "^#define[ \t]+SDL_IMAGE_MAJOR_VERSION[ \t]+[0-9]+$")
	+ file(STRINGS "${SDL2_IMAGE_INCLUDE_DIR}/SDL_image.h" SDL2_IMAGE_VERSION_MINOR_LINE REGEX "^#define[ \t]+SDL2_IMAGE_MINOR_VERSION[ \t]+[0-9]+$")
	+ file(STRINGS "${SDL2_IMAGE_INCLUDE_DIR}/SDL_image.h" SDL2_IMAGE_VERSION_PATCH_LINE REGEX "^#define[ \t]+SDL2_IMAGE_PATCHLEVEL[ \t]+[0-9]+$")
	+ string(REGEX REPLACE "^#define[ \t]+SDL2_IMAGE_MAJOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_IMAGE_VERSION_MAJOR "${SDL2_IMAGE_VERSION_MAJOR_LINE}")
	+ string(REGEX REPLACE "^#define[ \t]+SDL2_IMAGE_MINOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_IMAGE_VERSION_MINOR "${SDL2_IMAGE_VERSION_MINOR_LINE}")
	+ string(REGEX REPLACE "^#define[ \t]+SDL2_IMAGE_PATCHLEVEL[ \t]+([0-9]+)$" "\\1" SDL2_IMAGE_VERSION_PATCH "${SDL2_IMAGE_VERSION_PATCH_LINE}")
	+ set(SDL2_IMAGE_VERSION_STRING ${SDL2_IMAGE_VERSION_MAJOR}.${SDL2_IMAGE_VERSION_MINOR}.${SDL2_IMAGE_VERSION_PATCH})
	+ unset(SDL2_IMAGE_VERSION_MAJOR_LINE)
	+ unset(SDL2_IMAGE_VERSION_MINOR_LINE)
	+ unset(SDL2_IMAGE_VERSION_PATCH_LINE)
	+ unset(SDL2_IMAGE_VERSION_MAJOR)
	+ unset(SDL2_IMAGE_VERSION_MINOR)
	+ unset(SDL2_IMAGE_VERSION_PATCH)
	+endif()
	+
	+set(SDL2_IMAGE_LIBRARIES ${SDL2_IMAGE_LIBRARY})
	+set(SDL2_IMAGE_INCLUDE_DIRS ${SDL2_IMAGE_INCLUDE_DIR})
	+
	+include(FindPackageHandleStandardArgs)
	+
	+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2_image
	+ REQUIRED_VARS SDL2_IMAGE_LIBRARIES SDL2_IMAGE_INCLUDE_DIRS
	+ VERSION_VAR SDL2_IMAGE_VERSION_STRING)
	+
	+# for backward compatiblity
	+#set(SDLIMAGE_LIBRARY ${SDL_IMAGE_LIBRARIES})
	+#set(SDLIMAGE_INCLUDE_DIR ${SDL_IMAGE_INCLUDE_DIRS})
	+#set(SDLIMAGE_FOUND ${SDL_IMAGE_FOUND})
	+
	+mark_as_advanced(SDL2_IMAGE_LIBRARY SDL2_IMAGE_INCLUDE_DIR)
	diff --git a/cmake/Modules/FindSDL2_mixer.cmake b/cmake/Modules/FindSDL2_mixer.cmake
	new file mode 100644
	index 0000000..604c520
	--- /dev/null
	+++ b/cmake/Modules/FindSDL2_mixer.cmake
	@@ -0,0 +1,83 @@
	+# Locate SDL2_mixer library
	+#
	+# This module defines:
	+#
	+# ::
	+#
	+# SDL2_MIXER_LIBRARIES, the name of the library to link against
	+# SDL2_MIXER_INCLUDE_DIRS, where to find the headers
	+# SDL2_MIXER_FOUND, if false, do not try to link against
	+# SDL2_MIXER_VERSION_STRING - human-readable string containing the version of SDL2_mixer
	+#
	+#
	+#
	+# $SDL2DIR is an environment variable that would correspond to the
	+# ./configure --prefix=$SDL2DIR used in building SDL2.
	+#
	+# Created by Eric Wing. This was influenced by the FindSDL.cmake
	+# module, but with modifications to recognize OS X frameworks and
	+# additional Unix paths (FreeBSD, etc).
	+
	+#=============================================================================
	+# Copyright 2005-2009 Kitware, Inc.
	+# Copyright 2012 Benjamin Eikel
	+#
	+# Distributed under the OSI-approved BSD License (the "License");
	+# see accompanying file Copyright.txt for details.
	+#
	+# This software is distributed WITHOUT ANY WARRANTY; without even the
	+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	+# See the License for more information.
	+#=============================================================================
	+# (To distribute this file outside of CMake, substitute the full
	+# License text for the above reference.)
	+
	+find_path(SDL2_MIXER_INCLUDE_DIR SDL_mixer.h
	+ HINTS
	+ ENV SDL2MIXERDIR
	+ ENV SDL2DIR
	+ PATH_SUFFIXES SDL2
	+ # path suffixes to search inside ENV{SDL2DIR}
	+ include/SDL2 include
	+)
	+
	+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
	+ set(VC_LIB_PATH_SUFFIX lib/x64)
	+else()
	+ set(VC_LIB_PATH_SUFFIX lib/x86)
	+endif()
	+
	+find_library(SDL2_MIXER_LIBRARY
	+ NAMES SDL2_mixer
	+ HINTS
	+ ENV SDL2MIXERDIR
	+ ENV SDL2DIR
	+ PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX}
	+)
	+
	+if(SDL2_MIXER_INCLUDE_DIR AND EXISTS "${SDL2_MIXER_INCLUDE_DIR}/SDL_mixer.h")
	+ file(STRINGS "${SDL2_MIXER_INCLUDE_DIR}/SDL_mixer.h" SDL2_MIXER_VERSION_MAJOR_LINE REGEX "^#define[ \t]+SDL_MIXER_MAJOR_VERSION[ \t]+[0-9]+$")
	+ file(STRINGS "${SDL2_MIXER_INCLUDE_DIR}/SDL_mixer.h" SDL2_MIXER_VERSION_MINOR_LINE REGEX "^#define[ \t]+SDL_MIXER_MINOR_VERSION[ \t]+[0-9]+$")
	+ file(STRINGS "${SDL2_MIXER_INCLUDE_DIR}/SDL_mixer.h" SDL2_MIXER_VERSION_PATCH_LINE REGEX "^#define[ \t]+SDL_MIXER_PATCHLEVEL[ \t]+[0-9]+$")
	+ string(REGEX REPLACE "^#define[ \t]+SDL_MIXER_MAJOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_MIXER_VERSION_MAJOR "${SDL2_MIXER_VERSION_MAJOR_LINE}")
	+ string(REGEX REPLACE "^#define[ \t]+SDL_MIXER_MINOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_MIXER_VERSION_MINOR "${SDL2_MIXER_VERSION_MINOR_LINE}")
	+ string(REGEX REPLACE "^#define[ \t]+SDL_MIXER_PATCHLEVEL[ \t]+([0-9]+)$" "\\1" SDL2_MIXER_VERSION_PATCH "${SDL2_MIXER_VERSION_PATCH_LINE}")
	+ set(SDL2_MIXER_VERSION_STRING ${SDL2_MIXER_VERSION_MAJOR}.${SDL2_MIXER_VERSION_MINOR}.${SDL2_MIXER_VERSION_PATCH})
	+ unset(SDL2_MIXER_VERSION_MAJOR_LINE)
	+ unset(SDL2_MIXER_VERSION_MINOR_LINE)
	+ unset(SDL2_MIXER_VERSION_PATCH_LINE)
	+ unset(SDL2_MIXER_VERSION_MAJOR)
	+ unset(SDL2_MIXER_VERSION_MINOR)
	+ unset(SDL2_MIXER_VERSION_PATCH)
	+endif()
	+
	+set(SDL2_MIXER_LIBRARIES ${SDL2_MIXER_LIBRARY})
	+set(SDL2_MIXER_INCLUDE_DIRS ${SDL2_MIXER_INCLUDE_DIR})
	+
	+include(FindPackageHandleStandardArgs)
	+
	+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2_mixer
	+ REQUIRED_VARS SDL2_MIXER_LIBRARIES SDL2_MIXER_INCLUDE_DIRS
	+ VERSION_VAR SDL2_MIXER_VERSION_STRING)
	+
	+mark_as_advanced(SDL2_MIXER_LIBRARY SDL2_MIXER_INCLUDE_DIR)
	diff --git a/cmake/Modules/FindSDL2_ttf.cmake b/cmake/Modules/FindSDL2_ttf.cmake
	new file mode 100644
	index 0000000..421fe2e
	--- /dev/null
	+++ b/cmake/Modules/FindSDL2_ttf.cmake
	@@ -0,0 +1,98 @@
	+# Locate SDL_image library
	+#
	+# This module defines:
	+#
	+# ::
	+#
	+# SDL_TTF_LIBRARIES, the name of the library to link against
	+# SDL_TTF_INCLUDE_DIRS, where to find the headers
	+# SDL_TTF_FOUND, if false, do not try to link against
	+# SDL_F_VERSION_STRING - human-readable string containing the version of SDL_ttf
	+#
	+#
	+#
	+# For backward compatiblity the following variables are also set:
	+#
	+# ::
	+#
	+# SDLTTF_LIBRARY (same value as SDL_TTF_LIBRARIES)
	+# SDLTTF_INCLUDE_DIR (same value as SDL_TTF_INCLUDE_DIRS)
	+# SDLTTF_FOUND (same value as SDL_TTF_FOUND)
	+#
	+#
	+#
	+# $SDLDIR is an environment variable that would correspond to the
	+# ./configure --prefix=$SDLDIR used in building SDL.
	+#
	+# Created by Eric Wing. This was influenced by the FindSDL.cmake
	+# module, but with modifications to recognize OS X frameworks and
	+# additional Unix paths (FreeBSD, etc).
	+
	+#=============================================================================
	+# Copyright 2005-2009 Kitware, Inc.
	+# Copyright 2012 Benjamin Eikel
	+#
	+# Distributed under the OSI-approved BSD License (the "License");
	+# see accompanying file Copyright.txt for details.
	+#
	+# This software is distributed WITHOUT ANY WARRANTY; without even the
	+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	+# See the License for more information.
	+#=============================================================================
	+# (To distribute this file outside of CMake, substitute the full
	+# License text for the above reference.)
	+
	+find_path(SDL2_TTF_INCLUDE_DIR SDL_ttf.h
	+ HINTS
	+ ENV SDL2TTFDIR
	+ ENV SDL2DIR
	+ PATH_SUFFIXES SDL2
	+ # path suffixes to search inside ENV{SDLDIR}
	+ include/SDL2 include
	+ PATHS ${SDL2_PATH}
	+ )
	+
	+if (CMAKE_SIZEOF_VOID_P EQUAL 8)
	+ set(VC_LIB_PATH_SUFFIX lib/x64)
	+else ()
	+ set(VC_LIB_PATH_SUFFIX lib/x86)
	+endif ()
	+
	+find_library(SDL2_TTF_LIBRARY
	+ NAMES SDL2_ttf
	+ HINTS
	+ ENV SDL2TTFDIR
	+ ENV SDL2DIR
	+ PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX}
	+ PATHS ${SDL2_PATH}
	+ )
	+
	+if (SDL2_TTF_INCLUDE_DIR AND EXISTS "${SDL2_TTF_INCLUDE_DIR}/SDL_ttf.h")
	+ file(STRINGS "${SDL2_TTF_INCLUDE_DIR}/SDL_ttf.h" SDL_TTF_VERSION_MAJOR_LINE REGEX "^#define[ \t]+SDL_TTF_MAJOR_VERSION[ \t]+[0-9]+$")
	+ file(STRINGS "${SDL2_TTF_INCLUDE_DIR}/SDL_ttf.h" SDL2_TTF_VERSION_MINOR_LINE REGEX "^#define[ \t]+SDL2_TTF_MINOR_VERSION[ \t]+[0-9]+$")
	+ file(STRINGS "${SDL2_TTF_INCLUDE_DIR}/SDL_ttf.h" SDL2_TTF_VERSION_PATCH_LINE REGEX "^#define[ \t]+SDL2_TTF_PATCHLEVEL[ \t]+[0-9]+$")
	+ string(REGEX REPLACE "^#define[ \t]+SDL2_TTF_MAJOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_TTF_VERSION_MAJOR "${SDL2_TTF_VERSION_MAJOR_LINE}")
	+ string(REGEX REPLACE "^#define[ \t]+SDL2_TTF_MINOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_TTF_VERSION_MINOR "${SDL2_TTF_VERSION_MINOR_LINE}")
	+ string(REGEX REPLACE "^#define[ \t]+SDL2_TTF_PATCHLEVEL[ \t]+([0-9]+)$" "\\1" SDL2_TTF_VERSION_PATCH "${SDL2_TTF_VERSION_PATCH_LINE}")
	+ set(SDL2_TTF_VERSION_STRING ${SDL2_TTF_VERSION_MAJOR}.${SDL2_TTF_VERSION_MINOR}.${SDL2_TTF_VERSION_PATCH})
	+ unset(SDL2_TTF_VERSION_MAJOR_LINE)
	+ unset(SDL2_TTF_VERSION_MINOR_LINE)
	+ unset(SDL2_TTF_VERSION_PATCH_LINE)
	+ unset(SDL2_TTF_VERSION_MAJOR)
	+ unset(SDL2_TTF_VERSION_MINOR)
	+ unset(SDL2_TTF_VERSION_PATCH)
	+endif ()
	+
	+set(SDL2_TTF_LIBRARIES ${SDL2_TTF_LIBRARY})
	+set(SDL2_TTF_INCLUDE_DIRS ${SDL2_TTF_INCLUDE_DIR})
	+
	+include(FindPackageHandleStandardArgs)
	+
	+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2_ttf
	+ REQUIRED_VARS SDL2_TTF_LIBRARIES SDL2_TTF_INCLUDE_DIRS
	+ VERSION_VAR SDL2_TTF_VERSION_STRING)
	+
	+# for backward compatiblity
	+#set(SDLTTF_LIBRARY ${SDL_TTF_LIBRARIES})
	+#set(SDLTTF_INCLUDE_DIR ${SDL_TTF_INCLUDE_DIRS})
	+#set(SDLTTF_FOUND ${SDL_TTF_FOUND})
	diff --git a/cmake/Modules/module_licences.md b/cmake/Modules/module_licences.md
	new file mode 100644
	index 0000000..45820e4
	--- /dev/null
	+++ b/cmake/Modules/module_licences.md
	@@ -0,0 +1,23 @@
	+FindLibArchive.cmake
	+Copyright 2010 Kitware, Inc.
	+
	+
	+FindSDL2.cmake
	+FindSDL2_image.cmake
	+FindSDL2_ttf.cmake
	+BSD license
	+Copyright 2003-2009 Kitware, Inc.
	+Modified by Eric Wing
	+
	+Found here:
	+https://github.com/tcbrindle/sdl2-cmake-scripts
	+
	+
	+FindSDL2_Mixer.cmake
	+FindSDL2_gfx.cmake
	+Copyright 2005-2009 Kitware, Inc.
	+Copyright 2012 Benjamin Eikel
	+
	+BSD license
	+Found here:
	+https://github.com/rodrigo21/sdl2-cmake-scripts
	diff --git a/src/Addons.cpp b/src/Addons.cpp
	index 9602ad4..c01b697 100644
	--- a/src/Addons.cpp
	+++ b/src/Addons.cpp
	@@ -1,935 +1,964 @@
	/*
	* 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 "Addons.h"
	#include "GameState.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "GUIObject.h"
	#include "GUIOverlay.h"
	#include "GUIScrollBar.h"
	#include "GUITextArea.h"
	#include "GUIListBox.h"
	#include "POASerializer.h"
	#include "InputManager.h"
	#include <string>
	#include <sstream>
	#include <iostream>
	#include "libs/tinyformat/tinyformat.h"
	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#ifdef __APPLE__
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_ttf.h>
	#endif


	using namespace std;

	-Addons::Addons():selected(NULL){
	+Addons::Addons(SDL_Renderer &renderer, ImageManager &imageManager):selected(NULL){
	//Render the title.
	- title=TTF_RenderUTF8_Blended(fontTitle,_("Addons"),themeTextColor);
	+ title=textureFromText(renderer, *fontTitle,_("Addons"),themeTextColor);

	//Load placeholder addon icons and screenshot.
	- addonIcon[0]=loadImage(getDataPath()+"/gfx/addon1.png");
	- SDL_SetAlpha(addonIcon[0],0,0);
	+ /*addonIcon[0]=loadImage(getDataPath()+"/gfx/addon1.png");
	+ SDL_SetSurfaceAlphaMod(addonIcon[0], 0);
	addonIcon[1]=loadImage(getDataPath()+"/gfx/addon2.png");
	- SDL_SetAlpha(addonIcon[1],0,0);
	+ SDL_SetSurfaceAlphaMod(addonIcon[1], 0);
	addonIcon[2]=loadImage(getDataPath()+"/gfx/addon3.png");
	- SDL_SetAlpha(addonIcon[2],0,0);
	- screenshot=loadImage(getDataPath()+"/gfx/screenshot.png");
	+ SDL_SetSurfaceAlphaMod(addonIcon[2], 0);*/
	+ addonIcon = {
	+ imageManager.loadTexture(getDataPath()+"/gfx/addon1.png", renderer),
	+ imageManager.loadTexture(getDataPath()+"/gfx/addon2.png", renderer),
	+ imageManager.loadTexture(getDataPath()+"/gfx/addon3.png", renderer)};
	+ for (auto tex : addonIcon) {
	+ SDL_SetTextureAlphaMod(tex.get(), 0);
	+ }
	+ screenshot=imageManager.loadTexture(getDataPath()+"/gfx/screenshot.png", renderer);
	+ //loadImage(getDataPath()+"/gfx/screenshot.png");

	//Open the addons file in the user cache path for writing (downloading) to.
	FILE* addon=fopen((getUserPath(USER_CACHE)+"addons").c_str(),"wb");

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

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

	- GUIObject* obj=new GUILabel(90,96,200,32,_("Unable to initialize addon menu:"));
	+ GUIObject* obj=new GUILabel(imageManager,renderer,90,96,200,32,_("Unable to initialize addon menu:"));
	obj->name="lbl";
	GUIObjectRoot->addChild(obj);

	- obj=new GUILabel(120,130,200,32,error.c_str());
	+ obj=new GUILabel(imageManager,renderer,120,130,200,32,error.c_str());
	obj->name="lbl";
	GUIObjectRoot->addChild(obj);

	- obj=new GUIButton(90,550,200,32,_("Back"));
	+ obj=new GUIButton(imageManager,renderer,90,550,200,32,_("Back"));
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->addChild(obj);
	return;
	}

	//Now create the GUI.
	- createGUI();
	+ createGUI(renderer, imageManager);
	}

	Addons::~Addons(){
	- //Free the title surface.
	- SDL_FreeSurface(title);
	-
	//If the GUIObjectRoot exist delete it.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}

	-void Addons::createGUI(){
	+void Addons::createGUI(SDL_Renderer& renderer, ImageManager& imageManager){
	//Downloaded the addons file now we can create the GUI.
	- GUIObjectRoot=new GUIObject(0,0,SCREEN_WIDTH,SCREEN_HEIGHT);
	+ GUIObjectRoot=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

	//Create list of categories
	- categoryList=new GUISingleLineListBox((SCREEN_WIDTH-360)/2,100,360,36);
	+ categoryList=new GUISingleLineListBox(imageManager,renderer,(SCREEN_WIDTH-360)/2,100,360,36);
	categoryList->name="lstTabs";
	//Loop through the categories and add them to the list.

	//FIXME: Hack for easy detecting which categories there are.
	{
	set<string> categories;
	set<string>::iterator mapIt;
	vector<Addon>::iterator it;
	for(it=addons.begin();it!=addons.end();++it)
	categories.insert(it->type);
	for(mapIt=categories.begin();mapIt!=categories.end();++mapIt)
	categoryList->addItem(mapIt,_(mapIt));
	}
	categoryList->value=0;
	categoryList->eventCallback=this;
	GUIObjectRoot->addChild(categoryList);

	//Create the list for the addons.
	//By default levels will be selected.
	- list=new GUIListBox(SCREEN_WIDTH0.1,160,SCREEN_WIDTH0.8,SCREEN_HEIGHT-210);
	- addonsToList(categoryList->getName());
	+ list=new GUIListBox(imageManager,renderer,SCREEN_WIDTH0.1,160,SCREEN_WIDTH0.8,SCREEN_HEIGHT-210);
	+ addonsToList(categoryList->getName(), renderer, imageManager);
	list->name="lstAddons";
	list->clickEvents=true;
	list->eventCallback=this;
	list->value=-1;
	GUIObjectRoot->addChild(list);
	type="levels";

	//The back button.
	- GUIObject* obj=new GUIButton(20,20,-1,32,_("Back"));
	+ GUIObject* obj=new GUIButton(imageManager,renderer,20,20,-1,32,_("Back"));
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->addChild(obj);
	}

	-bool Addons::getAddonsList(FILE* file){
	+bool Addons::getAddonsList(FILE* file, SDL_Renderer& renderer, ImageManager& imageManager){
	//First we download the file.
	if(downloadFile(getSettings()->getValue("addon_url"),file)==false){
	//NOTE: We keep the console output English so we put the string literal here twice.
	cerr<<"ERROR: unable to download addons file!"<<endl;
	error=_("ERROR: unable to download addons file!");
	return false;
	}
	fclose(file);

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

	if(!addonFile.good()) {
	//NOTE: We keep the console output English so we put the string literal here twice.
	cerr<<"ERROR: unable to load addon_list file!"<<endl;
	/// TRANSLATORS: addon_list is the name of a file and should not be translated.
	error=_("ERROR: unable to load addon_list file!");
	return false;
	}

	//Parse the addonsfile.
	TreeStorageNode obj;
	{
	POASerializer objSerializer;
	if(!objSerializer.readNode(addonFile,&obj,true)){
	//NOTE: We keep the console output English so we put the string literal here twice.
	cerr<<"ERROR: Invalid file format of addons file!"<<endl;
	error=_("ERROR: Invalid file format of addons file!");
	return false;
	}
	}

	//Check the addon version in the addons list.
	int version=0;
	if(!obj.attributes["version"].empty())
	version=atoi(obj.attributes["version"][0].c_str());
	if(version<MIN_VERSION \|\| version>MAX_VERSION){
	//NOTE: We keep the console output English so we put the string literal here twice.
	cerr<<"ERROR: Addon list version is unsupported! (received: "<<version<<" supported:"<<MIN_VERSION<<"-"<<MAX_VERSION<<")"<<endl;
	error=_("ERROR: Addon list version is unsupported!");
	return false;
	}

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

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

	//Also load the installed_addons file.
	iaddonFile.open((getUserPath(USER_CONFIG)+"installed_addons").c_str());
	if(!iaddonFile) {
	//NOTE: We keep the console output English so we put the string literal here twice.
	cerr<<"ERROR: Unable to create the installed_addons file."<<endl;
	/// TRANSLATORS: installed_addons is the name of a file and should not be translated.
	error=_("ERROR: Unable to create the installed_addons file.");
	return false;
	}
	}

	//And parse the installed_addons file.
	TreeStorageNode obj1;
	{
	POASerializer objSerializer;
	if(!objSerializer.readNode(iaddonFile,&obj1,true)){
	//NOTE: We keep the console output English so we put the string literal here twice.
	cerr<<"ERROR: Invalid file format of the installed_addons!"<<endl;
	error=_("ERROR: Invalid file format of the installed_addons!");
	return false;
	}
	}


	//Fill the vector.
	- fillAddonList(obj,obj1);
	+ fillAddonList(obj,obj1, renderer, imageManager);

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

	-void Addons::fillAddonList(TreeStorageNode &objAddons, TreeStorageNode &objInstalledAddons){
	+void Addons::fillAddonList(TreeStorageNode &objAddons, TreeStorageNode &objInstalledAddons,
	+ SDL_Renderer& renderer, ImageManager& imageManager){
	//Loop through the blocks of the addons file.
	//These should contain the types levels, levelpacks, themes.
	for(unsigned int i=0;i<objAddons.subNodes.size();i++){
	TreeStorageNode* block=objAddons.subNodes[i];
	if(block==NULL) continue;

	//Check what kind of block it is, only category at the moment.
	if(block->name=="category" && block->value.size()>0){
	string type=block->value[0];

	//Now loop the entries(subNodes) of the block.
	for(unsigned int i=0;i<block->subNodes.size();i++){
	TreeStorageNode* entry=block->subNodes[i];
	if(entry==NULL) continue;
	if(entry->name=="entry" && entry->value.size()==1){
	//The entry is valid so create a new Addon.
	Addon addon;
	- addon.icon=addon.screenshot=NULL;
	+ addon.icon=nullptr;
	+ addon.screenshot=nullptr;
	addon.type=type;
	addon.name=entry->value[0];

	if(!entry->attributes["file"].empty())
	addon.file=entry->attributes["file"][0];
	if(!entry->attributes["author"].empty())
	addon.author=entry->attributes["author"][0];
	if(!entry->attributes["description"].empty())
	addon.description=entry->attributes["description"][0];
	if(entry->attributes["icon"].size()>1){
	//There are (at least) two values, the url to the icon and its md5sum used for caching.
	- addon.icon=loadCachedImage(entry->attributes["icon"][0].c_str(),entry->attributes["icon"][1].c_str());
	- if(addon.icon)
	- SDL_SetAlpha(addon.icon,0,0);
	+ addon.icon=loadCachedImage(
	+ entry->attributes["icon"][0].c_str(),
	+ entry->attributes["icon"][1].c_str(),
	+ renderer,
	+ imageManager
	+ );
	+ if(addon.icon) {
	+ //SDL_SetSurfaceAlphaMod(addon.icon,0);
	+ SDL_SetTextureAlphaMod(addon.icon.get(), 0);
	+ }
	}
	if(entry->attributes["screenshot"].size()>1){
	//There are (at least) two values, the url to the screenshot and its md5sum used for caching.
	- addon.screenshot=loadCachedImage(entry->attributes["screenshot"][0].c_str(),entry->attributes["screenshot"][1].c_str());
	- if(addon.screenshot)
	- SDL_SetAlpha(addon.screenshot,0,0);
	+ addon.screenshot=loadCachedImage(
	+ entry->attributes["screenshot"][0].c_str(),
	+ entry->attributes["screenshot"][1].c_str(),
	+ renderer,
	+ imageManager
	+ );
	+ if(addon.screenshot) {
	+ //SDL_SetSurfaceAlphaMod(addon.screenshot,0);
	+ SDL_SetTextureAlphaMod(addon.icon.get(), 0);
	+ }
	}
	if(!entry->attributes["version"].empty())
	addon.version=atoi(entry->attributes["version"][0].c_str());
	addon.upToDate=false;
	addon.installed=false;

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

	//Read the dependencies and content from the file.
	for(unsigned int j=0;j<installed->subNodes.size();j++){
	if(installed->subNodes[j]->name=="content"){
	TreeStorageNode* obj=installed->subNodes[j];
	for(unsigned int k=0;k<obj->subNodes.size();k++){
	if(obj->subNodes[k]->value.size()==1)
	addon.content.push_back(pair<string,string>(obj->subNodes[k]->name,obj->subNodes[k]->value[0]));
	}
	}else if(installed->subNodes[j]->name=="dependencies"){
	TreeStorageNode* obj=installed->subNodes[j];
	for(unsigned int k=0;k<obj->subNodes.size();k++){
	if(obj->subNodes[k]->value.size()==1)
	addon.dependencies.push_back(pair<string,string>(obj->subNodes[k]->name,obj->subNodes[k]->value[0]));
	}
	}
	}
	}
	}
	}

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

	-void Addons::addonsToList(const std::string &type){
	+void Addons::addonsToList(const std::string &type, SDL_Renderer& renderer, ImageManager& imageManager){
	//Clear the list.
	list->clearItems();
	//Loop through the addons.
	for(unsigned int i=0;i<addons.size();i++) {
	//Make sure the addon is of the requested type.
	if(addons[i].type!=type)
	continue;

	- Addon addon=addons[i];
	+ const Addon& addon=addons[i];

	string entry=addon.name+" by "+addon.author;
	if(addon.installed){
	if(addon.upToDate){
	entry+=" *";
	}else{
	entry+=" +";
	}
	}

	- SDL_Surface* surf=SDL_CreateRGBSurface(SDL_SWSURFACE,list->width,74,32,RMASK,GMASK,BMASK,AMASK);
	+ //SDL_Surface* surf=SDL_CreateRGBSurface(SDL_SWSURFACE,list->width,74,32,RMASK,GMASK,BMASK,AMASK);
	+ SurfacePtr surf = createSurface(list->width,74);

	//Check if there's an icon for the addon.
	if(addon.icon){
	- applySurface(5,5,addon.icon,surf,NULL);
	+ //applySurface(5,5,addon.icon,surf,NULL);
	+ applyTexture(5, 5, *addon.icon, renderer);
	}else{
	if(type=="levels")
	- applySurface(5,5,addonIcon[0],surf,NULL);
	+ //applySurface(5,5,addonIcon[0],surf,NULL);
	+ applyTexture(5, 5, *addonIcon[0], renderer);
	else if(type=="levelpacks")
	- applySurface(5,5,addonIcon[1],surf,NULL);
	+ //applySurface(5,5,addonIcon[1],surf,NULL);
	+ applyTexture(5, 5, *addonIcon[1], renderer);
	else
	- applySurface(5,5,addonIcon[2],surf,NULL);
	+ //applySurface(5,5,addonIcon[2],surf,NULL);
	+ applyTexture(5, 5, *addonIcon[2], renderer);
	}

	SDL_Color black={0,0,0,0};
	SDL_Surface* nameSurf=TTF_RenderUTF8_Blended(fontGUI,addon.name.c_str(),black);
	- SDL_SetAlpha(nameSurf,0,0xFF);
	- applySurface(74,-1,nameSurf,surf,NULL);
	+ SDL_SetSurfaceAlphaMod(nameSurf,0xFF);
	+ applySurface(74,-1,nameSurf,surf.get(),NULL);
	SDL_FreeSurface(nameSurf);

	/// TRANSLATORS: indicates the author of an addon.
	string authorLine = tfm::format(_("by %s"),addon.author);
	SDL_Surface* authorSurf=TTF_RenderUTF8_Blended(fontText,authorLine.c_str(),black);
	- SDL_SetAlpha(authorSurf,0,0xFF);
	- applySurface(74,43,authorSurf,surf,NULL);
	+ SDL_SetSurfaceAlphaMod(authorSurf,0xFF);
	+ applySurface(74,43,authorSurf,surf.get(),NULL);
	SDL_FreeSurface(authorSurf);

	if(addon.installed){
	if(addon.upToDate){
	SDL_Surface* infoSurf=TTF_RenderUTF8_Blended(fontText,_("Installed"),black);
	- SDL_SetAlpha(infoSurf,0,0xFF);
	- applySurface(surf->w-infoSurf->w-32,(surf->h-infoSurf->h)/2,infoSurf,surf,NULL);
	+ SDL_SetSurfaceAlphaMod(infoSurf,0xFF);
	+ applySurface(surf->w-infoSurf->w-32,(surf->h-infoSurf->h)/2,infoSurf,surf.get(),NULL);
	SDL_FreeSurface(infoSurf);
	}else{
	SDL_Surface* infoSurf=TTF_RenderUTF8_Blended(fontText,_("Updatable"),black);
	- SDL_SetAlpha(infoSurf,0,0xFF);
	- applySurface(surf->w-infoSurf->w-32,(surf->h-infoSurf->h)/2,infoSurf,surf,NULL);
	+ SDL_SetSurfaceAlphaMod(infoSurf,0xFF);
	+ applySurface(surf->w-infoSurf->w-32,(surf->h-infoSurf->h)/2,infoSurf,surf.get(),NULL);
	SDL_FreeSurface(infoSurf);
	}
	}else{
	SDL_Color grey={127,127,127};
	SDL_Surface* infoSurf=TTF_RenderUTF8_Blended(fontText,_("Not installed"),grey);
	- SDL_SetAlpha(infoSurf,0,0xFF);
	- applySurface(surf->w-infoSurf->w-32,(surf->h-infoSurf->h)/2,infoSurf,surf,NULL);
	+ SDL_SetSurfaceAlphaMod(infoSurf,0xFF);
	+ applySurface(surf->w-infoSurf->w-32,(surf->h-infoSurf->h)/2,infoSurf,surf.get(),NULL);
	SDL_FreeSurface(infoSurf);
	}

	- list->addItem(entry,surf);
	+ list->addItem(renderer,entry,textureFromSurface(renderer,std::move(surf)));
	}
	}

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

	TreeStorageNode installed;

	//Loop through all the addons.
	vector<Addon>::iterator it;
	for(it=addons.begin();it!=addons.end();++it){
	//Check if the level is installed or not.
	if(it->installed) {
	TreeStorageNode *entry=new TreeStorageNode;
	entry->name="entry";
	entry->value.push_back(it->type);
	entry->value.push_back(it->name);
	char version[64];
	sprintf(version,"%d",it->installedVersion);
	entry->value.push_back(version);

	//Now add a subNode for each content.
	TreeStorageNode* content=new TreeStorageNode;
	content->name="content";
	for(unsigned int i=0;i<it->content.size();i++){
	TreeStorageNode* contentEntry=new TreeStorageNode;
	contentEntry->name=it->content[i].first;
	contentEntry->value.push_back(it->content[i].second);

	//Add the content node to the entry node.
	content->subNodes.push_back(contentEntry);
	}
	entry->subNodes.push_back(content);

	//Now add a sub node for the dependencies.
	TreeStorageNode* deps=new TreeStorageNode;
	deps->name="dependencies";
	for(unsigned int i=0;i<it->dependencies.size();i++){
	TreeStorageNode* depsEntry=new TreeStorageNode;
	depsEntry->name=it->dependencies[i].first;
	depsEntry->value.push_back(it->dependencies[i].second);

	//Add the content node to the entry node.
	deps->subNodes.push_back(depsEntry);
	}
	entry->subNodes.push_back(deps);

	//And add the entry to the top node.
	installed.subNodes.push_back(entry);
	}
	}

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

	return true;
	}

	-SDL_Surface* Addons::loadCachedImage(const char* url,const char* md5sum){
	+SharedTexture Addons::loadCachedImage(const char* url,const char* md5sum,
	+ SDL_Renderer& renderer, ImageManager& imageManager){
	//Check if the image is cached.
	string imageFile=getUserPath(USER_CACHE)+"images/"+md5sum;
	if(fileExists(imageFile.c_str())){
	//It is, so load the image.
	- return loadImage(imageFile);
	+ return imageManager.loadTexture(imageFile, renderer);//loadImage(imageFile);
	}else{
	//Download the image.
	FILE* file=fopen(imageFile.c_str(),"wb");

	//Downloading failed.
	if(!downloadFile(url,file)){
	cerr<<"ERROR: Unable to download image from "<<url<<endl;
	fclose(file);
	return NULL;
	}
	fclose(file);

	//Load the image.
	- return loadImage(imageFile);
	+ return imageManager.loadTexture(imageFile, renderer);//loadImage(imageFile);
	}
	}

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

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

	-void Addons::logic(){}
	+void Addons::logic(ImageManager&, SDL_Renderer&){}

	-void Addons::render(){
	+void Addons::render(ImageManager&, SDL_Renderer& renderer){
	//Draw background.
	- objThemes.getBackground(true)->draw(screen);
	+ objThemes.getBackground(true)->draw(renderer);

	//Draw the title.
	- applySurface((SCREEN_WIDTH-title->w)/2,40-TITLE_FONT_RAISE,title,screen,NULL);
	+ drawTitleTexture(SCREEN_WIDTH, *title, renderer);
	}

	-void Addons::resize(){
	+void Addons::resize(ImageManager& imageManager, SDL_Renderer& renderer){
	//Delete the gui (if any).
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//Now create a new one.
	- createGUI();
	+ createGUI(renderer, imageManager);
	}

	-void Addons::showAddon(){
	+void Addons::showAddon(ImageManager& imageManager, SDL_Renderer& renderer){
	//Make sure an addon is selected.
	if(!selected)
	return;

	//Create a root object.
	- GUIObject* root=new GUIFrame((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-400)/2,600,400,selected->name.c_str());
	+ GUIObject* root=new GUIFrame(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-400)/2,600,400,selected->name.c_str());

	//Create the 'by creator' label.
	- GUIObject* obj=new GUILabel(0,50,600,50,tfm::format(_("by %s"),selected->author).c_str(),0,true,true,GUIGravityCenter);
	+ GUIObject* obj=new GUILabel(imageManager,renderer,0,50,600,50,tfm::format(_("by %s"),selected->author).c_str(),0,true,true,GUIGravityCenter);
	root->addChild(obj);

	//Create the description text.
	- GUITextArea* description=new GUITextArea(10,100,370,200);
	- description->setString(selected->description.c_str());
	+ GUITextArea* description=new GUITextArea(imageManager,renderer,10,100,370,200);
	+ description->setString(renderer, selected->description.c_str());
	description->editable=false;
	description->resize();
	root->addChild(description);

	- //Create the screenshot image.
	- GUIImage* img=new GUIImage(390,100,200,150);
	- img->setImage(selected->screenshot?selected->screenshot:screenshot);
	+ //Create the screenshot image. (If a screenshot is missing, we use the default screenshot.)
	+ GUIImage* img=new GUIImage(imageManager,renderer,390,100,200,150,selected->screenshot?selected->screenshot:screenshot);
	+ // TODO FIX THIS
	+ std::cout << "STUB!" << __LINE__ << " " << __FILE__ << std::endl;
	+ //img->setImage(selected->screenshot?selected->screenshot:screenshot);
	root->addChild(img);

	//Add buttons depending on the installed/update status.
	if(selected->installed && !selected->upToDate){
	- GUIObject* bRemove=new GUIButton(root->width*0.97,350,-1,32,_("Remove"),0,true,true,GUIGravityRight);
	+ GUIObject* bRemove=new GUIButton(imageManager,renderer,root->width*0.97,350,-1,32,_("Remove"),0,true,true,GUIGravityRight);
	bRemove->name="cmdRemove";
	bRemove->eventCallback=this;
	root->addChild(bRemove);
	//Create a back button.
	- GUIObject* bBack=new GUIButton(root->width*0.03,350,-1,32,_("Back"),0,true,true,GUIGravityLeft);
	+ GUIObject* bBack=new GUIButton(imageManager,renderer,root->width*0.03,350,-1,32,_("Back"),0,true,true,GUIGravityLeft);
	bBack->name="cmdCloseOverlay";
	bBack->eventCallback=this;
	root->addChild(bBack);

	//Update widget sizes.
	- root->render(0,0,false);
	+ root->render(renderer, 0,0,false);

	//Create a nicely centered button.
	- obj=new GUIButton((int)floor((bBack->left+bBack->width+bRemove->left-bRemove->width)*0.5),350,-1,32,_("Update"),0,true,true,GUIGravityCenter);
	+ obj=new GUIButton(imageManager,renderer,(int)floor((bBack->left+bBack->width+bRemove->left-bRemove->width)*0.5),350,-1,32,_("Update"),0,true,true,GUIGravityCenter);
	obj->name="cmdUpdate";
	obj->eventCallback=this;
	root->addChild(obj);
	}else{
	if(!selected->installed){
	- obj=new GUIButton(root->width*0.9,350,-1,32,_("Install"),0,true,true,GUIGravityRight);
	+ obj=new GUIButton(imageManager,renderer,root->width*0.9,350,-1,32,_("Install"),0,true,true,GUIGravityRight);
	obj->name="cmdInstall";
	obj->eventCallback=this;
	root->addChild(obj);
	}else if(selected->upToDate){
	- obj=new GUIButton(root->width*0.9,350,-1,32,_("Remove"),0,true,true,GUIGravityRight);
	+ obj=new GUIButton(imageManager,renderer,root->width*0.9,350,-1,32,_("Remove"),0,true,true,GUIGravityRight);
	obj->name="cmdRemove";
	obj->eventCallback=this;
	root->addChild(obj);
	}
	//Create a back button.
	- obj=new GUIButton(root->width*0.1,350,-1,32,_("Back"),0,true,true,GUIGravityLeft);
	+ obj=new GUIButton(imageManager,renderer,root->width*0.1,350,-1,32,_("Back"),0,true,true,GUIGravityLeft);
	obj->name="cmdCloseOverlay";
	obj->eventCallback=this;
	root->addChild(obj);
	}

	- new GUIOverlay(root);
	+ new GUIOverlay(renderer, root);
	}

	-void Addons::GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	- if(name=="lstTabs"){
	+void Addons::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	+ if(name=="lstTabs"){
	//Get the category type.
	type=categoryList->getName();
	//Get the list corresponding with the category and select the first entry.
	- addonsToList(type);
	+ addonsToList(type, renderer, imageManager);
	list->value=0;
	//Call an event as if an entry in the addons listbox was clicked.
	- GUIEventCallback_OnEvent("lstAddons",list,GUIEventChange);
	+ GUIEventCallback_OnEvent(imageManager, renderer, "lstAddons",list,GUIEventChange);
	}else if(name=="lstAddons"){
	//Check which type of event.
	if(eventType==GUIEventChange){
	//Get the addon struct that belongs to it.
	Addon* addon=NULL;

	//Make sure the addon list on screen isn't empty.
	if(!list->item.empty()){
	//Get the name of the (newly) selected entry.
	string entry=list->getItem(list->value);

	//Loop through the addons of the selected category.
	for(unsigned int i=0;i<addons.size();i++){
	//Make sure the addons are of the same type.
	if(addons[i].type!=categoryList->getName())
	continue;

	string prefix=addons[i].name;
	if(!entry.compare(0,prefix.size(),prefix)){
	addon=&addons[i];
	}
	}
	}

	//Set the new addon as selected and unselect the list.
	selected=addon;
	list->value=-1;
	}else if(eventType==GUIEventClick){
	//Make sure an addon is selected.
	if(selected){
	- showAddon();
	+ showAddon(imageManager,renderer);
	}
	}
	}else if(name=="cmdBack"){
	saveInstalledAddons();
	setNextState(STATE_MENU);
	}else if(name=="cmdCloseOverlay"){
	//We can safely delete the GUIObjectRoot, since it's handled by the GUIOverlay.
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}else if(name=="cmdUpdate"){
	//NOTE: This simply removes the addon and reinstalls it.
	//The complete addon is downloaded either way so no need for checking what has been changed/added/removed/etc...
	if(selected){
	- removeAddon(selected);
	- installAddon(selected);
	+ removeAddon(imageManager,renderer,selected);
	+ installAddon(imageManager,renderer,selected);
	}
	- addonsToList(categoryList->getName());
	+ addonsToList(categoryList->getName(), renderer, imageManager);
	}else if(name=="cmdInstall"){
	if(selected)
	- installAddon(selected);
	- addonsToList(categoryList->getName());
	+ installAddon(imageManager,renderer,selected);
	+ addonsToList(categoryList->getName(), renderer, imageManager);
	}else if(name=="cmdRemove"){
	//TODO: Check for dependencies.
	//Loop through the addons to check if this addon is a dependency of another addon.
	vector<Addon>::iterator it;
	for(it=addons.begin();it!=addons.end();++it){
	//Check if the addon has dependencies.
	if(!it->dependencies.empty()){
	vector<pair<string,string> >::iterator depIt;
	for(depIt=it->dependencies.begin();depIt!=it->dependencies.end();++depIt){
	if(depIt->first=="addon" && depIt->second==selected->name){
	- msgBox("This addon can't be removed because it's needed by "+it->name,MsgBoxOKOnly,"Dependency");
	+ msgBox(imageManager,renderer,"This addon can't be removed because it's needed by "+it->name,MsgBoxOKOnly,"Dependency");
	return;
	}
	}
	}
	}

	if(selected)
	- removeAddon(selected);
	- addonsToList(categoryList->getName());
	+ removeAddon(imageManager,renderer,selected);
	+ addonsToList(categoryList->getName(), renderer, imageManager);
	}

	//NOTE: In case of install/remove/update we can delete the GUIObjectRoot, since it's managed by the GUIOverlay.
	if(name=="cmdUpdate" \|\| name=="cmdInstall" \|\| name=="cmdRemove"){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}

	-void Addons::removeAddon(Addon* addon){
	+void Addons::removeAddon(ImageManager& imageManager,SDL_Renderer& renderer, Addon* addon){
	//To remove an addon we loop over the content vector in the structure.
	//NOTE: This should contain all INSTALLED content, if something failed during installation it isn't added.
	for(unsigned int i=0;i<addon->content.size();i++){
	//Check the type of content.
	if(addon->content[i].first=="file"){
	string file=getUserPath(USER_DATA)+addon->content[i].second;
	//Check if the file exists.
	if(!fileExists(file.c_str())){
	cerr<<"WARNING: File '"<<file<<"' appears to have been removed already."<<endl;
	- msgBox("WARNING: File '"+file+"' appears to have been removed already.",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"WARNING: File '"+file+"' appears to have been removed already.",MsgBoxOKOnly,"Addon error");
	continue;
	}

	//Remove the file.
	if(!removeFile(file.c_str())){
	cerr<<"ERROR: Unable to remove file '"<<file<<"'!"<<endl;
	- msgBox("ERROR: Unable to remove file '"+file+"'!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"ERROR: Unable to remove file '"+file+"'!",MsgBoxOKOnly,"Addon error");
	continue;
	}
	}else if(addon->content[i].first=="folder"){
	string dir=getUserPath(USER_DATA)+addon->content[i].second;
	//Check if the directory exists.
	if(!dirExists(dir.c_str())){
	cerr<<"WARNING: Directory '"<<dir<<"' appears to have been removed already."<<endl;
	- msgBox("WARNING: Directory '"+dir+"' appears to have been removed already.",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"WARNING: Directory '"+dir+"' appears to have been removed already.",MsgBoxOKOnly,"Addon error");
	continue;
	}

	//Remove the directory.
	if(!removeDirectory(dir.c_str())){
	cerr<<"ERROR: Unable to remove directory '"<<dir<<"'!"<<endl;
	- msgBox("ERROR: Unable to remove directory '"+dir+"'!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"ERROR: Unable to remove directory '"+dir+"'!",MsgBoxOKOnly,"Addon error");
	continue;
	}
	}else if(addon->content[i].first=="level"){
	string file=getUserPath(USER_DATA)+"levels/"+addon->content[i].second;

	//Check if the level file exists.
	if(!fileExists(file.c_str())){
	cerr<<"WARNING: Level '"<<file<<"' appears to have been removed already."<<endl;
	- msgBox("WARNING: Level '"+file+"' appears to have been removed already.",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"WARNING: Level '"+file+"' appears to have been removed already.",MsgBoxOKOnly,"Addon error");
	continue;
	}
	//Remove the level file.
	if(!removeFile(file.c_str())){
	cerr<<"ERROR: Unable to remove level '"<<file<<"'!"<<endl;
	- msgBox("ERROR: Unable to remove level '"+file+"'!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"ERROR: Unable to remove level '"+file+"'!",MsgBoxOKOnly,"Addon error");
	continue;
	}
	//Also remove the level from the Levels levelpack.
	LevelPack* levelsPack=getLevelPackManager()->getLevelPack("Levels/");

	for(int i=0;i<levelsPack->getLevelCount();i++){
	if(levelsPack->getLevelFile(i)==file){
	//Remove the level and break out of the loop.
	levelsPack->removeLevel(i);
	break;
	}
	}
	}else if(addon->content[i].first=="levelpack"){
	//FIXME: We assume no trailing slash since there mustn't be one for installing, bad :(
	string dir=getUserPath(USER_DATA)+"levelpacks/"+addon->content[i].second+"/";
	//Check if the directory exists.
	if(!dirExists(dir.c_str())){
	cerr<<"WARNING: Levelpack directory '"<<dir<<"' appears to have been removed already."<<endl;
	- msgBox("WARNING: Levelpack directory '"+dir+"' appears to have been removed already.",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"WARNING: Levelpack directory '"+dir+"' appears to have been removed already.",MsgBoxOKOnly,"Addon error");
	continue;
	}

	//Remove the directory.
	if(!removeDirectory(dir.c_str())){
	cerr<<"ERROR: Unable to remove levelpack directory '"<<dir<<"'!"<<endl;
	- msgBox("ERROR: Unable to remove levelpack directory '"+dir+"'!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"ERROR: Unable to remove levelpack directory '"+dir+"'!",MsgBoxOKOnly,"Addon error");
	continue;
	}

	//Also remove the levelpack from the levelpackManager.
	getLevelPackManager()->removeLevelPack(dir);
	}
	}

	//Now that the content has been removed clear the content list itself.
	addon->content.clear();
	//And finally set the addon to not installed.
	addon->installed=false;
	addon->installedVersion=0;

	//Also clear the 'offline' information.
	addon->content.clear();
	addon->dependencies.clear();
	}

	-void Addons::installAddon(Addon* addon){
	+void Addons::installAddon(ImageManager& imageManager,SDL_Renderer& renderer, Addon* addon){
	string tmpDir=getUserPath(USER_CACHE)+"tmp/";
	string fileName=fileNameFromPath(addon->file,true);

	//Download the selected addon to the tmp folder.
	if(!downloadFile(addon->file,tmpDir)){
	cerr<<"ERROR: Unable to download addon file "<<addon->file<<endl;
	- msgBox("ERROR: Unable to download addon file "+addon->file,MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"ERROR: Unable to download addon file "+addon->file,MsgBoxOKOnly,"Addon error");
	return;
	}

	//Now extract the addon.
	if(!extractFile(tmpDir+fileName,tmpDir+"/addon/")){
	cerr<<"ERROR: Unable to extract addon file "<<addon->file<<endl;
	- msgBox("ERROR: Unable to extract addon file "+addon->file,MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"ERROR: Unable to extract addon file "+addon->file,MsgBoxOKOnly,"Addon error");
	return;
	}

	ifstream metadata((tmpDir+"/addon/metadata").c_str());
	if(!metadata){
	cerr<<"ERROR: Addon is missing metadata!"<<endl;
	- msgBox("ERROR: Addon is missing metadata!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"ERROR: Addon is missing metadata!",MsgBoxOKOnly,"Addon error");
	return;
	}

	//Read the metadata from the addon.
	TreeStorageNode obj;
	{
	POASerializer objSerializer;
	if(!objSerializer.readNode(metadata,&obj,true)){
	//NOTE: We keep the console output English so we put the string literal here twice.
	cerr<<"ERROR: Invalid file format for metadata file!"<<endl;
	- msgBox("ERROR: Invalid file format for metadata file!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"ERROR: Invalid file format for metadata file!",MsgBoxOKOnly,"Addon error");
	return;
	}
	}

	//Loop through the subNodes.
	for(unsigned int i=0;i<obj.subNodes.size();i++){
	//Check for the content subNode (there should only be one).
	if(obj.subNodes[i]->name=="content"){
	TreeStorageNode* obj1=obj.subNodes[i];

	//Loop through the subNodes of that.
	for(unsigned int j=0;j<obj1->subNodes.size();j++){
	TreeStorageNode* obj2=obj1->subNodes[j];

	//This code happens for all types of content.
	string source=tmpDir+"addon/content/";
	if(obj2->value.size()>0)
	source+=obj2->value[0];
	//The destination MUST be in the user data path.
	string dest=getUserPath(USER_DATA);
	if(obj2->value.size()>1)
	dest+=obj2->value[1];

	//Check what the content type is.
	if(obj2->name=="file" && obj2->value.size()==2){
	//Now copy the file.
	if(fileExists(dest.c_str())){
	cerr<<"WARNING: File '"<<dest<<"' already exists, addon may be broken or not working!"<<endl;
	- msgBox("WARNING: File '"+dest+"' already exists, addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"WARNING: File '"+dest+"' already exists, addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	continue;
	}
	if(!copyFile(source.c_str(),dest.c_str())){
	cerr<<"WARNING: Unable to copy file '"<<source<<"' to '"<<dest<<"', addon may be broken or not working!"<<endl;
	- msgBox("WARNING: Unable to copy file '"+source+"' to '"+dest+"', addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"WARNING: Unable to copy file '"+source+"' to '"+dest+"', addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	continue;
	}

	//Add it to the content vector.
	addon->content.push_back(pair<string,string>("file",obj2->value[1]));
	}else if(obj2->name=="folder" && obj2->value.size()==2){
	//The dest must NOT exist, otherwise it will fail.
	if(dirExists(dest.c_str())){
	cerr<<"WARNING: Destination directory '"<<dest<<"' already exists, addon may be broken or not working!"<<endl;
	- msgBox("WARNING: Destination directory '"+dest+"' already exists, addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"WARNING: Destination directory '"+dest+"' already exists, addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	continue;
	}
	//FIXME: Copy the directory instead of renaming it, in case the same folder/parts of the folder are needed in different places.
	if(!renameDirectory(source.c_str(),dest.c_str())){
	cerr<<"WARNING: Unable to move directory '"<<source<<"' to '"<<dest<<"', addon may be broken or not working!"<<endl;
	- msgBox("WARNING: Unable to move directory '"+source+"' to '"+dest+"', addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"WARNING: Unable to move directory '"+source+"' to '"+dest+"', addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	continue;
	}

	//Add it to the content vector.
	addon->content.push_back(pair<string,string>("folder",obj2->value[1]));
	}else if(obj2->name=="level" && obj2->value.size()==1){
	//The destination MUST be in the levels folder in the user data path.
	dest+="levels/"+fileNameFromPath(source);

	//Now copy the file.
	if(fileExists(dest.c_str())){
	cerr<<"WARNING: Level '"<<dest<<"' already exists, addon may be broken or not working!"<<endl;
	- msgBox("WARNING: Level '"+dest+"' already exists, addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"WARNING: Level '"+dest+"' already exists, addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	continue;
	}
	if(!copyFile(source.c_str(),dest.c_str())){
	cerr<<"WARNING: Unable to copy level '"<<source<<"' to '"<<dest<<"', addon may be broken or not working!"<<endl;
	- msgBox("WARNING: Unable to copy level '"+source+"' to '"+dest+"', addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"WARNING: Unable to copy level '"+source+"' to '"+dest+"', addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	continue;
	}

	//It's a level so add it to the Levels levelpack.
	LevelPack* levelsPack=getLevelPackManager()->getLevelPack("Levels/");
	if(levelsPack){
	levelsPack->addLevel(dest);
	levelsPack->setLocked(levelsPack->getLevelCount()-1);
	}else{
	cerr<<"ERROR: Unable to add level to Levels levelpack"<<endl;
	}
	addon->content.push_back(pair<string,string>("level",fileNameFromPath(source)));
	}else if(obj2->name=="levelpack" && obj2->value.size()==1){
	//TODO: Check if the source contains a trailing slash.

	//The destination MUST be in the user data path.
	dest+="levelpacks/"+fileNameFromPath(source);

	//The dest must NOT exist, otherwise it will fail.
	if(dirExists(dest.c_str())){
	cerr<<"WARNING: Levelpack directory '"<<dest<<"' already exists, addon may be broken or not working!"<<endl;
	- msgBox("WARNING: Levelpack directory '"+dest+"' already exists, addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"WARNING: Levelpack directory '"+dest+"' already exists, addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	continue;
	}
	//FIXME: Copy the directory instead of renaming it, in case the same folder/parts of the folder are needed in different places.
	if(!renameDirectory(source.c_str(),dest.c_str())){
	cerr<<"WARNING: Unable to move directory '"<<source<<"' to '"<<dest<<"', addon may be broken or not working!"<<endl;
	- msgBox("WARNING: Unable to move directory '"+source+"' to '"+dest+"', addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"WARNING: Unable to move directory '"+source+"' to '"+dest+"', addon may be broken or not working!",MsgBoxOKOnly,"Addon error");
	continue;
	}

	//It's a levelpack so add it to the levelpack manager.
	getLevelPackManager()->loadLevelPack(dest);
	addon->content.push_back(pair<string,string>("levelpack",fileNameFromPath(source)));
	}
	}
	}else if(obj.subNodes[i]->name=="dependencies"){
	TreeStorageNode* obj1=obj.subNodes[i];

	//Loop through the subNodes of that.
	for(unsigned int j=0;j<obj1->subNodes.size();j++){
	TreeStorageNode* obj2=obj1->subNodes[j];

	if(obj2->name=="addon" && obj2->value.size()>0){
	Addon* dep=NULL;

	//Check if the requested addon can be found.
	vector<Addon>::iterator it;
	for(it=addons.begin();it!=addons.end();++it){
	if(it->name==obj2->value[0]){
	dep=&(*it);
	break;
	}
	}

	if(!dep){
	cerr<<"ERROR: Addon requires another addon ("<<obj2->value[0]<<") which can't be found!"<<endl;
	- msgBox("ERROR: Addon requires another addon ("+obj2->value[0]+") which can't be found!",MsgBoxOKOnly,"Addon error");
	+ msgBox(imageManager,renderer,"ERROR: Addon requires another addon ("+obj2->value[0]+") which can't be found!",MsgBoxOKOnly,"Addon error");
	continue;
	}

	//The addon has been found, try to install it.
	//FIXME: Somehow prevent recursion, maybe max depth (??)
	if(!dep->installed){
	- msgBox("The addon "+dep->name+" is needed and will be installed now.",MsgBoxOKOnly,"Dependency");
	- installAddon(dep);
	+ msgBox(imageManager,renderer,"The addon "+dep->name+" is needed and will be installed now.",MsgBoxOKOnly,"Dependency");
	+ installAddon(imageManager,renderer, dep);
	}

	//Add the dependency to the addon.
	addon->dependencies.push_back(pair<string,string>("addon",dep->name));
	}
	}
	}
	}

	//The addon is installed and up to date, but not necessarily flawless.
	addon->installed=true;
	addon->upToDate=true;
	addon->installedVersion=addon->version;
	}
	diff --git a/src/Addons.h b/src/Addons.h
	index c61a386..9001383 100644
	--- a/src/Addons.h
	+++ b/src/Addons.h
	@@ -1,164 +1,166 @@
	/*
	* 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 <vector>
	#include <string>
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_mixer.h>
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_mixer.h>
	+#include <SDL2/SDL_ttf.h>
	#endif

	//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.
	- SDL_Surface* icon;
	+ SharedTexture icon;
	//Screenshot for the addon.
	- SDL_Surface* screenshot;
	+ 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.
	- SDL_Surface* title;
	+ TexturePtr title;

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

	//Placeholder screenshot for addons in case they don't provide one.
	- SDL_Surface* screenshot;
	-
	+ 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();
	+ Addons(SDL_Renderer& renderer, ImageManager& imageManager);
	//Destructor.
	~Addons();

	//Method that will create the GUI.
	- void createGUI();
	+ 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);
	+ bool getAddonsList(FILE* file, SDL_Renderer& renderer, ImageManager& imageManager);
	//
	- void fillAddonList(TreeStorageNode &objAddons,TreeStorageNode &objInstalledAddons);
	+ 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);
	+ void addonsToList(const string &type, SDL_Renderer &renderer, ImageManager &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: Pointer to the SDL_Surface.
	- SDL_Surface* loadCachedImage(const char* url,const char* md5sum);
	+ //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();
	+ void showAddon(ImageManager& imageManager,SDL_Renderer& renderer);

	- //Inherited from GameState.
	- void handleEvents();
	- void logic();
	- void render();
	- void resize();
	+ //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(std::string name,GUIObject* obj,int eventType);
	+ 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(Addon* addon);
	+ 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(Addon* addon);
	+ void installAddon(ImageManager& imageManager, SDL_Renderer &renderer, Addon* addon);

	};
	#endif
	diff --git a/src/Block.cpp b/src/Block.cpp
	index b6c0d5c..0f9bb2b 100644
	--- a/src/Block.cpp
	+++ b/src/Block.cpp
	@@ -1,1133 +1,1138 @@
	/*
	* 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 "GameObjects.h"
	#include "Game.h"
	#include "Player.h"
	#include "Block.h"
	#include "Functions.h"
	#include "Globals.h"
	+#include "LevelEditor.h"
	+
	#include <iostream>
	#include <stdlib.h>
	#include <stdio.h>
	using namespace std;

	Block::Block(Game* parent,int x,int y,int w,int h,int type):
	GameObject(parent),
	animation(0),
	animationSave(0),
	flags(0),
	flagsSave(0),
	temp(0),
	tempSave(0),
	dx(0),
	dxSave(0),
	dy(0),
	dySave(0),
	loop(true),
	speed(0),
	speedSave(0),
	editorSpeed(0),
	editorFlags(0),
	enabled(true),
	enabledSave(true)
	{
	//Make sure the type is set, if not init should be called somewhere else with this information.
	if(type>=0 && type<TYPE_MAX)
	init(x,y,w,h,type);
	}

	Block::~Block(){}

	void Block::init(int x,int y,int w,int h,int type){
	//First set the location and size of the box.
	//The default size is 50x50.
	box.x=boxBase.x=x;
	box.y=boxBase.y=y;
	box.w=boxBase.w=w;
	box.h=boxBase.h=h;

	//Set the save values.
	boxSave.x=x;
	boxSave.y=y;
	boxSave.w=w;
	boxSave.h=h;

	//Set the type.
	this->type=type;

	//Some types need type specific code.
	if(type==TYPE_START_PLAYER){
	//This is the player start so set the player here.
	//We center the player, the player is 23px wide.
	parent->player.setLocation(box.x+(box.w-23)/2,box.y);
	parent->player.fx=box.x+(box.w-23)/2;
	parent->player.fy=box.y;
	}else if(type==TYPE_START_SHADOW){
	//This is the shadow start so set the shadow here.
	//We center the shadow, the shadow is 23px wide.
	parent->shadow.setLocation(box.x+(box.w-23)/2,box.y);
	parent->shadow.fx=box.x+(box.w-23)/2;
	parent->shadow.fy=box.y;
	}

	objCurrentStand=NULL;
	inAir=inAirSave=true;
	xVel=yVel=xVelBase=yVelBase=0;
	xVelSave=yVelSave=xVelBaseSave=yVelBaseSave=0;

	//And load the appearance.
	objThemes.getBlock(type)->createInstance(&appearance);
	}

	-void Block::show(){
	+void Block::show(SDL_Renderer& renderer){
	//Make sure we are enabled.
	if(!enabled)
	return;

	//Check if the block is visible.
	if(checkCollision(camera,box)==true \|\| (stateID==STATE_LEVEL_EDITOR && checkCollision(camera,boxBase)==true)){
	SDL_Rect r={0,0,box.w,box.h};

	//What we need to draw depends on the type of block.
	switch(type){
	case TYPE_CHECKPOINT:
	//Check if the checkpoint is last used.
	if(parent!=NULL && parent->objLastCheckPoint==this){
	if(!temp) appearance.changeState("activated");
	temp=1;
	}else{
	if(temp) appearance.changeState("default");
	temp=0;
	}
	break;
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	if(animation){
	- appearance.draw(screen,box.x-camera.x-box.w+animation,box.y-camera.y,box.w*2-animation,box.h,&r);
	+ appearance.draw(renderer,box.x-camera.x-box.w+animation,box.y-camera.y,box.w*2-animation,box.h,&r);
	return;
	}
	break;
	case TYPE_NOTIFICATION_BLOCK:
	if(message.empty()==false){
	- appearance.draw(screen, box.x - camera.x, box.y - camera.y);
	+ appearance.draw(renderer, box.x - camera.x, box.y - camera.y);
	return;
	}
	break;
	}

	//Always draw the base.
	- appearance.drawState("base", screen, boxBase.x - camera.x, boxBase.y - camera.y, boxBase.w, boxBase.h);
	+ appearance.drawState("base", renderer, boxBase.x - camera.x, boxBase.y - camera.y, boxBase.w, boxBase.h);
	//Now draw normal.
	- appearance.draw(screen, box.x - camera.x, box.y - camera.y, box.w, box.h);
	+ appearance.draw(renderer, box.x - camera.x, box.y - camera.y, box.w, box.h);

	//Some types need to draw something on top of the base/default.
	switch(type){
	case TYPE_BUTTON:
	if(flags&4){
	if(animation<5) animation++;
	}else{
	if(animation>0) animation--;
	}
	- appearance.drawState("button",screen,box.x-camera.x,box.y-camera.y-5+animation);
	+ appearance.drawState("button",renderer,box.x-camera.x,box.y-camera.y-5+animation);
	break;
	}

	//Draw a stupid icon for scrpited blocks in edit mode.
	if(stateID==STATE_LEVEL_EDITOR && !scripts.empty()){
	- static SDL_Surface *bmGUI=NULL;
	- if(bmGUI==NULL) bmGUI=loadImage(getDataPath()+"gfx/gui.png");
	- static SDL_Rect r={0,32,16,16};
	- applySurface(box.x - camera.x + 2, box.y - camera.y + 2, bmGUI, screen, &r);
	+ auto bmGUI = static_cast<LevelEditor*>(parent)->getGuiTexture();
	+ if(!bmGUI) {
	+ return;
	+ }
	+ const SDL_Rect r={0,32,16,16};
	+ const SDL_Rect dstRect={box.x - camera.x + 2,box.y - camera.y + 2,16,16};
	+ SDL_RenderCopy(&renderer, bmGUI.get(), &r, &dstRect);
	}
	}
	}

	SDL_Rect Block::getBox(int boxType){
	SDL_Rect r={0,0,0,0};
	switch(boxType){
	case BoxType_Base:
	return boxBase;
	case BoxType_Previous:
	r.x=box.x-dx;
	r.y=box.y-dy;
	r.w=box.w;
	r.h=box.h;
	return r;
	case BoxType_Delta:
	r.x=dx;
	r.y=dy;
	return r;
	case BoxType_Velocity:
	r.x=xVel;
	r.y=yVel;
	//NOTE: In case of the pushable block we sometimes need to substract one from the vertical velocity.
	//The yVel is set to one when it's resting, but should be handled as zero in collision.
	if(type==TYPE_PUSHABLE && !inAir)
	r.y=0;
	return r;
	case BoxType_Current:
	return box;
	}
	return r;
	}

	void Block::moveTo(int x,int y){
	//The block has moved so calculate the delta.
	//NOTE: Every delta is summed since they all happened within one frame and for collision/movement we need the resulting delta.
	int delta=(x-box.x);
	dx+=delta;
	xVel+=delta;
	delta=(y-box.y);
	dy+=delta;
	yVel+=delta;

	//And set the new location.
	box.x=x;
	box.y=y;
	}

	void Block::growTo(int w,int h){
	//The block has changed size
	//NOTE: Every delta is summed since they all happened within one frame and for collision/movement we need the resulting delta.
	int delta=(w-box.w);
	dx+=delta;
	xVel+=delta;
	delta=(h-box.h);
	dy+=delta;
	yVel+=delta;

	//And set the new location.
	box.w=w;
	box.h=h;
	}

	void Block::saveState(){
	animationSave=animation;
	flagsSave=flags;
	tempSave=temp;
	dxSave=dx;
	dySave=dy;
	boxSave.x=box.x-boxBase.x;
	boxSave.y=box.y-boxBase.y;
	boxSave.w=box.w-boxBase.w;
	boxSave.h=box.h-boxBase.h;
	xVelSave=xVel;
	yVelSave=yVel;
	enabledSave=enabled;
	appearance.saveAnimation();

	//In case of a certain blocks we need to save some more.
	switch(type){
	case TYPE_PUSHABLE:
	xVelBaseSave=xVelBase;
	yVelBaseSave=yVelBase;
	inAirSave=inAir;
	break;
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	speedSave=speed;
	break;
	}
	}

	void Block::loadState(){
	//Restore the flags and animation var.
	animation=animationSave;
	flags=flagsSave;
	temp=tempSave;
	dx=dxSave;
	dy=dySave;
	//Restore the location.
	box.x=boxBase.x+boxSave.x;
	box.y=boxBase.y+boxSave.y;
	box.w=boxBase.w+boxSave.w;
	box.h=boxBase.h+boxSave.h;
	//And the velocity.
	xVel=xVelSave;
	yVel=yVelSave;
	//The enabled status.
	enabled=enabledSave;

	//Handle block type specific variables.
	switch(type){
	case TYPE_PUSHABLE:
	xVelBase=xVelBaseSave;
	yVelBase=yVelBaseSave;
	inAir=inAirSave;
	break;
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	speed=speedSave;
	break;
	}

	//And load the animation.
	appearance.loadAnimation();
	}

	void Block::reset(bool save){
	//We need to reset so we clear the animation and saves.
	if(save){
	animation=animationSave=0;
	boxSave.x=boxSave.y=boxSave.w=boxSave.h=0;
	flags=flagsSave=editorFlags;
	temp=tempSave=0;
	dx=dxSave=0;
	dy=dySave=0;
	}else{
	animation=0;
	flags=editorFlags;
	temp=0;
	dx=0;
	dy=0;
	}

	//Reset the block to its original location.
	box.x=boxBase.x;
	box.y=boxBase.y;
	box.w=boxBase.w;
	box.h=boxBase.h;

	//Reset any velocity.
	xVel=yVel=xVelBase=yVelBase=0;
	if(save)
	xVelSave=yVelSave=xVelBaseSave=yVelBaseSave=0;

	//Reset the enabled status.
	enabled=true;
	if(save)
	enabledSave=true;

	//Also reset the appearance.
	appearance.resetAnimation(save);
	appearance.changeState("default");
	//NOTE: We load the animation right after changing it to prevent a transition.
	if(save)
	appearance.loadAnimation();

	//Some types of block requires type specific code.
	switch(type){
	case TYPE_FRAGILE:
	{
	const char* s=(flags==0)?"default":((flags==1)?"fragile1":((flags==2)?"fragile2":"fragile3"));
	appearance.changeState(s);
	}
	break;
	case TYPE_PUSHABLE:
	inAir=false;
	if(save)
	inAirSave=false;
	break;
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	if(save)
	speed=speedSave=editorSpeed;
	else
	speed=editorSpeed;
	break;
	}
	}


	void Block::playAnimation(){
	switch(type){
	case TYPE_SWAP:
	appearance.changeState("activated");
	break;
	case TYPE_SWITCH:
	temp^=1;
	appearance.changeState(temp?"activated":"default");
	break;
	}
	}

	void Block::onEvent(int eventType){
	//Make sure we are enabled, otherwise no events should be handled.
	if(!enabled)
	return;

	//Iterator used to check if the map contains certain entries.
	map<int,int>::iterator it;

	//Check if there's a script for the event.
	it=compiledScripts.find(eventType);
	if(it!=compiledScripts.end()){
	//There is a script so execute it and check return value.
	int ret=getScriptExecutor()->executeScript(it->second,this);

	//Return value 1 means do default event process.
	//Other values are coming soon...
	if(ret!=1) return;
	}

	//Event handling.
	switch(eventType){
	case GameObjectEvent_PlayerWalkOn:
	switch(type){
	case TYPE_FRAGILE:
	flags++;
	{
	const char* s=(flags==0)?"default":((flags==1)?"fragile1":((flags==2)?"fragile2":"fragile3"));
	appearance.changeState(s);
	}
	break;
	}
	break;
	case GameObjectEvent_PlayerIsOn:
	switch(type){
	case TYPE_BUTTON:
	temp=1;
	break;
	}
	break;
	case GameObjectEvent_OnToggle:
	switch(type){
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	flags^=1;
	break;
	case TYPE_PORTAL:
	appearance.changeState("activated");
	break;
	case TYPE_COLLECTABLE:
	appearance.changeState("inactive");
	flags=1;
	break;
	}
	break;
	case GameObjectEvent_OnSwitchOn:
	switch(type){
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	flags&=~1;
	break;
	case TYPE_EXIT:
	appearance.changeState("default");
	break;
	}
	break;
	case GameObjectEvent_OnSwitchOff:
	switch(type){
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	flags\|=1;
	break;
	case TYPE_EXIT:
	appearance.changeState("closed");
	break;
	}
	break;
	}
	}

	int Block::queryProperties(int propertyType,Player* obj){
	switch(propertyType){
	case GameObjectProperty_PlayerCanWalkOn:
	switch(type){
	case TYPE_BLOCK:
	case TYPE_MOVING_BLOCK:
	case TYPE_CONVEYOR_BELT:
	case TYPE_BUTTON:
	case TYPE_PUSHABLE:
	return 1;
	case TYPE_SHADOW_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_SHADOW_CONVEYOR_BELT:
	if(obj!=NULL && obj->isShadow()) return 1;
	break;
	case TYPE_FRAGILE:
	if(flags<3) return 1;
	break;
	}
	break;
	case GameObjectProperty_IsSpikes:
	switch(type){
	case TYPE_SPIKES:
	case TYPE_MOVING_SPIKES:
	return 1;
	}
	break;
	case GameObjectProperty_Flags:
	return flags;
	break;
	default:
	break;
	}
	return 0;
	}

	void Block::getEditorData(std::vector<std::pair<std::string,std::string> >& obj){
	//Every block has an id.
	obj.push_back(pair<string,string>("id",id));

	//Block specific properties.
	switch(type){
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	{
	char s[64],s0[64];
	sprintf(s,"%d",(int)movingPos.size());
	obj.push_back(pair<string,string>("MovingPosCount",s));
	obj.push_back(pair<string,string>("activated",(editorFlags&0x1)?"0":"1"));
	obj.push_back(pair<string,string>("loop",loop?"1":"0"));
	for(unsigned int i=0;i<movingPos.size();i++){
	sprintf(s0+1,"%u",i);
	sprintf(s,"%d",movingPos[i].x);
	s0[0]='x';
	obj.push_back(pair<string,string>(s0,s));
	sprintf(s,"%d",movingPos[i].y);
	s0[0]='y';
	obj.push_back(pair<string,string>(s0,s));
	sprintf(s,"%d",movingPos[i].w);
	s0[0]='t';
	obj.push_back(pair<string,string>(s0,s));
	}
	}
	break;
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	{
	char s[64];
	obj.push_back(pair<string,string>("activated",(editorFlags&0x1)?"0":"1"));
	sprintf(s,"%d",editorSpeed);
	obj.push_back(pair<string,string>("speed",s));
	}
	break;
	case TYPE_PORTAL:
	obj.push_back(pair<string,string>("automatic",(editorFlags&0x1)?"1":"0"));
	obj.push_back(pair<string,string>("destination",destination));
	break;
	case TYPE_BUTTON:
	case TYPE_SWITCH:
	{
	string s;
	switch(editorFlags&0x3){
	case 1:
	s="on";
	break;
	case 2:
	s="off";
	break;
	default:
	s="toggle";
	break;
	}
	obj.push_back(pair<string,string>("behaviour",s));
	}
	break;
	case TYPE_NOTIFICATION_BLOCK:
	{
	string value=message;
	//Change \n with the characters '\n'.
	while(value.find('\n',0)!=string::npos){
	size_t pos=value.find('\n',0);
	value=value.replace(pos,1,"\\n");
	}

	obj.push_back(pair<string,string>("message",value));
	}
	break;
	case TYPE_FRAGILE:
	{
	char s[64];
	sprintf(s,"%d",editorFlags);
	obj.push_back(pair<string,string>("state",s));
	}
	break;
	}
	}

	void Block::setEditorData(std::map<std::string,std::string>& obj){
	//Iterator used to check if the map contains certain entries.
	map<string,string>::iterator it;

	//Check if the data contains the id block.
	it=obj.find("id");
	if(it!=obj.end()){
	//Set the id of the block.
	id=obj["id"];
	}

	//Block specific properties.
	switch(type){
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	{
	//Make sure that the editor data contains MovingPosCount.
	it=obj.find("MovingPosCount");
	if(it!=obj.end()){
	char s0[64];
	int m=atoi(obj["MovingPosCount"].c_str());
	movingPos.clear();
	for(int i=0;i<m;i++){
	SDL_Rect r={0,0,0,0};
	sprintf(s0+1,"%d",i);
	s0[0]='x';
	r.x=atoi(obj[s0].c_str());
	s0[0]='y';
	r.y=atoi(obj[s0].c_str());
	s0[0]='t';
	r.w=atoi(obj[s0].c_str());
	movingPos.push_back(r);
	}
	}

	//Check if the activated or disabled key is in the data.
	//NOTE: 'disabled' is obsolete in V0.5.
	it=obj.find("activated");
	if(it!=obj.end()){
	string s=it->second;
	editorFlags=0;
	if(!(s=="true" \|\| atoi(s.c_str()))) editorFlags\|=0x1;
	flags=flagsSave=editorFlags;
	}else{
	it=obj.find("disabled");
	if(it!=obj.end()){
	string s=it->second;
	editorFlags=0;
	if(s=="true" \|\| atoi(s.c_str())) editorFlags\|=0x1;
	flags=flagsSave=editorFlags;
	}
	}

	//Check if the loop key is in the data.
	it=obj.find("loop");
	if(it!=obj.end()){
	string s=obj["loop"];
	loop=false;
	if(s=="true" \|\| atoi(s.c_str()))
	loop=true;
	}

	}
	break;
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	{
	//Check if there's a speed key in the editor data.
	it=obj.find("speed");
	if(it!=obj.end()){
	editorSpeed=atoi(obj["speed"].c_str());
	speed=speedSave=editorSpeed;
	}

	//Check if the activated or disabled key is in the data.
	//NOTE: 'disabled' is obsolete in V0.5.
	it=obj.find("activated");
	if(it!=obj.end()){
	string s=it->second;
	editorFlags=0;
	if(!(s=="true" \|\| atoi(s.c_str()))) editorFlags\|=0x1;
	flags=flagsSave=editorFlags;
	}else{
	it=obj.find("disabled");
	if(it!=obj.end()){
	string s=it->second;
	editorFlags=0;
	if(s=="true" \|\| atoi(s.c_str())) editorFlags\|=0x1;
	flags=flagsSave=editorFlags;
	}
	}
	}
	break;
	case TYPE_PORTAL:
	{
	//Check if the automatic key is in the data.
	it=obj.find("automatic");
	if(it!=obj.end()){
	string s=obj["automatic"];
	editorFlags=0;
	if(s=="true" \|\| atoi(s.c_str())) editorFlags\|=0x1;
	flags=flagsSave=editorFlags;
	}

	//Check if the destination key is in the data.
	it=obj.find("destination");
	if(it!=obj.end()){
	destination=obj["destination"];
	}
	}
	break;
	case TYPE_BUTTON:
	case TYPE_SWITCH:
	{
	//Check if the behaviour key is in the data.
	it=obj.find("behaviour");
	if(it!=obj.end()){
	string s=obj["behaviour"];
	editorFlags=0;
	if(s=="on" \|\| s==_("On")) editorFlags\|=1;
	else if(s=="off" \|\| s==_("Off")) editorFlags\|=2;
	flags=flagsSave=editorFlags;
	}
	}
	break;
	case TYPE_NOTIFICATION_BLOCK:
	{
	//Check if the message key is in the data.
	it=obj.find("message");
	if(it!=obj.end()){
	message=obj["message"];
	//Change the characters '\n' to a real \n
	while(message.find("\\n")!=string::npos){
	message=message.replace(message.find("\\n"),2,"\n");
	}
	}
	}
	break;
	case TYPE_FRAGILE:
	{
	//Check if the status is in the data.
	it=obj.find("state");
	if(it!=obj.end()){
	editorFlags=atoi(obj["state"].c_str());
	flags=editorFlags;
	{
	const char* s=(flags==0)?"default":((flags==1)?"fragile1":((flags==2)?"fragile2":"fragile3"));
	appearance.changeState(s);
	}
	}
	}
	}
	}

	std::string Block::getEditorProperty(std::string property){
	//First get the complete editor data.
	vector<pair<string,string> > objMap;
	vector<pair<string,string> >::iterator it;
	getEditorData(objMap);

	//Loop through the entries.
	for(it=objMap.begin();it!=objMap.end();++it){
	if(it->first==property)
	return it->second;
	}

	//Nothing found.
	return "";
	}

	void Block::setEditorProperty(std::string property,std::string value){
	//Create a map to hold the property.
	std::map<std::string,std::string> editorData;
	editorData[property]=value;

	//And call the setEditorData method.
	setEditorData(editorData);
	}

	-bool Block::loadFromNode(TreeStorageNode* objNode){
	+bool Block::loadFromNode(ImageManager&, SDL_Renderer&, TreeStorageNode* objNode){
	//Make sure there are enough parameters.
	if(objNode->value.size()<3)
	return false;

	//Load the type and location.
	int type=Game::blockNameMap[objNode->value[0]];
	int x=atoi(objNode->value[1].c_str());
	int y=atoi(objNode->value[2].c_str());
	int w=50;
	int h=50;
	if(objNode->value.size()>3)
	w=atoi(objNode->value[3].c_str());
	if(objNode->value.size()>4)
	h=atoi(objNode->value[4].c_str());
	//Call the init method.
	init(x,y,w,h,type);

	//Loop through the attributes as editorProperties.
	map<string,string> obj;
	for(map<string,vector<string> >::iterator i=objNode->attributes.begin();i!=objNode->attributes.end();++i){
	if(i->second.size()>0) obj[i->first]=i->second[0];
	}
	setEditorData(obj);

	//Loop through the subNodes.
	for(unsigned int i=0;i<objNode->subNodes.size();i++){
	//FIXME: Ugly variable naming.
	TreeStorageNode* obj=objNode->subNodes[i];
	if(obj==NULL) continue;

	//Check for a script block.
	if(obj->name=="script" && !obj->value.empty()){
	map<string,int>::iterator it=Game::gameObjectEventNameMap.find(obj->value[0]);
	if(it!=Game::gameObjectEventNameMap.end()){
	int eventType=it->second;
	const std::string& script=obj->attributes["script"][0];
	if(!script.empty()) scripts[eventType]=script;
	}
	}
	}

	return true;
	}

	void Block::prepareFrame(){
	//Reset the delta variables.
	dx=dy=0;
	//Also reset the velocity, these should be set in the move method.
	if(type!=TYPE_PUSHABLE)
	xVel=yVel=0;
	}

	/*//debug
	int block_test_count=-1;
	bool block_test_only=false;*/

	void Block::move(){
	//Make sure we are enabled, if not return.
	if(!enabled)
	return;

	//First update the animation of the appearance.
	appearance.updateAnimation();

	//Block specific move code.
	switch(type){
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	{
	/*//debug
	if(block_test_only \|\| parent->time==416){
	cout<<"Time:"<<(parent->time)<<" Recorded:"<<block_test_count<<" Coord:"<<box.x<<","<<box.y<<endl;
	block_test_only=false;
	}*/

	//Make sure the block is enabled, if so increase the time.
	if(!(flags&0x1)) temp++;
	int t=temp;
	SDL_Rect r0={0,0,0,0},r1;
	dx=0;
	dy=0;

	//Loop through the moving positions.
	for(unsigned int i=0;i<movingPos.size();i++){
	r1.x=movingPos[i].x;
	r1.y=movingPos[i].y;
	r1.w=movingPos[i].w;
	if(t==0&&r1.w==0){
	r1.w=1;
	flags\|=0x1;
	}
	if(t>=0 && t<(int)r1.w){
	int newX=boxBase.x+(int)(float(r0.x)+(float(r1.x)-float(r0.x))*float(t)/float(r1.w));
	int newY=boxBase.y+(int)(float(r0.y)+(float(r1.y)-float(r0.y))*float(t)/float(r1.w));
	//Calculate the delta and velocity.
	xVel=dx=newX-box.x;
	yVel=dy=newY-box.y;
	//Set the new location of the moving block.
	box.x=newX;
	box.y=newY;
	return;
	}else if(t==(int)r1.w){
	//If the time is the time of the movingPosition then set it equal to the location.
	//We do this to prevent a slight edge between normal blocks and moving blocks.
	int newX=boxBase.x+r1.x;
	int newY=boxBase.y+r1.y;
	xVel=dx=newX-box.x;
	yVel=dy=newY-box.y;
	box.x=newX;
	box.y=newY;
	return;
	}
	t-=r1.w;
	r0.x=r1.x;
	r0.y=r1.y;
	}
	//Only reset the stuff when we're looping.
	if(loop){
	//Set the time back to zero.
	temp=0;
	//Calculate the delta movement.
	if(!movingPos.empty() && movingPos.back().x==0 && movingPos.back().y==0){
	dx=boxBase.x-box.x;
	dy=boxBase.y-box.y;
	}
	//Set the movingblock back to it's initial location.
	box.x=boxBase.x;
	box.y=boxBase.y;
	}
	}
	break;
	case TYPE_BUTTON:
	{
	//Check the third bit of flags to see if temp changed.
	int new_flags=temp?4:0;
	if((flags^new_flags)&4){
	//The button has been pressed or unpressed so change the third bit on flags.
	flags=(flags&~4)\|new_flags;

	if(parent && (new_flags \|\| (flags&3)==0)){
	//Make sure that id isn't empty.
	if(!id.empty()){
	parent->broadcastObjectEvent(0x10000\|(flags&3),-1,id.c_str());
	}else{
	cerr<<"WARNING: invalid button id!"<<endl;
	}
	}
	}
	temp=0;
	}
	break;
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	//Increase the conveyor belt animation.
	if((flags&1)==0){
	animation=(animation+speed)%box.w;
	if(animation<0) animation+=box.w;

	//Set the velocity NOTE This isn't the actual velocity of the block, but the speed of the player/shadow standing on it.
	xVel=speed;
	}
	break;
	case TYPE_PUSHABLE:
	{
	//Update the vertical velocity, horizontal is set by the player.
	if(inAir==true){
	yVel+=1;

	//Cap fall speed to 13.
	if(yVel>13)
	yVel=13;
	}
	if(objCurrentStand!=NULL){
	//Now get the velocity and delta of the object the player is standing on.
	SDL_Rect v=objCurrentStand->getBox(BoxType_Velocity);
	SDL_Rect delta=objCurrentStand->getBox(BoxType_Delta);

	switch(objCurrentStand->type){
	//For conveyor belts the velocity is transfered.
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	{
	xVelBase+=v.x;
	}
	break;
	//In other cases, such as, player on shadowm player on crate... the change in x position must be considered.
	default:
	{
	if(delta.x != 0)
	xVelBase+=delta.x;
	}
	break;
	}
	//NOTE: Only copy the velocity of the block when moving down.
	//Upwards is automatically resolved before the player is moved.
	if(v.y>0)
	yVelBase=v.y;
	else
	yVelBase=0;
	}

	//Set the object the player is currently standing to NULL.
	objCurrentStand=NULL;

	//Store the location of the player.
	int lastX=box.x;
	int lastY=box.y;

	//An array that will hold all the GameObjects that are involved in the collision/movement.
	vector<Block*> objects;
	//All the blocks have moved so if there's collision with the player, the block moved into him.
	for(unsigned int o=0;o<parent->levelObjects.size();o++){
	//Make sure to only check enabled blocks.
	if(!parent->levelObjects[o]->enabled)
	continue;
	//Make sure we aren't the block.
	if(parent->levelObjects[o]==this)
	continue;
	//Make sure the object is solid for the player.
	if(!parent->levelObjects[o]->queryProperties(GameObjectProperty_PlayerCanWalkOn,&parent->player))
	continue;

	//Check for collision.
	if(checkCollision(box,parent->levelObjects[o]->getBox()))
	objects.push_back(parent->levelObjects[o]);
	}
	//There was collision so try to resolve it.
	if(!objects.empty()){
	//FIXME: When multiple moving blocks are overlapping the player can be "bounced" off depending on the block order.
	for(unsigned int o=0;o<objects.size();o++){
	SDL_Rect r=objects[o]->getBox();
	SDL_Rect delta=objects[o]->getBox(BoxType_Delta);

	//Check on which side of the box the player is.
	if(delta.x!=0){
	if(delta.x>0){
	if((r.x+r.w)-box.x<=delta.x)
	box.x=r.x+r.w;
	}else{
	if((box.x+box.w)-r.x<=-delta.x)
	box.x=r.x-box.w;
	}
	}
	if(delta.y!=0){
	if(delta.y>0){
	if((r.y+r.h)-box.y<=delta.y)
	box.y=r.y+r.h;
	}else{
	if((box.y+box.h)-r.y<=-delta.y)
	box.y=r.y-box.h;
	}
	}
	}
	}

	//Reuse the objects array, this time for blocks the block moves into.
	objects.clear();
	//Determine the collision frame.
	SDL_Rect frame={box.x,box.y,box.w,box.h};
	//Keep the horizontal movement of the block in mind.
	if(xVel+xVelBase>=0){
	frame.w+=(xVel+xVelBase);
	}else{
	frame.x+=(xVel+xVelBase);
	frame.w-=(xVel+xVelBase);
	}
	//And the vertical movement.
	if(yVel+yVelBase>=0){
	frame.h+=(yVel+yVelBase);
	}else{
	frame.y+=(yVel+yVelBase);
	frame.h-=(yVel+yVelBase);
	}
	//Loop through the game objects.
	for(unsigned int o=0; o<parent->levelObjects.size(); o++){
	//Make sure the object is enabled.
	if(!parent->levelObjects[o]->enabled)
	continue;
	//Make sure we aren't the block.
	if(parent->levelObjects[o]==this)
	continue;
	//Check if the player can collide with this game object.
	if(!parent->levelObjects[o]->queryProperties(GameObjectProperty_PlayerCanWalkOn,&parent->player))
	continue;

	//Check if the block is inside the frame.
	if(checkCollision(frame,parent->levelObjects[o]->getBox()))
	objects.push_back(parent->levelObjects[o]);
	}
	//Horizontal pass.
	if(xVel+xVelBase!=0){
	box.x+=xVel+xVelBase;
	for(unsigned int o=0;o<objects.size();o++){
	SDL_Rect r=objects[o]->getBox();
	if(!checkCollision(box,r))
	continue;

	if(xVel+xVelBase>0){
	//We came from the left so the right edge of the player must be less or equal than xVel+xVelBase.
	if((box.x+box.w)-r.x<=xVel+xVelBase)
	box.x=r.x-box.w;
	}else{
	//We came from the left so the right edge of the player must be less or equal than xVel+xVelBase.
	if(box.x-(r.x+r.w)<=-(xVel+xVelBase))
	box.x=r.x+r.w;
	}
	}
	}
	//Some variables that are used in vertical movement.
	Block* lastStand=NULL;
	inAir=true;

	//Vertical pass.
	if(yVel+yVelBase!=0){
	box.y+=yVel+yVelBase;
	for(unsigned int o=0;o<objects.size();o++){
	SDL_Rect r=objects[o]->getBox();
	if(!checkCollision(box,r))
	continue;

	//Now check how we entered the block (vertically or horizontally).
	if(yVel+yVelBase>0){
	//We came from the top so the bottom edge of the player must be less or equal than yVel+yVelBase.
	if((box.y+box.h)-r.y<=yVel+yVelBase){
	//NOTE: lastStand is handled later since the player can stand on only one block at the time.

	//Check if there's already a lastStand.
	if(lastStand){
	//There is one, so check 'how much' the player is on the blocks.
	SDL_Rect r=objects[o]->getBox();
	int w=0;
	if(box.x+box.w>r.x+r.w)
	w=(r.x+r.w)-box.x;
	else
	w=(box.x+box.w)-r.x;

	//Do the same for the other box.
	r=lastStand->getBox();
	int w2=0;
	if(box.x+box.w>r.x+r.w)
	w2=(r.x+r.w)-box.x;
	else
	w2=(box.x+box.w)-r.x;

	//NOTE: It doesn't matter which block the player is on if they are both stationary.
	SDL_Rect v=objects[o]->getBox(BoxType_Velocity);
	SDL_Rect v2=lastStand->getBox(BoxType_Velocity);

	if(v.y==v2.y){
	if(w>w2)
	lastStand=objects[o];
	}else if(v.y<v2.y){
	lastStand=objects[o];
	}
	}else{
	lastStand=objects[o];
	}
	}
	}else{
	//We came from the bottom so the upper edge of the player must be less or equal than yVel+yVelBase.
	if(box.y-(r.y+r.h)<=-(yVel+yVelBase)){
	box.y=r.y+r.h;
	yVel=0;
	}
	}
	}
	}
	if(lastStand){
	inAir=false;
	yVel=1;
	SDL_Rect r=lastStand->getBox();
	box.y=r.y-box.h;
	}

	//Block will currently be standing on whatever it was last standing on.
	objCurrentStand=lastStand;

	dx=box.x-lastX;
	dy=box.y-lastY;
	xVel=0;
	xVelBase=0;
	}
	break;
	}
	}
	diff --git a/src/Block.h b/src/Block.h
	index 26d68ac..ad68b93 100644
	--- a/src/Block.h
	+++ b/src/Block.h
	@@ -1,198 +1,198 @@
	/*
	* 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 BLOCK_H
	#define BLOCK_H

	#include "GameObjects.h"
	#include "Globals.h"
	#include "ThemeManager.h"
	#include "ScriptUserData.h"
	#include "ScriptExecutor.h"
	#include <vector>
	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>

	class Block: public GameObject, public ScriptUserClass<'B','L','O','K',Block>{
	private:
	//Integer that a block can use for all animation or visual related things.
	int animation;
	//The save for animation when the state of the block is saved.
	int animationSave;

	//flags:
	//moving object 0x1=disabled
	//button bit0-1=behavior 0x4=pressed
	//switch bit0-1=behavior
	int flags;
	//The save for flags when the state of the block is saved.
	int flagsSave;

	//Temp variables used to keep track of time/state.
	int temp;
	//The save for temp when the state of the block is saved.
	int tempSave;

	//Save variables for the current location and size of the block.
	SDL_Rect boxSave;

	//Delta variables, if the block moves these must be set to the delta movement.
	int dx,dy;
	int dxSave,dySave;

	//Vector containing the poisitions of the moving block.
	std::vector<SDL_Rect> movingPos;
	//Boolean if the moving block loops his movement.
	//Default value is true.
	bool loop;

	//Integer containing the speed for conveyorbelts.
	int speed;
	int speedSave;
	int editorSpeed;

	//Following is for the pushable block.
	Block* objCurrentStand;

	//Flags of the block for the editor.
	//moving object 0x1=disabled
	//portal 0x1=automatic
	//fragile =state
	int editorFlags;
	public:
	//The Appearance of the block.
	ThemeBlockInstance appearance;

	//Velocity variables for the block, if the block moves these must be set for collision/movement of the player.
	int xVel,yVel;
	//Save variables for the velocity.
	int xVelSave,yVelSave;

	//Follwing is for pushable block.
	bool inAir;
	int xVelBase,yVelBase;
	//The save variables for each of the above.
	bool inAirSave;
	int xVelBaseSave,yVelBaseSave;

	//The id of the block.
	std::string id;
	//String containing the id of the destination for portals.
	std::string destination;
	//String containing the message of the notification block.
	std::string message;

	//The map that holds a script for every event.
	map<int,std::string> scripts;

	//Compiled scripts. Use lua_rawgeti(L, LUA_REGISTRYINDEX, r) to get the function.
	std::map<int,int> compiledScripts;

	//Boolean if the block is enabled.
	//If it's not enabled it will not collide with anything or execute any scripts.
	bool enabled,enabledSave;

	//Constructor.
	//objParent: Pointer to the Game object.
	//x: The x location of the block.
	//y: The y location of the block.
	//w: The width of the block.
	//h: The height of the block.
	//type: The block type.
	Block(Game* objParent,int x=0,int y=0,int w=50,int h=50,int type=-1);
	//Desturctor.
	~Block();

	//Method for initializing the block.
	//x: The x location of the block.
	//y: The y location of the block.
	//w: The width of the block.
	//h: The height of the block.
	//type: The block type.
	void init(int x,int y,int w,int h,int type);

	//Method used to draw the block.
	- void show();
	+ void show(SDL_Renderer &renderer) override;

	//Returns the box of a given type.
	//boxType: The type of box that should be returned.
	//See GameObjects.h for the types.
	//Returns: The box.
	virtual SDL_Rect getBox(int boxType=BoxType_Current);

	//Method for setting the block to a given location as if it moved there.
	//x: The new x location.
	//y: The new y location.
	void moveTo(int x,int y);

	//Method for setting a new size as if the block grew,
	//w: The new width of the block.
	//h: The new height of the block.
	void growTo(int w,int h);

	//Save the state of the block so we can load it later on.
	virtual void saveState();
	//Load the saved state of the block so.
	virtual void loadState();
	//Reset the block.
	//save: Boolean if the saved state should also be deleted.
	virtual void reset(bool save);

	//Play an animation.
	virtual void playAnimation();

	//Method called when there's an event.
	//eventType: The type of event.
	//See GameObjects.h for the eventtypes.
	virtual void onEvent(int eventType);

	//Method used to retrieve a property from the block.
	//propertyType: The type of property requested.
	//See GameObjects.h for the properties.
	//obj: Pointer to the player.
	//Returns: Integer containing the value of the property.
	virtual int queryProperties(int propertyType,Player* obj);

	//Get the editor data of the block.
	//obj: The vector that will be filled with the editorData.
	virtual void getEditorData(std::vector<std::pair<std::string,std::string> >& obj);
	//Set the editor data of the block.
	//obj: The new editor data.
	virtual void setEditorData(std::map<std::string,std::string>& obj);

	//Get a single property of the block.
	//property: The property to return.
	//Returns: The value for the requested property.
	virtual std::string getEditorProperty(std::string property);
	//Set a single property of the block.
	//property: The property to set.
	//value: The new value for the property.
	virtual void setEditorProperty(std::string property,std::string value);

	//Method for loading the Block from a node.
	//objNode: Pointer to the storage node to load from.
	//Returns: True if it succeeds without errors.
	- virtual bool loadFromNode(TreeStorageNode* objNode);
	+ virtual bool loadFromNode(ImageManager&, SDL_Renderer&, TreeStorageNode* objNode) override;

	//Method used for resetting the dx/dy and xVel/yVel variables.
	virtual void prepareFrame();
	//Method used for updating moving blocks or elements of blocks.
	virtual void move();
	};

	#endif
	diff --git a/src/CachedTexture.h b/src/CachedTexture.h
	new file mode 100644
	index 0000000..a8c7a9c
	--- /dev/null
	+++ b/src/CachedTexture.h
	@@ -0,0 +1,44 @@
	+#ifndef CACHEDTEXTURE_H
	+#define CACHEDTEXTURE_H
	+
	+#include "Render.h"
	+
	+//A class to cache textures that display stuff that is updated regularly
	+template <typename T>
	+class CachedTexture
	+{
	+private:
	+ T id;
	+ TexturePtr tex;
	+public:
	+ CachedTexture() {}
	+ TexturePtr& getTexture(){
	+ return tex;
	+ }
	+
	+ SDL_Texture* get(){
	+ return tex.get();
	+ }
	+
	+ // Check if the texture exists.
	+ bool exists() {
	+ return tex.get() != nullptr;
	+ }
	+
	+ // Check if the contained texture has to be updated.
	+ bool needsUpdate(const T& id){
	+ if (this->id!=id \|\| !tex) {
	+ return true;
	+ } else {
	+ return false;
	+ }
	+ }
	+
	+ //Update the contained texture with a new id and texture.
	+ void update(T id, TexturePtr&& texture) {
	+ this->id = id;
	+ this->tex = std::move(texture);
	+ }
	+};
	+
	+#endif // CACHEDTEXTURE_H
	diff --git a/src/FileManager.cpp b/src/FileManager.cpp
	index c120425..aa0fa79 100644
	--- a/src/FileManager.cpp
	+++ b/src/FileManager.cpp
	@@ -1,827 +1,827 @@
	/*
	* 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 "Globals.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

	//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--){
	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;
	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
	//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_file(file,fileName.c_str(),10240)) {
	+ 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_finish(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 Add your system's code here
	+#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 8d6d430..f33949b 100644
	--- a/src/Functions.cpp
	+++ b/src/Functions.cpp
	@@ -1,1744 +1,1743 @@
	/*
	* 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/SDL.h>
	+#include <SDL2/SDL.h>
	#ifdef __APPLE__
	-#include <SDL_mixer/SDL_mixer.h>
	-#include <SDL_gfx/SDL_gfxPrimitives.h>
	-#include <SDL_gfx/SDL_rotozoom.h>
	+#include <SDL2_mixer/SDL_mixer.h>
	+#include <SDL2_gfx/SDL2_gfxPrimitives.h>
	+#include <SDL2_gfx/SDL2_rotozoom.h>
	#else
	-#include <SDL/SDL_mixer.h>
	-#include <SDL/SDL_gfxPrimitives.h>
	-#include <SDL/SDL_rotozoom.h>
	+#include <SDL2/SDL_mixer.h>
	+#include <SDL2/SDL2_gfxPrimitives.h>
	+#include <SDL2/SDL2_rotozoom.h>
	#endif
	-#include <SDL/SDL_syswm.h>
	+#include <SDL2/SDL_syswm.h>
	#include <string>
	#include "Globals.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Player.h"
	#include "GameObjects.h"
	#include "LevelPack.h"
	#include "TitleMenu.h"
	#include "LevelEditSelect.h"
	#include "LevelEditor.h"
	#include "Game.h"
	#include "LevelPlaySelect.h"
	#include "Addons.h"
	#include "InputManager.h"
	#include "ImageManager.h"
	#include "MusicManager.h"
	#include "SoundManager.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 imagemanager.
	-//The ImageManager is used to prevent loading images multiple times.
	-ImageManager imageManager;
	-
	//Initialise the musicManager.
	//The MusicManager is used to prevent loading music files multiple times and for playing/fading music.
	MusicManager musicManager;

	//Initialise the 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=0;
	+Settings* settings=nullptr;
	+
	+SDL_Renderer* sdlRenderer=nullptr;

	#ifdef HARDWARE_ACCELERATION
	GLuint screenTexture;
	#endif

	-SDL_Surface* loadImage(string file){
	- //We use the imageManager to load the file.
	- return imageManager.loadImage(file);
	-}
	-
	void applySurface(int x,int y,SDL_Surface* source,SDL_Surface* dest,SDL_Rect* clip){
	//The offset is needed to draw at the right location.
	SDL_Rect offset;
	offset.x=x;
	offset.y=y;

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

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

	//Draw a box with anti-aliased borders using SDL_gfx.
	-void drawGUIBox(int x,int y,int w,int h,SDL_Surface* dest,Uint32 color){
	+void drawGUIBox(int x,int y,int w,int h,SDL_Renderer& renderer,Uint32 color){
	+ //FIXME, this may get the wrong color on system with different endianness.
	//Fill content's background color from function parameter
	- boxRGBA(dest,x+1,y+1,x+w-2,y+h-2,color >> 24,color >> 16,color >> 8,color >> 0);
	+ boxRGBA(&renderer,x+1,y+1,x+w-2,y+h-2,color >> 24,color >> 16,color >> 8,color >> 0);

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

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

	//Draw second lighter border around content
	- rectangleRGBA(dest,x+1,y+1,x+w-2,y+h-2,0,0,0,64);
	-
	+ //rectangleRGBA(&renderer,x+1,y+1,x+w-2,y+h-2,0,0,0,64);
	+ rectangleRGBA(&renderer,x+1,y+1,x+w-1,y+h-1,0,0,0,64);
	+
	//Create anti-aliasing in corners of second border
	- pixelRGBA(dest,x+1,y+1,0,0,0,50);
	- pixelRGBA(dest,x+1,y+h-2,0,0,0,50);
	- pixelRGBA(dest,x+w-2,y+1,0,0,0,50);
	- pixelRGBA(dest,x+w-2,y+h-2,0,0,0,50);
	+ pixelRGBA(&renderer,x+1,y+1,0,0,0,50);
	+ pixelRGBA(&renderer,x+1,y+h-2,0,0,0,50);
	+ pixelRGBA(&renderer,x+w-2,y+1,0,0,0,50);
	+ pixelRGBA(&renderer,x+w-2,y+h-2,0,0,0,50);
	}

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

	-void drawLineWithArrow(int x1,int y1,int x2,int y2,SDL_Surface* dest,Uint32 color,int spacing,int offset,int xsize,int ysize){
	+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,dest,color);
	+ 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),dest,color);
	+ 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),dest,color);
	+ int(x1+(p-xsize)dx+ysizedy+0.5),int(y1+(p-xsize)dy-ysizedx+0.5),renderer,color);
	}
	}

	-bool createScreen(){
	+ScreenData creationFailed() {
	+ return ScreenData();
	+}
	+
	+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 false;
	+ return creationFailed();
	#endif
	}else{
	//Set the flags.
	- Uint32 flags=SCREEN_FLAGS;
	-#if !defined(ANDROID)
	- flags \|= SDL_DOUBLEBUF;
	-#endif
	+// 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_FULLSCREEN;
	+ flags\|=SDL_WINDOW_FULLSCREEN; //TODO with SDL2 we can also do SDL_WINDOW_FULLSCREEN_DESKTOP
	else if(settings->getBoolValue("resizable"))
	- flags\|=SDL_RESIZABLE;
	+ flags\|=SDL_WINDOW_RESIZABLE;

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

	- //Create the temp surface, just a replica of the screen surface, free the previous one if any.
	- if(tempSurface)
	- SDL_FreeSurface(tempSurface);
	- tempSurface=SDL_CreateRGBSurface(SCREEN_FLAGS\|SDL_SRCALPHA,
	- screen->w,screen->h,screen->format->BitsPerPixel,
	- screen->format->Rmask,screen->format->Gmask,screen->format->Bmask,0);
	-
	//Set the the window caption.
	- SDL_WM_SetCaption(("Me and My Shadow "+version).c_str(),NULL);
	- SDL_EnableUNICODE(1);
	+ 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 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);
	+// 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(modes==NULL \|\| ((intptr_t)modes) == -1){
	+ 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(unsigned int i=0;modes[i]!=NULL;i++){
	+
	+ 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(modes[i]->w>=800 && modes[i]->h>=600){
	- _res res={modes[i]->w, modes[i]->h};
	+ 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_GetWMInfo(&wmInfo);
	+ 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())){
	- cerr<<"ERROR: Unable to allocate memory for XSizeHings."<<endl;
	+ 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.
	- (void)wmInfo.info.x11.lock_func;
	- XSetNormalHints(wmInfo.info.x11.display,wmInfo.info.x11.wmwindow,sizeHints);
	- (void)wmInfo.info.x11.unlock_func;
	+ //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.
	- cerr<<"WARNING: Unsupported window manager."<<endl;
	+ std::cerr<<"WARNING: Untested windowing system!"<<endl;
	}
	#elif defined(WIN32)
	//We overwrite the window proc of SDL
	- WNDPROC wndproc=(WNDPROC)GetWindowLong(wmInfo.window,GWL_WNDPROC);
	+ WNDPROC wndproc=(WNDPROC)GetWindowLong(wmInfo.win.window,GWL_WNDPROC);
	if(wndproc!=NULL && wndproc!=(WNDPROC)WindowProc){
	m_OldWindowProc=wndproc;
	- SetWindowLong(wmInfo.window,GWL_WNDPROC,(LONG)(WNDPROC)WindowProc);
	+ SetWindowLong(wmInfo.win.window,GWL_WNDPROC,(LONG)(WNDPROC)WindowProc);
	}
	#endif
	}

	-void onVideoResize(){
	+void onVideoResize(ImageManager& imageManager, SDL_Renderer &renderer){
	//Check if the resize event isn't malformed.
	- if(event.resize.w<=0 \|\| event.resize.h<=0)
	+ if(event.window.data1<=0 \|\| event.window.data2<=0)
	return;
	-
	+
	//Check the size limit.
	- if(event.resize.w<800)
	- event.resize.w=800;
	- if(event.resize.h<600)
	- event.resize.h=600;
	+ //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.resize.w && SCREEN_HEIGHT==event.resize.h)
	+ if(SCREEN_WIDTH==event.window.data1 && SCREEN_HEIGHT==event.window.data2)
	return;

	char s[32];

	//Set the new width and height.
	- sprintf(s,"%d",event.resize.w);
	+ snprintf(s,32,"%d",event.window.data1);
	getSettings()->setValue("width",s);
	- sprintf(s,"%d",event.resize.h);
	+ 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(""))
	+ if(!loadTheme(imageManager,renderer,""))
	return;

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

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

	//Initialze SDL_mixer (audio).
	- if(Mix_OpenAudio(22050,MIX_DEFAULT_FORMAT,2,512)==-1){
	- fprintf(stderr,"FATAL ERROR: Mix_OpenAudio failed\n");
	- return false;
	+ //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){
	- fprintf(stderr,"FATAL ERROR: TTF_Init failed\n");
	- return false;
	+ 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.
	- if(!createScreen())
	- return false;
	+ 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 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(){
	+static void generateArrows(SDL_Renderer& renderer){
	TTF_Font* fontArrow=loadFont(_("knewave"),18);

	- if(arrowLeft1){
	+ /*if(arrowLeft1){
	SDL_FreeSurface(arrowLeft1);
	SDL_FreeSurface(arrowRight1);
	SDL_FreeSurface(arrowLeft2);
	SDL_FreeSurface(arrowRight2);
	- }
	+ }*/

	- arrowLeft1=TTF_RenderUTF8_Blended(fontArrow,"<",themeTextColor);
	- arrowRight1=TTF_RenderUTF8_Blended(fontArrow,">",themeTextColor);
	- arrowLeft2=TTF_RenderUTF8_Blended(fontArrow,"<",themeTextColorDialog);
	- arrowRight2=TTF_RenderUTF8_Blended(fontArrow,">",themeTextColorDialog);
	+ 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(string name){
	+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")==NULL){
	+ 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")==NULL){
	+ if(objThemes.appendThemeFromFile(theme+"/theme.mnmstheme", imageManager, renderer)==NULL){
	printf("ERROR: Can't load theme %s\n",theme.c_str());
	success=false;
	}
	}

	- generateArrows();
	+ 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(){
	+bool loadFiles(ImageManager& imageManager, SDL_Renderer& renderer){
	//Load the fonts.
	if(!loadFonts())
	return false;

	//Show a loading screen
	{
	- SDL_Rect r={0,0,screen->w,screen->h};
	- SDL_FillRect(screen,&r,0);
	-
	- SDL_Color fg={255,255,255};
	- SDL_Surface *surface=TTF_RenderUTF8_Blended(fontTitle,_("Loading..."),fg);
	- if(surface!=NULL){
	- r.x=(screen->w-surface->w)/2;
	- r.y=(screen->h-surface->h)/2;
	- SDL_BlitSurface(surface,NULL,screen,&r);
	- SDL_FreeSurface(surface);
	- }
	-
	- SDL_Flip(screen);
	+ 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();
	- statsMgr.registerAchievements();
	+ 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(getSettings()->getValue("theme"))){
	+ 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(){
	- if(settings->getBoolValue("gl")){
	-#ifdef HARDWARE_ACCELERATION
	- glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
	- glLoadIdentity();
	-
	- //Create a texture from the screen surface.
	- glBindTexture(GL_TEXTURE_2D,screenTexture);
	-
	- //Set the texture's stretching properties
	- glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
	- glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
	-
	- glTexImage2D(GL_TEXTURE_2D,0,screen->format->BytesPerPixel,screen->w,screen->h,0,GL_BGRA,GL_UNSIGNED_BYTE,screen->pixels);
	-
	- glBegin(GL_QUADS);
	- glTexCoord2i(0,0); glVertex3f(0,0,0);
	- glTexCoord2i(1,0); glVertex3f(SCREEN_WIDTH,0,0);
	- glTexCoord2i(1,1); glVertex3f(SCREEN_WIDTH,SCREEN_HEIGHT,0);
	- glTexCoord2i(0,1); glVertex3f(0,SCREEN_HEIGHT,0);
	- glEnd();
	-
	- SDL_GL_SwapBuffers();
	-#else
	- //NOTE: Trying to flip the screen using gl while compiled without.
	- fprintf(stderr,"FATAL ERROR: Unable to draw to screen using OpenGL (compiled without).\n");
	-#endif
	- }else{
	- SDL_Flip(screen);
	- }
	+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;
	}

	- //Destroy the imageManager.
	- imageManager.destroy();
	+ //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_FreeSurface(tempSurface);
	+ SDL_DestroyRenderer(sdlRenderer);
	+ SDL_DestroyWindow(sdlWindow);
	+ arrowLeft1.reset(nullptr);
	+ arrowLeft2.reset(nullptr);
	+ arrowRight1.reset(nullptr);
	+ arrowRight2.reset(nullptr);

	//Stop audio.and quit
	Mix_CloseAudio();
	-#ifndef __APPLE__
	+//#ifndef __APPLE__
	Mix_Quit();
	-#endif
	+//#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(){
	+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();
	+ Game* game=new Game(renderer, imageManager);
	currentState=game;
	//Check if we should load record file or a level.
	if(!Game::recordFile.empty()){
	- game->loadRecord(Game::recordFile.c_str());
	+ game->loadRecord(imageManager,renderer,Game::recordFile.c_str());
	Game::recordFile.clear();
	}else{
	- game->loadLevel(levels->getLevelFile());
	+ game->loadLevel(imageManager,renderer,levels->getLevelFile());
	levels->saveLevelProgress();
	}
	}
	break;
	case STATE_MENU:
	- currentState=new Menu();
	+ currentState=new Menu(imageManager, renderer);
	break;
	case STATE_LEVEL_SELECT:
	- currentState=new LevelPlaySelect();
	+ currentState=new LevelPlaySelect(imageManager, renderer);
	break;
	case STATE_LEVEL_EDIT_SELECT:
	- currentState=new LevelEditSelect();
	+ currentState=new LevelEditSelect(imageManager, renderer);
	break;
	case STATE_LEVEL_EDITOR:
	{
	currentState=NULL;
	- LevelEditor* levelEditor=new LevelEditor();
	+ LevelEditor* levelEditor=new LevelEditor(renderer, imageManager);
	currentState=levelEditor;
	//Load the selected level.
	- levelEditor->loadLevel(levels->getLevelFile());
	+ levelEditor->loadLevel(imageManager,renderer,levels->getLevelFile());
	}
	break;
	case STATE_OPTIONS:
	- currentState=new Options();
	+ currentState=new Options(imageManager, renderer);
	break;
	case STATE_ADDONS:
	- currentState=new Addons();
	+ currentState=new Addons(renderer, imageManager);
	break;
	case STATE_CREDITS:
	- currentState=new Credits();
	+ currentState=new Credits(imageManager,renderer);
	break;
	case STATE_STATISTICS:
	- currentState=new StatisticsScreen();
	+ 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;
	- SDL_BlitSurface(screen,NULL,tempSurface,NULL);
	- while(fade>0){
	- fade-=17;
	+ while(fade>0){
	+ // FIXME: Disabled for now
	+ fade-=17;
	if(fade<0)
	fade=0;
	-
	- SDL_FillRect(screen,NULL,0);
	- SDL_SetAlpha(tempSurface, SDL_SRCALPHA, fade);
	- SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	- flipScreen();
	- SDL_Delay(25);
	+ 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(std::string name,GUIObject* obj,int eventType){
	+ 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(string prompt,msgBoxButtons buttons,const string& title){
	+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((SCREEN_WIDTH-600)/2,200,600,200,title.c_str());
	+ 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(0,y,root->width,25,lps,0,true,true,GUIGravityCenter));
	+ 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(root->width*places[i],y,-1,36,button[i].c_str(),value[i],true,true,GUIGravityCenter);
	+ 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(root);
	- overlay->enterLoop(true);
	+ 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(std::string name,GUIObject* obj,int eventType){
	+ 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();
	+ currentState->render(imageManager,renderer);

	//Prompt the user with a Yes or No question.
	/// TRANSLATORS: Filename is coming before this text
	- if(msgBox(tfm::format(_("%s already exists.\nDo you want to overwrite it?"),s),MsgBoxYesNo,_("Overwrite Prompt"))!=MsgBoxYes){
	+ 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();
	+ currentState->render(imageManager,renderer);

	//The file can't be opened so tell the user.
	- msgBox(tfm::format(_("Can't open file %s."),s),MsgBoxOKOnly,_("Error"));
	+ 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();
	+ currentState->render(imageManager,renderer);

	//Unable to open file so tell the user.
	- msgBox(tfm::format(_("Can't open file %s."),s),MsgBoxOKOnly,_("Error"));
	+ 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;
	}
	}
	}
	};
	-
	-bool fileDialog(string& fileName,const char* title,const char* extension,const char* path,bool isSave,bool verifyFile,bool files){
	+/*
	+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(root);
	- overlay->enterLoop();
	+ 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 83ac9ab..f0f20c7 100644
	--- a/src/Functions.h
	+++ b/src/Functions.h
	@@ -1,266 +1,272 @@
	/*
	* 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 "MusicManager.h"
	#include "SoundManager.h"
	#include "LevelPackManager.h"
	#include "ScriptExecutor.h"
	#include "Globals.h"

	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#include <string>
	#include <vector>

	//gettext function
	//message: The message to translate.
	//Returns: The translated string or the original string if there is not translation available.
	#define _(message) (dictionaryManager!=NULL?dictionaryManager->get_dictionary().translate(message).c_str():std::string(message).c_str())
	//gettext function
	//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)

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

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

	//Method used to draw an rectangle.
	//x: The top left x location of the rectangle.
	//y: The top left y location of the rectangle.
	//w: The width of the rectangle,
	//h: The height of the rectangle.
	//dest: The SDL_Surface to draw on.
	//color: The color of the rectangle border to draw.
	-void drawRect(int x,int y,int w,int h,SDL_Surface* dest,Uint32 color=0);
	+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.
	-//dest: The SDL_Surface to draw on.
	+//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_Surface* dest,Uint32 color);
	+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_Surface* dest,Uint32 color=0);
	+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_Surface* dest,Uint32 color=0,int spacing=16,int offset=0,int xsize=5,int ysize=5);
	+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(string name);
	+bool loadTheme(ImageManager& imageManager, SDL_Renderer& renderer, string name);
	+
	+struct ScreenData{
	+ SDL_Renderer* renderer=nullptr;
	+ 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.
	-bool createScreen();
	+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();
	+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.
	-bool init();
	+ScreenData init();
	//Loads some important files, like the background music and the default theme.
	//Returns: True if everything goes well.
	-bool loadFiles();
	+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();
	+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();
	+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(std::string prompt,msgBoxButtons buttons,const std::string& title);
	+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(std::string& fileName,const char* title=NULL,const char* extension=NULL,const char* path=NULL,bool isSave=false,bool verifyFile=false,bool files=true);
	+//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/GUIListBox.cpp b/src/GUIListBox.cpp
	index cb8d35b..4bca152 100644
	--- a/src/GUIListBox.cpp
	+++ b/src/GUIListBox.cpp
	@@ -1,528 +1,553 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "GUIListBox.h"
	using namespace std;

	-GUIListBox::GUIListBox(int left,int top,int width,int height,bool enabled,bool visible,int gravity):
	-GUIObject(left,top,width,height,NULL,-1,enabled,visible,gravity),selectable(true),clickEvents(false){
	+namespace {
	+ inline int tHeight(const SharedTexture& t) {
	+ return rectFromTexture(*t).h;
	+ }
	+ inline int tWidth(const SharedTexture& t) {
	+ return rectFromTexture(*t).w;
	+ }
	+}
	+
	+GUIListBox::GUIListBox(ImageManager& imageManager, SDL_Renderer& renderer,int left,int top,int width,int height,bool enabled,bool visible,int gravity):
	+GUIObject(imageManager,renderer,left,top,width,height,NULL,-1,enabled,visible,gravity),selectable(true),clickEvents(false){
	//Set the state -1.
	state=-1;

	//Create the scrollbar and add it to the children.
	- scrollBar=new GUIScrollBar(width-16,0,16,height,1,0,0,0,1,1,true,true);
	+ scrollBar=new GUIScrollBar(imageManager,renderer,width-16,0,16,height,1,0,0,0,1,1,true,true);
	childControls.push_back(scrollBar);
	}

	GUIListBox::~GUIListBox(){
	//Remove all items and cache.
	clearItems();
	//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 GUIListBox::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	+bool GUIListBox::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 scrollbar.
	if(scrollBar->visible)
	- b=b\|\|scrollBar->handleEvents(x,y,enabled,visible,b);
	+ b=b\|\|scrollBar->handleEvents(renderer,x,y,enabled,visible,b);

	//Set state negative.
	state=-1;

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

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

	//Check if the mouse is inside the GUIListBox.
	if(i>=0&&i<width-4&&j>=0&&j<height-4){
	//Calculate selected item.
	int idx=-1;
	int yPos=-firstItemY;
	int i=scrollBar->value;
	if(yPos!=0) i--;
	for(;i<images.size();++i){
	+ const SharedTexture& tex = images.at(i);
	+ if(tex){
	+ yPos+=tHeight(tex);
	+ }
	+ if(j<yPos){
	+ idx=i;
	+ break;
	+ }
	+
	+ //SDL2 porting note. Not sure why there is a double pointer here?
	+ /*
	SDL_Surface** c=&images.at(i);
	if(c) yPos+=(c)->h;
	if(j<yPos){
	idx=i;
	break;
	- }
	+ }*/
	}

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

	//Check if the left mouse button is pressed.
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_LEFT){
	//Check if the slected item changed.
	if(value!=idx){
	value=idx;

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

	//After possibly a change event, there will always be a click event.
	if(eventCallback && clickEvents){
	GUIEvent e={eventCallback,name,this,GUIEventClick};
	GUIEventQueue.push_back(e);
	}
	}
	}

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

	//Process child controls event except for the scrollbar.
	//That's why i starts at one.
	for(unsigned int i=1;i<childControls.size();i++){
	- bool b1=childControls[i]->handleEvents(x,y,enabled,visible,b);
	+ 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 GUIListBox::render(int x,int y,bool draw){
	+void GUIListBox::render(SDL_Renderer& renderer, int x,int y,bool draw){
	if(updateScrollbar){
	//Calculate the height of the content.
	int maxY=0;
	- for(unsigned int i=0;i<images.size();i++){
	- maxY+=images.at(i)->h;
	+ for(const SharedTexture& t: images){
	+ maxY+=textureHeight(*t);
	}

	//Check if we need to show the scrollbar for many entries.
	if(maxY<height){
	scrollBar->maxValue=0;
	scrollBar->value=0;
	scrollBar->visible=false;
	}else{
	scrollBar->visible=true;
	scrollBar->maxValue=item.size();
	int yy=0;
	for(int i=images.size()-1;i>0;i--){
	- yy+=images.at(i)->h;
	+ yy+=textureHeight(*images.at(i));
	if(yy>height)
	break;
	else
	scrollBar->maxValue--;
	}
	scrollBar->largeChange=item.size()/4;
	}
	updateScrollbar=false;
	}

	//Rectangle the size of the GUIObject, used to draw borders.
	//SDL_Rect r; //Unused local variable :/
	//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 background box.
	- SDL_Rect r={x,y,width,height};
	- SDL_FillRect(screen,&r,0xFFFFFFFF);
	+ SDL_Rect r={x,y,width,height};
	+ SDL_SetRenderDrawColor(&renderer,255,255,255,220);
	+ SDL_RenderFillRect(&renderer, &r);

	firstItemY=0;

	//Loop through the entries and draw them.
	if(scrollBar->value==scrollBar->maxValue&&scrollBar->visible){
	int lowNumber=height;
	int currentItem=images.size()-1;
	while(lowNumber>=0&&currentItem>=0){
	- lowNumber-=images.at(currentItem)->h;
	+ const SharedTexture& currentTexture = images.at(currentItem);
	+ lowNumber-=tHeight(currentTexture);//->h;

	if(lowNumber>0){
	if(selectable){
	//Check if the mouse is hovering on current entry. If so draw borders around it.
	if(state==currentItem)
	- drawGUIBox(x,y+lowNumber-1,width,images.at(currentItem)->h+1,screen,0x00000000);
	+ drawGUIBox(x,y+lowNumber-1,width,tHeight(currentTexture)+1,renderer,0x00000000);

	//Check if the current entry is selected. If so draw a gray background.
	if(value==currentItem)
	- drawGUIBox(x,y+lowNumber-1,width,images.at(currentItem)->h+1,screen,0xDDDDDDFF);
	+ drawGUIBox(x,y+lowNumber-1,width,tHeight(currentTexture)+1,renderer,0xDDDDDDFF);
	}

	- applySurface(x,y+lowNumber,images.at(currentItem),screen,NULL);
	+ applyTexture(x,y+lowNumber,*currentTexture,renderer);
	}else{
	if(selectable){
	//Check if the mouse is hovering on current entry. If so draw borders around it.
	if(state==currentItem)
	- drawGUIBox(x,y,width,images.at(currentItem)->h+lowNumber+1,screen,0x00000000);
	+ drawGUIBox(x,y,width,tHeight(currentTexture)+lowNumber+1,renderer,0x00000000);

	//Check if the current entry is selected. If so draw a gray background.
	if(value==currentItem)
	- drawGUIBox(x,y,width,images.at(currentItem)->h+lowNumber+1,screen,0xDDDDDDFF);
	+ drawGUIBox(x,y,width,tHeight(currentTexture)+lowNumber+1,renderer,0xDDDDDDFF);
	}

	firstItemY=-lowNumber;

	- SDL_Rect clip;
	- clip.x=0;
	- clip.y=-lowNumber;
	- clip.w=images.at(currentItem)->w;
	- clip.h=images.at(currentItem)->h+lowNumber;
	- applySurface(x,y,images.at(currentItem),screen,&clip);
	+ const SDL_Rect clip = rectFromTexture(0, -lowNumber, *currentTexture);
	+// clip.x=0;
	+// clip.y=-lowNumber;
	+
	+// clip.w=images.at(currentItem)->w;
	+// clip.h=images.at(currentItem)->h+lowNumber;
	+// clip.h+=lowNumber;
	+ const SDL_Rect dstRect{x, y, 10/clip.w/, clip.h};
	+ SDL_RenderCopy(&renderer, currentTexture.get(), &clip, &dstRect);
	+ //applyTexture(x, y, *currentTexture, renderer, &clip);
	break;
	}

	currentItem--;
	}
	}else{
	for(int i=scrollBar->value,j=y+1;j>height,i<(int)item.size();i++){
	//Check if the current item is out side of the widget.
	- int yOver=images[i]->h;
	- if(j+images[i]->h>y+height)
	+ int yOver=tHeight(images[i]);
	+ //if(j+images[i]->h>y+height)
	+ if(j+yOver>y+height)
	yOver=y+height-j;

	if(yOver>0){
	if(selectable){
	//Check if the mouse is hovering on current entry. If so draw borders around it.
	if(state==i)
	- drawGUIBox(x,j-1,width,yOver+1,screen,0x00000000);
	+ drawGUIBox(x,j-1,width,yOver+1,renderer,0x00000000);

	//Check if the current entry is selected. If so draw a gray background.
	if(value==i)
	- drawGUIBox(x,j-1,width,yOver+1,screen,0xDDDDDDFF);
	+ drawGUIBox(x,j-1,width,yOver+1,renderer,0xDDDDDDFF);
	}

	//Draw the image.
	- SDL_Rect clip;
	- clip.x=0;
	+ const SDL_Rect clip{0, 0, tWidth(images[i]), yOver};
	+ const SDL_Rect dstRect{x, j, clip.w, clip.h};
	+/* clip.x=0;
	clip.y=0;
	- clip.w=images[i]->w;
	- clip.h=yOver;
	- applySurface(x,j,images[i],screen,&clip);
	+ clip.w=tHeight(images[i]->w);
	+ clip.h=yOver;*/
	+ SDL_RenderCopy(&renderer, images[i].get(), &clip, &dstRect);
	}else{
	break;
	}
	- j+=images[i]->h;
	+ j+=tHeight(images[i]);
	}
	}

	//Draw borders around the whole thing.
	- drawGUIBox(x,y,width,height,screen,0x00000000);
	+ drawGUIBox(x,y,width,height,renderer,0x00000000);

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

	void GUIListBox::clearItems(){
	item.clear();
	- for(unsigned int i=0;i<images.size();i++){
	- SDL_FreeSurface(images[i]);
	- }
	images.clear();
	}

	-void GUIListBox::addItem(std::string name, SDL_Surface* image){
	- item.push_back(name);
	-
	- if(image){
	- images.push_back(image);
	- }else if(!image&&!name.empty()){
	- SDL_Color black={0,0,0,0};
	- SDL_Surface* tmp=TTF_RenderUTF8_Blended(fontText,name.c_str(),black);
	- images.push_back(tmp);
	- }
	-
	- updateScrollbar=true;
	+void GUIListBox::addItem(SDL_Renderer &renderer, std::string name, SharedTexture texture) {
	+
	+
	+ if(texture){
	+ images.push_back(texture);
	+ }else if(!texture&&!name.empty()){
	+ SDL_Color black={0,0,0,0};
	+ auto tex=SharedTexture(textureFromText(renderer, *fontText, name.c_str(), black));
	+ //TTF_RenderUTF8_Blended(fontText,name.c_str(),black);
	+ images.push_back(tex);
	+ } else {
	+ // If nothing was added, ignore it.
	+ return;
	+ }
	+ item.push_back(name);
	+ updateScrollbar=true;
	}

	-void GUIListBox::updateItem(int index, std::string newText, SDL_Surface* newImage){
	- item.at(index)=newText;
	-
	- if(newImage){
	- SDL_FreeSurface(images.at(index));
	- images.at(index)=newImage;
	- }else if(!newImage&&!newText.empty()){
	- SDL_FreeSurface(images.at(index));
	- SDL_Color black={0,0,0,0};
	- SDL_Surface* tmp=TTF_RenderUTF8_Blended(fontText,newText.c_str(),black);
	- images.at(index)=tmp;
	- }
	-
	- updateScrollbar=true;
	+void GUIListBox::updateItem(SDL_Renderer &renderer, int index, string newText, SharedTexture newTexture) {
	+ if(newTexture) {
	+ images.at(index) = newTexture;
	+ } else if (!newTexture&&!newText.empty()) {
	+ SDL_Color black={0,0,0,0};
	+ auto tex=SharedTexture(textureFromText(renderer, *fontText, name.c_str(), black));
	+ images.at(index)=tex;
	+ } else {
	+ return;
	+ }
	+ item.at(index)=newText;
	+ updateScrollbar=true;
	}

	std::string GUIListBox::getItem(int index){
	return item.at(index);
	}

	-GUISingleLineListBox::GUISingleLineListBox(int left,int top,int width,int height,bool enabled,bool visible,int gravity):
	-GUIObject(left,top,width,height,NULL,-1,enabled,visible,gravity),animation(0){}
	+GUISingleLineListBox::GUISingleLineListBox(ImageManager& imageManager, SDL_Renderer& renderer, int left, int top, int width, int height, bool enabled, bool visible, int gravity):
	+GUIObject(imageManager,renderer,left,top,width,height,NULL,-1,enabled,visible,gravity),animation(0){}

	void GUISingleLineListBox::addItem(string name,string label){
	//Check if the label is set, if not use the name.
	if(label.size()==0)
	label=name;

	item.push_back(pair<string,string>(name,label));
	}

	void GUISingleLineListBox::addItems(vector<pair<string,string> > items){
	vector<pair<string,string> >::iterator it;
	for(it=items.begin();it!=items.end();++it){
	addItem(it->first,it->second);
	}
	}

	void GUISingleLineListBox::addItems(vector<string> items){
	vector<string>::iterator it;
	for(it=items.begin();it!=items.end();++it){
	addItem(*it);
	}
	}

	string GUISingleLineListBox::getName(unsigned int index){
	if(index==-1)
	index=value;
	if(index<0\|\|index>item.size())
	return "";

	return item[index].first;
	}

	-bool GUISingleLineListBox::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	+bool GUISingleLineListBox::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(s) are enabled.
	enabled=enabled && this->enabled;
	//The GUIObject is only enabled when he and his parent(s) are enabled.
	visible=visible && this->visible;

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

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

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

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

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

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

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

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

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

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

	return b;
	}

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

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

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

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

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

	x-=gravityX;

	//Check if the enabled state changed or the caption, if so we need to clear the (old) cache.
	if(enabled!=cachedEnabled \|\| item[value].second.compare(cachedCaption)!=0){
	//Free the cache.
	- SDL_FreeSurface(cache);
	- cache=NULL;
	-
	+ cacheTex.reset(nullptr);
	+
	//And cache the new values.
	cachedEnabled=enabled;
	cachedCaption=item[value].second;
	}

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

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

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

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

	- //Draw the text and free the surface afterwards.
	- SDL_BlitSurface(cache,NULL,screen,&r);
	+ //Draw the text.
	+ applyTexture(r.x, r.y, cacheTex, renderer);
	}
	}
	}

	if(draw){
	//Draw the arrows.
	- SDL_Rect r2={48,0,16,16};
	r.x=x;
	if((state&0xF)==0x1)
	r.x+=abs(animation/2);
	r.y=y+4;
	if(inDialog)
	- applySurface(r.x,r.y,arrowLeft2,screen,NULL);
	+ applyTexture(r.x,r.y,*arrowLeft2,renderer);
	else
	- applySurface(r.x,r.y,arrowLeft1,screen,NULL);
	-
	+ applyTexture(r.x,r.y,*arrowLeft1,renderer);
	+
	r.x=x+width-16;
	if((state&0xF)==0x2)
	r.x-=abs(animation/2);
	if(inDialog)
	- applySurface(r.x,r.y,arrowRight2,screen,NULL);
	+ applyTexture(r.x,r.y,*arrowRight2,renderer);
	else
	- applySurface(r.x,r.y,arrowRight1,screen,NULL);
	+ applyTexture(r.x,r.y,*arrowRight1,renderer);
	}
	}
	diff --git a/src/GUIListBox.h b/src/GUIListBox.h
	index 1d95028..ce5238c 100644
	--- a/src/GUIListBox.h
	+++ b/src/GUIListBox.h
	@@ -1,142 +1,142 @@
	/*
	* 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 GUILISTBOX_H
	#define GUILISTBOX_H

	#include "GUIObject.h"
	#include "GUIScrollBar.h"

	//GUIObject that displays a list.
	//It extends GUIObject because it's a special GUIObject.
	class GUIListBox:public GUIObject{
	public:
	//Vector containing the entries of the list.
	std::vector<std::string> item;
	- std::vector<SDL_Surface*> images;
	+ std::vector<SharedTexture> images;
	bool selectable;

	//Boolean if the listbox should send click events.
	bool clickEvents;
	private:
	//Scrollbar used when there are more entries than fit on the screen.
	GUIScrollBar* scrollBar;

	int firstItemY;

	//Boolean if update for scrollbar is needed.
	bool updateScrollbar;
	public:
	//Constructor.
	//left: The relative x location of the GUIListBox.
	//top: The relative y location of the GUIListBox.
	//witdh: The width of the GUIListBox.
	//height: The height of the GUIListBox.
	//enabled: Boolean if the GUIListBox is enabled or not.
	//visible: Boolean if the GUIListBox is visisble or not.
	- GUIListBox(int left=0,int top=0,int width=0,int height=0,bool enabled=true,bool visible=true,int gravity=GUIGravityLeft);
	+ GUIListBox(ImageManager& imageManager, SDL_Renderer& renderer, int left=0, int top=0, int width=0, int height=0, bool enabled=true, bool visible=true, int gravity=GUIGravityLeft);

	//Destructor
	~GUIListBox();

	//Method to remove all items and clear cache.
	void clearItems();

	//Method to add an item to the widget.
	//name: Text of the item.
	- //image: Custom image for the widget, if NULL the image will be generated from name string.
	- void addItem(std::string name, SDL_Surface* image=NULL);
	+ //texture: Custom image for the widget, if NULL the image will be generated from name string.
	+ void addItem(SDL_Renderer& renderer, std::string name, SharedTexture texture=nullptr);

	//Method to update an item in the widget.
	//index: index of the item.
	//newName: New text for the item.
	- //newImage: New custom image for the widget, if NULL the image will be generated from newName string.
	- void updateItem(int index, std::string newText, SDL_Surface* newImage=NULL);
	+ //newTexture: New custom image for the widget, if NULL the image will be generated from newName string.
	+ void updateItem(SDL_Renderer& renderer, int index, std::string newText, SharedTexture newTexture=nullptr);

	//Method used the get item names from the widget.
	//index: index of the item.
	std::string getItem(int index);

	//Method used to handle mouse and/or key events.
	//x: The x mouse location.
	//y: The y mouse location.
	//enabled: Boolean if the parent is enabled or not.
	//visible: Boolean if the parent is visible or not.
	//processed: Boolean if the event has been processed (by the parent) or not.
	//Returns: Boolean if the event is processed by the child.
	- virtual bool handleEvents(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	+ 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 GUIListBox.
	//x: The x location to draw the GUIListBox. (x+left)
	//y: The y location to draw the GUIListBox. (y+top)
	- virtual void render(int x=0,int y=0,bool draw=true);
	+ virtual void render(SDL_Renderer &renderer, int x=0, int y=0, bool draw=true);
	};


	//GUIObject that displays a list on only one line.
	//Instead of clicking the entries of the list you iterate through them.
	//It extends GUIObject because it's a special GUIObject.
	class GUISingleLineListBox:public GUIObject{
	public:
	//Vector containing the entries of the list.
	std::vector<std::pair<std::string,std::string> > item;

	//Integer used for the animation of the arrow.
	int animation;
	public:
	//Constructor.
	//left: The relative x location of the GUIListBox.
	//top: The relative y location of the GUIListBox.
	//witdh: The width of the GUIListBox.
	//height: The height of the GUIListBox.
	//enabled: Boolean if the GUIListBox is enabled or not.
	//visible: Boolean if the GUIListBox is visisble or not.
	- GUISingleLineListBox(int left=0,int top=0,int width=0,int height=0,bool enabled=true,bool visible=true,int gravity=GUIGravityLeft);
	+ GUISingleLineListBox(ImageManager& imageManager, SDL_Renderer& renderer,int left=0,int top=0,int width=0,int height=0,bool enabled=true,bool visible=true,int gravity=GUIGravityLeft);

	//Method for adding an item to the list.
	//name: The name of the item.
	//label: The text that is displayed.
	void addItem(std::string name,std::string label="");

	//Method for adding items from a vector to the list.
	//items: Vector containing the items in pairs, first is the name, second the label.
	void addItems(std::vector<std::pair<std::string,std::string> > items);

	//Method for adding items from a vector to the list.
	//items: Vector containing the items, the name will also be used as label.
	void addItems(std::vector<std::string> items);

	//Method for retrieving the name of an item for a given index.
	//index: The index of the item, when -1 is entered the current one will be used.
	std::string getName(unsigned int index=-1);

	//Method used to handle mouse and/or key events.
	//x: The x mouse location.
	//y: The y mouse location.
	//enabled: Boolean if the parent is enabled or not.
	//visible: Boolean if the parent is visible or not.
	//processed: Boolean if the event has been processed (by the parent) or not.
	//Returns: Boolean if the event is processed by the child.
	- virtual bool handleEvents(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	+ 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 GUIListBox.
	//x: The x location to draw the GUIListBox. (x+left)
	//y: The y location to draw the GUIListBox. (y+top)
	- virtual void render(int x=0,int y=0,bool draw=true);
	+ virtual void render(SDL_Renderer &renderer, int x=0, int y=0, bool draw=true);
	};

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

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

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

	-void GUIObjectHandleEvents(bool kill){
	+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();
	+ 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(e.name,e.obj,e.eventType);
	+ 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(){
	- //The cache is used as the actual image for GUIObjectImage and shouldn't be freed.
	- if(cache){
	- SDL_FreeSurface(cache);
	- cache=NULL;
	- }
	//We need to delete every child we have.
	for(unsigned int i=0;i<childControls.size();i++){
	delete childControls[i];
	}
	//Deleted the childs now empty the childControls vector.
	childControls.clear();
	}

	-bool GUIObject::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	+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(x,y,enabled,visible,b);
	+ 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(int x,int y,bool draw){
	+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(x,y,draw);
	+ 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(int x,int y,bool enabled,bool visible,bool processed){
	+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(x,y,enabled,visible,b);
	+ 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;
	}

	-//Found on gmane.comp.lib.sdl mailing list, see: http://comments.gmane.org/gmane.comp.lib.sdl/33664
	-//Original code by "Patricia Curtis" and later modified by "Jason"
	-static void SetSurfaceTrans(SDL_Surface* Src,double PercentTrans){
	- Uint8 Sbpp = Src->format->BytesPerPixel;
	- Uint8 *Sbits;
	-
	-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
	- int amask = 0x000000ff;
	- int cmask = 0xffffff00;
	-#else
	- int amask = 0xff000000;
	- int cmask = 0x00ffffff;
	- int Shift = 24;
	-#endif
	-
	- int x,y;
	- Uint32 Pixels;
	- Uint32 Alpha;
	-
	- for(y=0;y<Src->h;y++)
	- {
	- for(x=0;x<Src->w;x++)
	- {
	- Sbits = ((Uint8 )Src->pixels+(ySrc->pitch)+(x*Sbpp));
	- Pixels = ((Uint32 )(Sbits));
	-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
	- Alpha = Pixels & mask;
	-#else
	- Alpha = (Pixels&amask)>>Shift;
	-#endif
	- Alpha*=PercentTrans;
	-
	-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
	- ((Uint32 )(Sbits)) = (Pixels & cmask)\|Alpha;
	-#else
	- ((Uint32 )(Sbits)) = (Pixels & cmask)\|(Alpha<<Shift);
	-#endif
	- }
	- }
	-}
	-
	-void GUIButton::render(int x,int y,bool draw){
	+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;

	//Rectangle the size of the widget.
	SDL_Rect r;

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

	- //Check if the enabled state changed or the caption, if so we need to clear the (old) cache.
	- if(enabled!=cachedEnabled \|\| caption.compare(cachedCaption)!=0 \|\| width<=0){
	- //Free the cache.
	- SDL_FreeSurface(cache);
	- cache=NULL;
	-
	- //And cache the new values.
	- cachedEnabled=enabled;
	- cachedCaption=caption;
	-
	- //Finally resize the widget
	- if(autoWidth)
	- width=-1;
	- }
	+ 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(!cache){
	+ if(!cacheTex){
	SDL_Color color;
	if(inDialog)
	color=themeTextColorDialog;
	else
	color=themeTextColor;

	- if(!smallFont)
	- cache=TTF_RenderUTF8_Blended(fontGUI,lp,color);
	- else
	- cache=TTF_RenderUTF8_Blended(fontGUISmall,lp,color);
	-
	+ if(!smallFont) {
	+ cacheTex = textureFromText(renderer, *fontGUI, lp, color);
	+ } else {
	+ cacheTex = textureFromText(renderer, *fontGUISmall, lp, color);
	+ }
	//Make the widget transparent if it's disabled.
	- if(!enabled)
	- SetSurfaceTrans(cache,0.5);
	-
	+ if(!enabled) {
	+ SDL_SetTextureAlphaMod(cacheTex.get(), 128);
	+ }
	//Calculate proper size for the widget.
	if(width<=0){
	- width=cache->w+50;
	+ 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.
	- r.x=x-gravityX+(width-cache->w)/2;
	- r.y=y+(height-cache->h)/2-GUI_FONT_RAISE;
	+ 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(cache->w+32<=width){
	- //Create a rectangle that selects the right image from bmGUI.
	- SDL_Rect r2={64,0,16,16};
	+ if(size.w+32<=width){
	if(state==1){
	if(inDialog){
	- applySurface(x-gravityX+(width-cache->w)/2+4+cache->w+5,y+2,arrowLeft2,screen,NULL);
	- applySurface(x-gravityX+(width-cache->w)/2-25,y+2,arrowRight2,screen,NULL);
	+ 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{
	- applySurface(x-gravityX+(width-cache->w)/2+4+cache->w+5,y+2,arrowLeft1,screen,NULL);
	- applySurface(x-gravityX+(width-cache->w)/2-25,y+2,arrowRight1,screen,NULL);
	+ 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){
	- applySurface(x-gravityX+(width-cache->w)/2+4+cache->w,y+2,arrowLeft2,screen,NULL);
	- applySurface(x-gravityX+(width-cache->w)/2-20,y+2,arrowRight2,screen,NULL);
	+ 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{
	- applySurface(x-gravityX+(width-cache->w)/2+4+cache->w,y+2,arrowLeft1,screen,NULL);
	- applySurface(x-gravityX+(width-cache->w)/2-20,y+2,arrowRight1,screen,NULL);
	+ 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 and free the surface.
	- SDL_BlitSurface(cache,NULL,screen,&r);
	+ //Draw the text.
	+ //SDL_BlitSurface(cache,NULL,screen,&r);
	+ applyTexture(drawX, drawY, *cacheTex, renderer);
	}
	}
	}

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

	-bool GUICheckBox::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	+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(int x,int y,bool draw){
	+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;
	-
	- //Check if the enabled state changed or the caption, if so we need to clear the (old) cache.
	- if(enabled!=cachedEnabled \|\| caption.compare(cachedCaption)!=0 \|\| width<=0){
	- //Free the cache.
	- SDL_FreeSurface(cache);
	- cache=NULL;
	-
	- //And cache the new values.
	- cachedEnabled=enabled;
	- cachedCaption=caption;
	-
	- //Finally resize the widget
	- if(autoWidth)
	- width=-1;
	- }
	+
	+ refreshCache(enabled);

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

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

	- cache=TTF_RenderUTF8_Blended(fontText,lp,color);
	+ cacheTex=textureFromText(renderer,*fontText,lp,color);
	}

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

	- //Draw the text and free the surface.
	- SDL_BlitSurface(cache,NULL,screen,&r);
	+ //Draw the text
	+ applyTexture(drawX, drawY, *cacheTex, renderer);
	}
	}

	if(draw){
	//Draw the check (or not).
	- SDL_Rect r1={0,0,16,16};
	- if(value==1\|\|value==2)
	- r1.x=value*16;
	- r.x=x+width-20;
	- r.y=y+(height-16)/2;
	- SDL_BlitSurface(bmGUI,&r1,screen,&r);
	+ //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(int x,int y,bool enabled,bool visible,bool processed){
	+bool GUILabel::handleEvents(SDL_Renderer&,int ,int ,bool ,bool ,bool processed){
	return processed;
	}

	-void GUILabel::render(int x,int y,bool draw){
	+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.
	- if(enabled!=cachedEnabled \|\| caption.compare(cachedCaption)!=0 \|\| width<=0){
	- //Free the cache.
	- SDL_FreeSurface(cache);
	- cache=NULL;
	-
	- //And cache the new values.
	- cachedEnabled=enabled;
	- cachedCaption=caption;
	-
	- //Finally resize the widget
	- if(autoWidth)
	- width=-1;
	- }
	+ 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(cache==NULL){
	+ if(!cacheTex){
	SDL_Color color;
	if(inDialog)
	color=themeTextColorDialog;
	else
	color=themeTextColor;

	- cache=TTF_RenderUTF8_Blended(fontText,lp,color);
	-
	+ cacheTex=textureFromText(renderer, *fontText, lp, color);
	if(width<=0)
	- width=cache->w;
	+ width=textureWidth(*cacheTex);
	}

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

	- r.y=y+(height - cache->h)/2;
	+ r.y=y+(height - size.h)/2;
	r.x+=gravityX;
	- SDL_BlitSurface(cache,NULL,screen,&r);
	+ 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(int x,int y,bool enabled,bool visible,bool processed){
	+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.
	- int key=(int)event.key.keysym.unicode;
	+ 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,char(key));
	+ 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,char(key));
	+ 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,char(key));
	+ caption.insert((size_t)highlightEnd,1,static_cast<char>(key));
	highlightEnd++;
	highlightStart=highlightEnd;
	highlightStartX=highlightEndX;
	}
	int advance;
	- TTF_GlyphMetrics(fontText,char(key),NULL,NULL,NULL,NULL,&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(cache&&!caption.empty()){
	+ 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(int x,int y,bool draw){
	+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.
	- if(enabled!=cachedEnabled \|\| caption.compare(cachedCaption)!=0 \|\| width<=0){
	- //Free the cache.
	- SDL_FreeSurface(cache);
	- cache=NULL;
	-
	- //And cache the new values.
	- cachedEnabled=enabled;
	- cachedCaption=caption;
	-
	- //Finally resize the widget
	- if(autoWidth)
	- width=-1;
	- }
	+ //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,screen,color);
	+ drawGUIBox(x,y,width,height,renderer,color);
	}

	//Rectangle used for drawing.
	- SDL_Rect r;
	+ 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(!cache){
	- //Draw the black text.
	- SDL_Color black={0,0,0,0};
	- cache=TTF_RenderUTF8_Blended(fontText,lp,black);
	- }
	+ 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_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_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--;
	+ tick--;
	}
	}

	//Calculate the location, center it vertically.
	- r.x=x+4;
	- r.y=y+(height - cache->h)/2;
	-
	+ //r.x=x+4;
	+ //r.y=y+(height - cache->h)/2;
	+ 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.
	- SDL_Rect tmp={0,0,width-2,25};
	- SDL_BlitSurface(cache,&tmp,screen,&r);
	+ const SDL_Rect srcRect={0,0,width-2,25};
	+ //SDL_BlitSurface(cache,&tmp,screen,&r);
	+ SDL_RenderCopy(&renderer, cacheTex.get(), &srcRect, &dstRect);
	+ //applyTexture(x+4, y+(height - textureHeight(*cacheTex))/2,cacheTex, renderer, &srcRect);
	}
	}else{
	//Only draw the carrot when focus.
	if(state==2&&draw){
	r.x=x+4;
	r.y=y+4;
	r.w=2;
	r.h=height-8;
	- SDL_FillRect(screen,&r,0);
	+ SDL_SetRenderDrawColor(&renderer, 0,0,0,0);
	+ SDL_RenderFillRect(&renderer, &r);
	}
	}
	}

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

	-bool GUIFrame::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	+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(x,y,enabled,visible,b);
	+ 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(int x,int y,bool draw){
	+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.
	- SDL_FreeSurface(cache);
	- cache=NULL;
	-
	+ 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,screen,color);
	+ 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(!cache)
	- cache=TTF_RenderUTF8_Blended(fontGUI,lp,themeTextColorDialog);
	-
	+ if(!cacheTex) {
	+ cacheTex = textureFromText(renderer, *fontGUI, lp, themeTextColorDialog);
	+ }
	//Draw the text.
	- if(draw)
	- applySurface(x+(width-cache->w)/2,y+6-GUI_FONT_RAISE,cache,screen,NULL);
	- }
	-
	+ 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(x,y,draw);
	+ childControls[i]->render(renderer,x,y,draw);
	}
	}

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

	GUIImage::~GUIImage(){
	- //Check if the surface is managed, if so free it.
	- if(managed)
	- SDL_FreeSurface(image);
	}

	-bool GUIImage::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	+bool GUIImage::handleEvents(SDL_Renderer&,int ,int ,bool ,bool ,bool processed){
	return processed;
	}

	void GUIImage::fitToImage(){
	- //Increase or decrease the width and height to fully show the image.
	- if(clip.w!=0)
	+ 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=image->w;
	- if(clip.h!=0)
	+ } else {
	+ width=imageSize.w;
	+ }
	+ if(clip.h!=0) {
	height=clip.h;
	- else
	- height=image->h;
	+ } else {
	+ height=imageSize.h;
	+ }
	}

	-void GUIImage::render(int x,int y,bool draw){
	+void GUIImage::render(SDL_Renderer& renderer, int x,int y,bool draw){
	//There's no need drawing the widget when it's invisible.
	- if(!visible)
	+ //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;
	+ SDL_Rect r{clip};
	//The width and height are capped by the GUIImage itself.
	- r=clip;
	- if(r.w>width \|\| r.w==0)
	+ if(r.w>width \|\| r.w==0) {
	r.w=width;
	- if(r.h>height \|\| r.h==0)
	+ }
	+ if(r.h>height \|\| r.h==0) {
	r.h=height;
	-
	- //Make sure the image isn't null.
	- if(image)
	- applySurface(x,y,image,screen,&r);
	+ }
	+
	+ const SDL_Rect dstRect{x,y,r.w,r.h};
	+ //applySurface(x,y,image,screen,&r);
	+ SDL_RenderCopy(&renderer, image.get(), &r, &dstRect);
	}
	diff --git a/src/GUIObject.h b/src/GUIObject.h
	index 1ea69f6..bf8103c 100644
	--- a/src/GUIObject.h
	+++ b/src/GUIObject.h
	@@ -1,396 +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 "Globals.h"
	#include "Functions.h"
	#include "FileManager.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;
	class GUIObject;

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

	- //Surface containing some gui images.
	- SDL_Surface* bmGUI;
	+ //Texture containing different gui images.
	+ SharedTexture bmGuiTex;

	//Surface that can be used to cache rendered text.
	- SDL_Surface* cache;
	+ 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(int left=0,int top=0,int width=0,int height=0,
	+ 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),
	- cache(NULL),cachedEnabled(enabled),gravityX(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.
	- bmGUI=loadImage(getDataPath()+"gfx/gui.png");
	+ 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(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	+ 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(int x=0,int y=0,bool draw=true);
	+ 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(bool kill=false);
	+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(int left=0,int top=0,int width=0,int height=0,
	+ 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(left,top,width,height,caption,value,enabled,visible,gravity),
	- smallFont(false){ };
	+ 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(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	+ 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(int x=0,int y=0,bool draw=true);
	+ 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(int left=0,int top=0,int width=0,int height=0,
	+ 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(left,top,width,height,caption,value,enabled,visible,gravity){ };
	- //Method used to handle mouse and/or key events.
	+ 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(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	+ 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(int x=0,int y=0,bool draw=true);
	+ virtual void render(SDL_Renderer &renderer, int x=0, int y=0, bool draw=true);
	};

	class GUILabel:public GUIObject{
	public:
	- GUILabel(int left=0,int top=0,int width=0,int height=0,
	+ 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(left,top,width,height,caption,value,enabled,visible,gravity){ };
	+ 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(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	+ 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(int x=0,int y=0,bool draw=true);
	+ virtual void render(SDL_Renderer &renderer, int x=0, int y=0, bool draw=true);
	};

	class GUITextBox:public GUIObject{
	public:
	- GUITextBox(int left=0,int top=0,int width=0,int height=0,
	+ 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(left,top,width,height,caption,value,enabled,visible,gravity),
	- highlightStart(0),highlightEnd(0),tick(15),key(-1),keyHoldTime(0),keyTime(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(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	+ 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(int x=0,int y=0,bool draw=true);
	+ 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(int left=0,int top=0,int width=0,int height=0,
	+ 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(left,top,width,height,caption,value,enabled,visible,gravity){
	+ 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(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	+ 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(int x=0,int y=0,bool draw=true);
	+ virtual void render(SDL_Renderer &renderer, int x=0, int y=0, bool draw=true);
	};

	-//A GUIObject that holds an SDL_Surface for rendering.
	-//NOTE: The image is not freed by the GUIImage.
	+//A GUIObject that holds an shared_ptr to a Texture for rendering.
	class GUIImage:public GUIObject{
	public:
	- GUIImage(int left=0,int top=0,int width=0,int height=0,
	- SDL_Surface* image=NULL,SDL_Rect clip=SDL_Rect(),bool managed=false,
	- bool enabled=true,bool visible=true):
	- GUIObject(left,top,width,height,NULL,0,enabled,visible,0),
	- image(image),clip(clip),managed(managed){ };
	+ 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(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	+ 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(int x=0,int y=0,bool draw=true);
	+ //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: SDL_Surface containing the image.
	- void setImage(SDL_Surface* surface){
	- image=surface;
	+ //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:
	- //Boolean if the image should be managed by the GUIImage.
	- //If set to true the image's surface will be freed upon deletion.
	- bool managed;
	-
	- //Pointer to the SDL_Surface to draw.
	- SDL_Surface* image;
	- //Optional rectangle for defining the section of the surface that should be drawn.
	+ //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/GUIOverlay.cpp b/src/GUIOverlay.cpp
	index bde0888..f70915a 100644
	--- a/src/GUIOverlay.cpp
	+++ b/src/GUIOverlay.cpp
	@@ -1,133 +1,132 @@
	/*
	* Copyright (C) 2012-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 "Globals.h"
	#include "GUIOverlay.h"
	//#include "StatisticsManager.h"

	using namespace std;

	-GUIOverlay::GUIOverlay(GUIObject* root,bool dim):root(root),dim(dim){
	+GUIOverlay::GUIOverlay(SDL_Renderer& renderer, GUIObject* root,bool dim):root(root),dim(dim){
	//First keep the pointer to the current GUIObjectRoot and currentState.
	parentState=currentState;
	tempGUIObjectRoot=GUIObjectRoot;

	//Now set the GUIObject root to the new root.
	currentState=this;
	GUIObjectRoot=root;

	//Dim the background.
	if(dim){
	- SDL_FillRect(tempSurface,NULL,0);
	- SDL_SetAlpha(tempSurface,SDL_SRCALPHA,155);
	- SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	+ dimScreen(renderer);
	}
	}

	GUIOverlay::~GUIOverlay(){
	//We need to place everything back.
	currentState=parentState;
	parentState=NULL;

	//Delete the GUI if present.
	if(GUIObjectRoot)
	delete GUIObjectRoot;

	//Now put back the parent gui.
	GUIObjectRoot=tempGUIObjectRoot;
	tempGUIObjectRoot=NULL;
	}

	-void GUIOverlay::enterLoop(bool skip){
	+void GUIOverlay::enterLoop(ImageManager& imageManager, SDL_Renderer& renderer, bool skip){
	while(GUIObjectRoot){
	while(SDL_PollEvent(&event)){
	//Check for a resize event.
	- if(event.type==SDL_VIDEORESIZE){
	- onVideoResize();
	+ if(event.type==SDL_WINDOWEVENT_RESIZED){
	+ onVideoResize(imageManager,renderer);
	continue;
	}
	- GUIObjectHandleEvents(true);
	+ GUIObjectHandleEvents(imageManager,renderer,true);

	//Also check for the return, escape or backspace button.
	//escape = KEYUP.
	//backspace and return = KEYDOWN.
	if(skip && ((event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_ESCAPE) \|\|
	(event.type==SDL_KEYDOWN && (event.key.keysym.sym==SDLK_RETURN \|\| event.key.keysym.sym==SDLK_BACKSPACE)))){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	//Render the gui.
	if(GUIObjectRoot)
	- GUIObjectRoot->render();
	+ GUIObjectRoot->render(renderer);
	/*//draw new achievements (if any)
	statsMgr.render();*/
	//display it
	- flipScreen();
	+ flipScreen(renderer);
	SDL_Delay(30);
	}

	//We broke out so clean up.
	delete this;
	}

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

	//Nothing to do here
	-void GUIOverlay::logic(){
	+void GUIOverlay::logic(ImageManager&, SDL_Renderer&){
	//Check if the GUIObjectRoot (of the overlay) is deleted.
	if(!GUIObjectRoot)
	delete this;
	}
	-void GUIOverlay::render(){}

	+void GUIOverlay::render(ImageManager&, SDL_Renderer&){}

	-void GUIOverlay::resize(){
	+void GUIOverlay::resize(ImageManager& imageManager, SDL_Renderer& renderer){
	//We recenter the GUI.
	GUIObjectRoot->left=(SCREEN_WIDTH-GUIObjectRoot->width)/2;
	GUIObjectRoot->top=(SCREEN_HEIGHT-GUIObjectRoot->height)/2;

	//Now let the parent state resize.
	GUIObjectRoot=tempGUIObjectRoot;
	- parentState->resize();
	+ parentState->resize(imageManager, renderer);
	//NOTE: After the resize it's likely that the GUIObjectRoot is new so we need to update our tempGUIObjectRoot pointer.
	tempGUIObjectRoot=GUIObjectRoot;

	//Now render the parentState.
	- parentState->render();
	+ parentState->render(imageManager,renderer);
	if(GUIObjectRoot)
	- GUIObjectRoot->render();
	+ GUIObjectRoot->render(renderer);

	//And set the GUIObjectRoot back to the overlay gui.
	GUIObjectRoot=root;

	//Dim the background.
	if(dim){
	- SDL_FillRect(tempSurface,NULL,0);
	- SDL_SetAlpha(tempSurface,SDL_SRCALPHA,155);
	- SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	+ //SDL_FillRect(tempSurface,NULL,0);
	+ //SDL_SetSurfaceAlphaMod(tempSurface,155);
	+ //SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	+ dimScreen(renderer);
	}
	}
	diff --git a/src/GUIOverlay.h b/src/GUIOverlay.h
	index 6ca3bcc..4ff1ddd 100644
	--- a/src/GUIOverlay.h
	+++ b/src/GUIOverlay.h
	@@ -1,63 +1,63 @@
	/*
	* 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 GUI_OVERLAY_H
	#define GUI_OVERLAY_H

	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#include "GameState.h"
	#include "GUIObject.h"


	//The GUIOverlay state, this is a special state since it doens't appear in the states list.
	//It is used to properly handle GUIs that overlay the current state, dialogs for example.
	class GUIOverlay : public GameState{
	private:
	//A pointer to the current state to put back when needed.
	GameState* parentState;

	//Pointer to the GUI root of the overlay.
	GUIObject* root;
	//Pointer to the previous GUIObjectRoot.
	GUIObject* tempGUIObjectRoot;

	//Boolean if the screen should be dimmed.
	bool dim;
	public:
	//Constructor.
	//root: Pointer to the new GUIObjectRoot.
	//dim: Boolean if the parent state should be dimmed.
	- GUIOverlay(GUIObject* root,bool dim=true);
	+ GUIOverlay(SDL_Renderer &renderer, GUIObject* root, bool dim=true);
	//Destructor.
	~GUIOverlay();

	//Method that can be used to create a "sub gameloop".
	//This is usefull in case the GUI that is overlayed is used for userinput which the function needs to return.
	//NOTE: This loop should be kept similar to the main loop.
	//skip: Boolean if this GUIOverlay can be "skipped", meaning it can be exited quickly by pressing escape or return.
	- void enterLoop(bool skip=false);
	+ void enterLoop(ImageManager &imageManager, SDL_Renderer& renderer, bool skip=false);

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

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

	#include "GUIScrollBar.h"
	+
	+namespace {
	+const int SCROLLBAR_IMAGE_WIDTH = 16;
	+const int SCROLLBAR_IMAGE_HEIGHT = 16;
	+}
	+
	using namespace std;

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

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

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

	-bool GUIScrollBar::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	+bool GUIScrollBar::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;

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

	return b;
	}

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

	- //The color.
	- int clr=-1;
	- //Rectangle the size of the button.
	- SDL_Rect r={x1,y1,x2-x1,y2-y1};
	-
	- //Check
	- if((state&0xFF)==index){
	- if(((state>>8)&0xFF)==index){
	- //Set the color gray.
	- clr=0xDDDDDDFF;
	- }else{
	- //Set the color to lightgray.
	- clr=0xFFFFFFFF;
	- }
	- }
	-
	- //Draw a box.
	- drawGUIBox(r.x,r.y,r.w,r.h,screen,clr);
	-
	+ {
	+ //The color.
	+ int clr=-1;
	+ //Rectangle the size of the button.
	+ const SDL_Rect r={x1,y1,x2-x1,y2-y1};
	+
	+ //Check
	+ if((state&0xFF)==index){
	+ if(((state>>8)&0xFF)==index){
	+ //Set the color gray.
	+ clr=0xDDDDDDFF;
	+ }else{
	+ //Set the color to lightgray.
	+ clr=0xFFFFFFFF;
	+ }
	+ }
	+
	+ //Draw a box.
	+ drawGUIBox(r.x,r.y,r.w,r.h,renderer,clr);
	+ }
	+
	//Boolean if there should be an image on the button.
	bool b;
	//The check depends on the orientation.
	if(orientation)
	b=(y2-y1>=14);
	else
	b=(x2-x1>=14);

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

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

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

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

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

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

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

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

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

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

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

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

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

	//Now the actual drawing begins.
	if(orientation&&draw){
	//The scrollbar is vertically orientated.
	if(valuePerPixel>0){
	//There are four buttons so draw them.
	- renderScrollBarButton(2,x+left,y+top,x+left+width,y+top+height,-1,-1);
	- renderScrollBarButton(1,x+left,y+top,x+left+width,y+top+16,80,0);
	- renderScrollBarButton(3,x+left,y-1+(int)thumbStart,x+left+width,y+1+(int)thumbEnd,0,16);
	- renderScrollBarButton(5,x+left,y+top+height-16,x+left+width,y+top+height,96,0);
	+ renderScrollBarButton(renderer, 2,x+left,y+top,x+left+width,y+top+height,-1,-1);
	+ renderScrollBarButton(renderer,1,x+left,y+top,x+left+width,y+top+16,80,0);
	+ renderScrollBarButton(renderer,3,x+left,y-1+(int)thumbStart,x+left+width,y+1+(int)thumbEnd,0,16);
	+ renderScrollBarButton(renderer,5,x+left,y+top+height-16,x+left+width,y+top+height,96,0);
	}else{
	//There are two buttons so draw them.
	int f=top+height/2;
	- renderScrollBarButton(1,x+left,y+top,x+left+width,y+1+f,80,0);
	- renderScrollBarButton(5,x+left,y+f,x+left+width,y+top+height,96,0);
	+ renderScrollBarButton(renderer,1,x+left,y+top,x+left+width,y+1+f,80,0);
	+ renderScrollBarButton(renderer,5,x+left,y+f,x+left+width,y+top+height,96,0);
	}
	}else{
	//The scrollbar is horizontally orientated.
	if(valuePerPixel>0){
	//There are five buttons so draw them.
	- renderScrollBarButton(1,x+left,y+top,x+left+16,y+top+height,80,16);
	- renderScrollBarButton(2,x+left+15,y+top,x+(int)thumbStart,y+top+height,-1,-1);
	- renderScrollBarButton(3,x-1+(int)thumbStart,y+top,x+1+(int)thumbEnd,y+top+height,16,16);
	- renderScrollBarButton(4,x+(int)thumbEnd,y+top,x+left+width-15,y+top+height,-1,-1);
	- renderScrollBarButton(5,x+left+width-16,y+top,x+left+width,y+top+height,96,16);
	+ renderScrollBarButton(renderer,1,x+left,y+top,x+left+16,y+top+height,80,16);
	+ renderScrollBarButton(renderer,2,x+left+15,y+top,x+(int)thumbStart,y+top+height,-1,-1);
	+ renderScrollBarButton(renderer,3,x-1+(int)thumbStart,y+top,x+1+(int)thumbEnd,y+top+height,16,16);
	+ renderScrollBarButton(renderer,4,x+(int)thumbEnd,y+top,x+left+width-15,y+top+height,-1,-1);
	+ renderScrollBarButton(renderer,5,x+left+width-16,y+top,x+left+width,y+top+height,96,16);
	}else{
	//There are two buttons so draw them.
	int f=left+width/2;
	- renderScrollBarButton(1,x+left,y+top,x+1+f,y+top+height,80,16);
	- renderScrollBarButton(5,x+f,y+top,x+left+width,y+top+height,96,16);
	+ renderScrollBarButton(renderer,1,x+left,y+top,x+1+f,y+top+height,80,16);
	+ renderScrollBarButton(renderer,5,x+f,y+top,x+left+width,y+top+height,96,16);
	}
	}
	}
	diff --git a/src/GUIScrollBar.h b/src/GUIScrollBar.h
	index 25cb214..8ad576c 100644
	--- a/src/GUIScrollBar.h
	+++ b/src/GUIScrollBar.h
	@@ -1,97 +1,97 @@
	/*
	* 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 GUISCROLLBAR_H
	#define GUISCROLLBAR_H

	#include "GUIObject.h"

	//Constant integers containing the two possible orientations of the scrollbar.
	const int ScrollBarHorizontal=0;
	const int ScrollBarVertical=1;

	class GUIScrollBar:public GUIObject{
	public:
	//The minimum value of the scrollbar.
	int minValue;
	//The maximum value of the scrollbar.
	int maxValue;

	//The step size when a small step is made.
	int smallChange;
	//The step size when a large step is made.
	int largeChange;

	//The orientation of the scrollbar.
	int orientation;
	private:
	//
	float thumbStart;
	//
	float thumbEnd;
	float valuePerPixel;
	//Float containing the start position when dragging the scrollbar.
	float startDragPos;

	int criticalValue;
	int timer;

	//Boolean if the scrollbar position has changed.
	bool changed;

	//Method that will calculate the position of the scrollbar.
	void calcPos();

	//Method that will render a scrollbar button.
	//index:
	//x1:
	//y1:
	//x2:
	//y2:
	//srcLeft:
	//srcRight:
	- void renderScrollBarButton(int index,int x1,int y1,int x2,int y2,int srcLeft,int srcTop);
	+ void renderScrollBarButton(SDL_Renderer &renderer, int index, int x1, int y1, int x2, int y2, int srcLeft, int srcTop);
	public:
	- GUIScrollBar(int left=0,int top=0,int width=0,int height=0,int orientation=0,
	+ GUIScrollBar(ImageManager& imageManager, SDL_Renderer& renderer,int left=0,int top=0,int width=0,int height=0,int orientation=0,
	int value=0,int minValue=0,int maxValue=100,int smallChange=10,int largeChange=50,
	bool enabled=true,bool visible=true):
	- GUIObject(left,top,width,height,NULL,value,enabled,visible),
	+ GUIObject(imageManager,renderer,left,top,width,height,NULL,value,enabled,visible),
	minValue(minValue),maxValue(maxValue),smallChange(smallChange),largeChange(largeChange),orientation(orientation),
	thumbStart(0.0f),thumbEnd(0.0f),valuePerPixel(0.0f),startDragPos(0.0f),criticalValue(0),timer(0),changed(false)
	{
	//In the constructor we simply call calcPos().
	calcPos();
	}


	//Method used to handle mouse and/or key events.
	//x: The x mouse location.
	//y: The y mouse location.
	//enabled: Boolean if the parent is enabled or not.
	//visible: Boolean if the parent is visible or not.
	//processed: Boolean if the event has been processed (by the parent) or not.
	//Returns: Boolean if the event is processed by the child.
	- virtual bool handleEvents(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	+ 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)
	- virtual void render(int x=0,int y=0,bool draw=true);
	+ virtual void render(SDL_Renderer& renderer, int x=0,int y=0,bool draw=true);
	};

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

	#include "GUISlider.h"
	using namespace std;

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

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

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

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

	-bool GUISlider::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	+bool GUISlider::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;

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

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

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

	return b;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	//Now the actual drawing begins.
	if(valuePerPixel>0){
	//Draw the line the slider moves along.
	- drawGUIBox(x+left,y+top+(height-4)/2,width,4,screen,0);
	- renderScrollBarButton(2,x-1+(int)thumbStart,y+top+(height/4),x+1+(int)thumbEnd,y+top+(height/4)*3,16,16);
	+ drawGUIBox(x+left,y+top+(height-4)/2,width,4,renderer,0);
	+ renderScrollBarButton(renderer,2,x-1+(int)thumbStart,y+top+(height/4),x+1+(int)thumbEnd,y+top+(height/4)*3,16,16);
	}else{
	//There are two buttons so draw them.
	int f=left+width/2;
	- renderScrollBarButton(1,x+left,y+top,x+1+f,y+top+height,48,0);
	- renderScrollBarButton(5,x+f,y+top,x+left+width,y+top+height,64,0);
	+ renderScrollBarButton(renderer,1,x+left,y+top,x+1+f,y+top+height,48,0);
	+ renderScrollBarButton(renderer,5,x+f,y+top,x+left+width,y+top+height,64,0);
	}
	}
	diff --git a/src/GUISlider.h b/src/GUISlider.h
	index eb7af89..a8fb3d5 100644
	--- a/src/GUISlider.h
	+++ b/src/GUISlider.h
	@@ -1,89 +1,89 @@
	/*
	* 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 GUISLIDER_H
	#define GUISLIDER_H

	#include "GUIObject.h"

	class GUISlider:public GUIObject{
	public:
	//The minimum value of the slider.
	int minValue;
	//The maximum value of the slider.
	int maxValue;

	//The step size when a large step is made.
	int largeChange;
	private:
	//
	float thumbStart;
	//
	float thumbEnd;
	//Float containing the value per pixel factor.
	float valuePerPixel;
	//Float containing the start position when dragging the scrollbar.
	float startDragPos;

	int criticalValue;
	int timer;

	//Boolean if the scrollbar position has changed.
	bool changed;

	//Method that will calculate the position of the scrollbar.
	void calcPos();

	//Method that will render a scrollbar button.
	//index:
	//x1:
	//y1:
	//x2:
	//y2:
	//srcLeft:
	//srcRight:
	- void renderScrollBarButton(int index,int x1,int y1,int x2,int y2,int srcLeft,int srcTop);
	+ void renderScrollBarButton(SDL_Renderer& renderer, int index,int x1,int y1,int x2,int y2,int srcLeft,int srcTop);
	public:
	- GUISlider(int left=0,int top=0,int width=0,int height=0,
	+ GUISlider(ImageManager& imageManager, SDL_Renderer& renderer,int left=0,int top=0,int width=0,int height=0,
	int value=0,int minValue=0,int maxValue=100,int largeChange=50,
	bool enabled=true,bool visible=true):
	- GUIObject(left,top,width,height,NULL,value,enabled,visible),
	+ GUIObject(imageManager,renderer,left,top,width,height,NULL,value,enabled,visible),
	minValue(minValue),maxValue(maxValue),largeChange(largeChange),
	thumbStart(0.0f),thumbEnd(0.0f),valuePerPixel(0.0f),startDragPos(0.0f),criticalValue(0),timer(0),changed(false)
	{
	//In the constructor we simply call calcPos().
	calcPos();
	}


	//Method used to handle mouse and/or key events.
	//x: The x mouse location.
	//y: The y mouse location.
	//enabled: Boolean if the parent is enabled or not.
	//visible: Boolean if the parent is visible or not.
	//processed: Boolean if the event has been processed (by the parent) or not.
	//Returns: Boolean if the event is processed by the child.
	- virtual bool handleEvents(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	+ 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)
	- virtual void render(int x=0,int y=0,bool draw=true);
	+ virtual void render(SDL_Renderer& renderer, int x=0,int y=0,bool draw=true) override;
	};

	#endif
	diff --git a/src/GUISpinBox.cpp b/src/GUISpinBox.cpp
	index eeb0a18..4bb66dd 100644
	--- a/src/GUISpinBox.cpp
	+++ b/src/GUISpinBox.cpp
	@@ -1,390 +1,401 @@
	/*
	* 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 "GUISpinBox.h"

	-bool GUISpinBox::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	+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.
	- int key=(int)event.key.keysym.unicode;
	+ 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 carrot to the place clicked
	+ //Move caret to the place clicked
	int click=i-x;

	- if(!cache){
	+ if(!cacheTex){
	value=0;
	- }else if(click>cache->w){
	+ }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_MOUSEBUTTONUP){
	- if(event.button.button==SDL_BUTTON_WHEELUP){
	+ if(event.type==SDL_MOUSEWHEEL){
	+ if(event.wheel.y > 0){
	updateValue(true);
	- }else if(event.button.button==SDL_BUTTON_WHEELDOWN){
	+ }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(int x,int y,bool draw){
	+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;
	}
	}
	}
	}

	- //Rectangle.
	- SDL_Rect r;
	-
	//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.
	- SDL_FreeSurface(cache);
	- cache=NULL;
	-
	+ //SDL_FreeSurface(cache);
	+ //cache.NULL;
	+ 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.
	- Uint32 color=0xFFFFFF00\|clr;
	- drawGUIBox(x,y,width,height,screen,color);
	+ const Uint32 color=0xFFFFFF00\|clr;
	+ drawGUIBox(x,y,width,height,renderer,color);

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

	if(!caption.empty()){
	//Update graphic cache if empty.
	- if(!cache){
	- SDL_Color black={0,0,0,0};
	- cache=TTF_RenderUTF8_Blended(fontText,caption.c_str(),black);
	+ if(!cacheTex){
	+ SDL_Color black={0,0,0,255};
	+// cache=TTF_RenderUTF8_Blended(fontText,caption.c_str(),black);
	+ 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){
	- r.x=x+2;
	- r.y=y+(height-cache->h)/2;
	-
	+ 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);
	//Draw the text.
	- SDL_Rect tmp={0,0,width-2,25};
	- SDL_BlitSurface(cache,&tmp,screen,&r);
	-
	- //Only draw the carrot when focus.
	+// SDL_Rect tmp={0,0,width-2,25};
	+
	+// SDL_BlitSurface(cache,&tmp,screen,&r);
	+ //SDL_RenderCopy(&renderer, cacheTex.get(), &tmp, &dstRect);
	+
	+
	+ //Only draw the caret when focus.
	if(state==2){
	- r.x=x;
	- r.y=y+4;
	- r.w=2;
	- r.h=height-8;
	+ 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);
	- r.x+=advance;
	+ caretRect.x+=advance;
	}

	//Make sure that the carrot is inside the textbox.
	- if(r.x<x+width)
	- SDL_FillRect(screen,&r,0);
	+ if(caretRect.x<x+width) {
	+ //Draw a box representing the caret.
	+ SDL_RenderFillRect(&renderer, &caretRect);
	+ }
	}
	+
	}else{
	- //Only draw the carrot when focus.
	+ //Only draw the caret when focus.
	if(state==2&&draw){
	- r.x=x+4;
	- r.y=y+4;
	- r.w=2;
	- r.h=height-8;
	- SDL_FillRect(screen,&r,0);
	+ 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/GUISpinBox.h b/src/GUISpinBox.h
	index 945f6f7..2aaea9f 100644
	--- a/src/GUISpinBox.h
	+++ b/src/GUISpinBox.h
	@@ -1,70 +1,70 @@
	/*
	* 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 GUISPINBOX_H
	#define GUISPINBOX_H

	#include "GUIObject.h"

	class GUISpinBox:public GUIObject{
	public:
	- GUISpinBox(int left=0,int top=0,int width=0,int height=0,
	+ GUISpinBox(ImageManager& imageManager,SDL_Renderer& renderer,int left=0,int top=0,int width=0,int height=0,
	bool enabled=true,bool visible=true):
	- GUIObject(left,top,width,height,NULL,0,enabled,visible),
	+ GUIObject(imageManager,renderer,left,top,width,height,NULL,0,enabled,visible),
	change(1.0f),limitMax(100),limitMin(-100),format("%-.2f"),
	- key(-1),keyHoldTime(0),keyTime(0){ };
	+ key(-1),keyHoldTime(0),keyTime(0){}

	//Amount of single change.
	float change;
	//Widget's value stays between these values.
	float limitMax,limitMin;

	//Standard C printf format used for displaying the number.
	const char* format;

	//Method to update widget's value.
	void update();

	//Method to change widget's value.
	//positive: Boolean if add or remove change.
	void updateValue(bool positive);

	//Method used to handle mouse and/or key events.
	//x: The x mouse location.
	//y: The y mouse location.
	//enabled: Boolean if the parent is enabled or not.
	//visible: Boolean if the parent is visible or not.
	//processed: Boolean if the event has been processed (by the parent) or not.
	//Returns: Boolean if the event is processed by the child.
	- virtual bool handleEvents(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	+ 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)
	- virtual void render(int x=0,int y=0,bool draw=true);
	+ virtual void render(SDL_Renderer& renderer, int x=0,int y=0,bool draw=true);
	private:
	//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;
	};

	#endif
	diff --git a/src/GUITextArea.cpp b/src/GUITextArea.cpp
	index 857f364..94ce49f 100644
	--- a/src/GUITextArea.cpp
	+++ b/src/GUITextArea.cpp
	@@ -1,897 +1,869 @@
	/*
	* 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 "GUITextArea.h"
	#include <cmath>
	#include <ctype.h>
	+
	using namespace std;

	-GUITextArea::GUITextArea(int left,int top,int width,int height,bool enabled,bool visible):
	- GUIObject(left,top,width,height,NULL,-1,enabled,visible),editable(true){
	+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(NULL);
	+ linesCache.push_back(nullptr);

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

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

	-GUITextArea::~GUITextArea(){
	- //Free cached images.
	- for(unsigned int i=0;i<linesCache.size();i++){
	- SDL_FreeSurface(linesCache[i]);
	- }
	- linesCache.clear();
	-}
	-
	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(int x,int y,bool enabled,bool visible,bool processed){
	+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(x,y,enabled,visible,b);
	+ 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.
	- int key=(int)event.key.keysym.unicode;
	+ SDL_Keycode key=event.key.keysym.sym;

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

	//Update cache.
	- SDL_Surface** c=&linesCache.at(highlightLineStart);
	- if(c) SDL_FreeSurface(c);
	- SDL_Color black={0,0,0,0};
	- *c=TTF_RenderUTF8_Blended(widgetFont,str->c_str(),black);
	+ 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();
	+ 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();
	+ deleteChar(renderer);
	}else if(event.key.keysym.sym==SDLK_RETURN){
	- removeHighlight();
	+ removeHighlight(renderer);
	//Split the current line and update.
	string str2=lines.at(highlightLineEnd).substr(highlightStart);
	lines.at(highlightLineStart)=lines.at(highlightLineStart).substr(0,highlightStart);

	- SDL_Surface** c=&linesCache.at(highlightLineStart);
	- if(c) SDL_FreeSurface(c);
	- SDL_Color black={0,0,0,0};
	- *c=TTF_RenderUTF8_Blended(widgetFont,lines.at(highlightLineStart).c_str(),black);
	+ 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);

	- SDL_Surface* c2;
	- c2=TTF_RenderUTF8_Blended(widgetFont,str2.c_str(),black);
	- linesCache.insert(linesCache.begin()+highlightLineStart,c2);
	+ //SDL_Surface* c2;
	+ 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();
	+ removeHighlight(renderer);
	//Add a tabulator or here just 2 spaces to the string.
	- string* str=&lines.at(highlightLineStart);
	- str->insert((size_t)highlightStart,2,char(' '));
	+ 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.
	- SDL_Surface** c=&linesCache.at(highlightLineStart);
	- if(c) SDL_FreeSurface(c);
	- SDL_Color black={0,0,0,0};
	- *c=TTF_RenderUTF8_Blended(widgetFont,str->c_str(),black);
	+ 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_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELDOWN){
	+ 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.button.button==SDL_BUTTON_WHEELUP){
	+ }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_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELDOWN){
	+ 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.button.button==SDL_BUTTON_WHEELUP){
	+ }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(x,y,enabled,visible,b);
	+ 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(){
	+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;
	}
	- string *str=&lines.at(highlightLineStart);
	- str->erase(start,end-start);
	+ std::string& str=lines.at(highlightLineStart);
	+ str.erase(start,end-start);

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

	// Update cache.
	- SDL_Surface** c=&linesCache.at(highlightLineStart);
	- if(c) SDL_FreeSurface(c);
	- SDL_Color black={0,0,0,0};
	- *c=TTF_RenderUTF8_Blended(widgetFont,str->c_str(),black);
	+ 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++){
	- SDL_Surface** c=&linesCache.at(i);
	- if(c) SDL_FreeSurface(c);
	lines.erase(lines.begin()+i);
	linesCache.erase(linesCache.begin()+i);
	endLine--;
	i--;
	}
	}

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

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

	- SDL_Surface** c=&linesCache.at(endLine);
	- if(c) SDL_FreeSurface(c);
	lines.erase(lines.begin()+endLine);
	linesCache.erase(linesCache.begin()+endLine);

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

	// Update cache.
	- c=&linesCache.at(startLine);
	- if(c) SDL_FreeSurface(c);
	- SDL_Color black={0,0,0,0};
	- *c=TTF_RenderUTF8_Blended(widgetFont,str->c_str(),black);
	+ linesCache.at(startLine) = textureFromText(renderer,*widgetFont,str->c_str(),BLACK);
	}
	adjustView();
	}

	-void GUITextArea::deleteChar(){
	+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();
	+ removeHighlight(renderer);
	//If there is an event callback.
	if(eventCallback){
	GUIEvent e={eventCallback,name,this,GUIEventChange};
	GUIEventQueue.push_back(e);
	}
	}

	-void GUITextArea::backspaceChar(){
	+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;
	- SDL_Surface** c=&linesCache.at(highlightLineStart);
	- if (c) highlightStartX=(c)->w;
	+ 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();
	+ 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;
	- SDL_Surface** c=&linesCache.at(highlightLineEnd);
	- if(c) highlightEndX=(c)->w;
	+ 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--;
	- string* str=&lines.at(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++){
	+ for(i=0;i<str.length();i++){
	int advance;
	- TTF_GlyphMetrics(widgetFont,str->at(i),NULL,NULL,NULL,NULL,&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();
	+ if(i==str.length()){
	+ highlightEnd=str.length();
	highlightEndX=0;
	- SDL_Surface** c=&linesCache.at(highlightLineEnd);
	- if(c) highlightEndX=(c)->w;
	+ 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;
	- SDL_Surface** c=&linesCache.at(highlightLineEnd);
	- if(c) highlightEndX=(c)->w;
	+ 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;
	- SDL_Surface** c=&linesCache.at(highlightLineEnd);
	- if(c) highlightEndX=(c)->w;
	+ 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(vector<SDL_Surface*>::iterator it=linesCache.begin();it!=linesCache.end();++it){
	- if((it)&&(it)->w>width-16&&(*it)->w>maxWidth)
	- maxWidth=(*it)->w;
	+ 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(int x,int y,SDL_Rect* r,Uint32 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_FillRect(screen,r,color);
	+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(int x,int y,bool draw){
	+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();
	+ backspaceChar(renderer);
	break;
	case SDLK_DELETE:
	- deleteChar();
	+ 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.
	- Uint32 color=0xFFFFFFFF;
	- drawGUIBox(x,y,width,height,screen,color);
	+ const Uint32 color=0xFFFFFFFF;
	+ drawGUIBox(x,y,width,height,renderer,color);
	+ }

	//Place the highlighted area.
	SDL_Rect r;
	- color=SDL_MapRGB(screen->format,128,128,128);
	+ 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(x,y,&r,color);
	+ 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(x,y,&r,color);
	+ 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(x,y,&r,color);
	+ drawHighlight(renderer,x,y,r,color);
	}
	}

	//Draw text.
	int lineY=0;
	- for(std::vector<SDL_Surface*>::iterator it=linesCache.begin()+scrollBar->value;it!=linesCache.end();++it){
	+ for(auto it = linesCache.begin()+scrollBar->value;it!=linesCache.end();++it){
	if(*it){
	if(lineY<height){
	- SDL_Rect r={scrollBarH->value,0,width-17,(*it)->h};
	+ SDL_Rect r={scrollBarH->value,0,width-17,textureHeight(*it->get())};
	int over=-height+lineY+fontHeight;
	if(over>0) r.h-=over;
	- applySurface(x+1,y+1+lineY,*it,screen,&r);
	+ 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)){
	- //SDL_FillRect(screen,&r,0);
	- drawHighlight(x,y,&r,0x00000000);
	+ 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(x,y,draw);
	+ childControls[i]->render(renderer,x,y,draw);
	}
	}

	-void GUITextArea::setString(std::string input){
	+void GUITextArea::setString(SDL_Renderer& renderer, std::string input){
	//Clear previous content if any.
	//Delete every line.
	lines.clear();
	- //Free cached images.
	- for(unsigned int i=0;i<linesCache.size();i++){
	- SDL_FreeSurface(linesCache[i]);
	- }
	linesCache.clear();

	size_t linePos=0,lineLen=0;
	- SDL_Color black={0,0,0,0};
	- SDL_Surface* bm=NULL;

	//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(NULL);
	+ linesCache.push_back(nullptr);
	}else{
	//Read the whole line.
	string line=input.substr(linePos,lineLen);
	lines.push_back(line);

	//Render and cache text.
	- bm=TTF_RenderUTF8_Blended(widgetFont,line.c_str(),black);
	- linesCache.push_back(bm);
	+ 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);
	- linesCache.push_back(bm);
	+ //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(std::vector<std::string> input){
	+void GUITextArea::setStringArray(SDL_Renderer& renderer, std::vector<std::string> input){
	//Free cached images.
	- for(unsigned int i=0;i<linesCache.size();i++){
	- SDL_FreeSurface(linesCache[i]);
	- }
	linesCache.clear();

	//Copy values.
	lines=input;

	- //Draw new strings.
	- SDL_Color black={0,0,0,0};
	- for(vector<string>::iterator it=lines.begin();it!=lines.end();++it){
	- SDL_Surface* bm=TTF_RenderUTF8_Blended(widgetFont,(*it).c_str(),black);
	- linesCache.push_back(bm);
	- }
	+ 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/GUITextArea.h b/src/GUITextArea.h
	index aa7cf38..036eb23 100644
	--- a/src/GUITextArea.h
	+++ b/src/GUITextArea.h
	@@ -1,130 +1,128 @@
	/*
	* 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 GUITEXTAREA_H
	#define GUITEXTAREA_H

	#ifdef __APPLE__
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_ttf.h>
	#endif

	#include "GUIObject.h"
	#include "GUIScrollBar.h"

	//Widget for multiline text input.
	class GUITextArea:public GUIObject{
	private:
	//Method that will remove the last character of the text.
	- void backspaceChar();
	- void deleteChar();
	+ void backspaceChar(SDL_Renderer &renderer);
	+ void deleteChar(SDL_Renderer &renderer);

	//Methods to move the carrot by one character/line.
	void moveCarrotLeft();
	void moveCarrotRight();
	void moveCarrotUp();
	void moveCarrotDown();

	// Move all highlighted text.
	- void removeHighlight();
	+ void removeHighlight(SDL_Renderer &renderer);

	//Method to adjust view so carrot stays visible.
	void adjustView();

	//Pointer to the font used in the widget.
	TTF_Font* widgetFont;

	//Widget's text.
	//One line per vector element.
	std::vector<std::string> lines;

	//Cache for rendered lines.
	//Will be updated alongside with variable text.
	- std::vector<SDL_Surface*> linesCache;
	+ //std::vector<SDL_Surface*> linesCache;
	+ std::vector<TexturePtr> linesCache;

	//Variable for carrot position.
	int highlightLineStart;
	int highlightLineEnd;
	int highlightStart;
	int highlightStartX;
	int highlightEnd;
	int highlightEndX;

	//Height of the font.
	int fontHeight;

	//Scrollbar widget.
	GUIScrollBar* scrollBar;
	GUIScrollBar* scrollBarH;

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

	- void drawHighlight(int x,int y,SDL_Rect* r,Uint32 color);
	+ void drawHighlight(SDL_Renderer& renderer, int x, int y, SDL_Rect r, SDL_Color color);
	public:
	//Constructor.
	//left: The relative x location of the GUITextArea.
	//top: The relative y location of the GUITextArea.
	//witdh: The width of the GUITextArea.
	//height: The height of the GUITextArea.
	//enabled: Boolean if the GUITextArea is enabled or not.
	//visible: Boolean if the GUITextArea is visisble or not.
	- GUITextArea(int left=0,int top=0,int width=0,int height=0,bool enabled=true,bool visible=true);
	-
	- //Destructor
	- ~GUITextArea();
	+ GUITextArea(ImageManager& imageManager, SDL_Renderer& renderer,int left=0,int top=0,int width=0,int height=0,bool enabled=true,bool visible=true);

	//Method used to change the font.
	//font: Pointer to the font
	void setFont(TTF_Font* font);

	//Method used to reposition scrollbars after a resize.
	void resize();

	//Method used to get widget's text in a single string.
	std::string getString();

	//Method used to set widget's text.
	- void setString(std::string input);
	- void setStringArray(std::vector<std::string> input);
	+ void setString(SDL_Renderer& renderer, std::string input);
	+ void setStringArray(SDL_Renderer &renderer, std::vector<std::string> input);

	//Bool if user can edit text in the widget.
	bool editable;

	//Method used to handle mouse and/or key events.
	//x: The x mouse location.
	//y: The y mouse location.
	//enabled: Boolean if the parent is enabled or not.
	//visible: Boolean if the parent is visible or not.
	//processed: Boolean if the event has been processed (by the parent) or not.
	//Returns: Boolean if the event is processed by the child.
	- virtual bool handleEvents(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	+ 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 GUITextArea.
	//x: The x location to draw the GUITextArea. (x+left)
	//y: The y location to draw the GUITextArea. (y+top)
	- virtual void render(int x=0,int y=0,bool draw=true);
	+ virtual void render(SDL_Renderer &renderer, int x=0, int y=0, bool draw=true);
	};

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

	#include "GUIWindow.h"
	using namespace std;

	-GUIWindow::GUIWindow(int left,int top,int width,int height,bool enabled,bool visible,const char* caption):
	- GUIObject(left,top,width,height,caption,-1,enabled,visible){
	+GUIWindow::GUIWindow(ImageManager& imageManager,SDL_Renderer& renderer,int left,int top,int width,int height,bool enabled,bool visible,const char* caption):
	+ GUIObject(imageManager,renderer,left,top,width,height,caption,-1,enabled,visible){

	//Set some default values.
	dragging=false;
	resizing=false;
	minWidth=minHeight=0;
	maxWidth=maxHeight=0;
	+
	+ const SDL_Color black={0,0,0,0};
	+ this->caption = textureFromText(renderer, *fontGUI, caption, black);
	}

	-bool GUIWindow::handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	+bool GUIWindow::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;

	//NOTE: We don't reset the state to have a "focus" effect.
	//Only check for events when the object is both enabled and visible.
	if(enabled&&visible){
	//Check if the titlebar is hit.
	bool clicked=(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_LEFT);

	//Check if the mouse is inside the window.
	SDL_Rect mouse={event.button.x,event.button.y,0,0};
	SDL_Rect titlebar={x,y+5,width,43}; //We have a resize edge at the top five pixels.

	//FIXME: Only set the cursor to POINTER when moving away from the GUIWindow?
	if(clicked && checkCollision(mouse,titlebar)){
	//Mouse pressed inside the window,so assume dragging
	dragging=true;
	}

	//Check for resizing.
	SDL_Rect edge={x,y,width,5};
	//Check each edge only if not resizing.
	//NOTE: This is done to preserve the resize cursor type when off the edge.
	bool topEdge=resizing?(resizeDirection==GUIResizeTop \|\| resizeDirection==GUIResizeTopLeft \|\| resizeDirection==GUIResizeTopRight):checkCollision(mouse,edge);
	edge.x=x+width-5;
	edge.w=5;
	edge.h=height;
	bool rightEdge=resizing?(resizeDirection==GUIResizeRight \|\| resizeDirection==GUIResizeTopRight \|\| resizeDirection==GUIResizeBottomRight):checkCollision(mouse,edge);
	edge.x=x;
	edge.y=y+height-5;
	edge.w=width;
	edge.h=5;
	bool bottomEdge=resizing?(resizeDirection==GUIResizeBottom \|\| resizeDirection==GUIResizeBottomLeft \|\| resizeDirection==GUIResizeBottomRight):checkCollision(mouse,edge);
	edge.y=y;
	edge.w=5;
	edge.h=height;
	bool leftEdge=resizing?(resizeDirection==GUIResizeLeft \|\| resizeDirection==GUIResizeTopLeft \|\| resizeDirection==GUIResizeBottomLeft):checkCollision(mouse,edge);

	//Set resizing true when resizing previously of clicking on a edge.
	if(topEdge \|\| rightEdge \|\| bottomEdge \|\| leftEdge)
	resizing=resizing?true:clicked;
	//Determine the resize direction.
	if(topEdge){
	resizeDirection=GUIResizeTop;
	currentCursor=CURSOR_SIZE_VER;

	//Check if there's an additional horizontal edge (corner).
	if(leftEdge){
	currentCursor=CURSOR_SIZE_FDIAG;
	resizeDirection=GUIResizeTopLeft;
	}else if(rightEdge){
	currentCursor=CURSOR_SIZE_BDIAG;
	resizeDirection=GUIResizeTopRight;
	}
	}else if(bottomEdge){
	resizeDirection=GUIResizeBottom;
	currentCursor=CURSOR_SIZE_VER;

	//Check if there's an additional horizontal edge (corner).
	if(leftEdge){
	currentCursor=CURSOR_SIZE_BDIAG;
	resizeDirection=GUIResizeBottomLeft;
	}else if(rightEdge){
	currentCursor=CURSOR_SIZE_FDIAG;
	resizeDirection=GUIResizeBottomRight;
	}
	}else if(leftEdge){
	resizeDirection=GUIResizeLeft;
	currentCursor=CURSOR_SIZE_HOR;
	}else if(rightEdge){
	resizeDirection=GUIResizeRight;
	currentCursor=CURSOR_SIZE_HOR;
	}

	if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT){
	//Stop dragging
	dragging=false;

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

	//Check if close button clicked
	{
	SDL_Rect r={left+width-36,top+12,24,24};
	if(checkCollision(mouse,r)){
	this->visible=false;
	//And we add a close event to the queue.
	GUIEvent e={eventCallback,name,this,GUIEventClick};
	GUIEventQueue.push_back(e);
	}
	}
	}else if(event.type==SDL_MOUSEMOTION){
	if((event.motion.state & SDL_BUTTON_LMASK)==0){
	//Stop dragging or resizing.
	dragging=false;
	resizing=false;
	}else if(dragging){
	move(left+event.motion.xrel,top+event.motion.yrel);
	}else if(resizing){
	//Check what the resize direction is.
	switch(resizeDirection){
	case GUIResizeTop:
	resize(left,top+event.motion.yrel,width,height-event.motion.yrel);
	break;
	case GUIResizeTopRight:
	resize(left,top+event.motion.yrel,width+event.motion.xrel,height-event.motion.yrel);
	break;
	case GUIResizeRight:
	resize(left,top,width+event.motion.xrel,height);
	break;
	case GUIResizeBottomRight:
	resize(left,top,width+event.motion.xrel,height+event.motion.yrel);
	break;
	case GUIResizeBottom:
	resize(left,top,width,height+event.motion.yrel);
	break;
	case GUIResizeBottomLeft:
	resize(left+event.motion.xrel,top,width-event.motion.xrel,height+event.motion.yrel);
	break;
	case GUIResizeLeft:
	resize(left+event.motion.xrel,top,width-event.motion.xrel,height);
	break;
	case GUIResizeTopLeft:
	resize(left+event.motion.xrel,top+event.motion.yrel,width-event.motion.xrel,height-event.motion.yrel);
	break;
	}
	}
	}

	//Also update the cursor type accordingly.
	if(dragging)
	currentCursor=CURSOR_DRAG;
	}

	//Process child controls event.
	for(unsigned int i=0;i<childControls.size();i++){
	- bool b1=childControls[i]->handleEvents(x,y,enabled,visible,b);
	+ 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 GUIWindow::move(int x,int y){
	//Check the horizontal bounds.
	if(x>SCREEN_WIDTH-width)
	x=SCREEN_WIDTH-width;
	else if(x<0)
	x=0;
	//Check the vertical bounds.
	if(y>SCREEN_HEIGHT-height)
	y=SCREEN_HEIGHT-height;
	else if(y<0)
	y=0;

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

	void GUIWindow::resize(int x,int y,int width,int height){
	//FIXME: In case of resizing to the left or top the window moves when the maximum size has been reached.
	//Check for the minimum width.
	if(minWidth){
	if(width<minWidth)
	width=minWidth;
	}
	//Check for the minimum height.
	if(minHeight){
	if(height<minHeight)
	height=minHeight;
	}
	//Check for maximum width.
	if(maxWidth){
	if(width>maxWidth)
	width=maxWidth;
	}
	//Check for maximum height.
	if(maxHeight){
	if(height>maxHeight)
	height=maxHeight;
	}

	//Now set the values.
	this->left=x;
	this->top=y;
	this->width=width;
	this->height=height;

	//And we add a resize event to the queue.
	GUIEvent e={eventCallback,name,this,GUIEventChange};
	GUIEventQueue.push_back(e);
	}

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

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

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

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

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

	if(checkCollision(mouse,r)){
	- drawGUIBox(r.x,r.y,r.w,r.h,screen,0x999999FFU);
	+ drawGUIBox(r.x,r.y,r.w,r.h,renderer,0x99999FFU);
	}

	- SDL_Rect r1={112,0,16,16};
	- applySurface(left+width-32,top+16,bmGUI,screen,&r1);
	+ const SDL_Rect srcRect={112,0,16,16};
	+ const SDL_Rect dstRect={left+width-32, top+16, 16, 16};
	+ SDL_RenderCopy(&renderer, bmGuiTex.get(), &srcRect, &dstRect);
	}

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

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

	-void GUIWindow::GUIEventCallback_OnEvent(string name,GUIObject* obj,int eventType){
	+void GUIWindow::GUIEventCallback_OnEvent(ImageManager& imageManager,SDL_Renderer& renderer,string name,GUIObject* obj,int eventType){
	//Check if we have a eventCallback.
	if(eventCallback){
	//We call the onEvent method of the callback, but change the GUIObject pointer to ourself.
	- eventCallback->GUIEventCallback_OnEvent(name,this,eventType);
	+ eventCallback->GUIEventCallback_OnEvent(imageManager,renderer,name,this,eventType);
	}
	}
	diff --git a/src/GUIWindow.h b/src/GUIWindow.h
	index b1a216d..efcbcee 100644
	--- a/src/GUIWindow.h
	+++ b/src/GUIWindow.h
	@@ -1,94 +1,96 @@
	/*
	* Copyright (C) 2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef GUIWINDOW_H
	#define GUIWINDOW_H

	#include "GUIObject.h"

	//Resize directions.
	const int GUIResizeTop=0;
	const int GUIResizeTopRight=1;
	const int GUIResizeRight=2;
	const int GUIResizeBottomRight=3;
	const int GUIResizeBottom=4;
	const int GUIResizeBottomLeft=5;
	const int GUIResizeLeft=6;
	const int GUIResizeTopLeft=7;

	//It extends GUIObject because it's a special GUIObject.
	class GUIWindow:public GUIObject,public GUIEventCallback{
	private:
	//Boolean if the window is being dragged.
	bool dragging;

	//Boolean if the window is being resized.
	bool resizing;
	//The direction the resizing occurs.
	int resizeDirection;

	+ TexturePtr caption;
	+
	//GUI events received by the GUIWindow will be passed on to the eventCallback.
	//NOTE: This contraption is used to "group" events from GUIObjects of the GUIWindow.
	//The object pointer of the OnEvent method will be the GUIWindow.
	//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 GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType);
	+ void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType);
	public:
	//The minimum and maximum size of the window.
	int minWidth,minHeight;
	int maxWidth,maxHeight;

	//Constructor.
	//left: The relative x location of the GUIWindow.
	//top: The relative y location of the GUIWindow.
	//witdh: The width of the GUIWindow.
	//height: The height of the GUIWindow.
	//enabled: Boolean if the GUIWindow is enabled or not.
	//visible: Boolean if the GUIWindow is visisble or not.
	//caption: The title of the Window.
	- GUIWindow(int left=0,int top=0,int width=0,int height=0,bool enabled=true,bool visible=true,const char* caption=NULL);
	+ GUIWindow(ImageManager& imageManager, SDL_Renderer& renderer, int left=0, int top=0, int width=0, int height=0, bool enabled=true, bool visible=true, const char* caption=NULL);

	//Method used for moving the window around, also used internally by handleEvents.
	//x: The desired x location to move the window to.
	//y: The desired y location to move the window to.
	void move(int x,int y);

	//Method that will resize the window.
	//x: The new x location of the window.
	//y: The new y location of the window.
	//width: The new width of the resized window.
	//height: The new height of the resized window.
	void resize(int x,int y,int width,int height);

	//Method used to handle mouse and/or key events.
	//x: The x mouse location.
	//y: The y mouse location.
	//enabled: Boolean if the parent is enabled or not.
	//visible: Boolean if the parent is visible or not.
	//processed: Boolean if the event has been processed (by the parent) or not.
	//Returns: Boolean if the event is processed by the child.
	- virtual bool handleEvents(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	+ 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 GUITextArea.
	//x: The x location to draw the GUITextArea. (x+left)
	//y: The y location to draw the GUITextArea. (y+top)
	- virtual void render(int x=0,int y=0,bool draw=true);
	+ virtual void render(SDL_Renderer &renderer, int x=0, int y=0, bool draw=true);
	};

	#endif
	diff --git a/src/Game.cpp b/src/Game.cpp
	index ef35e3b..0cfd8ab 100644
	--- a/src/Game.cpp
	+++ b/src/Game.cpp
	@@ -1,1661 +1,1687 @@
	/*
	* 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 "GameState.h"
	#include "Globals.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "GameObjects.h"
	#include "ThemeManager.h"
	#include "Game.h"
	#include "TreeStorageNode.h"
	#include "POASerializer.h"
	#include "InputManager.h"
	+#include "Render.h"
	#include "StatisticsManager.h"
	#include <fstream>
	#include <iostream>
	#include <sstream>
	#include <vector>
	#include <map>
	#include <algorithm>
	#include <locale>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

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

	map<string,int> Game::blockNameMap;
	map<int,string> Game::gameObjectEventTypeMap;
	map<string,int> Game::gameObjectEventNameMap;
	map<int,string> Game::levelEventTypeMap;
	map<string,int> Game::levelEventNameMap;
	string Game::recordFile;

	-Game::Game():isReset(false)
	+Game::Game(SDL_Renderer &renderer, ImageManager &imageManager):isReset(false)
	,currentLevelNode(NULL)
	,customTheme(NULL)
	,background(NULL)
	,won(false)
	,interlevel(false)
	,gameTipIndex(0)
	,time(0),timeSaved(0)
	,recordings(0),recordingsSaved(0)
	,cameraMode(CAMERA_PLAYER),cameraModeSaved(CAMERA_PLAYER)
	,player(this),shadow(this),objLastCheckPoint(NULL)
	,currentCollectables(0),totalCollectables(0),currentCollectablesSaved(0){

	saveStateNextTime=false;
	loadStateNextTime=false;

	recentSwap=recentSwapSaved=-10000;
	recentLoad=recentSave=0;

	- //Reserve the memory for the GameObject tips.
	- memset(bmTips,0,sizeof(bmTips));
	-
	- action=loadImage(getDataPath()+"gfx/actions.png");
	- medals=loadImage(getDataPath()+"gfx/medals.png");
	+ action=imageManager.loadTexture(getDataPath()+"gfx/actions.png", renderer);
	+ medals=imageManager.loadTexture(getDataPath()+"gfx/medals.png", renderer);
	//Get the collectable image from the theme.
	//NOTE: Isn't there a better way to retrieve the image?
	objThemes.getBlock(TYPE_COLLECTABLE)->createInstance(&collectable);

	//Hide the cursor if not in the leveleditor.
	if(stateID!=STATE_LEVEL_EDITOR)
	SDL_ShowCursor(SDL_DISABLE);
	}

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

	//Before we leave make sure the cursor is visible.
	SDL_ShowCursor(SDL_ENABLE);
	}

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

	//Loop through the backgroundLayers and delete them.
	std::map<std::string,std::vector<Scenery*> >::iterator it;
	for(it=backgroundLayers.begin();it!=backgroundLayers.end();++it){
	for(unsigned int i=0;i<it->second.size();i++)
	delete it->second[i];
	}
	backgroundLayers.clear();

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

	- //Loop through the tips.
	- for(int i=0;i<TYPE_MAX;i++){
	- //If it exist free the SDL_Surface.
	- if(bmTips[i])
	- SDL_FreeSurface(bmTips[i]);
	- }
	- memset(bmTips,0,sizeof(bmTips));
	-
	//Remove everything from the themeManager.
	background=NULL;
	if(customTheme)
	objThemes.removeTheme();
	customTheme=NULL;
	//If there's a (partial) theme bundled with the levelpack remove that as well.
	if(levels->customTheme)
	objThemes.removeTheme();

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

	//Reset the time.
	time=timeSaved=0;
	recordings=recordingsSaved=0;
	recentSwap=recentSwapSaved=-10000;

	//Set the music list back to the configured list.
	getMusicManager()->setMusicList(getSettings()->getValue("musiclist"));
	}

	-void Game::loadLevelFromNode(TreeStorageNode* obj,const string& fileName){
	+void Game::loadLevelFromNode(ImageManager& imageManager,SDL_Renderer& renderer,TreeStorageNode* obj,const string& fileName){
	//Make sure there's nothing left from any previous levels.
	//Not needed since loadLevelFromNode is only called from the changeState method, meaning it's a new instance of Game.
	//destroy();

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

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

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

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

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

	//Also check for bundled (partial) themes.
	if(levels->customTheme){
	- if(objThemes.appendThemeFromFile(levels->levelpackPath+"/theme/theme.mnmstheme")==NULL){
	+ if(objThemes.appendThemeFromFile(levels->levelpackPath+"/theme/theme.mnmstheme",imageManager,renderer)==NULL){
	//The theme failed to load so set the customTheme boolean to false.
	levels->customTheme=false;
	}
	}
	}

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

	//Get the music.
	{
	//Check if level music is enabled.
	if(getSettings()->getBoolValue("levelmusic")){
	//Check if the levelpack has a prefered music list.
	if(!levels->levelpackMusicList.empty())
	getMusicManager()->setMusicList(levels->levelpackMusicList);

	//Check for the music to use.
	string &s=editorData["music"];
	if(!s.empty()){
	getMusicManager()->playMusic(s);
	}else{
	getMusicManager()->pickMusic();
	}
	}
	}

	//Load the data from the level node.
	for(unsigned int i=0;i<obj->subNodes.size();i++){
	TreeStorageNode* obj1=obj->subNodes[i];
	if(obj1==NULL) continue;
	if(obj1->name=="tile"){
	Block* block=new Block(this);
	- if(!block->loadFromNode(obj1)){
	+ if(!block->loadFromNode(imageManager,renderer,obj1)){
	delete block;
	continue;
	}

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

	//Add the block to the levelObjects vector.
	levelObjects.push_back(block);
	}else if(obj1->name=="backgroundlayer" && obj1->value.size()==1){
	//Loop through the sub nodes.
	for(unsigned int j=0;j<obj1->subNodes.size();j++){
	TreeStorageNode* obj2=obj1->subNodes[j];
	if(obj2==NULL) continue;

	if(obj2->name=="object"){
	//Load the scenery from node.
	Scenery* scenery=new Scenery(this);
	- if(!scenery->loadFromNode(obj2)){
	+ if(!scenery->loadFromNode(imageManager,renderer,obj2)){
	delete scenery;
	continue;
	}

	backgroundLayers[obj1->value[0]].push_back(scenery);
	}
	}
	}else if(obj1->name=="script" && !obj1->value.empty()){
	map<string,int>::iterator it=Game::levelEventNameMap.find(obj1->value[0]);
	if(it!=Game::levelEventNameMap.end()){
	int eventType=it->second;
	const std::string& script=obj1->attributes["script"][0];
	if(!script.empty()) scripts[eventType]=script;
	}
	}
	}

	//Close exits if there are collectables
	if(totalCollectables>0){
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(levelObjects[i]->type==TYPE_EXIT){
	levelObjects[i]->onEvent(GameObjectEvent_OnSwitchOff);
	}
	}
	}

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

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

	SDL_Color fg={0,0,0,0};
	- bmTips[0]=TTF_RenderUTF8_Blended(fontText,s.c_str(),fg);
	+ bmTips[0]=textureFromText(renderer, *fontText,s.c_str(),fg);
	}

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

	//Reset the script environment.
	getScriptExecutor()->reset();

	//Compile and run script (only in game mode).
	if(stateID!=STATE_LEVEL_EDITOR) compileScript();
	}

	-void Game::loadLevel(string fileName){
	+void Game::loadLevel(ImageManager& imageManager,SDL_Renderer& renderer,std::string fileName){
	//Create a TreeStorageNode that will hold the loaded data.
	TreeStorageNode *obj=new TreeStorageNode();
	{
	POASerializer objSerializer;
	string s=fileName;

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

	//Now call another function.
	- loadLevelFromNode(obj,fileName);
	+ loadLevelFromNode(imageManager,renderer,obj,fileName);
	}

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

	TreeStorageNode obj;
	POASerializer objSerializer;

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

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

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

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

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

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

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

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

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

	-void Game::loadRecord(const char* fileName){
	+void Game::loadRecord(ImageManager& imageManager, SDL_Renderer& renderer, const char* fileName){
	//Create a TreeStorageNode that will hold the loaded data.
	TreeStorageNode obj;
	{
	POASerializer objSerializer;
	string s=fileName;

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

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

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

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

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

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

	/////////////EVENT///////////////
	-void Game::handleEvents(){
	+void Game::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//First of all let the player handle input.
	player.handleInput(&shadow);

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

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

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

	//Check if 'r' is pressed.
	if(inputMgr.isKeyDownEvent(INPUTMGR_RESTART)){
	//Only set isReset true if this isn't a replay.
	if(!(player.isPlayFromRecord() && !interlevel))
	isReset=true;

	//Also delete any gui (most likely the interlevel gui). Only in game mode.
	if(GUIObjectRoot && stateID!=STATE_LEVEL_EDITOR){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

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

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

	//Now goto the next level.
	- gotoNextLevel();
	+ gotoNextLevel(imageManager,renderer);
	}
	}

	//Check if tab is pressed.
	if(inputMgr.isKeyDownEvent(INPUTMGR_TAB)){
	//Switch the camera mode.
	switch(cameraMode){
	case CAMERA_PLAYER:
	cameraMode=CAMERA_SHADOW;
	break;
	case CAMERA_SHADOW:
	case CAMERA_CUSTOM:
	cameraMode=CAMERA_PLAYER;
	break;
	}
	}
	}

	/////////////////LOGIC///////////////////
	-void Game::logic(){
	+void Game::logic(ImageManager& imageManager, SDL_Renderer& renderer){
	//Add one tick to the time.
	time++;

	//FIXME:Resetting dx/dy and xVel/yVel every loop interferes with movement logic of player and blocks.
	//First prepare each gameObject for the new frame.
	//This includes resetting dx/dy and xVel/yVel.
	//for(unsigned int o=0;o<levelObjects.size();o++)
	//levelObjects[o]->prepareFrame();

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

	//Check if the it has an id attached to it.
	if(e.target){
	//NOTE: Should we check if the target still exists???
	e.target->onEvent(e.eventType);
	}else if(e.flags\|1){
	//Loop through the levelObjects and give them the event if they have the right id.
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(e.objectType<0 \|\| levelObjects[i]->type==e.objectType){
	if(levelObjects[i]->id==e.id){
	levelObjects[i]->onEvent(e.eventType);
	}
	}
	}
	}else{
	//Loop through the levelObjects and give them the event.
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(e.objectType<0 \|\| levelObjects[i]->type==e.objectType){
	levelObjects[i]->onEvent(e.eventType);
	}
	}
	}
	}
	//Done processing the events so clear the queue.
	eventQueue.clear();

	//Check if we should save/load state.
	//NOTE: This happens after event handling so no eventQueue has to be saved/restored.
	if(saveStateNextTime){
	saveState();
	}else if(loadStateNextTime){
	loadState();
	}
	saveStateNextTime=false;
	loadStateNextTime=false;

	//Loop through the gameobjects to update them.
	for(unsigned int i=0;i<levelObjects.size();i++){
	//Send GameObjectEvent_OnEnterFrame event to the script
	levelObjects[i]->onEvent(GameObjectEvent_OnEnterFrame);
	}
	for(unsigned int i=0;i<levelObjects.size();i++){
	//Let the gameobject handle movement.
	levelObjects[i]->move();
	}
	//Also update the scenery.
	{
	std::map<std::string,std::vector<Scenery*> >::iterator it;
	for(it=backgroundLayers.begin();it!=backgroundLayers.end();++it){
	for(unsigned int i=0;i<it->second.size();i++)
	it->second[i]->move();
	}
	}

	//Let the player store his move, if recording.
	player.shadowSetState();
	//Let the player give his recording to the shadow, if configured.
	player.shadowGiveState(&shadow);
	//Let him move.
	player.move(levelObjects);

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

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

	//Update the camera.
	switch(cameraMode){
	case CAMERA_PLAYER:
	player.setMyCamera();
	break;
	case CAMERA_SHADOW:
	shadow.setMyCamera();
	break;
	case CAMERA_CUSTOM:
	//NOTE: The target is (should be) screen size independent so calculate the real target x and y here.
	int targetX=cameraTarget.x-(SCREEN_WIDTH/2);
	int targetY=cameraTarget.y-(SCREEN_HEIGHT/2);
	//Move the camera to the cameraTarget.
	if(camera.x>targetX){
	camera.x-=(camera.x-targetX)>>4;
	//Make sure we don't go too far.
	if(camera.x<targetX)
	camera.x=targetX;
	}else if(camera.x<targetX){
	camera.x+=(targetX-camera.x)>>4;
	//Make sure we don't go too far.
	if(camera.x>targetX)
	camera.x=targetX;
	}
	if(camera.y>targetY){
	camera.y-=(camera.y-targetY)>>4;
	//Make sure we don't go too far.
	if(camera.y<targetY)
	camera.y=targetY;
	}else if(camera.y<targetY){
	camera.y+=(targetY-camera.y)>>4;
	//Make sure we don't go too far.
	if(camera.y>targetY)
	camera.y=targetY;
	}
	break;
	}

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

	//Get current level
	LevelPack::Level *level=levels->getLevel();

	//Now check if we should update statistics
	{
	//Get previous and current medal
	int oldMedal=level->won?1:0,newMedal=1;

	int bestTime=level->time;
	int targetTime=level->targetTime;
	int bestRecordings=level->recordings;
	int targetRecordings=level->targetRecordings;

	if(oldMedal){
	if(targetTime<0){
	oldMedal=3;
	}else{
	if(targetTime<0 \|\| bestTime<=targetTime)
	oldMedal++;
	if(targetRecordings<0 \|\| bestRecordings<=targetRecordings)
	oldMedal++;
	}
	}else{
	bestTime=time;
	bestRecordings=recordings;
	}

	if(bestTime==-1 \|\| bestTime>time) bestTime=time;
	if(bestRecordings==-1 \|\| bestRecordings>recordings) bestRecordings=recordings;

	if(targetTime<0){
	newMedal=3;
	}else{
	if(targetTime<0 \|\| bestTime<=targetTime)
	newMedal++;
	if(targetRecordings<0 \|\| bestRecordings<=targetRecordings)
	newMedal++;
	}

	//Check if we need to update statistics
	if(newMedal>oldMedal){
	switch(oldMedal){
	case 0:
	statsMgr.completedLevels++;
	break;
	case 2:
	statsMgr.silverLevels--;
	break;
	}

	switch(newMedal){
	case 2:
	statsMgr.silverLevels++;
	break;
	case 3:
	statsMgr.goldLevels++;
	break;
	}
	}
	}

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

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

	//Now go to the interlevel screen.
	- replayPlay();
	+ replayPlay(imageManager,renderer);

	//Update achievements
	if(levels->levelpackName=="tutorial") statsMgr.updateTutorialAchievements();
	statsMgr.updateLevelAchievements();

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

	//Check if we should reset.
	if(isReset)
	//NOTE: In case of the interlevel popup the save data needs to be deleted so the restart behaviour is the same for key and button restart.
	reset(interlevel);
	isReset=false;
	}

	/////////////////RENDER//////////////////
	-void Game::render(){
	+void Game::render(ImageManager&,SDL_Renderer &renderer){
	//First of all render the background.
	{
	//Get a pointer to the background.
	ThemeBackground* bg=background;

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

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

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

	//Now draw the backgroundLayers.
	std::map<std::string,std::vector<Scenery*> >::iterator it;
	for(it=backgroundLayers.begin();it!=backgroundLayers.end();++it){
	for(unsigned int i=0;i<it->second.size();i++)
	- it->second[i]->show();
	+ it->second[i]->show(renderer);
	}

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

	//Followed by the player and the shadow.
	//NOTE: We draw the shadow first, because he needs to be behind the player.
	- shadow.show();
	- player.show();
	+ shadow.show(renderer);
	+ player.show(renderer);

	//Show the levelName if it isn't the level editor.
	if(stateID!=STATE_LEVEL_EDITOR && bmTips[0]!=NULL && !interlevel){
	- drawGUIBox(-2,SCREEN_HEIGHT-bmTips[0]->h-4,bmTips[0]->w+8,bmTips[0]->h+6,screen,0xFFFFFFFF);
	- applySurface(2,SCREEN_HEIGHT-bmTips[0]->h,bmTips[0],screen,NULL);
	+ withTexture(*bmTips[gameTipIndex], [&](SDL_Rect r){
	+ drawGUIBox(-2,SCREEN_HEIGHT-r.h-4,r.w+8,r.h+6,renderer,0xFFFFFFFF);
	+ applyTexture(2,SCREEN_HEIGHT-r.h,*bmTips[0],renderer,NULL);
	+ });
	}

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

	//If we have a string then it's a supported GameObject type.
	if(!s.empty()){
	SDL_Color fg={0,0,0,0};
	- bmTips[gameTipIndex]=TTF_RenderUTF8_Blended(fontText,s.c_str(),fg);
	+ bmTips[gameTipIndex]=textureFromText(renderer, *fontText, s.c_str(), fg);
	}
	}

	//We already have a gameTip for this type so draw it.
	if(bmTips[gameTipIndex]!=NULL){
	- drawGUIBox(-2,-2,bmTips[gameTipIndex]->w+8,bmTips[gameTipIndex]->h+6,screen,0xFFFFFFFF);
	- applySurface(2,2,bmTips[gameTipIndex],screen,NULL);
	+ withTexture(*bmTips[gameTipIndex], [&](SDL_Rect r){
	+ drawGUIBox(-2,-2,r.w+8,r.h+6,renderer,0xFFFFFFFF);
	+ applyTexture(2,2,*bmTips[gameTipIndex],renderer);
	+ });
	}
	}
	//Set the gameTip to 0.
	gameTipIndex=0;
	-
	- //Pointer to the sdl surface that will contain a message, if any.
	- SDL_Surface* bm=NULL;
	+ // Limit the scope of bm, as it's a borrowed pointer.
	+ {
	+ //Pointer to the sdl texture that will contain a message, if any.
	+ SDL_Texture* bm=NULL;

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

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

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

	//return view to player and keep it there
	cameraMode=CAMERA_PLAYER;
	}

	//Draw the tip.
	if(bm!=NULL){
	- int x=(SCREEN_WIDTH-bm->w)/2;
	+ const SDL_Rect textureSize = rectFromTexture(*bm);
	+ int x=(SCREEN_WIDTH-textureSize.w)/2;
	int y=32;
	- drawGUIBox(x-8,y-8,bm->w+16,bm->h+14,screen,0xFFFFFFFF);
	- applySurface(x,y,bm,screen,NULL);
	+ drawGUIBox(x-8,y-8,textureSize.w+16,textureSize.h+14,renderer,0xFFFFFFFF);
	+ applyTexture(x,y,*bm,renderer);
	}
	+ }

	//Show the number of collectables the user has collected if there are collectables in the level.
	//We hide this when interlevel.
	if(currentCollectables<=totalCollectables && totalCollectables!=0 && !interlevel && time>0){
	//Temp stringstream just to addup all the text nicely
	stringstream temp;
	temp << currentCollectables << "/" << totalCollectables;

	- SDL_Rect r;
	- SDL_Surface* bm=TTF_RenderText_Blended(fontText,temp.str().c_str(),themeTextColorDialog);
	+ SDL_Rect r{0,0,0,0};
	+ //TODO:Cache this!
	+ auto bm=textureFromText(renderer,*fontText,temp.str().c_str(),themeTextColorDialog);
	+ SDL_Rect bmSize = rectFromTexture(*bm);

	//Align the text properly
	- r.x=SCREEN_WIDTH-50-bm->w+22;
	- r.y=SCREEN_HEIGHT-bm->h;
	+ bmSize.x=SCREEN_WIDTH-50-bmSize.w+22;
	+ bmSize.y=SCREEN_HEIGHT-bmSize.h;

	//Draw background
	- drawGUIBox(SCREEN_WIDTH-bm->w-34,SCREEN_HEIGHT-bm->h-4,bm->w+34+2,bm->h+4+2,screen,0xFFFFFFFF);
	+ drawGUIBox(SCREEN_WIDTH-bmSize.w-34,SCREEN_HEIGHT-bmSize.h-4,bmSize.w+34+2,bmSize.h+4+2,renderer,0xFFFFFFFF);

	//Draw the collectable icon
	- collectable.draw(screen,SCREEN_WIDTH-50+12,SCREEN_HEIGHT-50+10);
	+ collectable.draw(renderer,SCREEN_WIDTH-50+12,SCREEN_HEIGHT-50+10);

	//Draw text
	- SDL_BlitSurface(bm,NULL,screen,&r);
	- SDL_FreeSurface(bm);
	+ applyTexture(r.x,r.y,bm,renderer);
	}

	//show time and records used in level editor.
	if(stateID==STATE_LEVEL_EDITOR && time>0){
	- SDL_Color fg={0,0,0,0},bg={255,255,255,0};
	- SDL_Surface *bm;
	- int y=SCREEN_HEIGHT;
	-
	- bm=TTF_RenderUTF8_Shaded(fontText,tfm::format(_("%d recordings"),recordings).c_str(),fg,bg);
	- SDL_SetAlpha(bm,SDL_SRCALPHA,160);
	- y-=bm->h;
	- applySurface(0,y,bm,screen,NULL);
	- SDL_FreeSurface(bm);
	-
	- char c[32];
	- sprintf(c,"%-.2fs",time/40.0f);
	- bm=TTF_RenderUTF8_Shaded(fontText,c,fg,bg);
	- SDL_SetAlpha(bm,SDL_SRCALPHA,160);
	- y-=bm->h;
	- applySurface(0,y,bm,screen,NULL);
	- SDL_FreeSurface(bm);
	+ const SDL_Color fg={0,0,0,255},bg={255,255,255,255};
	+ const int alpha = 160;
	+ if (recordingsTexture.needsUpdate(recordings)) {
	+ recordingsTexture.update(recordings,
	+ textureFromTextShaded(
	+ renderer,
	+ *fontText,
	+ tfm::format(_("%d recordings"),recordings).c_str(),
	+ fg,
	+ bg
	+ ));
	+ SDL_SetTextureAlphaMod(recordingsTexture.get(),alpha);
	+ }
	+
	+ int y=SCREEN_HEIGHT - textureHeight(*recordingsTexture.get());
	+
	+ applyTexture(0,y,*recordingsTexture.get(), renderer);
	+
	+ if(timeTexture.needsUpdate(time)) {
	+ const size_t len = 32;
	+ char c[len];
	+ snprintf(c,len,"%-.2fs",time/40.0f);
	+ timeTexture.update(time,
	+ textureFromTextShaded(
	+ renderer,
	+ *fontText,
	+ c,
	+ fg,
	+ bg
	+ ));
	+ y-=textureHeight(*timeTexture.get());
	+ }
	+
	+ applyTexture(0,y,*timeTexture.get(), renderer);
	}

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

	//if the game is play from record then draw something indicates it
	if(player.isPlayFromRecord()){
	//Dim the screen if interlevel is true.
	- if(interlevel){
	- SDL_BlitSurface(screen,NULL,tempSurface,NULL);
	- SDL_FillRect(screen,NULL,0);
	- SDL_SetAlpha(tempSurface, SDL_SRCALPHA,191);
	- SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	+ if( interlevel){
	+ dimScreen(renderer,191);
	}else if((time & 0x10)==0x10){
	SDL_Rect r={50,0,50,50};
	- applySurface(0,0,action,screen,&r);
	- applySurface(0,SCREEN_HEIGHT-50,action,screen,&r);
	- applySurface(SCREEN_WIDTH-50,SCREEN_HEIGHT-50,action,screen,&r);
	+ applyTexture(0,0,*action,renderer,&r);
	+ applyTexture(0,SCREEN_HEIGHT-50,*action,renderer,&r);
	+ applyTexture(SCREEN_WIDTH-50,SCREEN_HEIGHT-50,*action,renderer,&r);
	}
	}else if(player.objNotificationBlock){
	//If the player is in front of a notification block show the message.
	//And it isn't a replay.
	- std::string &untranslated_message=player.objNotificationBlock->message;
	- std::string message=_CC(levels->getDictionaryManager(),untranslated_message);
	- std::vector<char> string_data(message.begin(), message.end());
	- string_data.push_back('\0');
	-
	- int maxWidth = 0;
	- int y = 20;
	- vector<SDL_Surface*> lines;
	-
	- //Now process the prompt.
	- {
	- //Pointer to the string.
	- char* lps=&string_data[0];
	- //Pointer to a character.
	- char* lp=NULL;
	-
	- //We keep looping forever.
	- //The only way out is with the break statement.
	- for(;;){
	- //As long as it's still the same sentence we continue.
	- //It will stop when there's a newline or end of line.
	- for(lp=lps;lp!='\n'&&lp!='\r'&&*lp!=0;lp++);
	-
	- //Store the character we stopped on. (End or newline)
	- char c=*lp;
	- //Set the character in the string to 0, making lps a string containing one sentence.
	- *lp=0;
	-
	- //Integer used to center the sentence horizontally.
	- int x;
	- TTF_SizeText(fontText,lps,&x,NULL);
	-
	- //Find out largest width
	- if(x>maxWidth)
	- maxWidth=x;
	-
	- x=(SCREEN_WIDTH-x)/2;
	-
	- lines.push_back(TTF_RenderUTF8_Blended(fontText,lps,themeTextColorDialog));
	- //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;
	- }
	- }
	- maxWidth+=SCREEN_WIDTH*0.15;
	- drawGUIBox((SCREEN_WIDTH-maxWidth)/2,SCREEN_HEIGHT-y-25,maxWidth,y+20,screen,0xFFFFFFBF);
	- while(!lines.empty()){
	- SDL_Surface* bm=lines[0];
	-
	- if(bm!=NULL){
	- applySurface(100+((SCREEN_WIDTH-200-bm->w)/2),SCREEN_HEIGHT-y,bm,screen,NULL);
	- SDL_FreeSurface(bm);
	- }
	-
	- y-=25;
	- lines.erase(lines.begin());
	-
	- }
	+ //Check if we need to update the notification message texture.
	+ const auto& blockId = player.objNotificationBlock;
	+ int maxWidth = 0;
	+ int y = 20;
	+ //We check against blockId rather than the full message, as blockId is most likely shorter.
	+ if(notificationTexture.needsUpdate(blockId)) {
	+ const std::string &untranslated_message=player.objNotificationBlock->message;
	+ std::string message=_CC(levels->getDictionaryManager(),untranslated_message);
	+ std::vector<char> string_data(message.begin(), message.end());
	+ string_data.push_back('\0');
	+
	+ vector<SurfacePtr> lines;
	+ int num_lines = 0;
	+
	+ //Now process the prompt.
	+ {
	+ //Pointer to the string.
	+ char* lps=&string_data[0];
	+ //Pointer to a character.
	+ char* lp=NULL;
	+
	+ //We keep looping forever.
	+ //The only way out is with the break statement.
	+ for(;;){
	+ //As long as it's still the same sentence we continue.
	+ //It will stop when there's a newline or end of line.
	+ for(lp=lps;lp!='\n'&&lp!='\r'&&*lp!=0;lp++);
	+
	+ //Store the character we stopped on. (End or newline)
	+ char c=*lp;
	+ //Set the character in the string to 0, making lps a string containing one sentence.
	+ *lp=0;
	+
	+ //Integer used to center the sentence horizontally.
	+ int x=0;
	+ TTF_SizeText(fontText,lps,&x,NULL);
	+
	+ //Find out largest width
	+ if(x>maxWidth)
	+ maxWidth=x;
	+
	+ x=(SCREEN_WIDTH-x)/2;
	+
	+ lines.emplace_back(TTF_RenderUTF8_Blended(fontText,lps,themeTextColorDialog));
	+ //Increase y with 25, about the height of the text.
	+ y+=25;
	+ num_lines++;
	+
	+ //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;
	+ }
	+ }
	+
	+ maxWidth+=SCREEN_WIDTH*0.15;
	+
	+ SurfacePtr surf = createSurface(maxWidth, y);
	+ for(SurfacePtr &s : lines) {
	+ if(s) {
	+ applySurface((surf->w-s->w)/2,surf->h - y,s.get(),surf.get(),NULL);
	+ y -= 25;
	+ }
	+ }
	+ notificationTexture.update(blockId, textureUniqueFromSurface(renderer,std::move(surf)));
	+ } else {
	+ auto texSize = rectFromTexture(*notificationTexture.get());
	+ maxWidth=texSize.w;
	+ y=texSize.h;
	+ }
	+
	+ drawGUIBox((SCREEN_WIDTH-maxWidth)/2,SCREEN_HEIGHT-y-25,maxWidth,y+20,renderer,0xFFFFFFBF);
	+ applyTexture((SCREEN_WIDTH-maxWidth)/2,SCREEN_HEIGHT-y,notificationTexture.getTexture(),renderer);
	}
	}

	-void Game::resize(){
	+void Game::resize(ImageManager&, SDL_Renderer& /renderer/){
	//Check if the interlevel popup is shown.
	if(interlevel && GUIObjectRoot){
	GUIObjectRoot->left=(SCREEN_WIDTH-GUIObjectRoot->width)/2;
	}
	}

	-void Game::replayPlay(){
	+void Game::replayPlay(ImageManager& imageManager,SDL_Renderer& renderer){
	//Set interlevel true.
	interlevel=true;

	//Make a copy of the playerButtons.
	vector<int> recordCopy=player.recordButton;

	//Reset the game.
	reset(true);

	//Make the cursor visible when the interlevel popup is up.
	SDL_ShowCursor(SDL_ENABLE);

	//Set the copy of playerButtons back.
	player.recordButton=recordCopy;

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

	//Create the gui if it isn't already done.
	if(!GUIObjectRoot){
	//Create a new GUIObjectRoot the size of the screen.
	- GUIObjectRoot=new GUIObject(0,0,SCREEN_WIDTH,SCREEN_HEIGHT);
	+ GUIObjectRoot=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,SCREEN_HEIGHT);
	//Make child widgets change color properly according to theme.
	GUIObjectRoot->inDialog=true;

	//Create a GUIFrame for the upper frame.
	- GUIFrame* upperFrame=new GUIFrame(0,4,0,68);
	+ GUIFrame* upperFrame=new GUIFrame(imageManager,renderer,0,4,0,68);
	GUIObjectRoot->addChild(upperFrame);

	//Render the You've finished: text and add it to a GUIImage.
	- //NOTE: The surface is managed by the GUIImage so no need to free it ourselfs.
	- SDL_Surface* bm=TTF_RenderUTF8_Blended(fontGUI,_("You've finished:"),themeTextColorDialog);
	- GUIImage* title=new GUIImage(0,4-GUI_FONT_RAISE,bm->w,bm->h,bm,SDL_Rect(),true);
	+ //NOTE: The texture is managed by the GUIImage so no need to free it ourselfs.
	+ auto bm = SharedTexture(textureFromText(renderer, *fontGUI,_("You've finished:"),themeTextColorDialog));
	+ const SDL_Rect textureSize = rectFromTexture(*bm);
	+
	+ GUIImage* title=new GUIImage(imageManager,renderer,0,4-GUI_FONT_RAISE,textureSize.w,textureSize.h,bm);
	upperFrame->addChild(title);

	//Create the sub title.
	string s;
	if (levels->getLevelCount()>0){
	/// TRANSLATORS: Please do not remove %s or %d from your translation:
	/// - %d means the level number in a levelpack
	/// - %s means the name of current level
	s=tfm::format(_("Level %d %s"),levels->getCurrentLevel()+1,_CC(levels->getDictionaryManager(),levelName));
	}
	- GUIObject* obj=new GUILabel(0,40,0,28,s.c_str(),0,true,true,GUIGravityCenter);
	- obj->render(0,0,false);
	+ GUIObject* obj=new GUILabel(imageManager,renderer,0,40,0,28,s.c_str(),0,true,true,GUIGravityCenter);
	+ obj->render(renderer,0,0,false);
	upperFrame->addChild(obj);

	//Determine the width the upper frame should have.
	int width;
	- if(bm->w>obj->width)
	- width=bm->w+32;
	+ if(textureSize.w>obj->width)
	+ width=textureSize.w+32;
	else
	width=obj->width+32;
	//Set the left of the title.
	title->left=(width-title->width)/2;
	//Set the width of the level label to the width of the frame for centering.
	obj->width=width;
	//Now set the position and width of the frame.
	upperFrame->width=width;
	upperFrame->left=(SCREEN_WIDTH-width)/2;

	//Now create a GUIFrame for the lower frame.
	- GUIFrame* lowerFrame=new GUIFrame(0,SCREEN_HEIGHT-140,570,135);
	+ GUIFrame* lowerFrame=new GUIFrame(imageManager,renderer,0,SCREEN_HEIGHT-140,570,135);
	GUIObjectRoot->addChild(lowerFrame);

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

	int medal=1;
	if(targetTime<0){
	medal=3;
	}else{
	if(targetTime<0 \|\| bestTime<=targetTime)
	medal++;
	if(targetRecordings<0 \|\| bestRecordings<=targetRecordings)
	medal++;
	}

	int maxWidth=0;
	int x=20;

	//Is there a target time for this level?
	int timeY=0;
	bool isTargetTime=true;
	if(targetTime<=0){
	isTargetTime=false;
	timeY=12;
	}

	//Create the labels with the time and best time.
	/// TRANSLATORS: Please do not remove %-.2f from your translation:
	/// - %-.2f means time in seconds
	/// - s is shortened form of a second. Try to keep it so.
	- obj=new GUILabel(x,10+timeY,-1,36,tfm::format(_("Time: %-.2fs"),time/40.0f).c_str());
	+ obj=new GUILabel(imageManager,renderer,x,10+timeY,-1,36,tfm::format(_("Time: %-.2fs"),time/40.0f).c_str());
	lowerFrame->addChild(obj);

	- obj->render(0,0,false);
	+ obj->render(renderer,0,0,false);
	maxWidth=obj->width;

	/// TRANSLATORS: Please do not remove %-.2f from your translation:
	/// - %-.2f means time in seconds
	/// - s is shortened form of a second. Try to keep it so.
	- obj=new GUILabel(x,34+timeY,-1,36,tfm::format(_("Best time: %-.2fs"),bestTime/40.0f).c_str());
	+ obj=new GUILabel(imageManager,renderer,x,34+timeY,-1,36,tfm::format(_("Best time: %-.2fs"),bestTime/40.0f).c_str());
	lowerFrame->addChild(obj);

	- obj->render(0,0,false);
	+ obj->render(renderer,0,0,false);
	if(obj->width>maxWidth)
	maxWidth=obj->width;

	/// TRANSLATORS: Please do not remove %-.2f from your translation:
	/// - %-.2f means time in seconds
	/// - s is shortened form of a second. Try to keep it so.
	if(isTargetTime){
	- obj=new GUILabel(x,58,-1,36,tfm::format(_("Target time: %-.2fs"),targetTime/40.0f).c_str());
	+ obj=new GUILabel(imageManager,renderer,x,58,-1,36,tfm::format(_("Target time: %-.2fs"),targetTime/40.0f).c_str());
	lowerFrame->addChild(obj);

	- obj->render(0,0,false);
	+ obj->render(renderer,0,0,false);
	if(obj->width>maxWidth)
	maxWidth=obj->width;
	}

	x+=maxWidth+20;

	//Is there target recordings for this level?
	int recsY=0;
	bool isTargetRecs=true;
	if(targetRecordings<0){
	isTargetRecs=false;
	recsY=12;
	}

	//Now the ones for the recordings.
	/// TRANSLATORS: Please do not remove %d from your translation:
	/// - %d means the number of recordings user has made
	- obj=new GUILabel(x,10+recsY,-1,36,tfm::format(_("Recordings: %d"),recordings).c_str());
	+ obj=new GUILabel(imageManager,renderer,x,10+recsY,-1,36,tfm::format(_("Recordings: %d"),recordings).c_str());
	lowerFrame->addChild(obj);

	- obj->render(0,0,false);
	+ obj->render(renderer,0,0,false);
	maxWidth=obj->width;

	/// TRANSLATORS: Please do not remove %d from your translation:
	/// - %d means the number of recordings user has made
	- obj=new GUILabel(x,34+recsY,-1,36,tfm::format(_("Best recordings: %d"),bestRecordings).c_str());
	+ obj=new GUILabel(imageManager,renderer,x,34+recsY,-1,36,tfm::format(_("Best recordings: %d"),bestRecordings).c_str());
	lowerFrame->addChild(obj);

	- obj->render(0,0,false);
	+ obj->render(renderer,0,0,false);
	if(obj->width>maxWidth)
	maxWidth=obj->width;

	/// TRANSLATORS: Please do not remove %d from your translation:
	/// - %d means the number of recordings user has made
	if(isTargetRecs){
	- obj=new GUILabel(x,58,-1,36,tfm::format(_("Target recordings: %d"),targetRecordings).c_str());
	+ obj=new GUILabel(imageManager,renderer,x,58,-1,36,tfm::format(_("Target recordings: %d"),targetRecordings).c_str());
	lowerFrame->addChild(obj);

	- obj->render(0,0,false);
	+ obj->render(renderer,0,0,false);
	if(obj->width>maxWidth)
	maxWidth=obj->width;
	}

	x+=maxWidth;

	//The medal that is earned.
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - %s will be replaced with name of a prize medal (gold, silver or bronze)
	string s1=tfm::format(_("You earned the %s medal"),(medal>1)?(medal==3)?_("GOLD"):_("SILVER"):_("BRONZE"));
	- obj=new GUILabel(50,92,-1,36,s1.c_str(),0,true,true,GUIGravityCenter);
	+ obj=new GUILabel(imageManager,renderer,50,92,-1,36,s1.c_str(),0,true,true,GUIGravityCenter);
	lowerFrame->addChild(obj);

	- obj->render(0,0,false);
	+ obj->render(renderer,0,0,false);
	if(obj->left+obj->width>x){
	x=obj->left+obj->width+30;
	}else{
	obj->left=20+(x-20-obj->width)/2;
	}

	//Create the rectangle for the earned medal.
	SDL_Rect r;
	r.x=(medal-1)*30;
	r.y=0;
	r.w=30;
	r.h=30;

	//Create the medal on the left side.
	- obj=new GUIImage(16,92,30,30,medals,r);
	+ obj=new GUIImage(imageManager,renderer,16,92,30,30,medals,r);
	lowerFrame->addChild(obj);
	//And the medal on the right side.
	- obj=new GUIImage(x-24,92,30,30,medals,r);
	+ obj=new GUIImage(imageManager,renderer,x-24,92,30,30,medals,r);
	lowerFrame->addChild(obj);

	//Create the three buttons, Menu, Restart, Next.
	/// TRANSLATORS: used as return to the level selector menu
	- GUIObject* b1=new GUIButton(x,10,-1,36,_("Menu"),0,true,true,GUIGravityCenter);
	+ GUIObject* b1=new GUIButton(imageManager,renderer,x,10,-1,36,_("Menu"),0,true,true,GUIGravityCenter);
	b1->name="cmdMenu";
	b1->eventCallback=this;
	lowerFrame->addChild(b1);
	- b1->render(0,0,true);
	+ b1->render(renderer,0,0,true);

	/// TRANSLATORS: used as restart level
	- GUIObject* b2=new GUIButton(x,50,-1,36,_("Restart"),0,true,true,GUIGravityCenter);
	+ GUIObject* b2=new GUIButton(imageManager,renderer,x,50,-1,36,_("Restart"),0,true,true,GUIGravityCenter);
	b2->name="cmdRestart";
	b2->eventCallback=this;
	lowerFrame->addChild(b2);
	- b2->render(0,0,true);
	+ b2->render(renderer,0,0,true);

	/// TRANSLATORS: used as next level
	- GUIObject* b3=new GUIButton(x,90,-1,36,_("Next"),0,true,true,GUIGravityCenter);
	+ GUIObject* b3=new GUIButton(imageManager,renderer,x,90,-1,36,_("Next"),0,true,true,GUIGravityCenter);
	b3->name="cmdNext";
	b3->eventCallback=this;
	lowerFrame->addChild(b3);
	- b3->render(0,0,true);
	+ b3->render(renderer,0,0,true);

	maxWidth=b1->width;
	if(b2->width>maxWidth)
	maxWidth=b2->width;
	if(b3->width>maxWidth)
	maxWidth=b3->width;

	b1->left=b2->left=b3->left=x+maxWidth/2;

	x+=maxWidth;
	lowerFrame->width=x;
	lowerFrame->left=(SCREEN_WIDTH-lowerFrame->width)/2;
	}
	}

	-void Game::recordingEnded(){
	+void Game::recordingEnded(ImageManager& imageManager, SDL_Renderer& renderer){
	//Check if it's a normal replay, if so just stop.
	if(!interlevel){
	//Show the cursor so that the user can press the ok button.
	SDL_ShowCursor(SDL_ENABLE);
	//Now show the message box.
	- msgBox(_("Game replay is done."),MsgBoxOKOnly,_("Game Replay"));
	+ msgBox(imageManager,renderer,_("Game replay is done."),MsgBoxOKOnly,_("Game Replay"));
	//Go to the level select menu.
	setNextState(STATE_LEVEL_SELECT);

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

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

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

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

	//Save the camera mode and target.
	cameraModeSaved=cameraMode;
	cameraTargetSaved=cameraTarget;

	//Save the current collectables
	currentCollectablesSaved=currentCollectables;

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

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

	if(!player.isPlayFromRecord() && !interlevel){
	//Update achievements
	Uint32 t=SDL_GetTicks()+5000; //Add a bias to prevent bugs
	if(recentSave+1000>t){
	statsMgr.newAchievement("panicSave");
	}
	recentSave=t;

	//Update statistics.
	statsMgr.saveTimes++;

	//Update achievements
	switch(statsMgr.saveTimes){
	case 1000:
	statsMgr.newAchievement("save1k");
	break;
	}
	}

	//Execute the onSave event.
	executeScript(LevelEvent_OnSave);

	//Return true.
	return true;
	}

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

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

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

	//Load the camera mode and target.
	cameraMode=cameraModeSaved;
	cameraTarget=cameraTargetSaved;

	//Load the current collactbles
	currentCollectables=currentCollectablesSaved;

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

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

	if(!player.isPlayFromRecord() && !interlevel){
	//Update achievements.
	Uint32 t=SDL_GetTicks()+5000; //Add a bias to prevent bugs
	if(recentLoad+1000>t){
	statsMgr.newAchievement("panicLoad");
	}
	recentLoad=t;

	//Update statistics.
	statsMgr.loadTimes++;

	//Update achievements
	switch(statsMgr.loadTimes){
	case 1000:
	statsMgr.newAchievement("load1k");
	break;
	}
	}

	//Execute the onLoad event, if any.
	executeScript(LevelEvent_OnLoad);

	//Return true.
	return true;
	}

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

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

	saveStateNextTime=false;
	loadStateNextTime=false;

	//Reset the stats if interlevel isn't true.
	if(!interlevel){
	time=0;
	recordings=0;
	}

	recentSwap=-10000;
	if(save) recentSwapSaved=-10000;

	//Reset the camera.
	cameraMode=CAMERA_PLAYER;
	if(save) cameraModeSaved=CAMERA_PLAYER;
	cameraTarget.x=cameraTarget.y=cameraTarget.w=cameraTarget.h=0;
	if(save) cameraTargetSaved.x=cameraTargetSaved.y=cameraTargetSaved.w=cameraTargetSaved.h=0;

	//Reset the number of collectables
	currentCollectables=0;
	if(save)
	currentCollectablesSaved=0;

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

	//Clear the event queue, since all the events are from before the reset.
	eventQueue.clear();

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

	//Reset the script environment
	//NOTE: The scriptExecutor will only be reset between levels. (Why? by acme_pjz)
	getScriptExecutor()->reset();

	//Recompile and run script, only in game mode and edit mode with 'R' key pressed.
	//FIXME: We use an ad-hoc method to check if 'R' key is pressed, by checking isReset.
	if(stateID!=STATE_LEVEL_EDITOR \|\| isReset) compileScript();

	//Hide the cursor (if not the leveleditor).
	if(stateID!=STATE_LEVEL_EDITOR)
	SDL_ShowCursor(SDL_DISABLE);
	}

	void Game::compileScript(){
	compiledScripts.clear();

	for(map<int,string>::iterator it=scripts.begin();it!=scripts.end();++it){
	compiledScripts[it->first]=getScriptExecutor()->compileScript(it->second);
	}

	for(unsigned int i=0;i<levelObjects.size();i++){
	Block *block=levelObjects[i];

	block->compiledScripts.clear();

	for(map<int,string>::iterator it=block->scripts.begin();it!=block->scripts.end();++it){
	block->compiledScripts[it->first]=getScriptExecutor()->compileScript(it->second);
	}
	}

	//Call the level's onCreate event.
	executeScript(LevelEvent_OnCreate);

	//Send GameObjectEvent_OnCreate event to the script
	for(unsigned int i=0;i<levelObjects.size();i++){
	levelObjects[i]->onEvent(GameObjectEvent_OnCreate);
	}

	//Close exit(s) if there are any collectables
	if(totalCollectables>0){
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(levelObjects[i]->type==TYPE_EXIT){
	levelObjects[i]->onEvent(GameObjectEvent_OnSwitchOff);
	}
	}
	}
	}

	void Game::executeScript(int eventType){
	map<int,int>::iterator it;

	//Check if there's a script for the given event.
	it=compiledScripts.find(eventType);
	if(it!=compiledScripts.end()){
	//There is one so execute it.
	getScriptExecutor()->executeScript(it->second);
	}
	}

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

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

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

	-void Game::gotoNextLevel(){
	+void Game::gotoNextLevel(ImageManager& imageManager, SDL_Renderer& renderer){
	//Goto the next level.
	levels->nextLevel();

	//Check if the level exists.
	if(levels->getCurrentLevel()<levels->getLevelCount()){
	setNextState(STATE_GAME);
	}else{
	if(!levels->congratulationText.empty()){
	- msgBox(_CC(levels->getDictionaryManager(),levels->congratulationText),MsgBoxOKOnly,_("Congratulations"));
	+ msgBox(imageManager,renderer,_CC(levels->getDictionaryManager(),levels->congratulationText),MsgBoxOKOnly,_("Congratulations"));
	}else{
	- msgBox(_("You have finished the levelpack!"),MsgBoxOKOnly,_("Congratulations"));
	+ msgBox(imageManager,renderer,_("You have finished the levelpack!"),MsgBoxOKOnly,_("Congratulations"));
	}
	//Now go back to the levelselect screen.
	setNextState(STATE_LEVEL_SELECT);
	//And set the music back to menu.
	getMusicManager()->playMusic("menu");
	}
	}

	-void Game::GUIEventCallback_OnEvent(string name,GUIObject* obj,int eventType){
	+void Game::GUIEventCallback_OnEvent(ImageManager& imageManager,SDL_Renderer& renderer, string name,GUIObject* obj,int eventType){
	if(name=="cmdMenu"){
	setNextState(STATE_LEVEL_SELECT);

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

	interlevel=false;

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

	//And goto the next level.
	- gotoNextLevel();
	+ gotoNextLevel(imageManager,renderer);
	}
	}
	diff --git a/src/Game.h b/src/Game.h
	index c888003..f92f63c 100644
	--- a/src/Game.h
	+++ b/src/Game.h
	@@ -1,287 +1,295 @@
	/*
	* 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 GAME_H
	#define GAME_H

	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_mixer.h>
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_mixer.h>
	+#include <SDL2/SDL_ttf.h>
	#endif
	+#include <array>
	#include <vector>
	#include <map>
	#include <string>
	+
	+#include "CachedTexture.h"
	#include "GameState.h"
	#include "GUIObject.h"
	#include "GameObjects.h"
	#include "Scenery.h"
	#include "Player.h"
	+#include "Render.h"
	#include "Shadow.h"

	//This structure contains variables that make a GameObjectEvent.
	struct typeGameObjectEvent{
	//The type of event.
	int eventType;
	//The type of object that should react to the event.
	int objectType;
	//Flags, 0x1 means use the id.
	int flags;
	//Blocks with this id should react to the event.
	std::string id;

	//Optional pointer to the block the event should be called on.
	GameObject* target;
	};

	class ThemeManager;
	class ThemeBackground;
	class TreeStorageNode;

	//The different level events.
	enum LevelEventType{
	//Event called when the level is created, this happens after all the blocks are created and their onCreate is called.
	LevelEvent_OnCreate=1,
	//Event called when the game is saved.
	LevelEvent_OnSave,
	//Event called when the game is loaded.
	LevelEvent_OnLoad,
	//Event called when the game is reset.
	LevelEvent_OnReset,
	};

	class Game : public GameState,public GUIEventCallback{
	private:
	//Boolean if the game should reset.
	bool isReset;

	//contains currently played level.
	TreeStorageNode* currentLevelNode;

	protected:
	//Array containing "tooltips" for certain block types.
	//It will be shown in the topleft corner of the screen.
	- SDL_Surface* bmTips[TYPE_MAX];
	+ std::array<TexturePtr, TYPE_MAX> bmTips;

	- //SDL_Surface containing the action images (record, play, etc..)
	- SDL_Surface* action;
	- //SDL_Surface containing the medal image.
	- SDL_Surface* medals;
	+ //Texture containing the action images (record, play, etc..)
	+ SharedTexture action;
	+ //Texture containing the medal image.
	+ SharedTexture medals;

	//ThemeBlockInstance containing the collectable image.
	ThemeBlockInstance collectable;

	//The name of the current level.
	std::string levelName;
	//The path + file of the current level.
	std::string levelFile;

	//Editor data containing information like name, size, etc...
	std::map<std::string,std::string> editorData;

	//Vector used to queue the gameObjectEvents.
	std::vector<typeGameObjectEvent> eventQueue;

	//The themeManager.
	ThemeManager* customTheme;
	//The themeBackground.
	ThemeBackground* background;

	+ CachedTexture<int> recordingsTexture;
	+ CachedTexture<int> timeTexture;
	+ CachedTexture<Block*> notificationTexture;
	+
	//Load a level from node.
	//After calling this function the ownership of
	//node will transfer to Game class. So don't delete
	//the node after calling this function!
	- virtual void loadLevelFromNode(TreeStorageNode* obj, const std::string& fileName);
	+ virtual void loadLevelFromNode(ImageManager& imageManager, SDL_Renderer& renderer, TreeStorageNode* obj, const std::string& fileName);

	public:
	//Array used to convert GameObject type->string.
	static const char* blockName[TYPE_MAX];
	//Map used to convert GameObject string->type.
	static std::map<std::string,int> blockNameMap;

	//Map used to convert GameObjectEventType type->string.
	static std::map<int,std::string> gameObjectEventTypeMap;
	//Map used to convert GameObjectEventType string->type.
	static std::map<std::string,int> gameObjectEventNameMap;

	//Map used to convert LevelEventType type->string.
	static std::map<int,std::string> levelEventTypeMap;
	//Map used to convert LevelEventType string->type.
	static std::map<std::string,int> levelEventNameMap;

	//Boolean that is set to true when a game is won.
	bool won;

	//Boolean that is set to true when we should save game on next logic update.
	bool saveStateNextTime;

	//Boolean that is set to true when we should load game on next logic update.
	bool loadStateNextTime;

	//Boolean if the replaying currently done is for the interlevel screen.
	bool interlevel;

	//Integer containing the current tip index.
	int gameTipIndex;

	//Integer containing the number of ticks passed since the start of the level.
	int time;
	//Integer containing the stored value of time.
	int timeSaved;

	//Integer containing the number of recordings it took to finish.
	int recordings;
	//Integer containing the stored value of recordings.
	int recordingsSaved;

	//Integer keeping track of currently obtained collectables
	int currentCollectables;
	//Integer keeping track of total colletables in the level
	int totalCollectables;
	//Integer containing the stored value of current collectables
	int currentCollectablesSaved;

	//Time of recent swap, for achievements. (in game-ticks)
	int recentSwap,recentSwapSaved;

	//Store time of recent save/load for achievements (in millisecond)
	Uint32 recentLoad,recentSave;

	//Enumeration with the different camera modes.
	enum CameraMode{
	CAMERA_PLAYER,
	CAMERA_SHADOW,
	CAMERA_CUSTOM
	};
	//The current camera mode.
	CameraMode cameraMode;
	//Rectangle containing the target for the camera.
	SDL_Rect cameraTarget;

	//The saved cameraMode.
	CameraMode cameraModeSaved;
	SDL_Rect cameraTargetSaved;

	//Level scripts.
	std::map<int,std::string> scripts;

	//Compiled scripts. Use lua_rawgeti(L, LUA_REGISTRYINDEX, r) to get the function.
	std::map<int,int> compiledScripts;

	//Vector containing all the levelObjects in the current game.
	std::vector<Block*> levelObjects;

	//The background layers for the scenery.
	std::map<std::string,std::vector<Scenery*> > backgroundLayers;

	//The player...
	Player player;
	//... and his shadow.
	Shadow shadow;

	//warning: weak reference only, may point to invalid location
	Block* objLastCheckPoint;

	//Constructor.
	- Game();
	+ Game(SDL_Renderer& renderer, ImageManager& imageManager);
	//If this is not empty then when next Game class is created
	//it will play this record file.
	static std::string recordFile;
	//Destructor.
	//It will call destroy();
	~Game();

	//Method used to clean up the GameState.
	void destroy();

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

	//This method will load a level.
	//fileName: The fileName of the level.
	- virtual void loadLevel(std::string fileName);
	+ virtual void loadLevel(ImageManager& imageManager, SDL_Renderer& renderer, std::string fileName);

	//Method used to broadcast a GameObjectEvent.
	//eventType: The type of event.
	//objectType: The type of object that should react to the event.
	//id: The id of the blocks that should react.
	//target: Pointer to the object
	void broadcastObjectEvent(int eventType,int objectType=-1,const char* id=NULL,GameObject* target=NULL);

	//Compile all scripts and run onCreate script.
	//NOTE: Call this function only after script state reset, or there will be some memory leaks.
	void compileScript();

	//Method that will check if a script for a given levelEvent is present.
	//If that's the case the script will be executed.
	//eventType: The level event type to execute.
	void inline executeScript(int eventType);


	//Returns if the player and shadow can save the current state.
	bool canSaveState();

	//Method used to store the current state.
	//This is used for checkpoints.
	//Returns: True if it succeeds without problems.
	bool saveState();
	//Method used to load the stored state.
	//This is used for checkpoints.
	//Returns: True if it succeeds without problems.
	bool loadState();
	//Method that will reset the GameState to it's initial state.
	//save: Boolean if the saved state should also be delted.
	void reset(bool save);

	//Save current game record to the file.
	//fileName: The filename of the destination file.
	void saveRecord(const char* fileName);
	//Load game record (and its level) from file and play it.
	//fileName: The filename of the recording file.
	- void loadRecord(const char* fileName);
	+ void loadRecord(ImageManager& imageManager, SDL_Renderer& renderer, const char* fileName);

	//Method called by the player (or shadow) when he finished.
	- void replayPlay();
	+ void replayPlay(ImageManager& imageManager, SDL_Renderer &renderer);
	//Method that gets called when the recording has ended.
	- void recordingEnded();
	+ void recordingEnded(ImageManager& imageManager, SDL_Renderer& renderer);

	//get current level's auto-save record path,
	//using current level's MD5, file name and other information.
	void getCurrentLevelAutoSaveRecordPath(std::string &bestTimeFilePath,std::string &bestRecordingFilePath,bool createPath);

	//Method that will prepare the gamestate for the next level and start it.
	//If it's the last level it will show the congratulations text and return to the level select screen.
	- void gotoNextLevel();
	+ void gotoNextLevel(ImageManager& imageManager, SDL_Renderer& renderer);

	//Get the name of the current level.
	const std::string& getLevelName(){
	return levelName;
	}

	//GUI event handling is done here.
	- void GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType);
	+ void GUIEventCallback_OnEvent(ImageManager&imageManager, SDL_Renderer&renderer, std::string name, GUIObject* obj, int eventType) override;
	};

	#endif
	diff --git a/src/GameObjects.cpp b/src/GameObjects.cpp
	index 564f564..422bb53 100644
	--- a/src/GameObjects.cpp
	+++ b/src/GameObjects.cpp
	@@ -1,83 +1,83 @@
	/*
	* 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 "GameObjects.h"
	#include "Functions.h"
	#include "Globals.h"

	GameObject::GameObject(Game* parent):type(0),parent(parent){}
	GameObject::~GameObject(){}

	SDL_Rect GameObject::getBox(int boxType){
	//This is the default implementation of getBox(int) method.
	switch(boxType){
	case BoxType_Current:
	case BoxType_Previous:
	return box;
	case BoxType_Base:
	return boxBase;
	}

	//Return an empty SDL_Rect.
	SDL_Rect tmp={0,0,0,0};
	return tmp;
	}

	void GameObject::setLocation(int x,int y){
	box.x=x;
	box.y=y;
	}
	void GameObject::setBaseLocation(int x,int y){
	box.x=x;
	box.y=y;
	boxBase.x=x;
	boxBase.y=y;
	}

	void GameObject::setSize(int w,int h){
	box.w=w;
	box.h=h;
	}
	void GameObject::setBaseSize(int w,int h){
	box.w=w;
	box.h=h;
	boxBase.w=w;
	boxBase.h=h;
	}

	void GameObject::saveState(){}
	void GameObject::loadState(){}
	void GameObject::reset(bool save){}

	void GameObject::playAnimation(){}
	void GameObject::onEvent(int eventType){}

	int GameObject::queryProperties(int propertyType,Player* obj){
	return 0;
	}

	void GameObject::getEditorData(std::vector<std::pair<std::string,std::string> >& obj){}
	void GameObject::setEditorData(std::map<std::string,std::string>& obj){}
	std::string GameObject::getEditorProperty(std::string property){return "";}
	void GameObject::setEditorProperty(std::string property,std::string value){}

	-bool GameObject::loadFromNode(TreeStorageNode* objNode){return true;}
	+bool GameObject::loadFromNode(ImageManager&, SDL_Renderer&, TreeStorageNode*){return true;}

	void GameObject::prepareFrame(){}
	void GameObject::move(){}
	diff --git a/src/GameObjects.h b/src/GameObjects.h
	index 155ad16..65cb626 100644
	--- a/src/GameObjects.h
	+++ b/src/GameObjects.h
	@@ -1,174 +1,174 @@
	/*
	* 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 GAME_OBJECTS_H
	#define GAME_OBJECTS_H

	#include "Globals.h"
	#include "TreeStorageNode.h"
	#include "Player.h"
	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#include <string>
	#include <vector>
	#include <utility>
	#include <map>

	class Game;
	class Player;

	//The different gameObject events.
	enum GameObjectEventType{
	//Event called when the player walks on the gameObject.
	GameObjectEvent_PlayerWalkOn=1,
	//Event called when the player is on the gameObject.
	GameObjectEvent_PlayerIsOn,
	//Event called when the player leaves the gameObject.
	GameObjectEvent_PlayerLeave,
	//Event called when the gameObject is created.
	//Only used for scripting purpose.
	GameObjectEvent_OnCreate,
	//Event called every frame.
	//Only used for scripting purpose.
	GameObjectEvent_OnEnterFrame,

	//Event called when the player toggles it. (DOWN key)
	GameObjectEvent_OnToggle=0x10000,
	//Event called when the player switches it on. (DOWN key)
	GameObjectEvent_OnSwitchOn=0x10001,
	//Event called when the player switches it off. (DOWN key)
	GameObjectEvent_OnSwitchOff=0x10002,
	};

	//The different gameObject properties.
	enum GameObjectPropertyType{
	//If the player can walk on the gameObject.
	GameObjectProperty_PlayerCanWalkOn=1,
	//If the object is spiked.
	GameObjectProperty_IsSpikes,
	//If the gameObject has some flags.
	GameObjectProperty_Flags,
	};

	//The different box types that can be requested using the getBox(int boxType) method.
	enum GameObjectBoxType{
	//Box of the current position.
	BoxType_Current=0,
	//Box of the base/start position.
	BoxType_Base,
	//Box of the previous position.
	BoxType_Previous,
	//The movement of the block since last position.
	BoxType_Delta,
	//The velocity for when the player is standing on it.
	BoxType_Velocity,
	};

	//The GameObject class.
	class GameObject{
	protected:
	//The box of the gameObject.
	//It's used for the current location of the gameObject and its size.
	SDL_Rect box;
	//The base location of the game object.
	SDL_Rect boxBase;
	public:
	//The type of the GameObject.
	int type;
	//Pointer to the Game state.
	Game* parent;

	//Constructor.
	//parent: Pointer to the Game state.
	GameObject(Game* parent);
	//Destructor.
	- ~GameObject();
	+ virtual ~GameObject();

	//Method used to retrieve a certain box from the GameObject.
	//boxType: The type of box that is requested. (default=0)
	//Returns: An SDL_Rect.
	virtual SDL_Rect getBox(int boxType=0);

	//This method is used to place the location on a given location.
	//x: The x location to place the gameObject.
	//y: The y location to place the gameObject.
	virtual void setLocation(int x,int y);
	//This method is used to set the base of an object to a given location.
	//x: The x location to place the gameObject.
	//y: The y location to place the gameObject.
	virtual void setBaseLocation(int x,int y);

	//This method sets the size of the object to a given size.
	//w: The new width of the gameObject.
	//h: The new height the gameObject.
	virtual void setSize(int w,int h);
	//This method sets the size of the base of the object to a given size.
	//w: The new width of the gameObject.
	//h: The new height of the gameObject.
	virtual void setBaseSize(int w,int h);

	//Method used to draw the GameObject.
	- virtual void show()=0;
	+ virtual void show(SDL_Renderer& renderer)=0;
	//Save the state of the GameObject, used for moving blocks, etc.
	virtual void saveState();
	//Load the state of the GameObject, used for moving blocks, etc.
	virtual void loadState();
	//Reset the state of the GameObject, used for moving blocks, etc.
	//save: Boolean if the saved state should also be reset.
	virtual void reset(bool save);

	//Play an animation.
	virtual void playAnimation();
	//Invoke an event of the GameObject.
	//eventType: The event type.
	virtual void onEvent(int eventType);
	//Method used to request certain properties of the GameObject.
	//propertyType: The property that is requested.
	//obj: Pointer to the player.
	virtual int queryProperties(int propertyType,Player* obj);

	//Method used to retrieve the additional editor data for the GameObject.
	//Used for messages, moving positions, etc...
	//obj: Vector containing the editorData pairs. (key, value)
	virtual void getEditorData(std::vector<std::pair<std::string,std::string> >& obj);
	//Set the editorData.
	//obj: Map containing the key/value for the editor data.
	virtual void setEditorData(std::map<std::string,std::string>& obj);

	//Get a single property of the block.
	//property: The property to return.
	//Returns: The value for the requested property.
	virtual std::string getEditorProperty(std::string property);
	//Set a single property of the block.
	//property: The property to set.
	//value: The new value for the property.
	virtual void setEditorProperty(std::string property,std::string value);

	//Method for loading the GameObject from a node.
	//objNode: Pointer to the storage node to load from.
	//Returns: True if it succeeds without errors.
	- virtual bool loadFromNode(TreeStorageNode* objNode);
	+ virtual bool loadFromNode(ImageManager&, SDL_Renderer&, TreeStorageNode*);

	//Method that is called before the move method.
	//It can be used to reset variables like delta movement and velocity.
	virtual void prepareFrame();
	//Update method for GameObjects, used for moving blocks.
	virtual void move();
	};

	#endif
	diff --git a/src/GameState.h b/src/GameState.h
	index fae3acd..b3f9b6e 100644
	--- a/src/GameState.h
	+++ b/src/GameState.h
	@@ -1,43 +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;
	+class ImageManager;

	class GameState{
	public:
	//Destructor.
	- virtual ~GameState(){};
	+ 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()=0;
	+ 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()=0;
	+ virtual void logic(ImageManager& imageManager, SDL_Renderer& renderer)=0;

	//This method handles all the rendering.
	- virtual void render()=0;
	+ 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()=0;
	+ virtual void resize(ImageManager& imageManager, SDL_Renderer& renderer)=0;
	};

	#endif
	diff --git a/src/Globals.cpp b/src/Globals.cpp
	index 4974779..a935d37 100644
	--- a/src/Globals.cpp
	+++ b/src/Globals.cpp
	@@ -1,96 +1,92 @@
	/*
	* 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 "Globals.h"
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_mixer.h>
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_mixer.h>
	+#include <SDL2/SDL_ttf.h>
	#endif
	#include "libs/tinygettext/tinygettext.hpp"

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

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

	-//The timer used to keep a constant fps.
	-Timer timer;
	-
	//The language that in which the game should be translated.
	std::string language;
	//The DictionaryManager that is used to translate the game itself.
	tinygettext::DictionaryManager* dictionaryManager=NULL;

	-//Set both the screen and the tempSurface to NULL.
	-SDL_Surface* screen=NULL;
	-SDL_Surface* tempSurface=NULL;
	+//SDL Window and renderer
	+SDL_Window* sdlWindow=NULL;

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

	//Small arrows used for GUI widgets.
	//2 directions and 2 different/same colors depending on theme.
	-SDL_Surface* arrowLeft1=NULL;
	-SDL_Surface* arrowRight1=NULL;
	-SDL_Surface* arrowLeft2=NULL;
	-SDL_Surface* arrowRight2=NULL;
	+TexturePtr arrowLeft1=nullptr;
	+TexturePtr arrowRight1=nullptr;
	+TexturePtr arrowLeft2=nullptr;
	+TexturePtr arrowRight2=nullptr;

	//Set the current stateID and the nextState.
	int stateID=STATE_NULL;
	int nextState=STATE_NULL;
	GameState* currentState=NULL;

	LevelPack* levels=NULL;
	//The name of the current level.
	std::string levelName;

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

	//The SDL_Event object.
	SDL_Event event;

	//Themable colors
	SDL_Color themeTextColor={0,0,0};
	SDL_Color themeTextColorDialog={0,0,0};

	//The current cursor type.
	CursorType currentCursor=CURSOR_POINTER;
	//Array containing the SDL_Cursors.
	SDL_Cursor* cursors[CURSOR_MAX];
	diff --git a/src/Globals.h b/src/Globals.h
	index 5233b85..417f918 100644
	--- a/src/Globals.h
	+++ b/src/Globals.h
	@@ -1,264 +1,268 @@
	/*
	* 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 GLOBALS_H
	#define GLOBALS_H

	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_mixer.h>
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_mixer.h>
	+#include <SDL2/SDL_ttf.h>
	#endif
	#include <string>
	#include "libs/tinygettext/tinygettext.hpp"
	#include "Timer.h"
	#include "LevelPack.h"
	#include "GameState.h"
	+#include "Render.h"

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

	#define TITLE_FONT_RAISE 19
	#define GUI_FONT_RAISE 5

	//Global constants
	//The width of the screen.
	extern int SCREEN_WIDTH;
	//The height of the screen.
	extern int SCREEN_HEIGHT;
	//The depth of the screen.
	#if defined(ANDROID)
	//TODO: change other surface creating code to make the game runs faster
	const int SCREEN_BPP=16; //??? 24?? 32??
	-const int SCREEN_FLAGS=SDL_HWSURFACE;
	+//const int SCREEN_FLAGS=SDL_HWSURFACE;
	#else
	const int SCREEN_BPP=32;
	-const int SCREEN_FLAGS=SDL_HWSURFACE;
	+//const int SCREEN_FLAGS=SDL_HWSURFACE;
	#endif
	+const int SCREEN_FLAGS = 0;

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

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

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

	//The target frames per seconds.
	const int FPS=40;
	-//Timer used to maintain a constant number of fps.
	-extern Timer timer;

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

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

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

	//Small arrows used for GUI widgets.
	//2 directions and 2 different/same colors depending on theme.
	-extern SDL_Surface* arrowLeft1;
	-extern SDL_Surface* arrowRight1;
	-extern SDL_Surface* arrowLeft2;
	-extern SDL_Surface* arrowRight2;
	+extern TexturePtr arrowLeft1;
	+extern TexturePtr arrowRight1;
	+extern TexturePtr arrowLeft2;
	+extern TexturePtr arrowRight2;

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

	//GUI
	class GUIObject;
	extern GUIObject *GUIObjectRoot;

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

	//Pointer to the current levelpack.
	extern LevelPack* levels;
	//String containing the name of the current level.
	extern std::string levelName;

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

	//Themable colors
	extern SDL_Color themeTextColor;
	extern SDL_Color themeTextColorDialog;
	+const SDL_Color BLACK = SDL_Color{0,0,0,0};

	//Enumeration containing the different cursor types there are.
	enum CursorType{
	//The default pointer.
	CURSOR_POINTER,

	//The vertical ibeam, used to indicate text input.
	CURSOR_CARROT,

	//A closed hand, used for indicating a drag action.
	CURSOR_DRAG,

	//The different (window) size cursor icons.
	CURSOR_SIZE_HOR,
	CURSOR_SIZE_VER,
	CURSOR_SIZE_FDIAG,
	CURSOR_SIZE_BDIAG,

	//Remove cursor used in level editor
	CURSOR_REMOVE,

	//The number of cursor types there are.
	CURSOR_MAX
	};
	//Currently used cursor type.
	extern CursorType currentCursor;
	//Array containing the SDL_Cursors.
	extern SDL_Cursor* cursors[CURSOR_MAX];

	//Enumeration containing the ids of the game states.
	enum GameStates{
	//State null is a special state used to indicate no state.
	//This is used when no next state is defined.
	STATE_NULL,

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

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

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

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

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

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

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

	//Solid block which works like
	TYPE_CONVEYOR_BELT,
	TYPE_SHADOW_CONVEYOR_BELT,

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

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

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

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

	#endif
	diff --git a/src/ImageManager.cpp b/src/ImageManager.cpp
	index 17617ab..844033e 100644
	--- a/src/ImageManager.cpp
	+++ b/src/ImageManager.cpp
	@@ -1,77 +1,89 @@
	/*
	* 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 "ImageManager.h"
	#include <stdio.h>

	-SDL_Surface* ImageManager::loadImage(std::string file){
	- //Pointer to an SDL_Surface to which the image will be loaded.
	- SDL_Surface* load=NULL;
	- //This SDL_Surface is used to set the alpha correct.
	+SDL_Surface* ImageManager::loadImage(const std::string &file){
	SDL_Surface* opt=NULL;

	//First check if the image isn't already in the imageCollection.
	opt=imageCollection[file];
	if(opt!=NULL)
	return opt;

	//Now load the image to load.
	- load=IMG_Load(file.c_str());
	+ opt=IMG_Load(file.c_str());

	//Check if loading didn't fail.
	- if(load!=NULL){
	+ if(opt!=NULL){
	//Check if there's an alpha mask.
	- if(load->format->Amask){
	- //There is so let opt use it.
	- opt=SDL_DisplayFormatAlpha(load);
	- //We don't need load anymore so free it.
	- SDL_FreeSurface(load);
	- }else{
	+ if(!opt->format->Amask){
	//We use cyan for alpha, so set the alpha color key.
	- SDL_SetColorKey(load,SDL_SRCCOLORKEY,SDL_MapRGB(load->format,0,0xFF,0xFF));
	- //Let opt use the alpha.
	- opt=SDL_DisplayFormat(load);
	- //We don't need load anymore so free it.
	- SDL_FreeSurface(load);
	+ SDL_SetColorKey(opt,SDL_TRUE,SDL_MapRGB(opt->format,0,0xFF,0xFF));
	}
	}else{
	//We couldn't load the image.
	- fprintf(stderr,"ERROR: Can't open image file %s\n",file.c_str());
	+ fprintf(stderr,"ERROR: Can't open image file %s\n. Error:%s\n",file.c_str(),IMG_GetError());
	return NULL;
	}

	//Add a pointer to the imageCollection.
	imageCollection[file]=opt;
	//And return the SDL_Surface*.
	return opt;
	}

	+SharedTexture ImageManager::loadTexture(const std::string &file, SDL_Renderer& renderer) {
	+ //First check if the image isn't already in the textureCollection.
	+ SharedTexture opt=textureCollection[file];
	+ if(opt.get()) {
	+ return opt;
	+ }
	+
	+ //Now try to load the image into a texture.
	+ opt=SharedTexture(IMG_LoadTexture(&renderer, file.c_str()), SDL_DestroyTexture);
	+ if(opt.get()) {
	+ //Add a pointer to the textureCollection.
	+ textureCollection[file]=opt;
	+ return opt;
	+ } else {
	+ fprintf(stderr,"ERROR: Can't open image file %s\n. Error:%s\n",file.c_str(),IMG_GetError());
	+ return opt;
	+ }
	+}
	+
	ImageManager::~ImageManager(){
	//We call destroy().
	destroy();
	}

	void ImageManager::destroy(){
	- //Loop through the imageCollection and free them.
	- std::map<std::string,SDL_Surface*>::iterator i;
	- for(i=imageCollection.begin();i!=imageCollection.end();++i){
	- SDL_FreeSurface(i->second);
	- }
	- imageCollection.clear();
	+ {
	+ //Loop through the imageCollection and free them.
	+ std::map<std::string,SDL_Surface*>::iterator i;
	+ for(i=imageCollection.begin();i!=imageCollection.end();++i){
	+ SDL_FreeSurface(i->second);
	+ }
	+ imageCollection.clear();
	+ }
	+ {
	+ textureCollection.clear();
	+ }
	}
	diff --git a/src/ImageManager.h b/src/ImageManager.h
	index cb36c49..4b621a4 100644
	--- a/src/ImageManager.h
	+++ b/src/ImageManager.h
	@@ -1,53 +1,67 @@
	/*
	* 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 IMAGEMANAGER_H
	#define IMAGEMANAGER_H

	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#ifdef __APPLE__
	#include <SDL_image/SDL_image.h>
	#else
	-#include <SDL/SDL_image.h>
	+#include <SDL2/SDL_image.h>
	#endif
	#include <string>
	#include <map>
	+#include <memory>
	+
	+using SharedTexture = std::shared_ptr<SDL_Texture>;

	//Class for loading images.
	class ImageManager{
	public:
	//Constructor.
	- ImageManager(){}
	+ ImageManager(){}
	//Destructor.
	~ImageManager();

	//Loads an image.
	//file: The image file to load.
	//Returns: The SDL_Surface containing the image.
	- SDL_Surface* loadImage(std::string file);
	+ SDL_Surface* loadImage(const std::string& file);
	+ //Load an image directly to a texture. Returns NULL on failure.
	+ //This does not support color keyed textures.
	+ //SDL_Texture* loadTexture(const std::string& file, SDL_Renderer& renderer);
	+ //Load an image directly to a texture. Terminates on failure.
	+ //This does not support color keyed textures.
	+ SharedTexture loadTexture(const std::string& file, SDL_Renderer& renderer);

	//Destroys the images
	void destroy();
	private:
	+ //Forbid copying
	+ ImageManager(const ImageManager&) = delete;
	+ ImageManager& operator=(ImageManager const&) = delete;
	+
	//Map containing the images.
	//The key is the name of the image and the value is a pointer to the SDL_Surface.
	- std::map<std::string,SDL_Surface*> imageCollection;
	+ std::map<std::string, SDL_Surface*> imageCollection;
	+ std::map<std::string, SharedTexture> textureCollection;
	};

	#endif
	diff --git a/src/InputManager.cpp b/src/InputManager.cpp
	index 3317ace..0fc1d7a 100644
	--- a/src/InputManager.cpp
	+++ b/src/InputManager.cpp
	@@ -1,453 +1,465 @@
	/*
	* 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 "InputManager.h"
	#include "Globals.h"
	#include "Settings.h"
	#include "Functions.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "GUIOverlay.h"
	#include <stdlib.h>
	#include <stdio.h>
	#include <string>
	using namespace std;

	InputManager inputMgr;

	//the order must be the same as InputManagerKeys
	static const char* keySettingNames[INPUTMGR_MAX]={
	"key_up","key_down","key_left","key_right","key_jump","key_action","key_space","key_cancelRecording",
	"key_escape","key_restart","key_tab","key_save","key_load","key_swap",
	"key_teleport","key_suicide","key_shift","key_next","key_previous","key_select"
	};

	//the order must be the same as InputManagerKeys
	static const char* keySettingDescription[INPUTMGR_MAX]={
	__("Up (in menu)"),__("Down (in menu)"),__("Left"),__("Right"),__("Jump"),__("Action"),__("Space (Record)"),__("Cancel recording"),
	__("Escape"),__("Restart"),__("Tab (View shadow/Level prop.)"),__("Save game (in editor)"),__("Load game"),__("Swap (in editor)"),
	__("Teleport (in editor)"),__("Suicide (in editor)"),__("Shift (in editor)"),__("Next block type (in Editor)"),
	__("Previous block type (in editor)"), __("Select (in menu)")
	};

	//A class that handles the gui events of the inputDialog.
	class InputDialogHandler:public GUIEventCallback{
	private:
	//the list box which contains keys.
	GUIListBox* listBox;
	//the parent object.
	InputManager* parent;

	//update specified key config item
	- void updateConfigItem(int index){
	+ void updateConfigItem(SDL_Renderer& renderer,int index){
	//Get the description of the key.
	std::string s=_(keySettingDescription[index]);
	s+=": ";

	//Get the key code name.
	int keyCode=parent->getKeyCode((InputManagerKeys)index,false);
	s+=_(InputManager::getKeyCodeName(keyCode));
	-
	+
	//Add the alternative key if there is one.
	int keyCodeAlt=parent->getKeyCode((InputManagerKeys)index,true);
	if(keyCodeAlt!=0){
	s+=" ";
	s+=_("OR");
	s+=" ";
	s+=_(InputManager::getKeyCodeName(keyCodeAlt));
	}

	//Update item.
	- listBox->updateItem(index,s);
	+ listBox->updateItem(renderer, index,s);
	}
	public:
	//Constructor.
	- InputDialogHandler(GUIListBox* listBox,InputManager* parent):listBox(listBox),parent(parent){
	+ InputDialogHandler(SDL_Renderer& renderer,GUIListBox* listBox,InputManager* parent):listBox(listBox),parent(parent){
	//load the available keys to the list box.
	for(int i=0;i<INPUTMGR_MAX;i++){
	//Get the description of the key.
	std::string s=_(keySettingDescription[i]);
	s+=": ";

	//Get key code name.
	int keyCode=parent->getKeyCode((InputManagerKeys)i,false);
	s+=_(InputManager::getKeyCodeName(keyCode));

	//Add the alternative key if there is one.
	int keyCodeAlt=parent->getKeyCode((InputManagerKeys)i,true);
	if(keyCodeAlt!=0){
	s+=" ";
	s+=_("OR");
	s+=" ";
	s+=_(InputManager::getKeyCodeName(keyCodeAlt));
	}

	//Add item.
	- listBox->addItem(s);
	+ listBox->addItem(renderer, s);
	}
	}

	//When a key is pressed call this to set the key to currently-selected item.
	- void onKeyDown(int keyCode){
	+ void onKeyDown(SDL_Renderer& renderer,int keyCode){
	//Check if an item is selected.
	int index=listBox->value;
	if(index<0 \|\| index>=INPUTMGR_MAX) return;

	//Update the key.
	//SDLK_BACKSPACE will erase the key.
	if(keyCode==SDLK_BACKSPACE){
	parent->setKeyCode((InputManagerKeys)index,0,true);
	parent->setKeyCode((InputManagerKeys)index,0,false);
	- updateConfigItem(index);
	+ updateConfigItem(renderer,index);
	}else{
	//Update the main key if there isn't one. Otherwise update the alternative key if there isn't one.
	int key=parent->getKeyCode((InputManagerKeys)index,false);
	int altKey=parent->getKeyCode((InputManagerKeys)index,true);
	if(key==0){
	parent->setKeyCode((InputManagerKeys)index,keyCode,false);
	}else if((altKey==0)&&(keyCode!=key)){
	parent->setKeyCode((InputManagerKeys)index,keyCode,true);
	}
	- updateConfigItem(index);
	+ updateConfigItem(renderer,index);
	}
	}

	- void GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	+ void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Do nothing...
	}
	};

	//Event handler.
	static InputDialogHandler* handler;

	//A GUIObject that is used to create events for key presses.
	class GUIKeyListener:public GUIObject{
	+public:

	+ GUIKeyListener(ImageManager& imageManager, SDL_Renderer& renderer)
	+ :GUIObject(imageManager,renderer){}
	+private:
	//Leave empty.
	~GUIKeyListener(){}

	- bool handleEvents(int x,int y,bool enabled,bool visible,bool processed){
	+ bool handleEvents(SDL_Renderer& renderer,int x,int y,bool enabled,bool visible,bool processed){
	if(enabled && handler){
	if(event.type==SDL_KEYDOWN){
	- handler->onKeyDown(event.key.keysym.sym);
	+ handler->onKeyDown(renderer,event.key.keysym.sym);
	}
	//Joystick
	else if(event.type==SDL_JOYAXISMOTION){
	if(event.jaxis.value>3200){
	- handler->onKeyDown(0x00010001 \| (int(event.jaxis.axis)<<8));
	+ handler->onKeyDown(renderer,0x00010001 \| (int(event.jaxis.axis)<<8));
	}else if(event.jaxis.value<-3200){
	- handler->onKeyDown(0x000100FF \| (int(event.jaxis.axis)<<8));
	+ handler->onKeyDown(renderer,0x000100FF \| (int(event.jaxis.axis)<<8));
	}
	}
	else if(event.type==SDL_JOYBUTTONDOWN){
	- handler->onKeyDown(0x00020000 \| (int(event.jbutton.button)<<8));
	+ handler->onKeyDown(renderer,0x00020000 \| (int(event.jbutton.button)<<8));
	}
	else if(event.type==SDL_JOYHATMOTION){
	if(event.jhat.value & SDL_HAT_LEFT){
	- handler->onKeyDown(0x00030000 \| (int(event.jhat.hat)<<8) \| SDL_HAT_LEFT);
	+ handler->onKeyDown(renderer,0x00030000 \| (int(event.jhat.hat)<<8) \| SDL_HAT_LEFT);
	}else if(event.jhat.value & SDL_HAT_RIGHT){
	- handler->onKeyDown(0x00030000 \| (int(event.jhat.hat)<<8) \| SDL_HAT_RIGHT);
	+ handler->onKeyDown(renderer,0x00030000 \| (int(event.jhat.hat)<<8) \| SDL_HAT_RIGHT);
	}else if(event.jhat.value & SDL_HAT_UP){
	- handler->onKeyDown(0x00030000 \| (int(event.jhat.hat)<<8) \| SDL_HAT_UP);
	+ handler->onKeyDown(renderer,0x00030000 \| (int(event.jhat.hat)<<8) \| SDL_HAT_UP);
	}else if(event.jhat.value & SDL_HAT_DOWN){
	- handler->onKeyDown(0x00030000 \| (int(event.jhat.hat)<<8) \| SDL_HAT_DOWN);
	+ handler->onKeyDown(renderer,0x00030000 \| (int(event.jhat.hat)<<8) \| SDL_HAT_DOWN);
	}
	}
	}
	return false;
	}

	//Nothing to do.
	void render(){}
	};

	int InputManager::getKeyCode(InputManagerKeys key,bool isAlternativeKey){
	if(isAlternativeKey) return alternativeKeys[key];
	else return keys[key];
	}

	void InputManager::setKeyCode(InputManagerKeys key,int keyCode,bool isAlternativeKey){
	if(isAlternativeKey) alternativeKeys[key]=keyCode;
	else keys[key]=keyCode;
	}

	void InputManager::loadConfig(){
	for(int i=0;i<INPUTMGR_MAX;i++){
	string s=keySettingNames[i];

	keys[i]=atoi(getSettings()->getValue(s).c_str());

	s+="2";
	alternativeKeys[i]=atoi(getSettings()->getValue(s).c_str());

	//Move the alternative key to main key if the main key is empty.
	if(keys[i]==0&&alternativeKeys[i]!=0){
	keys[i]=alternativeKeys[i];
	alternativeKeys[i]=0;
	}

	//Remove duplicate.
	if(keys[i]==alternativeKeys[i])
	alternativeKeys[i]=0;
	}
	}

	void InputManager::saveConfig(){
	int i;
	char c[32];
	for(i=0;i<INPUTMGR_MAX;i++){
	string s=keySettingNames[i];

	//Remove duplicate.
	if(keys[i]==alternativeKeys[i])
	alternativeKeys[i]=0;

	sprintf(c,"%d",keys[i]);
	getSettings()->setValue(s,c);

	s+="2";
	sprintf(c,"%d",alternativeKeys[i]);
	getSettings()->setValue(s,c);
	}
	}

	-GUIObject* InputManager::showConfig(int height){
	+GUIObject* InputManager::showConfig(ImageManager& imageManager, SDL_Renderer& renderer,int height){
	//Create the new GUI.
	- GUIObject* root=new GUIObject(0,0,SCREEN_WIDTH,height);
	+ GUIObject* root=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,height);

	//Instruction label.
	- GUIObject* obj=new GUILabel(0,6,root->width,36,_("Select an item and press a key to change it."),0,true,true,GUIGravityCenter);
	+ GUIObject* obj=new GUILabel(imageManager,renderer,0,6,root->width,36,_("Select an item and press a key to change it."),0,true,true,GUIGravityCenter);
	root->addChild(obj);

	- obj=new GUILabel(0,30,root->width,36,_("Press backspace to clear the selected item."),0,true,true,GUIGravityCenter);
	+ obj=new GUILabel(imageManager,renderer,0,30,root->width,36,_("Press backspace to clear the selected item."),0,true,true,GUIGravityCenter);
	root->addChild(obj);

	//The listbox for keys.
	- GUIListBox listBox=new GUIListBox(SCREEN_WIDTH0.15,72,SCREEN_WIDTH*0.7,height-72-8);
	+ GUIListBox listBox=new GUIListBox(imageManager,renderer,SCREEN_WIDTH0.15,72,SCREEN_WIDTH*0.7,height-72-8);
	root->addChild(listBox);

	//Create the event handler.
	if(handler)
	delete handler;
	- handler=new InputDialogHandler(listBox,this);
	+ handler=new InputDialogHandler(renderer,listBox,this);

	- obj=new GUIKeyListener();
	+ obj=new GUIKeyListener(imageManager,renderer);
	root->addChild(obj);

	//Return final widget.
	return root;
	}

	//Get key name from key code.
	std::string InputManager::getKeyCodeName(int keyCode){
	char c[64];
	- if(keyCode>0 && keyCode <0x1000){
	+// if(keyCode>0 && keyCode <0x1000){
	//Keyboard.
	- char* s=SDL_GetKeyName((SDLKey)keyCode);
	+ const char* s=SDL_GetKeyName(static_cast<SDL_Keycode>(keyCode));
	if(s!=NULL){
	return s;
	}else{
	+ //TODO - don't use insecure sprintf
	sprintf(c,"(Key %d)",keyCode);
	return c;
	}
	- }else if(keyCode>0x1000){
	+ //TODO Key code numbers seems to have changed in SDL2
	+/* }else if(keyCode>0x1000){
	//Joystick. First set it to invalid value.
	sprintf(c,"(Joystick 0x%08X)",keyCode);
	//Check the input type.
	switch((keyCode & 0x00FF0000)>>16){
	case 1:
	//Axis.
	switch(keyCode & 0xFF){
	case 1:
	sprintf(c,"Joystick axis %d +",(keyCode & 0x0000FF00)>>8);
	break;
	case 0xFF:
	sprintf(c,"Joystick axis %d -",(keyCode & 0x0000FF00)>>8);
	break;
	}
	break;
	case 2:
	//Button.
	sprintf(c,"Joystick button %d",(keyCode & 0x0000FF00)>>8);
	break;
	case 3:
	//Hat.
	switch(keyCode & 0xFF){
	case SDL_HAT_LEFT:
	sprintf(c,"Joystick hat %d left",(keyCode & 0x0000FF00)>>8);
	break;
	case SDL_HAT_RIGHT:
	sprintf(c,"Joystick hat %d right",(keyCode & 0x0000FF00)>>8);
	break;
	case SDL_HAT_UP:
	sprintf(c,"Joystick hat %d up",(keyCode & 0x0000FF00)>>8);
	break;
	case SDL_HAT_DOWN:
	sprintf(c,"Joystick hat %d down",(keyCode & 0x0000FF00)>>8);
	break;
	}
	break;
	}
	return c;
	}else{
	//Disabled or unknown.
	return "-";
	- }
	+ }*/
	}

	InputManager::InputManager(){
	//Clear the arrays.
	for(int i=0;i<INPUTMGR_MAX;i++){
	keys[i]=alternativeKeys[i]=keyFlags[i]=0;
	}
	}

	InputManager::~InputManager(){
	closeAllJoysticks();
	}

	int InputManager::getKeyState(int keyCode,int oldState,bool hasEvent){
	int state=0;
	- if(keyCode>0 && keyCode<0x1000){
	+// if(keyCode>0 && keyCode<0x1000){
	//Keyboard.
	if(hasEvent){
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==keyCode){
	state\|=0x2;
	}
	if(event.type==SDL_KEYUP && event.key.keysym.sym==keyCode){
	state\|=0x4;
	}
	}
	- if(keyCode<SDLK_LAST && SDL_GetKeyState(NULL)[keyCode]){
	+ //Get keyboard state for key code
	+ //SDL_GetKeyboardState needs a scankey rather than keycode, so we convert
	+ int numKeys = 0;
	+ const Uint8* keyStates = SDL_GetKeyboardState(&numKeys);
	+ SDL_Scancode scanCode = SDL_GetScancodeFromKey(keyCode);
	+ if(scanCode<numKeys && keyStates[scanCode]){
	state\|=0x1;
	}
	- }else if(keyCode>0x1000){
	+ //TODO - key code numbers seems to have changed in SDL2, so disabling joystick for now
	+/* }else if(keyCode>0x1000){
	//Joystick.
	int index=(keyCode & 0x0000FF00)>>8;
	int value=keyCode & 0xFF;
	int i,v;
	switch((keyCode & 0x00FF0000)>>16){
	case 1:
	//Axis.
	if(hasEvent){
	if(event.type==SDL_JOYAXISMOTION && event.jaxis.axis==index){
	if((value==1 && event.jaxis.value>3200) \|\| (value==0xFF && event.jaxis.value<-3200)){
	if((oldState & 0x1)==0) state\|=0x2;
	}else{
	if(oldState & 0x1) state\|=0x4;
	}
	}
	}
	for(i=0;i<(int)joysticks.size();i++){
	v=SDL_JoystickGetAxis(joysticks[i],index);
	if((value==1 && v>3200) \|\| (value==0xFF && v<-3200)){
	state\|=0x1;
	break;
	}
	}
	break;
	case 2:
	//Button.
	if(hasEvent){
	if(event.type==SDL_JOYBUTTONDOWN && event.jbutton.button==index){
	state\|=0x2;
	}
	if(event.type==SDL_JOYBUTTONUP && event.jbutton.button==index){
	state\|=0x4;
	}
	}
	for(i=0;i<(int)joysticks.size();i++){
	v=SDL_JoystickGetButton(joysticks[i],index);
	if(v){
	state\|=0x1;
	break;
	}
	}
	break;
	case 3:
	//Hat.
	if(hasEvent){
	if(event.type==SDL_JOYHATMOTION && event.jhat.hat==index){
	if(event.jhat.value & value){
	if((oldState & 0x1)==0) state\|=0x2;
	}else{
	if(oldState & 0x1) state\|=0x4;
	}
	}
	}
	for(i=0;i<(int)joysticks.size();i++){
	v=SDL_JoystickGetHat(joysticks[i],index);
	if(v & value){
	state\|=0x1;
	break;
	}
	}
	break;
	}
	- }
	+ }*/
	return state;
	}

	//Update the key state, according to current SDL event, etc.
	void InputManager::updateState(bool hasEvent){
	for(int i=0;i<INPUTMGR_MAX;i++){
	keyFlags[i]=getKeyState(keys[i],keyFlags[i],hasEvent)\|getKeyState(alternativeKeys[i],keyFlags[i],hasEvent);
	}
	}

	//Check if there is KeyDown event.
	bool InputManager::isKeyDownEvent(InputManagerKeys key){
	return keyFlags[key]&0x2;
	}

	//Check if there is KeyUp event.
	bool InputManager::isKeyUpEvent(InputManagerKeys key){
	return keyFlags[key]&0x4;
	}

	//Check if specified key is down.
	bool InputManager::isKeyDown(InputManagerKeys key){
	return keyFlags[key]&0x1;
	}

	//Open all joysticks.
	void InputManager::openAllJoysitcks(){
	int i,m;
	//First close previous joysticks.
	closeAllJoysticks();

	//Open all joysticks.
	m=SDL_NumJoysticks();
	for(i=0;i<m;i++){
	SDL_Joystick *j=SDL_JoystickOpen(i);
	if(j==NULL){
	printf("ERROR: Couldn't open Joystick %d\n",i);
	}else{
	joysticks.push_back(j);
	}
	}
	}

	//Close all joysticks.
	void InputManager::closeAllJoysticks(){
	for(int i=0;i<(int)joysticks.size();i++){
	SDL_JoystickClose(joysticks[i]);
	}
	joysticks.clear();
	}
	diff --git a/src/InputManager.h b/src/InputManager.h
	index fa8cebb..3dca10f 100644
	--- a/src/InputManager.h
	+++ b/src/InputManager.h
	@@ -1,115 +1,115 @@
	/*
	* 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 INPUTMANAGER_H
	#define INPUTMANAGER_H

	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#include <vector>
	#include <string>

	#include "GUIObject.h"

	enum InputManagerKeys{
	INPUTMGR_UP,
	INPUTMGR_DOWN,
	INPUTMGR_LEFT,
	INPUTMGR_RIGHT,
	INPUTMGR_JUMP,
	INPUTMGR_ACTION,
	INPUTMGR_SPACE,
	INPUTMGR_CANCELRECORDING,
	INPUTMGR_ESCAPE,
	INPUTMGR_RESTART,
	INPUTMGR_TAB,
	INPUTMGR_SAVE,
	INPUTMGR_LOAD,
	INPUTMGR_SWAP,
	INPUTMGR_TELEPORT,
	INPUTMGR_SUICIDE,
	INPUTMGR_SHIFT,
	INPUTMGR_NEXT,
	INPUTMGR_PREVIOUS,
	INPUTMGR_SELECT,
	INPUTMGR_MAX
	};

	class InputManager{
	public:
	InputManager();
	~InputManager();

	//Get and set key code of each key.
	int getKeyCode(InputManagerKeys key,bool isAlternativeKey);
	void setKeyCode(InputManagerKeys key,int keyCode,bool isAlternativeKey);

	//Load and save key settings from config file.
	void loadConfig();
	void saveConfig();

	//Show the config screen.
	- GUIObject* showConfig(int height);
	+ GUIObject* showConfig(ImageManager& imageManager, SDL_Renderer& renderer, int height);

	//Get key name from key code
	static std::string getKeyCodeName(int keyCode);

	//Update the key state, according to current SDL event, etc.
	void updateState(bool hasEvent);

	//Check if there is KeyDown event.
	bool isKeyDownEvent(InputManagerKeys key);
	//Check if there is KeyUp event.
	bool isKeyUpEvent(InputManagerKeys key);
	//Check if specified key is down.
	bool isKeyDown(InputManagerKeys key);

	//Open all joysticks.
	void openAllJoysitcks();
	//Close all joysticks.
	void closeAllJoysticks();
	private:
	//The key code of each key.
	// - note of key code:
	// 0 means this key is disabled
	// 1 to 4095 (0xFFF) means keyboard keys,
	// currently SDLKey is less than 4095
	// >= 4096: bit field value means joystick.
	// 0xWWXXYYZZ
	// WW = joystick index. currently unused, should be 0.
	// XX = joystick button type: 1-axis 2-button 3-hat, currently ball is unsupported
	// YY = joystick button index. (we assume joystick has at most 256 buttons)
	// ZZ = value. if type=axis then value should be 1 or 0xFF.
	// if type=button then it's unused.
	// if type=hat then it's SDL_HAT_LEFT, SDL_HAT_RIGHT, SDL_HAT_UP or SDL_HAT_DOWN.
	int keys[INPUTMGR_MAX];
	int alternativeKeys[INPUTMGR_MAX];
	//The bit-field flag array saves the key states.
	// 0x1 means the key is down.
	// 0x2 means KeyDown event.
	// 0x4 means KeyUp event.
	int keyFlags[INPUTMGR_MAX];
	//Contains all joysticks.
	std::vector<SDL_Joystick*> joysticks;
	//Internal function.
	int getKeyState(int keyCode,int oldState,bool hasEvent);
	};

	extern InputManager inputMgr;

	#endif //INPUTMANAGER_H
	diff --git a/src/LevelEditSelect.cpp b/src/LevelEditSelect.cpp
	index ce72f48..049ec5a 100644
	--- a/src/LevelEditSelect.cpp
	+++ b/src/LevelEditSelect.cpp
	@@ -1,743 +1,744 @@
	/*
	* Copyright (C) 2012-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 "LevelEditSelect.h"
	#include "GameState.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "GUIScrollBar.h"
	#include "InputManager.h"
	#include "StatisticsManager.h"
	#include "Game.h"
	#include "GUIOverlay.h"
	#ifdef __APPLE__
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_ttf.h>
	#endif
	#include <algorithm>
	#include <string>
	#include <iostream>

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

	-LevelEditSelect::LevelEditSelect():LevelSelect(_("Map Editor"),LevelPackManager::CUSTOM_PACKS){
	+LevelEditSelect::LevelEditSelect(ImageManager& imageManager, SDL_Renderer& renderer):LevelSelect(imageManager,renderer,_("Map Editor"),LevelPackManager::CUSTOM_PACKS){
	//Create the gui.
	- createGUI(true);
	+ createGUI(imageManager,renderer, true);

	//Set the levelEditGUIObjectRoot.
	levelEditGUIObjectRoot=GUIObjectRoot;

	//show level list
	changePack();
	- refresh();
	+ refresh(imageManager, renderer);
	}

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

	-void LevelEditSelect::createGUI(bool initial){
	+void LevelEditSelect::createGUI(ImageManager& imageManager,SDL_Renderer &renderer, bool initial){
	if(initial){
	//The levelpack name text field.
	- levelpackName=new GUITextBox(280,104,240,32);
	+ levelpackName=new GUITextBox(imageManager,renderer,280,104,240,32);
	levelpackName->eventCallback=this;
	levelpackName->visible=false;
	GUIObjectRoot->addChild(levelpackName);
	}

	if(!initial){
	//Remove the previous buttons.
	//TODO: better way to do this?
	for(int i=0;i<(int)GUIObjectRoot->childControls.size();i++){
	if(GUIObjectRoot->childControls[i]->caption!=_("Back")){
	delete GUIObjectRoot->childControls[i];
	GUIObjectRoot->childControls.erase(GUIObjectRoot->childControls.begin()+i);
	i--;
	}
	}
	}

	//Create the six buttons at the bottom of the screen.
	- GUIButton* obj=new GUIButton(SCREEN_WIDTH*0.02,SCREEN_HEIGHT-120,-1,32,_("New Levelpack"));
	+ GUIButton* obj=new GUIButton(imageManager,renderer,SCREEN_WIDTH*0.02,SCREEN_HEIGHT-120,-1,32,_("New Levelpack"));
	obj->name="cmdNewLvlpack";
	obj->eventCallback=this;
	GUIObjectRoot->addChild(obj);

	- propertiesPack=new GUIButton(SCREEN_WIDTH*0.5,SCREEN_HEIGHT-120,-1,32,_("Pack Properties"),0,true,true,GUIGravityCenter);
	+ propertiesPack=new GUIButton(imageManager,renderer,SCREEN_WIDTH*0.5,SCREEN_HEIGHT-120,-1,32,_("Pack Properties"),0,true,true,GUIGravityCenter);
	propertiesPack->name="cmdLvlpackProp";
	propertiesPack->eventCallback=this;
	GUIObjectRoot->addChild(propertiesPack);

	- removePack=new GUIButton(SCREEN_WIDTH*0.98,SCREEN_HEIGHT-120,-1,32,_("Remove Pack"),0,true,true,GUIGravityRight);
	+ removePack=new GUIButton(imageManager,renderer,SCREEN_WIDTH*0.98,SCREEN_HEIGHT-120,-1,32,_("Remove Pack"),0,true,true,GUIGravityRight);
	removePack->name="cmdRmLvlpack";
	removePack->eventCallback=this;
	GUIObjectRoot->addChild(removePack);

	- move=new GUIButton(SCREEN_WIDTH*0.02,SCREEN_HEIGHT-60,-1,32,_("Move Map"));
	+ move=new GUIButton(imageManager,renderer,SCREEN_WIDTH*0.02,SCREEN_HEIGHT-60,-1,32,_("Move Map"));
	move->name="cmdMoveMap";
	move->eventCallback=this;
	//NOTE: Set enabled equal to the inverse of initial.
	//When resizing the window initial will be false and therefor the move button can stay enabled.
	move->enabled=false;
	GUIObjectRoot->addChild(move);

	- remove=new GUIButton(SCREEN_WIDTH*0.5,SCREEN_HEIGHT-60,-1,32,_("Remove Map"),0,false,true,GUIGravityCenter);
	+ remove=new GUIButton(imageManager,renderer,SCREEN_WIDTH*0.5,SCREEN_HEIGHT-60,-1,32,_("Remove Map"),0,false,true,GUIGravityCenter);
	remove->name="cmdRmMap";
	remove->eventCallback=this;
	GUIObjectRoot->addChild(remove);

	- edit=new GUIButton(SCREEN_WIDTH*0.98,SCREEN_HEIGHT-60,-1,32,_("Edit Map"),0,false,true,GUIGravityRight);
	+ edit=new GUIButton(imageManager,renderer,SCREEN_WIDTH*0.98,SCREEN_HEIGHT-60,-1,32,_("Edit Map"),0,false,true,GUIGravityRight);
	edit->name="cmdEdit";
	edit->eventCallback=this;
	GUIObjectRoot->addChild(edit);

	//Now update widgets and then check if they overlap
	- GUIObjectRoot->render(0,0,false);
	+ GUIObjectRoot->render(renderer,0,0,false);
	if(propertiesPack->left-propertiesPack->gravityX < obj->left+obj->width \|\|
	propertiesPack->left-propertiesPack->gravityX+propertiesPack->width > removePack->left-removePack->gravityX){
	obj->smallFont=true;
	obj->width=-1;

	propertiesPack->smallFont=true;
	propertiesPack->width=-1;

	removePack->smallFont=true;
	removePack->width=-1;

	move->smallFont=true;
	move->width=-1;

	remove->smallFont=true;
	remove->width=-1;

	edit->smallFont=true;
	edit->width=-1;
	}

	//Check again
	- GUIObjectRoot->render(0,0,false);
	+ GUIObjectRoot->render(renderer,0,0,false);
	if(propertiesPack->left-propertiesPack->gravityX < obj->left+obj->width \|\|
	propertiesPack->left-propertiesPack->gravityX+propertiesPack->width > removePack->left-removePack->gravityX){
	obj->left = SCREEN_WIDTH*0.02;
	obj->top = SCREEN_HEIGHT-140;
	obj->smallFont=false;
	obj->width=-1;
	obj->gravity = GUIGravityLeft;

	propertiesPack->left = SCREEN_WIDTH*0.02;
	propertiesPack->top = SCREEN_HEIGHT-100;
	propertiesPack->smallFont=false;
	propertiesPack->width=-1;
	propertiesPack->gravity = GUIGravityLeft;

	removePack->left = SCREEN_WIDTH*0.02;
	removePack->top = SCREEN_HEIGHT-60;
	removePack->smallFont=false;
	removePack->width=-1;
	removePack->gravity = GUIGravityLeft;

	move->left = SCREEN_WIDTH*0.98;
	move->top = SCREEN_HEIGHT-140;
	move->smallFont=false;
	move->width=-1;
	move->gravity = GUIGravityRight;

	remove->left = SCREEN_WIDTH*0.98;
	remove->top = SCREEN_HEIGHT-100;
	remove->smallFont=false;
	remove->width=-1;
	remove->gravity = GUIGravityRight;

	edit->left = SCREEN_WIDTH*0.98;
	edit->top = SCREEN_HEIGHT-60;
	edit->smallFont=false;
	edit->width=-1;
	edit->gravity = GUIGravityRight;
	}
	}

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

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

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

	-void LevelEditSelect::packProperties(bool newPack){
	+void LevelEditSelect::packProperties(ImageManager& imageManager,SDL_Renderer& renderer, bool newPack){
	//Open a message popup.
	- GUIObject* root=new GUIFrame((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-320)/2,600,320,_("Properties"));
	+ GUIObject* root=new GUIFrame(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-320)/2,600,320,_("Properties"));
	GUIObject* obj;

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

	- obj=new GUITextBox(60,80,480,36,packName.c_str());
	+ obj=new GUITextBox(imageManager,renderer,60,80,480,36,packName.c_str());
	if(newPack)
	obj->caption="";
	obj->name="LvlpackName";
	root->addChild(obj);

	- obj=new GUILabel(40,120,240,36,_("Description:"));
	+ obj=new GUILabel(imageManager,renderer,40,120,240,36,_("Description:"));
	root->addChild(obj);

	- obj=new GUITextBox(60,150,480,36,levels->levelpackDescription.c_str());
	+ obj=new GUITextBox(imageManager,renderer,60,150,480,36,levels->levelpackDescription.c_str());
	if(newPack)
	obj->caption="";
	obj->name="LvlpackDescription";
	root->addChild(obj);

	- obj=new GUILabel(40,190,240,36,_("Congratulation text:"));
	+ obj=new GUILabel(imageManager,renderer,40,190,240,36,_("Congratulation text:"));
	root->addChild(obj);

	- obj=new GUITextBox(60,220,480,36,levels->congratulationText.c_str());
	+ obj=new GUITextBox(imageManager,renderer,60,220,480,36,levels->congratulationText.c_str());
	if(newPack)
	obj->caption="";
	obj->name="LvlpackCongratulation";
	root->addChild(obj);

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

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

	if(newPack){
	packName.clear();
	}
	}

	-void LevelEditSelect::addLevel(){
	+void LevelEditSelect::addLevel(ImageManager& imageManager,SDL_Renderer& renderer){
	//Open a message popup.
	- GUIObject* root=new GUIFrame((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-200)/2,600,200,_("Add level"));
	+ GUIObject* root=new GUIFrame(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-200)/2,600,200,_("Add level"));
	GUIObject* obj;

	- obj=new GUILabel(40,80,240,36,_("File name:"));
	+ obj=new GUILabel(imageManager,renderer,40,80,240,36,_("File name:"));
	root->addChild(obj);

	char s[64];
	- sprintf(s,"map%02d.map",levels->getLevelCount()+1);
	- obj=new GUITextBox(300,80,240,36,s);
	+ snprintf(s,64,"map%02d.map",levels->getLevelCount()+1);
	+ obj=new GUITextBox(imageManager,renderer,300,80,240,36,s);
	obj->name="LvlFile";
	root->addChild(obj);

	- obj=new GUIButton(root->width*0.3,200-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	+ obj=new GUIButton(imageManager,renderer,root->width*0.3,200-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgAddOK";
	obj->eventCallback=this;
	root->addChild(obj);
	- obj=new GUIButton(root->width*0.7,200-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	+ obj=new GUIButton(imageManager,renderer,root->width*0.7,200-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgAddCancel";
	obj->eventCallback=this;
	root->addChild(obj);

	//Dim the screen using the tempSurface.\
	//NOTE: We don't need to store a pointer since it will auto cleanup itself.
	- new GUIOverlay(root);
	+ new GUIOverlay(renderer,root);
	}

	-void LevelEditSelect::moveLevel(){
	+void LevelEditSelect::moveLevel(ImageManager& imageManager,SDL_Renderer& renderer){
	//Open a message popup.
	- GUIObject* root=new GUIFrame((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-200)/2,600,200,_("Move level"));
	+ GUIObject* root=new GUIFrame(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-200)/2,600,200,_("Move level"));
	GUIObject* obj;

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

	- obj=new GUITextBox(300,60,240,36,"1");
	+ obj=new GUITextBox(imageManager,renderer,300,60,240,36,"1");
	obj->name="MoveLevel";
	root->addChild(obj);

	- obj=new GUISingleLineListBox(root->width*0.5,110,240,36,true,true,GUIGravityCenter);
	+ obj=new GUISingleLineListBox(imageManager,renderer,root->width*0.5,110,240,36,true,true,GUIGravityCenter);
	obj->name="lstPlacement";
	vector<string> v;
	v.push_back(_("Before"));
	v.push_back(_("After"));
	v.push_back(_("Swap"));
	(dynamic_cast<GUISingleLineListBox*>(obj))->addItems(v);
	obj->value=0;
	root->addChild(obj);

	- obj=new GUIButton(root->width*0.3,200-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	+ obj=new GUIButton(imageManager,renderer,root->width*0.3,200-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgMoveOK";
	obj->eventCallback=this;
	root->addChild(obj);
	- obj=new GUIButton(root->width*0.7,200-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	+ obj=new GUIButton(imageManager,renderer,root->width*0.7,200-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgMoveCancel";
	obj->eventCallback=this;
	root->addChild(obj);

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

	-void LevelEditSelect::refresh(bool change){
	+void LevelEditSelect::refresh(ImageManager& imageManager, SDL_Renderer& renderer, bool change){
	int m=levels->getLevelCount();

	if(change){
	numbers.clear();

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

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

	for(int n=0;n<=m;n++){
	- numbers.push_back(Number());
	+ numbers.emplace_back(imageManager, renderer);
	}
	}

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

	m++; //including the "+" button
	if(m>LEVELS_DISPLAYED_IN_SCREEN){
	levelScrollBar->maxValue=(m-LEVELS_DISPLAYED_IN_SCREEN+LEVELS_PER_ROW-1)/LEVELS_PER_ROW;
	levelScrollBar->visible=true;
	}else{
	levelScrollBar->maxValue=0;
	levelScrollBar->visible=false;
	}
	if(!levels->levelpackDescription.empty())
	levelpackDescription->caption=_CC(levels->getDictionaryManager(),levels->levelpackDescription);
	else
	levelpackDescription->caption="";
	}

	-void LevelEditSelect::selectNumber(unsigned int number,bool selected){
	+void LevelEditSelect::selectNumber(ImageManager& imageManager, SDL_Renderer& renderer, unsigned int number, bool selected){
	if(selected){
	levels->setCurrentLevel(number);
	setNextState(STATE_LEVEL_EDITOR);
	}else{
	if(number==numbers.size()-1){
	- addLevel();
	+ addLevel(imageManager,renderer);
	}else if(number<numbers.size()){
	selectedNumber=&numbers[number];

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

	-void LevelEditSelect::render(){
	+void LevelEditSelect::render(ImageManager& imageManager,SDL_Renderer &renderer){
	//Let the levelselect render.
	- LevelSelect::render();
	+ LevelSelect::render(imageManager,renderer);
	}

	-void LevelEditSelect::resize(){
	+void LevelEditSelect::resize(ImageManager& imageManager, SDL_Renderer &renderer){
	//Let the levelselect resize.
	- LevelSelect::resize();
	+ LevelSelect::resize(imageManager, renderer);

	//Create the GUI.
	- createGUI(false);
	+ createGUI(imageManager,renderer, false);

	//NOTE: This is a workaround for buttons failing when resizing.
	if(packName=="Custom Levels"){
	removePack->enabled=false;
	propertiesPack->enabled=false;
	}
	if(selectedNumber)
	- selectNumber(selectedNumber->getNumber(),false);
	+ selectNumber(imageManager, renderer, selectedNumber->getNumber(),false);

	}

	-void LevelEditSelect::renderTooltip(unsigned int number,int dy){
	- SDL_Color fg={0,0,0};
	- SDL_Surface* name;
	-
	- if(number==(unsigned)levels->getLevelCount()){
	- //Render the name of the level.
	- name=TTF_RenderUTF8_Blended(fontText,_("Add level"),fg);
	- }else{
	- //Render the name of the level.
	- name=TTF_RenderUTF8_Blended(fontText,_CC(levels->getDictionaryManager(),levels->getLevelName(number)),fg);
	- }
	+void LevelEditSelect::renderTooltip(SDL_Renderer& renderer,unsigned int number,int dy){
	+
	+ if (!toolTip.name \|\| toolTip.number != number) {
	+ SDL_Color fg={0,0,0,0};
	+ toolTip.number = number;
	+
	+ if(number==static_cast<size_t>(levels->getLevelCount())){
	+ //Add level button
	+ toolTip.name=textureFromText(renderer,*fontText,_("Add level"),fg);
	+ }else{
	+ //Render the name of the level.
	+ toolTip.name=textureFromText(renderer,*fontText,_CC(levels->getDictionaryManager(),levels->getLevelName(number)),fg);
	+ }
	+ }

	//Check if name isn't null.
	- if(name==NULL)
	+ if(!toolTip.name)
	return;

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

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

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

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

	//Now we render the name if the surface isn't null.
	- if(name!=NULL){
	+ if(toolTip.name){
	//Draw the name.
	- SDL_BlitSurface(name,NULL,screen,&r2);
	+ applyTexture(r2.x, r2.y, toolTip.name, renderer);
	}
	-
	- //And free the surfaces.
	- SDL_FreeSurface(name);
	}

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

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

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

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

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

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

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

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

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

	//And the levelpack list.
	vector<pair<string,string> >::iterator it1;
	for(it1=levelpacks->item.begin();it1!=levelpacks->item.end();++it1){
	if(it1!=levelpacks->item.end()){
	levelpacks->item.erase(it1);
	break;
	}
	}
	}else{
	//It's a new levelpack so we need to change the levels array.
	LevelPack* pack=new LevelPack;
	levels=pack;

	//Now create the dirs.
	if(!createDirectory((getUserPath(USER_DATA)+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption).c_str())){
	cerr<<"ERROR: Unable to create levelpack directory "<<(getUserPath(USER_DATA)+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption)<<endl;
	}
	if(!createFile((getUserPath(USER_DATA)+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption+"/levels.lst").c_str())){
	cerr<<"ERROR: Unable to create levelpack file "<<(getUserPath(USER_DATA)+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption+"/levels.lst")<<endl;
	}
	}
	//And set the new name.
	packName=GUIObjectRoot->childControls[i]->caption;
	levels->levelpackName=packName;
	levels->levelpackPath=(getUserPath(USER_DATA)+"custom/levelpacks/"+packName+"/");

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

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

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

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

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

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

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

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

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

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

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

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

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

	if(!createFile(path.c_str())){
	cerr<<"ERROR: Unable to create level file "<<path<<endl;
	}else{
	//Update statistics.
	statsMgr.newAchievement("create1");
	if((++statsMgr.createdLevels)>=50) statsMgr.newAchievement("create50");
	}
	levels->addLevel(path);
	//NOTE: Also add the level to the levels levelpack in case of custom levels.
	if(packName=="Custom Levels"){
	LevelPack* levelsPack=getLevelPackManager()->getLevelPack("Levels/");
	if(levelsPack){
	levelsPack->addLevel(path);
	levelsPack->setLocked(levelsPack->getLevelCount()-1);
	}else{
	cerr<<"ERROR: Unable to add level to Levels levelpack"<<endl;
	}
	}
	if(packName!="Custom Levels")
	levels->saveLevels(getUserPath(USER_DATA)+"custom/levelpacks/"+packName+"/levels.lst");
	- refresh();
	+ refresh(imageManager, renderer);

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

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

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

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

	- refresh();
	+ refresh(imageManager, renderer);

	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}else if(name=="cfgMoveCancel"){
	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	}
	diff --git a/src/LevelEditSelect.h b/src/LevelEditSelect.h
	index 8b112fc..920ceef 100644
	--- a/src/LevelEditSelect.h
	+++ b/src/LevelEditSelect.h
	@@ -1,102 +1,102 @@
	/*
	* 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 LEVELEDITSELECT_H
	#define LEVELEDITSELECT_H

	#include "LevelSelect.h"
	#include "GameState.h"
	#include "GameObjects.h"
	#include "Player.h"
	#include "GUIObject.h"
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_mixer.h>
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_mixer.h>
	+#include <SDL2/SDL_ttf.h>
	#endif
	#include <vector>
	#include <string>

	//This is the LevelEditSelect state, here you can select levelpacks and levels.
	class LevelEditSelect :public LevelSelect{
	private:
	//Pointer to the GUIObjectRoot of the levelselect main gui.
	GUIObject* levelEditGUIObjectRoot;

	//Pointer to the new levelpack textfield.
	GUIObject* levelpackName;

	//Pointer to the remove levelpack button.
	GUIButton* propertiesPack;
	//Pointer to the remove levelpack button.
	GUIButton* removePack;

	//Pointer to the move map button.
	GUIButton* move;
	//Pointer to the remove map button.
	GUIButton* remove;
	//Pointer to the edit map button.
	GUIButton* edit;

	//String that contains the name of the current levelpack.
	std::string packName;

	//Method that will create the GUI elements.
	//initial: Boolean if it is the first time the gui is created.
	- void createGUI(bool initial);
	+ void createGUI(ImageManager& imageManager, SDL_Renderer& renderer, bool initial);

	//Method that should be called when changing the current levelpack in an abnormal way.
	void changePack();

	//This method will show a popup with levelpack specific settings.
	//newPack: Boolean if it's a new levelpack.
	- void packProperties(bool newPack);
	+ void packProperties(ImageManager& imageManager, SDL_Renderer &renderer, bool newPack);

	//This method will show an add level dialog.
	- void addLevel();
	+ void addLevel(ImageManager& imageManager, SDL_Renderer &renderer);

	//This method will show an move level dialog.
	- void moveLevel();
	+ void moveLevel(ImageManager& imageManager, SDL_Renderer &renderer);
	public:
	//Constructor.
	- LevelEditSelect();
	+ LevelEditSelect(ImageManager &imageManager, SDL_Renderer& renderer);
	//Destructor.
	~LevelEditSelect();

	//Inherited from LevelSelect.
	//change: Boolean if the levelpack changed, if not we only have to rearrange the numbers.
	- void refresh(bool change=true);
	- void selectNumber(unsigned int number,bool selected);
	+ void refresh(ImageManager &imageManager, SDL_Renderer &renderer, bool change=true) override;
	+ void selectNumber(ImageManager &imageManager, SDL_Renderer &renderer, unsigned int number,bool selected) override;

	//Inherited from GameState.
	- void render();
	+ void render(ImageManager&imageManager, SDL_Renderer& renderer) override;

	//Inherited from GameState.
	- void resize();
	+ void resize(ImageManager &imageManager, SDL_Renderer& renderer) override;

	//Inherited from LevelSelect.
	- void renderTooltip(unsigned int number,int dy);
	+ void renderTooltip(SDL_Renderer& renderer,unsigned int number,int dy) override;

	//GUI events will be handled here.
	- void GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType);
	+ void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType) override;
	};

	#endif
	diff --git a/src/LevelEditor.cpp b/src/LevelEditor.cpp
	index 61bddf0..00c6aa9 100644
	--- a/src/LevelEditor.cpp
	+++ b/src/LevelEditor.cpp
	@@ -1,3525 +1,3519 @@
	/*
	* 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 "GameState.h"
	#include "Globals.h"
	#include "Functions.h"
	#include "FileManager.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 "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
	#include <windows.h>
	#include <shlobj.h>
	#else
	#include <strings.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include <dirent.h>
	#endif

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

	static int levelTime,levelRecordings;

	//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;
	}
	- SDL_Surface* createItem(const char* caption,int icon){
	+ 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};
	- SDL_Surface* tip=TTF_RenderUTF8_Blended(fontText,caption,fg);
	- SDL_SetAlpha(tip,0,0xFF);
	+ 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.
	- SDL_Surface* 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,&itemRect,0x00FFFFFF);
	- itemRect.y=3;
	- itemRect.h=16;
	- SDL_FillRect(item,&itemRect,0xFFFFFFFF);
	+ 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,item,NULL);
	+ 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,&r);
	+ applySurface(4,3,bmGUI,item.get(),&r);
	}

	- //Free the tip surface.
	- SDL_FreeSurface(tip);
	-
	//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 item;
	+ if(item->w+8>rect.w) {
	+ rect.w=item->w+8;
	+ }
	+
	+ return textureFromSurface(renderer, std::move(item));
	}
	- void updateItem(int index,const char* action,const char* caption,int icon=0){
	- SDL_Surface* item=createItem(caption,icon);
	- actions->updateItem(index,action,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(const char* action,const char* caption,int icon=0){
	- SDL_Surface* item=createItem(caption,icon);
	- actions->addItem(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(LevelEditor* parent, GameObject* target, int x=0, int y=0){
	+ 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=loadImage(getDataPath()+"gfx/gui.png");
	+ 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(0,0,0,0);
	+ actions=new GUIListBox(imageManager,renderer,0,0,0,0);
	actions->eventCallback=this;

	//Check if it's a block or not.
	if(target!=NULL)
	- addBlockItems();
	+ addBlockItems(renderer);
	else
	- addLevelItems();
	+ 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(){
	+ 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("Deselect",_("Deselect"));
	+ addItem(renderer,"Deselect",_("Deselect"));
	else
	- addItem("Select",_("Select"));
	- addItem("Delete",_("Delete"),8);
	+ 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("Link",_("Link"),8*3);
	- addItem("Remove Links",_("Remove Links"));
	+ 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("Automatic",_("Automatic"),(target->getEditorProperty("automatic")=="1")?2:1);
	+ 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("Behaviour",behaviour[currentBehaviour].c_str());
	+ addItem(renderer,"Behaviour",behaviour[currentBehaviour].c_str());
	}
	}else{
	- addItem("Path",_("Path"));
	- addItem("Remove Path",_("Remove Path"));
	+ addItem(renderer,"Path",_("Path"));
	+ addItem(renderer,"Remove Path",_("Remove Path"));

	//FIXME: We use hardcoded indeces, if the order changes we have a problem.
	- addItem("Activated",_("Activated"),(target->getEditorProperty("activated")=="1")?2:1);
	- addItem("Looping",_("Looping"),(target->getEditorProperty("loop")=="1")?2:1);
	+ 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("Activated",_("Activated"),(target->getEditorProperty("activated")=="1")?2:1);
	- addItem("Speed",_("Speed"));
	+ 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("State",states[currentState].c_str());
	+ addItem(renderer,"State",states[currentState].c_str());
	}
	//Check if it's a notification block.
	if(type==TYPE_NOTIFICATION_BLOCK)
	- addItem("Message",_("Message"));
	+ addItem(renderer,"Message",_("Message"));
	//Finally add scripting to the bottom.
	- addItem("Scripting",_("Scripting"),8*2+1);
	+ addItem(renderer,"Scripting",_("Scripting"),8*2+1);
	}

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

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

	- void render(){
	+ void render(SDL_Renderer& renderer){
	//Draw the actions.
	- actions->render(rect.x,rect.y);
	+ actions->render(renderer,rect.x,rect.y);

	//get mouse position
	- int x,y;
	+ /*int x,y;
	SDL_GetMouseState(&x,&y);
	- SDL_Rect mouse={x,y,0,0};
	+ SDL_Rect mouse={x,y,0,0};*/
	}
	- void handleEvents(){
	+ 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(rect.x,rect.y);
	+ actions->handleEvents(renderer,rect.x,rect.y);
	}
	- void GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	+ 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((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-250)/2,600,250,true,true,_("Notification block"));
	+ 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(40,50,240,36,_("Enter message here:"));
	+ obj=new GUILabel(imageManager,renderer,40,50,240,36,_("Enter message here:"));
	root->addChild(obj);
	- GUITextArea* textarea=new GUITextArea(50,90,500,100);
	+ 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(tmp);
	+ textarea->setString(renderer, tmp);
	root->addChild(textarea);

	- obj=new GUIButton(root->width*0.3,250-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	+ 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(root->width*0.7,250-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	+ 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(actions->value,"Enabled",_("Enabled"),enabled?2:1);
	+ 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(actions->value,"Looping",_("Looping"),loop?2:1);
	+ 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(actions->value,"Automatic",_("Automatic"),automatic?2:1);
	+ 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(actions->value,"Behaviour",behaviour[currentBehaviour].c_str());
	+ 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(actions->value,"State",states[currentState].c_str());
	+ updateItem(renderer,actions->value,"State",states[currentState].c_str());
	actions->value=-1;
	return;
	}else if(action=="Speed"){
	//Create the GUI.
	- GUIWindow* root=new GUIWindow((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-250)/2,600,250,true,true,_("Conveyor belt speed"));
	+ 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(40,100,240,36,_("Enter speed here:"));
	+ obj=new GUILabel(imageManager,renderer,40,100,240,36,_("Enter speed here:"));
	root->addChild(obj);
	- GUISpinBox* obj2=new GUISpinBox(240,100,320,36);
	+ 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(root->width*0.3,250-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	+ 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(root->width*0.7,250-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	+ 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((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-500)/2,600,500,true,true,_("Scripting"));
	+ 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(50,60,240,36,_("Id:"));
	+ obj=new GUILabel(imageManager,renderer,50,60,240,36,_("Id:"));
	root->addChild(obj);

	- obj=new GUITextBox(100,60,240,36,dynamic_cast<Block*>(target)->id.c_str());
	+ 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(50,100,500,36);
	+ 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(50,140,500,300);
	+ 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(it->second);
	+ text->setString(renderer, it->second);

	root->addChild(text);
	}


	- obj=new GUIButton(root->width*0.3,500-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	+ 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(root->width*0.7,500-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	+ 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();
	+ parent->levelSettings(imageManager,renderer);

	//And dismiss this popup.
	dismiss();
	return;
	}else if(action=="LevelScripting"){
	//Create the GUI.
	- GUIWindow* root=new GUIWindow((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-500)/2,600,500,true,true,_("Level Scripting"));
	+ 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(50,60,500,36);
	+ 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(50,100,500,340);
	+ 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(it->second);
	+ text->setString(renderer, it->second);

	root->addChild(text);
	}


	- obj=new GUIButton(root->width*0.3,500-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	+ 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(root->width*0.7,500-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	+ 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
	+ //The parent object.
	LevelEditor* parent;

	- //The position of window
	+ //The position of window.
	SDL_Rect rect;

	- //GUI image
	- SDL_Surface* bmGUI;
	+ //GUI image.
	+ SharedTexture bmGUI;

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

	- //The scrollbar
	+ //The scrollbar.
	GUIScrollBar* scrollBar;

	- //Highlighted object
	+ //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(){
	+ 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(0,0,16,rect.h-16,ScrollBarVertical,startRow,0,m,1,showedRow);
	+ 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(){
	+ 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();
	+ updateScrollBar(imageManager,renderer);
	}
	}
	void dismiss(){
	if(parent!=NULL && parent->selectionPopup==this){
	parent->selectionPopup=NULL;
	}
	delete this;
	}
	- LevelEditorSelectionPopup(LevelEditor* parent, std::vector<GameObject*>& selection, int x=0, int y=0){
	+ 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();
	+ updateScrollBar(imageManager,renderer);

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

	//background
	- drawGUIBox(rect.x,rect.y,rect.w,rect.h,screen,0xFFFFFFFFU);
	+ 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;
	+ //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];
	- SDL_FillRect(screen,&r,0xCCCCCC);
	+ //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);
	- }
	-
	- //draw name
	- SDL_Color fg={0,0,0};
	- SDL_Surface* txt=TTF_RenderUTF8_Blended(fontText,_(blockNames[type]),fg);
	- if(txt!=NULL){
	- SDL_Rect r2={r.x+64,r.y+(64-txt->h)/2,0,0};
	- SDL_BlitSurface(txt,NULL,screen,&r2);
	- SDL_FreeSurface(txt);
	+ //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,screen,0x999999FFU);
	+ drawGUIBox(r2.x,r2.y,r2.w,r2.h,renderer,0x999999FFU);
	tooltipRect=r2;
	- tooltip=_("Select");
	+ //tooltip=_("Select");
	highlightedBtn=1;
	+ toolTip=ToolTips::Select;
	}
	r2.x+=4;
	r2.y+=4;
	- SDL_BlitSurface(bmGUI,&r1,screen,&r2);
	+ 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,screen,0x999999FFU);
	+ drawGUIBox(r2.x,r2.y,r2.w,r2.h,renderer,0x999999FFU);
	tooltipRect=r2;
	- tooltip=_("Delete");
	+ //tooltip=_("Delete");
	highlightedBtn=2;
	+ toolTip=ToolTips::Delete;
	}
	r2.x+=4;
	r2.y+=4;
	- SDL_BlitSurface(bmGUI,&r1,screen,&r2);
	+ 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,screen,0x999999FFU);
	+ drawGUIBox(r2.x,r2.y,r2.w,r2.h,renderer,0x999999FFU);
	tooltipRect=r2;
	- tooltip=_("Configure");
	+ //tooltip=_("Configure");
	+ toolTip=ToolTips::Configure;
	highlightedBtn=3;
	}
	r2.x+=4;
	r2.y+=4;
	- SDL_BlitSurface(bmGUI,&r1,screen,&r2);
	+ r2.w=r1.w;
	+ r2.h=r1.h;
	+ SDL_RenderCopy(&renderer, bmGUI.get(),&r1,&r2);
	}
	}
	}

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

	//draw tooltip
	- if(!tooltip.empty()){
	- //The back and foreground colors.
	- SDL_Color fg={0,0,0};
	-
	+ if(parent && int(toolTip) < parent->tooltipTextures.size()){
	//Tool specific text.
	- SDL_Surface* tip=TTF_RenderUTF8_Blended(fontText,tooltip.c_str(),fg);
	+ //SDL_Surface* tip=TTF_RenderUTF8_Blended(fontText,tooltip.c_str(),fg);
	+ TexturePtr& tip=parent->tooltipTextures.at(size_t(toolTip));

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

	- if(tooltipRect.x+tip->w>SCREEN_WIDTH-20)
	- tooltipRect.x=SCREEN_WIDTH-20-tip->w;
	+ 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,tip->w+4,tip->h+4,screen,color);
	+ drawGUIBox(tooltipRect.x-2,tooltipRect.y-2,tipSize.w+4,tipSize.h+4,renderer,color);

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

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

	if(event.type==SDL_MOUSEBUTTONDOWN){
	- //check mousewheel
	- if(event.button.button==SDL_BUTTON_WHEELUP){
	- startRow-=2;
	- updateScrollBar();
	- return;
	- }else if(event.button.button==SDL_BUTTON_WHEELDOWN){
	- startRow+=2;
	- updateScrollBar();
	- return;
	- }else if(event.button.button==SDL_BUTTON_LEFT){
	+ 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(parent,highlightedObj,mouse.x,mouse.y);
	+ 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():Game(){
	+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(0,0,SCREEN_WIDTH,SCREEN_HEIGHT);
	+ GUIObjectRoot=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

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

	selectionPopup=NULL;
	actionsPopup=NULL;

	movingSpeedWidth=-1;

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

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

	//Load the gui images.
	- bmGUI=loadImage(getDataPath()+"gfx/gui.png");
	-
	- //Create the semi transparent surface.
	- placement=SDL_CreateRGBSurface(SDL_SWSURFACE\|SDL_SRCALPHA,SCREEN_WIDTH,SCREEN_HEIGHT,32,RMASK,GMASK,BMASK,0);
	- SDL_SetColorKey(placement,SDL_SRCCOLORKEY\|SDL_RLEACCEL,SDL_MapRGB(placement->format,255,0,255));
	- SDL_SetAlpha(placement,SDL_SRCALPHA,125);
	+ 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();

	- //Free the placement surface.
	- SDL_FreeSurface(placement);
	-
	//Delete the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

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

	//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(TreeStorageNode* obj, const std::string& fileName){
	+void LevelEditor::loadLevelFromNode(ImageManager& imageManager, SDL_Renderer& renderer,TreeStorageNode* obj, const std::string& fileName){
	//call the method of base class.
	- Game::loadLevelFromNode(obj,fileName);
	+ 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(){
	+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();
	+ 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(_("Are you sure you want to quit?"),MsgBoxYesNo,_("Quit prompt"))==MsgBoxYes){
	+ 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();
	+ 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();
	+ 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();
	+ 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(tfm::format(_("Level \"%s\" saved"),fileNameFromPath(levelFile)),MsgBoxOKOnly,_("Saved"));
	+ msgBox(imageManager,renderer,tfm::format(_("Level \"%s\" saved"),fileNameFromPath(levelFile)),MsgBoxOKOnly,_("Saved"));
	else
	- msgBox(tfm::format(_("Level \"%s\" saved"),levelName),MsgBoxOKOnly,_("Saved"));
	+ 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_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELUP) \|\| inputMgr.isKeyDownEvent(INPUTMGR_NEXT)){
	+ 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_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELDOWN) \|\| inputMgr.isKeyDownEvent(INPUTMGR_PREVIOUS)){
	+ 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){
	+ if(clickObjects.size()==999){
	//We have collision meaning that the mouse is above an object.
	std::vector<GameObject*>::iterator it;
	it=find(selection.begin(),selection.end(),clickObjects[0]);

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

	//Check if the clicked object is in the selection or not.
	bool isSelected=(it!=selection.end());
	if(event.button.button==SDL_BUTTON_LEFT){
	onClickObject(clickObjects[0],isSelected);
	}else if(event.button.button==SDL_BUTTON_RIGHT){
	- onRightClickObject(clickObjects[0],isSelected);
	+ onRightClickObject(imageManager,renderer,clickObjects[0],isSelected);
	}
	- }else if(clickObjects.size()>1){
	+ }else if(clickObjects.size()>=1){
	//There are more than one object under the mouse
	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,clickObjects,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(mouse.x,mouse.y);
	+ 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();
	+ 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(tfm::format(_("Level \"%s\" saved"),fileNameFromPath(levelFile)),MsgBoxOKOnly,_("Saved"));
	+ msgBox(imageManager,renderer,tfm::format(_("Level \"%s\" saved"),fileNameFromPath(levelFile)),MsgBoxOKOnly,_("Saved"));
	else
	- msgBox(tfm::format(_("Level \"%s\" saved"),levelName),MsgBoxOKOnly,_("Saved"));
	+ 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(){
	+void LevelEditor::levelSettings(ImageManager& imageManager,SDL_Renderer& renderer){
	//It isn't so open a popup asking for a name.
	- GUIWindow* root=new GUIWindow((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-300)/2,600,300,true,true,_("Level settings"));
	+ 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(40,50,240,36,_("Name:"));
	+ obj=new GUILabel(imageManager,renderer,40,50,240,36,_("Name:"));
	root->addChild(obj);
	- obj=new GUITextBox(140,50,410,36,levelName.c_str());
	+ obj=new GUITextBox(imageManager,renderer,140,50,410,36,levelName.c_str());
	obj->name="name";
	root->addChild(obj);

	- obj=new GUILabel(40,100,240,36,_("Theme:"));
	+ obj=new GUILabel(imageManager,renderer,40,100,240,36,_("Theme:"));
	root->addChild(obj);
	- obj=new GUITextBox(140,100,410,36,levelTheme.c_str());
	+ 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(40,150,240,36,_("Target time (s):"));
	+ obj=new GUILabel(imageManager,renderer,40,150,240,36,_("Target time (s):"));
	root->addChild(obj);
	- GUISpinBox* obj2=new GUISpinBox(290,150,260,36);
	+ 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(40,200,240,36,_("Target recordings:"));
	+ obj=new GUILabel(imageManager,renderer,40,200,240,36,_("Target recordings:"));
	root->addChild(obj);
	- obj2=new GUISpinBox(290,200,260,36);
	+ 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(root->width*0.3,300-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	+ 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(root->width*0.7,300-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	+ 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_GetAppState()&SDL_APPMOUSEFOCUS)){
	+ 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(GameObject* obj,bool selected){
	+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(this,obj,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(int x,int y){
	+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(this,NULL,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;
	//cout<<"x:"<<diffx<<",y:"<<diffy<<endl; //debug
	camera.x+=diffx;
	camera.y+=diffy;

	//Set the position of player and shadow
	//(although it's unnecessary if there is player and shadow start)
	player.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;

	//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(std::string name,GUIObject* obj,int eventType){
	+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(){
	+void LevelEditor::logic(ImageManager& imageManager, SDL_Renderer& renderer){
	if(playMode){
	//PlayMode so let the game do it's logic.
	- Game::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(){
	+void LevelEditor::render(ImageManager& imageManager,SDL_Renderer& renderer){
	//Always let the game render the game.
	- Game::render();
	+ 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,screen,0xFFFFFF33);
	+ drawGUIBox(r.x,r.y,r.w,r.h,renderer,0xFFFFFF33);

	//Draw the selectionMarks.
	- applySurface(r.x,r.y,selectionMark,screen,NULL);
	- applySurface(r.x+r.w-5,r.y,selectionMark,screen,NULL);
	- applySurface(r.x,r.y+r.h-5,selectionMark,screen,NULL);
	- applySurface(r.x+r.w-5,r.y+r.h-5,selectionMark,screen,NULL);
	+ 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);
	}
	-
	- //Clear the placement surface.
	- SDL_FillRect(placement,NULL,0x00FF00FF);

	- Uint32 color=SDL_MapRGB(placement->format,themeTextColor.r,themeTextColor.g,themeTextColor.b);
	+ //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;
	+ 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_FillRect(placement,&r,color);
	- }
	- if(camera.x>LEVEL_WIDTH-SCREEN_WIDTH){
	- //Draw right side.
	- r.x=LEVEL_WIDTH-camera.x;
	- r.y=0;
	- r.w=SCREEN_WIDTH-(LEVEL_WIDTH-camera.x);
	- r.h=SCREEN_HEIGHT;
	- SDL_FillRect(placement,&r,color);
	- }
	- if(camera.y<0){
	- //Draw the top.
	- r.x=0;
	- r.y=0;
	- r.w=SCREEN_WIDTH;
	- r.h=0-camera.y;
	- SDL_FillRect(placement,&r,color);
	- }
	+ 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=0;
	+ r.x=leftWidth;
	r.y=LEVEL_HEIGHT-camera.y;
	- r.w=SCREEN_WIDTH;
	+ r.w=SCREEN_WIDTH-rightWidth-leftWidth;
	r.h=SCREEN_HEIGHT-(LEVEL_HEIGHT-camera.y);
	- SDL_FillRect(placement,&r,color);
	- }
	+ SDL_RenderFillRect(&renderer, &r);
	+ }

	- //Check if we should draw on the placement surface.
	- showConfigure();
	+ //Check if we should draw on stuff.
	+ showConfigure(renderer);
	if(selectionDrag){
	- showSelectionDrag();
	+ showSelectionDrag(renderer);
	}else{
	if(tool==ADD){
	- showCurrentObject();
	+ 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,screen,0xFF000055);
	+ 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,screen,0xFFFFFF33);
	+ 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,screen);
	-
	- //Render the placement surface.
	- applySurface(0,0,placement,screen,NULL);
	+ drawRect(-camera.x,-camera.y,LEVEL_WIDTH,LEVEL_HEIGHT,renderer);

	//Render the hud layer.
	- renderHUD();
	+ 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();
	+ selectionPopup->render(imageManager,renderer);
	}
	}

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

	-void LevelEditor::renderHUD(){
	+void LevelEditor::renderHUD(SDL_Renderer& renderer){
	//If moving show the moving speed in the top right corner.
	if(moving){
	+ //TODO: Cache this!
	//Calculate width of text "Movespeed: 100" to keep the same position with every value
	if (movingSpeedWidth==-1){
	int w;
	TTF_SizeUTF8(fontText,tfm::format(_("Movespeed: %s"),100).c_str(),&w,NULL);
	movingSpeedWidth=w+4;
	}

	//Now render the text.
	- SDL_Color black={0,0,0,0};
	- SDL_Surface* bm=TTF_RenderUTF8_Blended(fontText,tfm::format(_("Movespeed: %s"),movingSpeed).c_str(),black);
	+ const SDL_Color black={0,0,0,0};
	+ TexturePtr bm=textureFromText(renderer,*fontText,tfm::format(_("Movespeed: %s"),movingSpeed).c_str(),black);

	- //Draw the text in box and free the surface.
	- drawGUIBox(SCREEN_WIDTH-movingSpeedWidth-2,-2,movingSpeedWidth+8,bm->h+6,screen,0xFFFFFFFF);
	- applySurface(SCREEN_WIDTH-movingSpeedWidth,2,bm,screen,NULL);
	- SDL_FreeSurface(bm);
	+ //Draw the text in the box.
	+ drawGUIBox(SCREEN_WIDTH-movingSpeedWidth-2,-2,movingSpeedWidth+8,textureHeight(*bm)+6,renderer,0xFFFFFFFF);
	+ applyTexture(SCREEN_WIDTH-movingSpeedWidth,2,bm,renderer,NULL);
	}

	//On top of all render the toolbar.
	- drawGUIBox(toolbarRect.x,toolbarRect.y,8*50+10,52,screen,0xEDEDEDFF);
	+ drawGUIBox(toolbarRect.x,toolbarRect.y,8*50+10,52,renderer,0xEDEDEDFF);
	//Draw the first four options.
	- SDL_Rect r={0,0,200,50};
	- applySurface(toolbarRect.x+5,toolbarRect.y,toolbar,screen,&r);
	+ 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.
	- r.x=200;
	- r.w=150;
	- applySurface(toolbarRect.x+255,toolbarRect.y,toolbar,screen,&r);
	-
	- //Now render a tooltip.
	- if(tooltip>=0){
	- //The back and foreground colors.
	- SDL_Color fg={0,0,0};
	+ srcRect.x=200;
	+ srcRect.w=150;
	+ dstRect.x=toolbarRect.x+255;
	+ dstRect.w=srcRect.w;
	+ SDL_RenderCopy(&renderer, toolbar.get(), &srcRect, &dstRect);

	- //Tool specific text.
	- SDL_Surface* tip=NULL;
	- switch(tooltip){
	- case 0:
	- tip=TTF_RenderUTF8_Blended(fontText,_("Select"),fg);
	- break;
	- case 1:
	- tip=TTF_RenderUTF8_Blended(fontText,_("Add"),fg);
	- break;
	- case 2:
	- tip=TTF_RenderUTF8_Blended(fontText,_("Delete"),fg);
	- break;
	- case 3:
	- tip=TTF_RenderUTF8_Blended(fontText,_("Play"),fg);
	- break;
	- case 5:
	- tip=TTF_RenderUTF8_Blended(fontText,_("Level settings"),fg);
	- break;
	- case 6:
	- tip=TTF_RenderUTF8_Blended(fontText,_("Save level"),fg);
	- break;
	- case 7:
	- tip=TTF_RenderUTF8_Blended(fontText,_("Back to menu"),fg);
	- break;
	- default:
	- break;
	- }
	-
	- //Draw only if there's a tooltip available
	- if(tip!=NULL){
	- SDL_Rect r={(SCREEN_WIDTH-390)/2+(tooltip40)+(tooltip10),SCREEN_HEIGHT-45,40,40};
	- r.y=SCREEN_HEIGHT-50-tip->h;
	- if(r.x+tip->w>SCREEN_WIDTH-50)
	- r.x=SCREEN_WIDTH-50-tip->w;
	-
	- //Draw borders around text
	- Uint32 color=0xFFFFFF00\|230;
	- drawGUIBox(r.x-2,r.y-2,tip->w+4,tip->h+4,screen,color);
	-
	- //Draw tooltip's text
	- SDL_BlitSurface(tip,NULL,screen,&r);
	- SDL_FreeSurface(tip);
	- }
	+ //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,screen,0xFFFFFF00\|230);
	+ drawGUIBox(-2,-2,SCREEN_WIDTH+4,66,renderer,0xFFFFFF00\|230);

	//Draw the hide icon.
	- SDL_Rect r={SCREEN_WIDTH-20,2,0,0};
	- SDL_Rect r2={80,0,16,16};
	+ SDL_Rect r={SCREEN_WIDTH-20,2,16,16};
	+ SDL_Rect r2={80,0,r.w,r.h};
	r.x=SCREEN_WIDTH-20;
	- SDL_BlitSurface(bmGUI,&r2,screen,&r);
	+ 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_BlitSurface(bmGUI,&r2,screen,&r);
	+ 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_BlitSurface(bmGUI,&r2,screen,&r);
	+ 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,screen,0xDDDDDDFF);
	+ drawGUIBox(i*64+24,3,64,58,renderer,0xDDDDDDFF);
	}

	ThemeBlock* obj=objThemes.getBlock(editorTileOrder[i+toolboxIndex]);
	if(obj){
	- obj->editorPicture.draw(screen,i*64+24+7,7);
	+ 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){
	- SDL_Color fg={0,0,0};
	- SDL_Surface* tip=TTF_RenderUTF8_Blended(fontText,_(blockNames[editorTileOrder[i+toolboxIndex]]),fg);
	+ 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+tip->w>SCREEN_WIDTH-50)
	- r.x=SCREEN_WIDTH-50-tip->w;
	+ 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,tip->w+4,tip->h+4,screen,color);
	+ drawGUIBox(r.x-2,r.y-2,tipSize.w+4,tipSize.h+4,renderer,color);

	- //Draw tooltip's text
	- SDL_BlitSurface(tip,NULL,screen,&r);
	- SDL_FreeSurface(tip);
	+ //Draw tooltip's text
	+ applyTexture(r.x, r.y, tip, renderer);
	}
	}
	}else{
	- SDL_Color fg={0,0,0};
	- SDL_Surface* tip=TTF_RenderUTF8_Blended(fontText,_("Toolbox"),fg);
	+ const SDL_Rect tbtSize = rectFromTexture(*toolboxText);

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

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

	- SDL_BlitSurface(tip,NULL,screen,&r);
	- SDL_FreeSurface(tip);
	+ //Draw "Toolbox" text.
	+ applyTexture(r.x, r.y, toolboxText, renderer);

	- SDL_Rect r2={96,0,16,16};
	+ const SDL_Rect r2={96,0,16,16};
	r.x=SCREEN_WIDTH-20;
	- SDL_BlitSurface(bmGUI,&r2,screen,&r);
	+ 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,screen,color);
	+ drawGUIBox((SCREEN_WIDTH-390)/2+(tool40)+(tool10),SCREEN_HEIGHT-46,42,42,renderer,color);
	}

	-void LevelEditor::showCurrentObject(){
	+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(placement,x-camera.x,y-camera.y);
	+ obj->editorPicture.draw(renderer,x-camera.x,y-camera.y);
	}
	}
	}

	-void LevelEditor::showSelectionDrag(){
	+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.
	- SDL_Rect r=dragCenter->getBox();
	+ 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){
	- SDL_Rect r1=selection[o]->getBox();
	- obj->editorPicture.draw(placement,(r1.x-r.x)+x-camera.x,(r1.y-r.y)+y-camera.y);
	+ 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(){
	+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,placement,color,32,arrowAnimation%32);
	+ 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.
	- applySurface(r.x-camera.x+25-2,r.y-camera.y+25-2,selectionMark,screen,NULL);
	- applySurface(r1.x-camera.x+25-2,r1.y-camera.y+25-2,selectionMark,screen,NULL);
	+ 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,placement,color,32,arrowAnimation%32);
	+ 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,placement,color,32,offset);
	+ 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,placement);
	+ drawLine(r.x,r.y,x,y,renderer);
	}
	}

	//And draw a marker at the end.
	- applySurface(x-13,y-13,movingMark,screen,NULL);
	+ 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,placement,color,32,offset);
	- applySurface(x+12,y+12,movingMark,screen,NULL);
	+ drawLineWithArrow(posX+25,posY+25,x+25,y+25,renderer,color,32,offset);
	+ applyTexture(x+12,y+12,movingMark,renderer);
	}

	}

	-void LevelEditor::resize(){
	+void LevelEditor::resize(ImageManager &imageManager, SDL_Renderer &renderer){
	//Call the resize method of the Game.
	- Game::resize();
	-
	- //Now update the placement surface.
	- if(placement)
	- SDL_FreeSurface(placement);
	- placement=SDL_CreateRGBSurface(SDL_SWSURFACE\|SDL_SRCALPHA,SCREEN_WIDTH,SCREEN_HEIGHT,32,RMASK,GMASK,BMASK,0);
	- SDL_SetColorKey(placement,SDL_SRCCOLORKEY\|SDL_RLEACCEL,SDL_MapRGB(placement->format,255,0,255));
	- SDL_SetAlpha(placement,SDL_SRCALPHA,125);
	+ 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/LevelEditor.h b/src/LevelEditor.h
	index 0715fb2..9e326ee 100644
	--- a/src/LevelEditor.h
	+++ b/src/LevelEditor.h
	@@ -1,307 +1,328 @@
	/*
	* 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 LEVELEDITOR_H
	#define LEVELEDITOR_H

	+#include "CachedTexture.h"
	#include "GameState.h"
	#include "GameObjects.h"
	#include "Player.h"
	#include "Game.h"
	#include "GUIObject.h"
	#include <vector>
	#include <map>
	#include <string>
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_mixer.h>
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_mixer.h>
	+#include <SDL2/SDL_ttf.h>
	#endif

	+enum class ToolTips {
	+ Select = 0,
	+ Add,
	+ Delete,
	+ Play,
	+ //This is at this position as there is a space
	+ //here on the toolbar.
	+ NoTooltip,
	+ LevelSettings,
	+ SaveLevel,
	+ BackToMenu,
	+ Configure,
	+ TooltipMax,
	+};
	+
	//Class that represents a moving position for moving blocks.
	class MovingPosition{
	public:
	//Integer containing the relative time used to store in the level.
	int time;
	//The x location.
	int x;
	//The x location.
	int y;

	//Constructor.
	//x: The x position relative to the moving block's position.
	//y: The y position relative to the moving block's position.
	//time: The time it takes from the previous position to here.
	MovingPosition(int x,int y,int time);
	//Destructor.
	~MovingPosition();

	//This will update the moving position.
	//x: The x position relative to the moving block's position.
	//y: The y position relative to the moving block's position.
	void updatePosition(int x,int y);
	};

	//Internal selection popup class.
	class LevelEditorSelectionPopup;

	//Internal actions popup class.
	class LevelEditorActionsPopup;

	//The LevelEditor state, it's based on the Game state.
	class LevelEditor: public Game{
	friend class LevelEditorSelectionPopup;
	friend class LevelEditorActionsPopup;
	private:
	//Boolean if the user isplaying/testing the level.
	bool playMode;

	//Enumaration containing the tools.
	//SELECT: The select tool, for selecting/dragging blocks.
	//ADD: For adding blocks.
	//REMOVE: For removing blocks.
	enum Tools{
	SELECT,
	ADD,
	REMOVE,
	-
	NUMBER_TOOLS
	};
	//The tool the user has selected.
	Tools tool;
	//The toolbar surface.
	- SDL_Surface* toolbar;
	+ SharedTexture toolbar;
	//Rectangle the size and location of the toolbar on screen.
	SDL_Rect toolbarRect;

	//The selection popup (if any)
	LevelEditorSelectionPopup* selectionPopup;
	//The actions popup (if any)
	LevelEditorActionsPopup* actionsPopup;

	//Map used to get the GameObject that belongs to a certain GUIWindow.
	map<GUIObject,GameObject> objectWindows;

	//Vector containing pointers to the selected GameObjects.
	vector<GameObject*> selection;
	//The selection square.
	- SDL_Surface* selectionMark;
	-
	- //Surface used for drawing transparent selection/dragging.
	- SDL_Surface* placement;
	+ SharedTexture selectionMark;

	//A circle at the location of moving positions in configure mode.
	- SDL_Surface* movingMark;
	+ SharedTexture movingMark;

	//GUI image.
	- SDL_Surface* bmGUI;
	+ SharedTexture bmGUI;
	+ //Texture containing the text "Toolbox"
	+ TexturePtr toolboxText;

	//The current type of block to place in Add mode.
	int currentType;

	+ std::array<TexturePtr,TYPE_MAX> typeTextTextures;
	+ std::array<TexturePtr,static_cast<size_t>(ToolTips::TooltipMax)> tooltipTextures;
	+
	//Boolean if the tool box is displayed.
	bool toolboxVisible;
	//The rect of tool box tip.
	SDL_Rect toolboxRect;
	//The first item in tool box.
	int toolboxIndex;

	//Boolean if the shift button is pressed.
	bool pressedShift;
	//Boolean if the left mouse button is pressed.
	bool pressedLeftMouse;
	//Boolean if the mouse is dragged. (Left button pressed and moved)
	bool dragging;

	//The camera x velocity.
	int cameraXvel;
	int cameraYvel;
	//SDL_Rect used to store the camera's location when entering playMode.
	SDL_Rect cameraSave;

	//Boolean if the selection is dragged.
	bool selectionDrag;
	//Pointer to the gameobject that's the center of the drag.
	GameObject* dragCenter;

	//Integer containing a unique id.
	//Everytime a new id is needed it will increase by one.
	unsigned int currentId;

	//Vector containing the trigger GameObjects.
	map<Block,vector<GameObject> > triggers;
	//Boolean used in configure mode when linking triggers with their targets.
	bool linking;
	//Pointer to the trigger that's is being linked.
	Block* linkingTrigger;

	//Vector containing the moving GameObjects.
	map<Block*,vector<MovingPosition> > movingBlocks;
	//Integer containing the speed the block is moving for newly added blocks.
	//The movingSpeed is capped at 100.
	int movingSpeed;
	//Boolean used in configure mode when configuring moving blocks.
	bool moving;
	//Pointer to the moving block that's is being configured.
	Block* movingBlock;

	//Value used for placing the Movespeed label
	int movingSpeedWidth;

	//The clipboard.
	vector<map<string,string> > clipboard;

	//String containing the levelTheme.
	std::string levelTheme;

	//Integer containing the button of which a tool tip should be shown.
	int tooltip;

	//GUI event handling is done here.
	- void GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType);
	+ void GUIEventCallback_OnEvent(ImageManager&, SDL_Renderer&, std::string name,GUIObject* obj,int eventType);

	//Method for deleting a GUIWindow.
	//NOTE: This function checks for the presence of the window in the GUIObjectRoot and objectWindows map.
	//window: Pointer to the GUIWindow.
	void destroyWindow(GUIObject* window);

	//Method that will let you configure the levelSettings.
	- void levelSettings();
	+ void levelSettings(ImageManager& imageManager,SDL_Renderer &renderer);

	//Method used to save the level.
	//fileName: Thge filename to write the level to.
	void saveLevel(string fileName);

	//Method used to convert a given x and y to snap to grid.
	//x: Pointer to the x location.
	//y: Pointer to the y location.
	void snapToGrid(int* x,int* y);

	//Method used to check if the cursor is near the border of screen and we should move the camera.
	//This method will check if the mouse is near a screen edge.
	//r: An array of SDL_Rect, does nothing if mouse inside these rectange(s).
	//count: Number of rectangles.
	//If so it will move the camera.
	void setCamera(const SDL_Rect* r,int count);

	public:
	//Array containing the ids of different block types in a wanted order
	//Maybe also useful to disable deprecated block types in the editor
	//PLEASE NOTE: Must be updated for new block types
	//Ordered for Edward Liis proposal:

	//Normal->Shadow->Spikes->Fragile
	//Normal moving->Shadow moving->Moving spikes
	//Conveyor belt->Shadow conveyor belt
	//Button->Switch->Portal->Swap->Checkpoint->Notification block
	//Player start->Shadow start->Exit
	//Collectable->Pushable

	static const int EDITOR_ORDER_MAX=20;
	static const int editorTileOrder[EDITOR_ORDER_MAX];

	protected:
	//Inherits the function loadLevelFromNode from Game class.
	- virtual void loadLevelFromNode(TreeStorageNode* obj, const std::string& fileName);
	+ virtual void loadLevelFromNode(ImageManager& imageManager, SDL_Renderer& renderer, TreeStorageNode* obj, const std::string& fileName) override;

	public:
	//Constructor.
	- LevelEditor();
	+ LevelEditor(SDL_Renderer &renderer, ImageManager &imageManager);
	//Destructor.
	- ~LevelEditor();
	+ ~LevelEditor();

	//Method that will reset some default values.
	void reset();

	//Inherited from Game(State).
	- void handleEvents();
	- void logic();
	- void render();
	- void resize();
	+ void handleEvents(ImageManager& imageManager, SDL_Renderer& renderer) override;
	+ void logic(ImageManager& imageManager, SDL_Renderer& renderer) override;
	+ void render(ImageManager& imageManager, SDL_Renderer& renderer) override;
	+ void resize(ImageManager& imageManager, SDL_Renderer& renderer) override;

	//Method used to draw the currentType on the placement surface.
	//This will only be called when the tool is ADD.
	- void showCurrentObject();
	+ void showCurrentObject(SDL_Renderer &renderer);
	//Method used to draw the selection that's being dragged.
	- void showSelectionDrag();
	+ void showSelectionDrag(SDL_Renderer &renderer);
	//Method used to draw configure tool specific things like moving positions, teleport lines.
	- void showConfigure();
	+ void showConfigure(SDL_Renderer &renderer);

	//Method that will render the HUD.
	//It will be rendered after the placement suface but before the toolbar.
	- void renderHUD();
	+ void renderHUD(SDL_Renderer &renderer);

	//Method called after loading a level.
	//It will fill the triggers vector.
	void postLoad();

	//Event that is invoked when there's a mouse click on an object.
	//obj: Pointer to the GameObject clicked on.
	//selected: Boolean if the GameObject that has been clicked on was selected.
	void onClickObject(GameObject* obj,bool selected);
	//Event that is invoked when there's a right mouse button click on an object.
	//obj: Pointer to the GameObject clicked on.
	//selected: Boolean if the GameObject that has been clicked on was selected.
	- void onRightClickObject(GameObject* obj,bool selected);
	+ void onRightClickObject(ImageManager& imageManager, SDL_Renderer& renderer, GameObject* obj, bool);
	//Event that is invoked when there's a mouse click but not on any object.
	//x: The x location of the click on the game field (+= camera.x).
	//y: The y location of the click on the game field (+= camera.y).
	void onClickVoid(int x,int y);
	//Event that is invoked when there's a mouse right click but not on any object.
	//x: The x location of the click on the game field (+= camera.x).
	//y: The y location of the click on the game field (+= camera.y).
	- void onRightClickVoid(int x,int y);
	+ void onRightClickVoid(ImageManager& imageManager, SDL_Renderer& renderer, int x,int y);
	//Event that is invoked when the dragging starts.
	//x: The x location the drag started. (mouse.x+camera.x)
	//y: The y location the drag started. (mouse.y+camera.y)
	void onDragStart(int x,int y);
	//Event that is invoked when the mouse is dragged.
	//dx: The relative x distance the mouse dragged.
	//dy: The relative y distance the mouse dragged.
	void onDrag(int dx,int dy);
	//Event that is invoked when the mouse stopped dragging.
	//x: The x location the drag stopped. (mouse.x+camera.x)
	//y: The y location the drag stopped. (mouse.y+camera.y)
	void onDrop(int x,int y);
	//Event that is invoked when the camera is moved.
	//dx: The relative x distance the camera moved.
	//dy: The relative y distance the camera moved.
	void onCameraMove(int dx,int dy);
	//Event that is invoked when enter is pressed above an object.
	//obj: Pointer to the GameObject entered above.
	void onEnterObject(GameObject* obj);

	//Method used to add a GameObject to the level.
	//obj: Pointer to the gameobject to add.
	void addObject(GameObject* obj);
	//Method used to move a GameObject from the level.
	//obj: Pointer to the gameobject to move.
	//x: The new x location of the GameObject.
	//y: The new y location of the GameObject.
	void moveObject(GameObject* obj,int x,int y);
	//Method used to remove a GameObject from the level.
	//obj: Pointer to the gameobject to remove.
	void removeObject(GameObject* obj);

	//Call this function to start test play.
	void enterPlayMode();
	+
	+ inline SharedTexture& getGuiTexture() {
	+ return bmGUI;
	+ }
	};
	#endif
	diff --git a/src/LevelInfoRender.cpp b/src/LevelInfoRender.cpp
	new file mode 100644
	index 0000000..9c762b7
	--- /dev/null
	+++ b/src/LevelInfoRender.cpp
	@@ -0,0 +1,70 @@
	+#include "Functions.h"
	+
	+#include "LevelInfoRender.h"
	+
	+LevelInfoRender::LevelInfoRender(ImageManager &imageManager, SDL_Renderer &renderer, const std::string& dataPath, TTF_Font &font, SDL_Color textColor)
	+{
	+ playButton=imageManager.loadTexture(dataPath+"gfx/playbutton.png",renderer);
	+ timeIcon=imageManager.loadTexture(dataPath+"gfx/time.png",renderer);
	+ recordingsIcon=imageManager.loadTexture(dataPath+"gfx/recordings.png",renderer);
	+ //Skip doing this here as it will be called LevelPlaySelect::refresh which is called by it's constructor anyhow.
	+ //resetText(renderer, font, textColor);
	+}
	+
	+void LevelInfoRender::resetText(SDL_Renderer &renderer, TTF_Font &font, SDL_Color textColor) {
	+ auto tex = [&](const char* text){
	+ return textureFromText(renderer,font,text,textColor);
	+ };
	+
	+ levelDescription=tex(_("Choose a level"));
	+ timeText=tex(_("Time:"));
	+ recordingsText=tex(_("Recordings:"));
	+ levelTime=tex("- / -");
	+ levelRecs=tex("- / -");
	+}
	+
	+void LevelInfoRender::update(SDL_Renderer &renderer, TTF_Font &font, SDL_Color textColor,
	+ const std::string &description, const std::string& time, const std::string& recordings) {
	+ auto tex = [&](const std::string& text){
	+ return textureFromText(renderer,font,text.c_str(),textColor);
	+ };
	+ if(description.empty()) {
	+ levelDescription=nullptr;
	+ } else {
	+ levelDescription=tex(description);
	+ }
	+ levelTime=tex(time);
	+ levelRecs=tex(recordings);
	+}
	+
	+void LevelInfoRender::render(SDL_Renderer &renderer) {
	+
	+ //Avoid crashing if this is somehow not initialized.
	+ if(!timeText) {
	+ return;
	+ }
	+ int w=0,h=0;
	+ SDL_GetRendererOutputSize(&renderer,&w,&h);
	+ if(levelDescription) {
	+ applyTexture(100,h-130+(50-textureHeight(*levelDescription))/2,levelDescription, renderer);
	+ }
	+
	+ //Draw time the icon.
	+ applyTexture(w-405,h-130+3,timeIcon,renderer);
	+
	+ //Now draw the text (title).
	+ applyTexture(w-380,h-130+3,timeText,renderer);
	+
	+ //Now draw the second text (value).
	+ applyTexture(w-textureWidth(*levelTime)-80,h-130+3,levelTime,renderer);
	+
	+ //Draw the icon.
	+ applyTexture(w-405,h-98+(6)/2,recordingsIcon,renderer);
	+
	+ //Now draw the text (title).
	+ applyTexture(w-380,h-98+(32-textureHeight(*recordingsText))/2,
	+ recordingsText,renderer);
	+ //Now draw the second text (value).
	+ applyTexture(w-textureWidth(levelRecs)-80,h-98+(30-textureHeight(levelRecs))/2,levelRecs,renderer);
	+ //applySurface(SCREEN_WIDTH-bm->w-80,SCREEN_HEIGHT-98+(32-bm->h)/2,bm,screen,NULL);
	+}
	diff --git a/src/LevelInfoRender.h b/src/LevelInfoRender.h
	new file mode 100644
	index 0000000..78bcd29
	--- /dev/null
	+++ b/src/LevelInfoRender.h
	@@ -0,0 +1,33 @@
	+#ifndef LEVELINFORENDER_H
	+#define LEVELINFORENDER_H
	+
	+#include "Render.h"
	+class LevelPlaySelect;
	+
	+class LevelInfoRender
	+{
	+ friend class LevelPlaySelect;
	+private:
	+ //Icons
	+ SharedTexture playButton;
	+ SharedTexture timeIcon;
	+ SharedTexture recordingsIcon;
	+ //Texture displaying the level description.
	+ TexturePtr levelDescription;
	+ //Texture displaying "Time" (or other language equivalent).
	+ TexturePtr timeText;
	+ //Texture displaying "Recordings" (or other language equivalent).
	+ TexturePtr recordingsText;
	+ //Texture displaying the actual level time.
	+ TexturePtr levelTime;
	+ TexturePtr levelRecs;
	+public:
	+ LevelInfoRender(ImageManager& imageManager, SDL_Renderer& renderer,
	+ const std::string &dataPath, TTF_Font& font, SDL_Color textColor);
	+ void resetText(SDL_Renderer& renderer, TTF_Font& font, SDL_Color textColor);
	+ void update(SDL_Renderer& renderer,TTF_Font& font, SDL_Color textColor,
	+ const std::string& description, const std::string& time, const std::string& recordings);
	+ void render(SDL_Renderer& renderer);
	+};
	+
	+#endif // LEVELINFORENDER_H
	diff --git a/src/LevelPack.h b/src/LevelPack.h
	index f126932..5e9e060 100644
	--- a/src/LevelPack.h
	+++ b/src/LevelPack.h
	@@ -1,213 +1,213 @@
	/*
	* 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 LEVELPACK_H
	#define LEVELPACK_H

	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_mixer.h>
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_mixer.h>
	+#include <SDL2/SDL_ttf.h>
	#endif
	#include <vector>
	#include <string>

	#include "libs/tinygettext/tinygettext.hpp"

	enum LevelPackType{
	//Main levelpacks are distibuted along with the game and located in the data path.
	MAIN,
	//Addon levelpacks are downloaded/added packs which reside in the user data path.
	ADDON,
	//Custom levelpacks are user made and are located in the
	CUSTOM,

	//Collection levelpacks can contain levels from different locations.
	//This type is used for the Levels and Custom Levels levelpacks.
	//NOTE: The levelpackPath is ignored for these type of levelpacks since levels can be anywhere.
	COLLECTION
	};

	class LevelPack{
	public:
	//A level entry structure.
	struct Level{
	//The name of the level.
	std::string name;
	//The filename of the level.
	std::string file;

	//Boolean if the level is locked.
	bool locked;
	//Boolean if the level is won.
	bool won;

	//Integer containing the number of ticks (40 = 1s) it took to finish the level.
	//If there's no time the value will be -1.
	int time;
	//Integer containing the target time to get a medal.
	int targetTime;

	//Integer containing the number of recordings used to finish the level.
	//When not won the value is -1.
	int recordings;
	//Integer containing the target recordings to get a medal.
	int targetRecordings;

	//MD5 of level node. :/
	unsigned char md5Digest[16];
	};
	private:
	//Index of the current level.
	int currentLevel;

	//Boolean if the levels are loaded.
	bool loaded;

	//Vector containing the filenames of the levels.
	std::vector<Level> levels;

	//The file name of the level progress.
	std::string levelProgressFile;

	public:
	//The name of the levelpack.
	std::string levelpackName;
	//The location the levelpack is stored.
	std::string levelpackPath;
	//A description of the levelpack.
	std::string levelpackDescription;

	//The type of levelpack.
	LevelPackType type;

	//The text that will be displayed when the levels are finished.
	std::string congratulationText;

	//The preferred music list to be used with this levelpack.
	std::string levelpackMusicList;

	//The dictionaryManager of the levelpack, used to translate strings.
	tinygettext::DictionaryManager* dictionaryManager;

	//Boolean if the levelpack has a custom theme/partial theme bundled with it.
	//NOTE: Themes can't be preloaded since they would be destroyed by the ThemeStack.
	bool customTheme;

	//Constructor.
	LevelPack();
	//Destructor.
	~LevelPack();

	//gettext function
	inline tinygettext::DictionaryManager* getDictionaryManager() const{
	return dictionaryManager;
	}

	//Method for updating the language to the configured one.
	//NOTE: This is called when changing the translation in the Options menu.
	void updateLanguage();

	//Adds a level to the levels.
	//levelFileName: The filename of the level to add.
	//level: The index of the level to add.
	void addLevel(const std::string& levelFileName,int levelno=-1);
	//Removes a level from the levels.
	//level: The index of the level to remove.
	void removeLevel(unsigned int level);
	//Moves the level to a given index.
	//level1: The level to move.
	//level2: The destination.
	void moveLevel(unsigned int level1,unsigned int level2);
	//Swaps two level.
	//level1: The first level to swap.
	//level2: The second level to swap.
	void swapLevel(unsigned int level1,unsigned int level2);

	//Get the levelFile for a given level.
	//level: The level index to get the levelFile from.
	//Returns: String containing the levelFileName (full path to the file).
	const std::string getLevelFile(int level=-1);
	//Get the levelpackPath of the levels.
	//Returns: String containing the levelpackPath.
	const std::string& getLevelpackPath();
	//Get the levelName for a given level.
	//level: The level index to get the levelName from.
	//Returns: String containing the levelName.
	const std::string& getLevelName(int level=-1);
	//Sets the levelName for a given level.
	//level: The level index to get the levelName from.
	//name: The new name of the level.
	void setLevelName(unsigned int level,const std::string& name);
	//Get the MD5 for a given level.
	//level: The level index.
	//Returns: const unsigned char[16] containing the digest.
	const unsigned char* getLevelMD5(int level=-1);

	//get level's auto-save record path,
	//using level's MD5, file name and other information.
	void getLevelAutoSaveRecordPath(int level,std::string &bestTimeFilePath,std::string &bestRecordingFilePath,bool createPath);

	//Method for getting the path to the progress file.
	//Returns: The path + filename to the progress file.
	std::string getLevelProgressPath();

	//Set the currentLevel.
	//level: The new current level.
	void setCurrentLevel(unsigned int level);
	//Get the currentLevel.
	//Returns: The currentLevel.
	inline int getCurrentLevel(){return currentLevel;}
	//Get the levelCount.
	//Returns: The level count.
	inline int getLevelCount(){return levels.size();}

	//Method that will return the requested level.
	//level: The index of the level, default is the current level.
	//Returns: Pointer to the requested level structure.
	struct Level* getLevel(int level=-1);

	//Method that will reset any progress/statistics for a given level.
	//level: The index of the level to reset, default is currentLevel.
	void resetLevel(int level=-1);

	//Check if a certain level is locked.
	//level: The index of the level to check.
	//Returns: True if the level is locked.
	bool getLocked(unsigned int level);
	//Set a level locked or not.
	//level: The level to (un)lock.
	//locked: The new status of the level, default is unlocked (false).
	void setLocked(unsigned int level,bool locked=false);

	//Empties the levels.
	void clear();


	bool loadLevels(const std::string& levelListFile);
	void loadProgress();
	void saveLevels(const std::string& levelListFile);
	void saveLevelProgress();

	void nextLevel();

	};
	#endif
	diff --git a/src/LevelPackManager.h b/src/LevelPackManager.h
	index f6bdb18..b32d5ce 100644
	--- a/src/LevelPackManager.h
	+++ b/src/LevelPackManager.h
	@@ -1,93 +1,93 @@
	/*
	* 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 LEVELPACKMANAGER_H
	#define LEVELPACKMANAGER_H

	#include "LevelPack.h"
	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#ifdef __APPLE__
	#include <SDL_image/SDL_image.h>
	#else
	-#include <SDL/SDL_image.h>
	+#include <SDL2/SDL_image.h>
	#endif
	#include <string>
	#include <map>
	#include <vector>

	//Class for loading and managing levelpacks.
	class LevelPackManager{
	public:
	//Constructor.
	LevelPackManager(){}
	//Destructor.
	~LevelPackManager();

	//Load a levelpack and add it to the map.
	//path: The path of the levelpack files.
	void loadLevelPack(std::string path);

	//Insert a levelpack in the LevelPackManager.
	//levelpack: Pointer to the levelpack to add.
	void addLevelPack(LevelPack* levelpack);

	//Removes a levelpack from the LevelPackManager.
	//path: The path to the levelpack to remove.
	void removeLevelPack(std::string path);

	//Method that will return a levelpack.
	//path: The path to the levelpack.
	//Returns: Pointer to the requested levelpack.
	LevelPack* getLevelPack(std::string path);

	//Method that will return a vector containing all (or a subset) of the levelpacks.
	//type: The list type, default is ALL_PACKS.
	std::vector<std::pair<std::string,std::string> > enumLevelPacks(int type=ALL_PACKS);

	//Method that will update the translation of the levelpacks.
	//NOTE: This is called when changing the language in the Options menu.
	void updateLanguage();

	//Destroys the levelpacks.
	void destroy();

	//Enumeration containing the different types of levelpack lists.
	enum LevelPackLists
	{
	//This list contains every levelpack.
	ALL_PACKS,
	//This list contains all the custom levelpacks (and Levels).
	CUSTOM_PACKS

	};

	//The tutorial level pack path.
	std::string tutorialLevelPackPath;

	//Get the tutorial level pack.
	LevelPack* getTutorialLevelPack(){
	return getLevelPack(tutorialLevelPackPath);
	};
	private:
	//Map containing the levelpacks.
	//The key is the path to the levelpack and the value is a pointer to the levelpack.
	std::map<std::string,LevelPack*> levelpacks;
	};

	#endif
	diff --git a/src/LevelPlaySelect.cpp b/src/LevelPlaySelect.cpp
	index f2537d4..3b24a86 100644
	--- a/src/LevelPlaySelect.cpp
	+++ b/src/LevelPlaySelect.cpp
	@@ -1,452 +1,415 @@
	/*
	* 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 "LevelPlaySelect.h"
	#include "GameState.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "LevelSelect.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "GUIScrollBar.h"
	#include "InputManager.h"
	#include "Game.h"
	#ifdef __APPLE__
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_ttf.h>
	#endif
	#include <stdio.h>
	#include <string>
	#include <sstream>
	#include <iostream>
	-using namespace std;

	/////////////////////LEVEL SELECT/////////////////////
	-static string levelDescription,levelMedal2,levelMedal3,levelTime,levelRecs;
	-static string bestTimeFilePath,bestRecordingFilePath;
	-
	-LevelPlaySelect::LevelPlaySelect():LevelSelect(_("Select Level")){
	+LevelPlaySelect::LevelPlaySelect(ImageManager& imageManager, SDL_Renderer& renderer)
	+ :LevelSelect(imageManager,renderer,_("Select Level")),
	+ levelInfoRender(imageManager,renderer,getDataPath(),*fontText,themeTextColor){
	//Load the play button if needed.
	- playButtonImage=loadImage(getDataPath()+"gfx/playbutton.png");
	- timeIcon=loadImage(getDataPath()+"gfx/time.png");
	- recordingsIcon=loadImage(getDataPath()+"gfx/recordings.png");
	+ playButtonImage=imageManager.loadTexture(getDataPath()+"gfx/playbutton.png", renderer);

	//Create the gui.
	- createGUI(true);
	+ createGUI(imageManager,renderer, true);

	//Show level list
	- refresh();
	+ refresh(imageManager,renderer);
	}

	LevelPlaySelect::~LevelPlaySelect(){
	play=NULL;
	- recordingsIcon=NULL;
	- timeIcon=NULL;

	//Clear the selected level.
	if(selectedNumber!=NULL){
	delete selectedNumber;
	selectedNumber=NULL;
	}
	}

	-void LevelPlaySelect::createGUI(bool initial){
	+void LevelPlaySelect::createGUI(ImageManager& imageManager,SDL_Renderer &renderer, bool initial){
	//Create the play button.
	if(initial){
	- play=new GUIButton(SCREEN_WIDTH-240,SCREEN_HEIGHT-60,240,32,_("Play"));
	+ play=new GUIButton(imageManager,renderer,SCREEN_WIDTH-240,SCREEN_HEIGHT-60,240,32,_("Play"));
	}else{
	play->left=SCREEN_WIDTH-240;
	play->top=SCREEN_HEIGHT-60;
	}
	play->name="cmdPlay";
	play->eventCallback=this;
	play->enabled=false;
	if(initial)
	GUIObjectRoot->addChild(play);
	}

	-void LevelPlaySelect::refresh(bool change){
	+void LevelPlaySelect::refresh(ImageManager& imageManager, SDL_Renderer& renderer, bool /change/){
	int m=levels->getLevelCount();
	numbers.clear();
	+ levelInfoRender.resetText(renderer, *fontText, themeTextColor);

	//Clear the selected level.
	if(selectedNumber!=NULL){
	delete selectedNumber;
	selectedNumber=NULL;
	}
	//Recreate the non selected number.
	- selectedNumber=new Number();
	+ selectedNumber=new Number(imageManager, renderer);
	SDL_Rect box={40,SCREEN_HEIGHT-130,50,50};
	- selectedNumber->init(" ",box);
	+ selectedNumber->init(renderer," ",box);
	selectedNumber->setLocked(true);

	- levelDescription=_("Choose a level");
	- levelMedal2=string(_("Time:"));
	- levelMedal3=string(_("Recordings:"));
	- levelTime=string("- / -");
	- levelRecs=string("- / -");
	-
	bestTimeFilePath.clear();
	bestRecordingFilePath.clear();

	//Disable the play button.
	play->enabled=false;

	for(int n=0; n<m; n++){
	- numbers.push_back(Number());
	+ numbers.emplace_back(imageManager, renderer);
	}

	for(int n=0; n<m; n++){
	- SDL_Rect box={(n%LEVELS_PER_ROW)64+(SCREEN_WIDTH0.2)/2,(n/LEVELS_PER_ROW)*64+184,0,0};
	- numbers[n].init(n,box);
	+ SDL_Rect box={(n%LEVELS_PER_ROW)64+static_cast<int>(SCREEN_WIDTH0.2)/2,(n/LEVELS_PER_ROW)*64+184,0,0};
	+ numbers[n].init(renderer,n,box);
	numbers[n].setLocked(levels->getLocked(n));
	int medal=levels->getLevel(n)->won;
	if(medal){
	if(levels->getLevel(n)->targetTime<0 \|\| levels->getLevel(n)->time<=levels->getLevel(n)->targetTime)
	medal++;
	if(levels->getLevel(n)->targetRecordings<0 \|\| levels->getLevel(n)->recordings<=levels->getLevel(n)->targetRecordings)
	medal++;
	}
	numbers[n].setMedal(medal);
	}

	if(m>LEVELS_DISPLAYED_IN_SCREEN){
	levelScrollBar->maxValue=(m-LEVELS_DISPLAYED_IN_SCREEN+(LEVELS_PER_ROW-1))/LEVELS_PER_ROW;
	levelScrollBar->visible=true;
	}else{
	levelScrollBar->maxValue=0;
	levelScrollBar->visible=false;
	}
	if(!levels->levelpackDescription.empty())
	levelpackDescription->caption=_CC(levels->getDictionaryManager(),levels->levelpackDescription);
	else
	levelpackDescription->caption="";
	}

	-void LevelPlaySelect::selectNumber(unsigned int number,bool selected){
	+void LevelPlaySelect::selectNumber(ImageManager& imageManager, SDL_Renderer& renderer, unsigned int number,bool selected){
	if(selected){
	levels->setCurrentLevel(number);
	setNextState(STATE_GAME);
	}else{
	- displayLevelInfo(number);
	+ displayLevelInfo(imageManager, renderer,number);
	}
	}

	-void LevelPlaySelect::checkMouse(){
	+void LevelPlaySelect::checkMouse(ImageManager &imageManager, SDL_Renderer &renderer){
	int x,y;

	//Get the current mouse location.
	SDL_GetMouseState(&x,&y);

	//Check if we should replay the record.
	if(selectedNumber!=NULL){
	SDL_Rect mouse={x,y,0,0};
	if(!bestTimeFilePath.empty()){
	SDL_Rect box={SCREEN_WIDTH-420,SCREEN_HEIGHT-130,372,32};
	if(checkCollision(box,mouse)){
	Game::recordFile=bestTimeFilePath;
	levels->setCurrentLevel(selectedNumber->getNumber());
	setNextState(STATE_GAME);
	return;
	}
	}
	if(!bestRecordingFilePath.empty()){
	SDL_Rect box={SCREEN_WIDTH-420,SCREEN_HEIGHT-98,372,32};
	if(checkCollision(box,mouse)){
	Game::recordFile=bestRecordingFilePath;
	levels->setCurrentLevel(selectedNumber->getNumber());
	setNextState(STATE_GAME);
	return;
	}
	}
	}

	//Call the base method from the super class.
	- LevelSelect::checkMouse();
	+ LevelSelect::checkMouse(imageManager, renderer);
	}

	-void LevelPlaySelect::displayLevelInfo(int number){
	+void LevelPlaySelect::displayLevelInfo(ImageManager& imageManager, SDL_Renderer& renderer, int number){
	//Update currently selected level
	if(selectedNumber==NULL){
	- selectedNumber=new Number();
	+ selectedNumber=new Number(imageManager, renderer);
	}
	SDL_Rect box={40,SCREEN_HEIGHT-130,50,50};
	- selectedNumber->init(number,box);
	+ selectedNumber->init(renderer,number,box);
	selectedNumber->setLocked(false);

	- //Show level description
	- levelDescription=levels->getLevelName(number);
	-
	//Show level medal
	int medal=levels->getLevel(number)->won;
	int time=levels->getLevel(number)->time;
	int targetTime=levels->getLevel(number)->targetTime;
	int recordings=levels->getLevel(number)->recordings;
	int targetRecordings=levels->getLevel(number)->targetRecordings;

	if(medal){
	if(targetTime<0){
	medal=-1;
	}else{
	if(targetTime<0 \|\| time<=targetTime)
	medal++;
	if(targetRecordings<0 \|\| recordings<=targetRecordings)
	medal++;
	}
	}
	selectedNumber->setMedal(medal);
	+ std::string levelTime;
	+ std::string levelRecs;

	//Show best time and recordings
	if(medal){
	char s[64];

	if(time>0)
	if(targetTime>0)
	sprintf(s,"%-.2fs / %-.2fs",time/40.0f,targetTime/40.0f);
	else
	sprintf(s,"%-.2fs / -",time/40.0f);
	else
	s[0]='\0';
	- levelTime=string(s);
	+ levelTime=s;

	if(recordings>=0)
	if(targetRecordings>=0)
	sprintf(s,"%5d / %d",recordings,targetRecordings);
	else
	sprintf(s,"%5d / -",recordings);
	else
	s[0]='\0';
	- levelRecs=string(s);
	+ levelRecs=s;
	}else{
	- levelTime=string("- / -");
	- levelRecs=string("- / -");
	+ levelTime="- / -";
	+ levelRecs="- / -";
	}

	//Show the play button.
	play->enabled=true;

	//Check if there is auto record file
	levels->getLevelAutoSaveRecordPath(number,bestTimeFilePath,bestRecordingFilePath,false);
	if(!bestTimeFilePath.empty()){
	FILE *f;
	f=fopen(bestTimeFilePath.c_str(),"rb");
	if(f==NULL){
	bestTimeFilePath.clear();
	}else{
	fclose(f);
	}
	}
	if(!bestRecordingFilePath.empty()){
	FILE *f;
	f=fopen(bestRecordingFilePath.c_str(),"rb");
	if(f==NULL){
	bestRecordingFilePath.clear();
	}else{
	fclose(f);
	}
	}
	+
	+ //Show level description
	+ const std::string& levelDescription=levels->getLevelName(number);
	+
	+ levelInfoRender.update(renderer, *fontText, themeTextColor,
	+ levelDescription, levelTime, levelRecs);
	}

	-void LevelPlaySelect::render(){
	+void LevelPlaySelect::render(ImageManager& imageManager, SDL_Renderer &renderer){
	//First let the levelselect render.
	- LevelSelect::render();
	+ LevelSelect::render(imageManager,renderer);

	int x,y,dy=0;

	//Get the current mouse location.
	SDL_GetMouseState(&x,&y);

	if(levelScrollBar)
	dy=levelScrollBar->value;
	//Upper bound of levels we'd like to display.
	y+=dy*64;

	SDL_Rect mouse={x,y,0,0};

	//Show currently selected level (if any)
	if(selectedNumber!=NULL){
	- selectedNumber->show(0);
	-
	- SDL_Surface* bm;
	+ selectedNumber->show(renderer, 0);

	- if(!levelDescription.empty()){
	- bm=TTF_RenderUTF8_Blended(fontText,_CC(levels->getDictionaryManager(),levelDescription.c_str()),themeTextColor);
	- applySurface(100,SCREEN_HEIGHT-130+(50-bm->h)/2,bm,screen,NULL);
	- SDL_FreeSurface(bm);
	- }
	+ levelInfoRender.render(renderer);

	- //Only show the replay if the level is completed (won).
	+ //Only show the replay button if the level is completed (won).
	if(selectedNumber->getNumber()>=0 && selectedNumber->getNumber()<levels->getLevelCount()) {
	if(levels->getLevel(selectedNumber->getNumber())->won){
	if(!bestTimeFilePath.empty()){
	+
	SDL_Rect r={0,0,32,32};
	- SDL_Rect box={SCREEN_WIDTH-420,SCREEN_HEIGHT-130,372,32};
	+ const SDL_Rect box={SCREEN_WIDTH-420,SCREEN_HEIGHT-130,372,32};

	if(checkCollision(box,mouse)){
	r.x=32;
	- SDL_FillRect(screen,&box,0xFFCCCCCC);
	+ SDL_SetRenderDrawColor(&renderer, 0xFF,0xCC,0xCC,0xCC);
	+ SDL_RenderDrawRect(&renderer, &box);
	}
	-
	- applySurface(SCREEN_WIDTH-80,SCREEN_HEIGHT-130,playButtonImage,screen,&r);
	+ const SDL_Rect dstRect = {SCREEN_WIDTH-80,SCREEN_HEIGHT-130,r.w,r.h};
	+ SDL_RenderCopy(&renderer,playButtonImage.get(),&r, &dstRect);
	}

	if(!bestRecordingFilePath.empty()){
	SDL_Rect r={0,0,32,32};
	- SDL_Rect box={SCREEN_WIDTH-420,SCREEN_HEIGHT-98,372,32};
	+ const SDL_Rect box={SCREEN_WIDTH-420,SCREEN_HEIGHT-98,372,32};

	if(checkCollision(box,mouse)){
	- r.x=32;
	- SDL_FillRect(screen,&box,0xFFCCCCCC);
	+ r.x=32;
	+ SDL_SetRenderDrawColor(&renderer, 0xFF,0xCC,0xCC,0xCC);
	+ SDL_RenderDrawRect(&renderer, &box);
	}

	- applySurface(SCREEN_WIDTH-80,SCREEN_HEIGHT-98,playButtonImage,screen,&r);
	+ const SDL_Rect dstRect = {SCREEN_WIDTH-80,SCREEN_HEIGHT-98,r.w,r.h};
	+ SDL_RenderCopy(&renderer,playButtonImage.get(),&r, &dstRect);
	}
	}
	}
	-
	- if(!levelMedal2.empty()){
	- //Draw the icon.
	- applySurface(SCREEN_WIDTH-405,SCREEN_HEIGHT-130+3,timeIcon,screen,NULL);
	-
	- //Now draw the text (title).
	- bm=TTF_RenderUTF8_Blended(fontText,levelMedal2.c_str(),themeTextColor);
	- applySurface(SCREEN_WIDTH-380,SCREEN_HEIGHT-130+3,bm,screen,NULL);
	- SDL_FreeSurface(bm);
	-
	- //Now draw the second text (value).
	- bm=TTF_RenderUTF8_Blended(fontText,levelTime.c_str(),themeTextColor);
	- applySurface(SCREEN_WIDTH-bm->w-80,SCREEN_HEIGHT-130+3,bm,screen,NULL);
	- SDL_FreeSurface(bm);
	- }
	-
	- if(!levelMedal3.empty()){
	- //Draw the icon.
	- applySurface(SCREEN_WIDTH-405,SCREEN_HEIGHT-98+(6)/2,recordingsIcon,screen,NULL);
	-
	- //Now draw the text (title).
	- bm=TTF_RenderUTF8_Blended(fontText,levelMedal3.c_str(),themeTextColor);
	- applySurface(SCREEN_WIDTH-380,SCREEN_HEIGHT-98+(32-bm->h)/2,bm,screen,NULL);
	- SDL_FreeSurface(bm);
	-
	- //Now draw the second text (value).
	- bm=TTF_RenderUTF8_Blended(fontText,levelRecs.c_str(),themeTextColor);
	- applySurface(SCREEN_WIDTH-bm->w-80,SCREEN_HEIGHT-98+(32-bm->h)/2,bm,screen,NULL);
	- SDL_FreeSurface(bm);
	- }
	}
	}

	-void LevelPlaySelect::renderTooltip(unsigned int number,int dy){
	- SDL_Color themeTextColor={0,0,0};
	- char s[64];
	-
	- //Render the name of the level.
	- SDL_Surface* name=TTF_RenderUTF8_Blended(fontText,_CC(levels->getDictionaryManager(),levels->getLevelName(number)),themeTextColor);
	- SDL_Surface* time=NULL;
	- SDL_Surface* recordings=NULL;
	-
	- //The time it took.
	- if(levels->getLevel(number)->time>0){
	- sprintf(s,"%-.2fs",levels->getLevel(number)->time/40.0f);
	- time=TTF_RenderUTF8_Blended(fontText,s,themeTextColor);
	- }
	-
	- //The number of recordings it took.
	- if(levels->getLevel(number)->recordings>=0){
	- sprintf(s,"%d",levels->getLevel(number)->recordings);
	- recordings=TTF_RenderUTF8_Blended(fontText,s,themeTextColor);
	- }
	-
	+void LevelPlaySelect::renderTooltip(SDL_Renderer &renderer, unsigned int number, int dy){
	+ if (!toolTip.name \|\| toolTip.number != number) {
	+ SDL_Color themeTextColor={0,0,0};
	+ const int SLEN = 64;
	+ char s[SLEN];
	+
	+ //Render the name of the level.
	+ toolTip.name=textureFromText(renderer,*fontText,_CC(levels->getDictionaryManager(),levels->getLevelName(number)),themeTextColor);
	+ toolTip.time=nullptr;
	+ toolTip.recordings=nullptr;
	+ toolTip.number=number;
	+
	+ //The time it took.
	+ if(levels->getLevel(number)->time>0){
	+ snprintf(s,SLEN,"%-.2fs",levels->getLevel(number)->time/40.0f);
	+ toolTip.time=textureFromText(renderer,*fontText,s,themeTextColor);//TTF_RenderUTF8_Blended(fontText,s,themeTextColor);
	+ }
	+
	+ //The number of recordings it took.
	+ if(levels->getLevel(number)->recordings>=0){
	+ snprintf(s,SLEN,"%d",levels->getLevel(number)->recordings);
	+ toolTip.recordings = textureFromText(renderer,*fontText,s,themeTextColor);
	+ }
	+ }

	+ const SDL_Rect nameSize = rectFromTexture(*toolTip.name);
	//Now draw a square the size of the three texts combined.
	SDL_Rect r=numbers[number].box;
	r.y-=dy*64;
	- if(time!=NULL && recordings!=NULL){
	- r.w=(name->w)>(25+time->w+40+recordings->w)?(name->w):(25+time->w+40+recordings->w);
	- r.h=name->h+5+20;
	+ if(toolTip.time && toolTip.recordings){
	+ const int recW = textureWidth(*toolTip.recordings);
	+ const int timeW = textureWidth(*toolTip.time);
	+ r.w=(nameSize.w)>(25+timeW+40+recW)?(nameSize.w):(25+timeW+40+recW);
	+ r.h=nameSize.h+5+20;
	}else{
	- r.w=name->w;
	- r.h=name->h;
	+ r.w=nameSize.w;
	+ r.h=nameSize.h;
	}

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

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

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

	//Now we render the name if the surface isn't null.
	- if(name!=NULL){
	+ if(toolTip.name){
	//Draw the name.
	- SDL_BlitSurface(name,NULL,screen,&r2);
	+ applyTexture(r2.x, r2.y, toolTip.name, renderer);
	}
	//Increase the height to leave a gap between name and stats.
	r2.y+=30;
	- if(time!=NULL){
	+ if(toolTip.time){
	//Now draw the time.
	- applySurface(r2.x,r2.y,timeIcon,screen,NULL);
	+ applyTexture(r2.x,r2.y,levelInfoRender.timeIcon,renderer);
	r2.x+=25;
	- SDL_BlitSurface(time,NULL,screen,&r2);
	- r2.x+=time->w+15;
	+ applyTexture(r2.x, r2.y, toolTip.time, renderer);
	+ r2.x+=textureWidth(*toolTip.time)+15;
	}
	- if(recordings!=NULL){
	+ if(toolTip.recordings){
	//Now draw the recordings.
	- applySurface(r2.x,r2.y,recordingsIcon,screen,NULL);
	+ applyTexture(r2.x,r2.y,levelInfoRender.recordingsIcon,renderer);
	r2.x+=25;
	- SDL_BlitSurface(recordings,NULL,screen,&r2);
	+ applyTexture(r2.x, r2.y, toolTip.recordings, renderer);
	}
	-
	- //And free the surfaces.
	- SDL_FreeSurface(name);
	- SDL_FreeSurface(time);
	- SDL_FreeSurface(recordings);
	}

	-void LevelPlaySelect::resize(){
	+void LevelPlaySelect::resize(ImageManager &imageManager, SDL_Renderer &renderer){
	//Let the LevelSelect do his stuff.
	- LevelSelect::resize();
	+ LevelSelect::resize(imageManager, renderer);

	//Now create our gui again.
	- createGUI(false);
	+ createGUI(imageManager,renderer, false);
	}

	-void LevelPlaySelect::GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	+void LevelPlaySelect::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Let the level select handle his GUI events.
	- LevelSelect::GUIEventCallback_OnEvent(name,obj,eventType);
	+ LevelSelect::GUIEventCallback_OnEvent(imageManager,renderer,name,obj,eventType);

	//Check for the play button.
	if(name=="cmdPlay"){
	if(selectedNumber!=NULL){
	levels->setCurrentLevel(selectedNumber->getNumber());
	setNextState(STATE_GAME);
	}
	}
	}
	diff --git a/src/LevelPlaySelect.h b/src/LevelPlaySelect.h
	index 4afd185..7b25951 100644
	--- a/src/LevelPlaySelect.h
	+++ b/src/LevelPlaySelect.h
	@@ -1,85 +1,87 @@
	/*
	* 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 LEVELPLAYSELECT_H
	#define LEVELPLAYSELECT_H

	#include "GameState.h"
	#include "LevelSelect.h"
	+#include "LevelInfoRender.h"
	#include "GameObjects.h"
	#include "Player.h"
	#include "GUIObject.h"
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_mixer.h>
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_mixer.h>
	+#include <SDL2/SDL_ttf.h>
	#endif
	#include <vector>
	#include <string>

	//This is the LevelSelect state, here you can select levelpacks and levels.
	class LevelPlaySelect : public LevelSelect{
	private:
	//Pointer to the play button, it is only shown when a level is selected.
	GUIObject* play;

	//Image of a play icon used as button to start replays.
	- SDL_Surface* playButtonImage;
	-
	- //Image containing the time icon.
	- SDL_Surface* timeIcon;
	- //Image containing the recordings icon.
	- SDL_Surface* recordingsIcon;
	+ SharedTexture playButtonImage;
	+
	+ //Textures to display level info.
	+ LevelInfoRender levelInfoRender;
	+
	+ std::string bestTimeFilePath;
	+ std::string bestRecordingFilePath;

	//Method that will create the GUI elements.
	//initial: Boolean if it is the first time the gui is created.
	- void createGUI(bool initial);
	+ void createGUI(ImageManager& imageManager, SDL_Renderer& renderer, bool initial);

	//display level info.
	- void displayLevelInfo(int number);
	+ void displayLevelInfo(ImageManager &imageManager, SDL_Renderer &renderer, int number);

	//Check where and if the mouse clicked on a number.
	//If so it will start the level.
	- void checkMouse();
	+ void checkMouse(ImageManager &imageManager, SDL_Renderer &renderer) override;
	public:
	//Constructor.
	- LevelPlaySelect();
	+ LevelPlaySelect(ImageManager &imageManager, SDL_Renderer &renderer);
	//Destructor.
	~LevelPlaySelect();

	//Inherited from LevelSelect.
	- void refresh(bool change=true);
	- void selectNumber(unsigned int number,bool selected);
	+ void refresh(ImageManager &imageManager, SDL_Renderer &renderer, bool change=true) override;
	+ void selectNumber(ImageManager &imageManager, SDL_Renderer &renderer, unsigned int number, bool selected) override;

	//Inherited from GameState.
	- void render();
	+ void render(ImageManager&imageManager, SDL_Renderer& renderer) override;

	//Inherited from GameState.
	- void resize();
	+ void resize(ImageManager &imageManager, SDL_Renderer& renderer) override;

	//Inherited from LevelSelect.
	- void renderTooltip(unsigned int number,int dy);
	+ void renderTooltip(SDL_Renderer& renderer,unsigned int number,int dy) override;

	//GUI events will be handled here.
	- void GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType);
	+ void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType);
	};

	#endif
	diff --git a/src/LevelSelect.cpp b/src/LevelSelect.cpp
	index ecd7b8e..62bd372 100644
	--- a/src/LevelSelect.cpp
	+++ b/src/LevelSelect.cpp
	@@ -1,415 +1,414 @@
	/*
	* 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 "GameState.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "LevelSelect.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "GUIScrollBar.h"
	#include "InputManager.h"
	#include "Game.h"
	#ifdef __APPLE__
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_ttf.h>
	#endif
	#include <stdio.h>
	#include <string>
	#include <sstream>
	#include <iostream>

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

	////////////////////NUMBER////////////////////////
	-Number::Number(){
	+Number::Number(ImageManager& imageManager, SDL_Renderer& renderer){
	image=NULL;
	number=0;
	medal=0;
	selected=false;
	locked=false;

	//Set the default dimensions.
	box.x=0;
	box.y=0;
	box.h=50;
	box.w=50;

	//Load the medals image.
	- medals=loadImage(getDataPath()+"gfx/medals.png");
	+ //medals=loadImage(getDataPath()+"gfx/medals.png");
	+ medals=imageManager.loadTexture(getDataPath()+"gfx/medals.png", renderer);
	+ //To make sure it can be added to a vector, stop here rather than generate a massive error.
	+ static_assert(std::is_move_constructible<Number>::value, "Not move constructable!");
	}

	-Number::~Number(){
	- //We only need to free the SDLSurface.
	- if(image) SDL_FreeSurface(image);
	-}
	-
	-void Number::init(int number,SDL_Rect box){
	+void Number::init(SDL_Renderer& renderer,int number,SDL_Rect box){
	//First set the number and update our status.
	this->number=number;

	//Write our text, number+1 since the counting doens't start with 0, but with 1.
	std::stringstream text;
	number++;
	text<<number;

	//Create the text image.
	- SDL_Color black={0,0,0};
	- if(image) SDL_FreeSurface(image);
	+ const SDL_Color black={0,0,0,0};
	//Create the text image.
	//Also check which font to use, if the number is higher than 100 use the small font.
	- image=TTF_RenderUTF8_Blended(fontGUI,text.str().c_str(),black);
	+ image = textureFromText(renderer,*fontGUI,text.str().c_str(),black);

	//Set the new location of the number.
	this->box.x=box.x;
	this->box.y=box.y;

	//Load background blocks.
	objThemes.getBlock(TYPE_BLOCK,true)->createInstance(&block);
	block.changeState("unlocked");

	objThemes.getBlock(TYPE_SHADOW_BLOCK,true)->createInstance(&blockLocked);
	blockLocked.changeState("locked");
	}

	-void Number::init(std::string text,SDL_Rect box){
	+void Number::init(SDL_Renderer& renderer,std::string text,SDL_Rect box){
	//First set the number and update our status.
	this->number=-1;

	//Create the text image.
	SDL_Color black={0,0,0};
	- if(image) SDL_FreeSurface(image);
	- image=TTF_RenderUTF8_Blended(fontGUI,text.c_str(),black);
	+ image = textureFromText(renderer,*fontGUI,text.c_str(),black);

	//Set the new location of the number.
	this->box.x=box.x;
	this->box.y=box.y;

	//Load background blocks.
	objThemes.getBlock(TYPE_BLOCK,true)->createInstance(&block);
	block.changeState("unlocked");

	objThemes.getBlock(TYPE_SHADOW_BLOCK,true)->createInstance(&blockLocked);
	blockLocked.changeState("locked");
	}

	-void Number::show(int dy){
	+void Number::show(SDL_Renderer& renderer, int dy){
	//First draw the background, also apply the yOffset(dy).
	if(!locked)
	- block.draw(screen,box.x,box.y-dy);
	+ block.draw(renderer,box.x,box.y-dy);
	else
	- blockLocked.draw(screen,box.x,box.y-dy);
	+ blockLocked.draw(renderer,box.x,box.y-dy);
	//Now draw the text image over the background.
	//We draw it centered inside the box.
	- applySurface((box.x+25-(image->w/2)),box.y-dy,image,screen,NULL);
	+ applyTexture(box.x+25-(textureWidth(*image)/2),box.y-dy,image,renderer);

	//Draw the selection mark.
	if(selected){
	- drawGUIBox(box.x,box.y-dy,50,50,screen,0xFFFFFF23);
	+ drawGUIBox(box.x,box.y-dy,50,50,renderer,0xFFFFFF23);
	}

	//Draw the medal.
	- if(medal>0){
	- SDL_Rect r={(medal-1)*30,0,30,30};
	- applySurface(box.x+30,(box.y+30)-dy,medals,screen,&r);
	+ if(medal>0&&medals){
	+ const SDL_Rect srcRect={(medal-1)*30,0,30,30};
	+ const SDL_Rect dstRect={box.x+30,(box.y+30)-dy,30,30};
	+ SDL_RenderCopy(&renderer,medals.get(),&srcRect,&dstRect);
	}
	}

	void Number::setLocked(bool locked){
	this->locked=locked;
	}

	void Number::setMedal(int medal){
	this->medal=medal;
	}


	/////////////////////LEVEL SELECT/////////////////////
	-LevelSelect::LevelSelect(string titleText,LevelPackManager::LevelPackLists packType){
	+LevelSelect::LevelSelect(ImageManager& imageManager,SDL_Renderer& renderer, const char* titleText, LevelPackManager::LevelPackLists packType){
	//clear the selected level
	selectedNumber=NULL;

	//Calculate the LEVELS_PER_ROW and LEVEL_ROWS if they aren't calculated already.
	calcRows();

	//Render the title.
	- title=TTF_RenderUTF8_Blended(fontTitle,titleText.c_str(),themeTextColor);
	-
	+ title=textureFromText(renderer,*fontTitle,titleText,themeTextColor);
	+
	//create GUI (test only)
	GUIObject* obj;
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	- GUIObjectRoot=new GUIObject(0,0,SCREEN_WIDTH,SCREEN_HEIGHT);
	+ GUIObjectRoot=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

	//the level select scroll bar
	- levelScrollBar=new GUIScrollBar(SCREEN_WIDTH*0.9,184,16,SCREEN_HEIGHT-344,ScrollBarVertical,0,0,0,1,4,true,false);
	+ levelScrollBar=new GUIScrollBar(imageManager,renderer,SCREEN_WIDTH*0.9,184,16,SCREEN_HEIGHT-344,ScrollBarVertical,0,0,0,1,4,true,false);
	GUIObjectRoot->addChild(levelScrollBar);

	//level pack description
	- levelpackDescription=new GUILabel(0,140,SCREEN_WIDTH,32,"",0,true,true,GUIGravityCenter);
	+ levelpackDescription=new GUILabel(imageManager,renderer,0,140,SCREEN_WIDTH,32,"",0,true,true,GUIGravityCenter);
	GUIObjectRoot->addChild(levelpackDescription);

	- levelpacks=new GUISingleLineListBox((SCREEN_WIDTH-500)/2,104,500,32);
	+ levelpacks=new GUISingleLineListBox(imageManager,renderer,(SCREEN_WIDTH-500)/2,104,500,32);
	levelpacks->name="cmdLvlPack";
	levelpacks->eventCallback=this;
	vector<pair<string,string> > v=getLevelPackManager()->enumLevelPacks(packType);
	levelpacks->addItems(v);
	levelpacks->value=0;

	//Check if we can find the lastlevelpack.
	for(vector<pair<string,string> >::iterator i=v.begin(); i!=v.end(); ++i){
	if(i->first==getSettings()->getValue("lastlevelpack")){
	levelpacks->value=i-v.begin();
	}
	}

	//Load the progress.
	levels=getLevelPackManager()->getLevelPack(v[levelpacks->value].first);
	levels->loadProgress();

	//And add the levelpack single line listbox to the GUIObjectRoot.
	GUIObjectRoot->addChild(levelpacks);

	- obj=new GUIButton(20,20,-1,32,_("Back"));
	+ obj=new GUIButton(imageManager,renderer,20,20,-1,32,_("Back"));
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->addChild(obj);

	section=1;
	}

	LevelSelect::~LevelSelect(){
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	levelScrollBar=NULL;
	levelpackDescription=NULL;

	selectedNumber=NULL;
	-
	- //Free the rendered title surface.
	- SDL_FreeSurface(title);
	}

	void LevelSelect::calcRows(){
	//Calculate the number of rows and the number of levels per row.
	LEVELS_PER_ROW=(SCREEN_WIDTH*0.8)/64;
	int LEVEL_ROWS=(SCREEN_HEIGHT-344)/64;
	LEVELS_DISPLAYED_IN_SCREEN=LEVELS_PER_ROW*LEVEL_ROWS;
	}

	-void LevelSelect::selectNumberKeyboard(int x,int y){
	+void LevelSelect::selectNumberKeyboard(ImageManager& imageManager, SDL_Renderer& renderer, int x,int y){
	if(section==2){
	//Move selection
	int realNumber=0;
	if(selectedNumber)
	realNumber=selectedNumber->getNumber()+x+(y*LEVELS_PER_ROW);

	//If selection is outside of the map grid, change section
	if(realNumber<0 \|\| realNumber>(int)numbers.size()-1){
	section=1;
	for(int i=0;i<levels->getLevelCount();i++){
	numbers[i].selected=false;
	- refresh();
	+ refresh(imageManager, renderer);
	}
	}else{
	//If not, move selection
	if(!numbers[realNumber].getLocked()){
	for(int i=0;i<levels->getLevelCount();i++){
	numbers[i].selected=(i==realNumber);
	}
	- selectNumber(realNumber,false);
	+ selectNumber(imageManager,renderer,realNumber,false);
	}
	}
	}else if(section==1){
	//Loop through levelpacks and update GUI
	levelpacks->value+=x;

	if(levelpacks->value<0){
	levelpacks->value=levelpacks->item.size()-1;
	}else if(levelpacks->value>(int)levelpacks->item.size()-1){
	levelpacks->value=0;
	}

	- GUIEventCallback_OnEvent("cmdLvlPack",static_cast<GUIObject*>(levelpacks),0);
	+ GUIEventCallback_OnEvent(imageManager,renderer,"cmdLvlPack",static_cast<GUIObject*>(levelpacks),0);

	//If up is pressed, change section
	if(y==1){
	section=2;
	- selectNumber(0,false);
	+ selectNumber(imageManager,renderer,0,false);
	numbers[0].selected=true;
	}
	}else{
	section=clamp(section+y,0,2);
	}
	}

	-void LevelSelect::handleEvents(){
	+void LevelSelect::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//Check for an SDL_QUIT event.
	if(event.type==SDL_QUIT){
	setNextState(STATE_EXIT);
	}

	//Check for a mouse click.
	if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT){
	- checkMouse();
	+ checkMouse(imageManager, renderer);
	}

	//Check focus movement
	if(inputMgr.isKeyDownEvent(INPUTMGR_RIGHT)){
	- selectNumberKeyboard(1,0);
	+ selectNumberKeyboard(imageManager, renderer, 1,0);
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_LEFT)){
	- selectNumberKeyboard(-1,0);
	+ selectNumberKeyboard(imageManager, renderer, -1,0);
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_UP)){
	- selectNumberKeyboard(0,-1);
	+ selectNumberKeyboard(imageManager, renderer, 0,-1);
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_DOWN)){
	- selectNumberKeyboard(0,1);
	+ selectNumberKeyboard(imageManager, renderer, 0,1);
	}

	//Check if enter is pressed
	if(section==2 && inputMgr.isKeyUpEvent(INPUTMGR_SELECT)){
	- selectNumber(selectedNumber->getNumber(),true);
	+ selectNumber(imageManager,renderer,selectedNumber->getNumber(),true);
	}

	//Check if escape is pressed.
	if(inputMgr.isKeyUpEvent(INPUTMGR_ESCAPE)){
	setNextState(STATE_MENU);
	}

	//Check for scrolling down and up.
	- if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELDOWN && levelScrollBar){
	- if(levelScrollBar->value<levelScrollBar->maxValue) levelScrollBar->value++;
	- return;
	- }else if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELUP && levelScrollBar){
	- if(levelScrollBar->value>0) levelScrollBar->value--;
	- return;
	+// if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELDOWN && levelScrollBar){
	+ if(event.type==SDL_MOUSEWHEEL && levelScrollBar){
	+ if(levelScrollBar->value<levelScrollBar->maxValue) {
	+ //TODO - tweak the scroll amount
	+ levelScrollBar->value += event.wheel.y;
	+ }
	}
	+// return;
	+// }else if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELUP && levelScrollBar){
	+// if(levelScrollBar->value>0) levelScrollBar->value--;
	+// return;
	+// }
	}

	-void LevelSelect::checkMouse(){
	+void LevelSelect::checkMouse(ImageManager &imageManager, SDL_Renderer &renderer){
	int x,y,dy=0,m=numbers.size();

	//Get the current mouse location.
	SDL_GetMouseState(&x,&y);

	//Check if there's a scrollbar, if so get the value.
	if(levelScrollBar)
	dy=levelScrollBar->value;
	//Upper bound of levels we'd like to display.
	if(m>dy*LEVELS_PER_ROW+LEVELS_DISPLAYED_IN_SCREEN)
	m=dy*LEVELS_PER_ROW+LEVELS_DISPLAYED_IN_SCREEN;
	y+=dy*64;

	SDL_Rect mouse={x,y,0,0};

	for(int n=dy*LEVELS_PER_ROW; n<m; n++){
	if(!numbers[n].getLocked()){
	if(checkCollision(mouse,numbers[n].box)==true){
	if(numbers[n].selected){
	- selectNumber(n,true);
	+ selectNumber(imageManager, renderer, n,true);
	}else{
	//Select current level
	for(int i=0;i<levels->getLevelCount();i++){
	numbers[i].selected=(i==n);
	}
	- selectNumber(n,false);
	+ selectNumber(imageManager, renderer,n,false);
	}
	section=2;
	break;
	}
	}
	}
	}

	-void LevelSelect::logic(){}
	+void LevelSelect::logic(ImageManager&, SDL_Renderer&){}

	-void LevelSelect::render(){
	+void LevelSelect::render(ImageManager&, SDL_Renderer& renderer){
	int x,y,dy=0,m=numbers.size();
	int idx=-1;

	//Get the current mouse location.
	SDL_GetMouseState(&x,&y);

	if(levelScrollBar)
	dy=levelScrollBar->value;
	//Upper bound of levels we'd like to display.
	if(m>dy*LEVELS_PER_ROW+LEVELS_DISPLAYED_IN_SCREEN)
	m=dy*LEVELS_PER_ROW+LEVELS_DISPLAYED_IN_SCREEN;
	y+=dy*64;

	SDL_Rect mouse={x,y,0,0};

	//Draw background.
	- objThemes.getBackground(true)->draw(screen);
	+ objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();
	//Draw the title.
	- applySurface((SCREEN_WIDTH-title->w)/2,40-TITLE_FONT_RAISE,title,screen,NULL);
	-
	+ drawTitleTexture(SCREEN_WIDTH, *title, renderer);
	+
	//Loop through the level blocks and draw them.
	for(int n=dy*LEVELS_PER_ROW;n<m;n++){
	- numbers[n].show(dy*64);
	+ numbers[n].show(renderer,dy*64);
	if(numbers[n].getLocked()==false && checkCollision(mouse,numbers[n].box)==true)
	idx=n;
	}

	//Show the tool tip text.
	if(idx>=0){
	- renderTooltip(idx,dy);
	+ renderTooltip(renderer,idx,dy);
	}
	}

	-void LevelSelect::resize(){
	+void LevelSelect::resize(ImageManager& imageManager,SDL_Renderer& renderer){
	calcRows();
	- refresh(false);
	+ refresh(imageManager,renderer,false);

	//NOTE: We don't need to recreate the listbox and the back button, only resize the list.
	levelpacks->left=(SCREEN_WIDTH-500)/2;
	levelpackDescription->width = SCREEN_WIDTH;
	}

	-void LevelSelect::GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	+void LevelSelect::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	if(name=="cmdLvlPack"){
	getSettings()->setValue("lastlevelpack",static_cast<GUISingleLineListBox*>(obj)->item[obj->value].first);
	}else if(name=="cmdBack"){
	setNextState(STATE_MENU);
	return;
	}else{
	return;
	}

	//new: reset the level list scroll bar
	if(levelScrollBar)
	levelScrollBar->value=0;

	levels=getLevelPackManager()->getLevelPack(static_cast<GUISingleLineListBox*>(obj)->item[obj->value].first);

	//Load the progress file.
	levels->loadProgress();

	//And refresh the numbers.
	- refresh();
	+ refresh(imageManager, renderer);
	}
	diff --git a/src/LevelSelect.h b/src/LevelSelect.h
	index abe3407..3ed2c92 100644
	--- a/src/LevelSelect.h
	+++ b/src/LevelSelect.h
	@@ -1,171 +1,178 @@
	/*
	* 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 LEVELSELECT_H
	#define LEVELSELECT_H

	#include "GameState.h"
	#include "GameObjects.h"
	#include "Player.h"
	#include "GUIObject.h"
	#include "GUIScrollBar.h"
	#include "GUIListBox.h"
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_mixer.h>
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_mixer.h>
	+#include <SDL2/SDL_ttf.h>
	#endif
	#include <vector>
	#include <string>

	//Class that represents a level in the levelselect menu.
	class Number{
	private:
	//The background image of the number.
	ThemeBlockInstance block;
	//The background image of the number when it's locked.
	ThemeBlockInstance blockLocked;
	//The (text) image of the number.
	- SDL_Surface* image;
	+ TexturePtr image;

	//Image containing the three stars a player can earn.
	- SDL_Surface* medals;
	-
	+ SharedTexture medals;
	+
	//The number (or text).
	int number;
	//Integer containing the medal the player got.
	//0 = none, 1 = bronze, 2 = silver, 3 = gold
	int medal;

	//Boolean if the number is locked or not.
	bool locked;
	public:
	//The location and size of the number.
	SDL_Rect box;

	//If the Number is selected then we draw something indicates it.
	bool selected;

	//Constructor.
	- Number();
	- //Destructor.
	- ~Number();
	+ Number(ImageManager &imageManager, SDL_Renderer &renderer);

	//Method used for initialising the number.
	//number: The number.
	//box: The location and size of the number.
	- void init(int number,SDL_Rect box);
	+ void init(SDL_Renderer &renderer, int number, SDL_Rect box);

	//Method used for initialising the number.
	//text: The caption of the number.
	//box: The location and size of the number.
	- void init(std::string text,SDL_Rect box);
	+ void init(SDL_Renderer& renderer,std::string text,SDL_Rect box);

	//get current number.
	inline int getNumber(){return number;}

	//Method used to set the locked status of the number.
	//locked: Boolean if it should be locked or not.
	void setLocked(bool locked=true);
	//Method used to retrieve the locked status of the number.
	//Returns: True if the number is locked.
	inline bool getLocked(){return locked;}

	//Method used to set the medal for this number.
	//medal: The new medal for this number.
	void setMedal(int medal);

	//Method that is used to draw the number.
	//dy: The y offset.
	- void show(int dy);
	+ void show(SDL_Renderer &renderer, int dy);
	+};
	+
	+struct ToolTip {
	+ TexturePtr name;
	+ TexturePtr time;
	+ TexturePtr recordings;
	+ size_t number;
	};

	//This is the LevelSelect state, here you can select levelpacks and levels.
	class LevelSelect : public GameState,public GUIEventCallback{
	protected:
	//Surface containing the title.
	- SDL_Surface* title;
	+ TexturePtr title;
	+
	+ ToolTip toolTip;

	//Vector containing the numbers.
	std::vector<Number> numbers;

	//Contains selected level number (displayed at bottom left corner).
	//If it's NULL then nothing selected.
	Number* selectedNumber;

	//Pointer to the scrollbar.
	GUIScrollBar* levelScrollBar;
	//Pointer to the description.
	GUIObject* levelpackDescription;

	//Pointer to the levelpack list.
	GUISingleLineListBox* levelpacks;

	//Check where and if the mouse clicked on a number.
	//If so select that number.
	- virtual void checkMouse();
	+ virtual void checkMouse(ImageManager& imageManager, SDL_Renderer& renderer);

	//Selected section for keyboard/gamepad control
	int section;

	//The number of blocks in a row.
	int LEVELS_PER_ROW;
	//The number of levels displayed on screen at once.
	int LEVELS_DISPLAYED_IN_SCREEN;
	public:
	//Constructor.
	//titleText: The title that is shown at the top of the screen.
	//packType: The type of levelpacks that should be listed (See LevelPackManager.h).
	- LevelSelect(std::string titleText,LevelPackManager::LevelPackLists packType=LevelPackManager::ALL_PACKS);
	+ LevelSelect(ImageManager& imageManager, SDL_Renderer &renderer, const char* titleText, LevelPackManager::LevelPackLists packType=LevelPackManager::ALL_PACKS);
	//Destructor.
	virtual ~LevelSelect();

	//Method that will calculate the number of rows and the number of levels per row.
	void calcRows();

	//Method used to update the numbers and the scrollbar.
	//change: Boolean if the levelpack changed, if not only the numbers need to be replaced.
	- virtual void refresh(bool change=true)=0;
	+ virtual void refresh(ImageManager& imageManager, SDL_Renderer& renderer, bool change=true)=0;

	//Method that is called when a number is selected.
	//number: The selected number.
	//selected: Boolean if the number was already selected.
	- virtual void selectNumber(unsigned int number,bool selected)=0;
	+ virtual void selectNumber(ImageManager &imageManager, SDL_Renderer &renderer, unsigned int number,bool selected)=0;

	//Used for keyboard/gamepad navigation
	- void selectNumberKeyboard(int x,int y);
	+ void selectNumberKeyboard(ImageManager &imageManager, SDL_Renderer &renderer, int x, int y);

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

	//Method that is called to render the tooltip.
	//number: The number that the tooltip should be drawn for.
	//dy: The y offset of the number, used to draw the tooltip in the right place.
	- virtual void renderTooltip(unsigned int number,int dy)=0;
	+ virtual void renderTooltip(SDL_Renderer& renderer,unsigned int number,int dy)=0;

	//GUI events will be handled here.
	- virtual void GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType)=0;
	+ virtual void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType)=0;
	};

	#endif
	diff --git a/src/Main.cpp b/src/Main.cpp
	index 7edac86..f77ac43 100644
	--- a/src/Main.cpp
	+++ b/src/Main.cpp
	@@ -1,247 +1,258 @@
	/*
	* 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 "Globals.h"
	#include "TitleMenu.h"
	#include "GUIObject.h"
	#include "InputManager.h"
	#include "StatisticsManager.h"
	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#include <stdlib.h>
	#include <time.h>
	#include <stdio.h>
	#include <string.h>

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

	//Variables for recording.
	//To enable picture recording uncomment the next line:
	//#define RECORD_PICUTRE_SEQUENCE
	#ifdef RECORD_PICUTRE_SEQUENCE
	bool recordPictureSequence=false;
	int recordPictureIndex=0;
	#endif
	#ifdef __APPLE__
	int SDL_main(int argc, char** argv) {
	#else
	int main(int argc, char** argv) {
	#endif
	#ifdef _MSC_VER
	//Fix the non-latin file name bug under Visual Studio
	setlocale(LC_ALL,"");
	#endif

	//Relocate the standard output for debug purpose (?)
	#if defined(ANDROID)
	freopen("stdout.txt","w",stdout);
	freopen("stderr.txt","w",stderr);
	#endif
	//First parse the comand line arguments.
	int s=parseArguments(argc,argv);
	if(s==-1){
	printf("Usage: %s [OPTIONS] ...\n",argv[0]);
	printf("%s","Available options:\n");
	printf(" %-5s%-30s %s\n","","--data-dir <dir>","Specifies the data directory.");
	printf(" %-5s%-30s %s\n","","--user-dir <dir>","Specifies the user preferences directory.");
	printf(" %-5s%-30s %s\n","-f,","--fullscreen","Run the game fullscreen.");
	printf(" %-5s%-30s %s\n","-w,","--windowed","Run the game windowed.");
	printf(" %-5s%-30s %s\n","-mv,","--music <volume>","Set the music volume.");
	printf(" %-5s%-30s %s\n","-sv,","--sound <volume>","Set the sound volume.");
	printf(" %-5s%-30s %s\n","-s,","--set <setting> <value>","Change a setting to a given value.");
	printf(" %-5s%-30s %s\n","-v,","--version","Display the version and quit.");
	printf(" %-5s%-30s %s\n","-h,","--help","Display this help message.");
	return 0;
	}else if(s==0){
	return 0;
	}

	//Try to configure the dataPath, userPath, etc...
	if(configurePaths()==false){
	fprintf(stderr,"FATAL ERROR: Failed to configure paths.\n");
	return 1;
	}
	//Load the settings.
	if(loadSettings()==false){
	fprintf(stderr,"ERROR: Unable to load config file, default values will be used.\n");
	}
	+ ScreenData screenData = init();
	//Initialise some stuff like SDL, the window, SDL_Mixer.
	- if(init()==false) {
	+ if(!screenData) {
	fprintf(stderr,"FATAL ERROR: Failed to initialize game.\n");
	return 1;
	}
	+
	+ SDL_Renderer& renderer = *screenData.renderer;
	+ //Initialise the imagemanager.
	+ //The ImageManager is used to prevent loading images multiple times.
	+ ImageManager imageManager;
	+
	//Load some important files like the background music, default theme.
	- if(loadFiles()==false){
	+ if(loadFiles(imageManager,renderer)==false){
	fprintf(stderr,"FATAL ERROR: Failed to load necessary files.\n");
	return 1;
	}

	//Seed random.
	srand((unsigned)time(NULL));

	//Set the currentState id to the main menu and create it.
	stateID=STATE_MENU;
	- currentState=new Menu();
	+ currentState=new Menu(imageManager,renderer);

	//Set the fadeIn value to zero.
	int fadeIn=0;

	//Keep the last resize event, this is to only process one.
	- SDL_Event lastResize={};
	+ SDL_Event lastResize={};
	+ Timer timer;

	//Start the game loop.
	while(stateID!=STATE_EXIT){
	//We start the timer.
	timer.start();

	//Loop the SDL events.
	while(SDL_PollEvent(&event)){
	//Check if user resizes the window.
	- if(event.type==SDL_VIDEORESIZE){
	- lastResize=event;
	+ if(event.type==SDL_WINDOWEVENT){
	+ if(event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
	+ {
	+ lastResize=event;

	- //Don't let other objects process this event (?)
	- continue;
	+ //Don't let other objects process this event (?)
	+ continue;
	+ }
	}

	//Check if the fullscreen toggle shortcut is pressed (Alt+Enter).
	if(event.type==SDL_KEYUP && event.key.keysym.sym==SDLK_RETURN && (event.key.keysym.mod & KMOD_ALT)){
	getSettings()->setValue("fullscreen",getSettings()->getBoolValue("fullscreen")?"0":"1");

	//We need to create a new screen.
	if(!createScreen()){
	//Screen creation failed so set to safe settings.
	getSettings()->setValue("fullscreen","0");
	getSettings()->setValue("width","800");
	getSettings()->setValue("height","600");

	//Try it with the safe settings.
	if(!createScreen()){
	//Everything fails so quit.
	setNextState(STATE_EXIT);
	cerr<<"ERROR: Unable to create screen."<<endl;
	}
	}

	//The screen is created, now load the (menu) theme.
	- if(!loadTheme("")){
	+ if(!loadTheme(imageManager,renderer,"")){
	//Loading the theme failed so quit.
	setNextState(STATE_EXIT);
	cerr<<"ERROR: Unable to load theme after toggling fullscreen."<<endl;
	}

	//Don't let other objects process this event.
	continue;
	}

	#ifdef RECORD_PICUTRE_SEQUENCE
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_F10){
	recordPictureSequence=!recordPictureSequence;
	printf("Record Picture Sequence %s\n",recordPictureSequence?"ON":"OFF");
	}
	#endif
	//Set the cursor type to the default one, the GUI can change that if needed.
	currentCursor=CURSOR_POINTER;

	//Let the input manager handle the events.
	inputMgr.updateState(true);
	//Let the currentState handle the events.
	- currentState->handleEvents();
	+ currentState->handleEvents(imageManager,renderer);
	//Also pass the events to the GUI.
	- GUIObjectHandleEvents();
	+ GUIObjectHandleEvents(imageManager,renderer);
	}

	//Process the resize event.
	- if(lastResize.type==SDL_VIDEORESIZE){
	+ if(lastResize.type==SDL_WINDOWEVENT){
	+ //TODO - used to be SDL_VIDEORESIZE
	+ // so this may trigger on more events than intended
	event=lastResize;
	- onVideoResize();
	+ onVideoResize(imageManager,renderer);

	//After resize we erase the event type
	- lastResize.type=SDL_NOEVENT;
	+ //TODO - used to be SDL_NOEVENT
	+ lastResize.type=SDL_FIRSTEVENT;
	}

	//maybe we should add a check here (??) to fix some bugs (ticket #47)
	if(nextState!=STATE_NULL){
	//Check if fading is enabled.
	if(getSettings()->getBoolValue("fading"))
	fadeIn=17;
	else
	fadeIn=255;
	- changeState();
	+ changeState(imageManager,renderer);
	}
	if(stateID==STATE_EXIT) break;

	//update input state (??)
	inputMgr.updateState(false);
	//Now it's time for the state to do his logic.
	- currentState->logic();
	+ currentState->logic(imageManager,renderer);

	- currentState->render();
	+ currentState->render(imageManager,renderer);
	//TODO: Shouldn't the gamestate take care of rendering the GUI?
	- if(GUIObjectRoot) GUIObjectRoot->render();
	+ if(GUIObjectRoot) GUIObjectRoot->render(renderer);

	//draw new achievements (if any)
	- statsMgr.render();
	+ statsMgr.render(imageManager,renderer);

	//draw fading effect
	- if(fadeIn>0&&fadeIn<255){
	- SDL_BlitSurface(screen,NULL,tempSurface,NULL);
	- SDL_FillRect(screen,NULL,0);
	- SDL_SetAlpha(tempSurface, SDL_SRCALPHA, fadeIn);
	- SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	+ if(fadeIn>0&&fadeIn<255){
	+ dimScreen(renderer, static_cast<Uint8>(255-fadeIn));
	fadeIn+=17;
	}

	#ifdef RECORD_PICUTRE_SEQUENCE
	if(recordPictureSequence){
	char s[64];
	recordPictureIndex++;
	sprintf(s,"pic%08d.bmp",recordPictureIndex);
	printf("Save screen to %s\n",s);
	SDL_SaveBMP(screen,(getUserPath(USER_CACHE)+s).c_str());
	}
	#endif
	//Before flipping the screen set the cursor.
	SDL_SetCursor(cursors[currentCursor]);

	//And draw the screen surface to the actual screen.
	- flipScreen();
	+ flipScreen(renderer);

	//Now calcualte how long we need to wait to keep a constant framerate.
	int t=timer.getTicks();
	- t=(1000/FPS)-t;
	+ t=(1000/FPS)-t;
	if(t>0){
	SDL_Delay(t);
	}
	}

	//The game has ended, save the settings just to be sure.
	if(!saveSettings()){
	fprintf(stderr,"ERROR: Unable to save settings in config file.\n");
	}

	//Clean everything up.
	clean();

	//End of program.
	return 0;
	}
	diff --git a/src/MusicManager.h b/src/MusicManager.h
	index 652b97b..a9272b6 100644
	--- a/src/MusicManager.h
	+++ b/src/MusicManager.h
	@@ -1,155 +1,155 @@
	/*
	* 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 MUSICMANAGER_H
	#define MUSICMANAGER_H

	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#else
	-#include <SDL/SDL_mixer.h>
	+#include <SDL2/SDL_mixer.h>
	#endif
	#include <string>
	#include <map>
	#include <vector>

	//Class for loading and playing the music.
	class MusicManager{
	private:
	//This structure is used to hold music information.
	struct Music{
	//Pointer to the actual music.
	Mix_Music* music;
	//Pointer to the loop music, if any.
	Mix_Music* loop;

	//String containing the name of the music.
	//This is the same name as in the musicCollection.
	std::string name;

	//String containing the track name of the music.
	//This is the name given by the author.
	std::string trackName;
	//String containing the name of the author.
	std::string author;
	//String containing the license the music is released under.
	std::string license;

	//Integer containing the time where to start playing.
	int start;

	//The volume to play the music with.
	//Scale 0-128.
	int volume;

	//Integer containing the loopstart.
	int loopStart;
	//Integer containing the loopend.
	//NOTE: loopend doesn't work and is thus ignored.
	int loopEnd;

	//Integer used to keep track when which music was played.
	int lastTime;
	};
	public:
	//Constructor.
	MusicManager();
	//Destructor.
	~MusicManager();

	//Destroys the music.
	void destroy();

	//Method that will either disable or enable music.
	//enable: Boolean if the musicManager should be enabled or not.
	void setEnabled(bool enable=true);

	//Method that will set the volume of the music.
	//NOTE: The set volume isn't presistent, only use this to update the volume after a change to the music setting.
	//volume: The new volume.
	void setVolume(int volume);

	//This method will load one music file and add it to the collection.
	//file: The filename of the music file.
	//list: The music list the music belongs to.
	//Returns: String containing the loaded music comma sperated, it's empty if it fails.
	std::string loadMusic(const std::string &file,const std::string &list="");

	//This method will load from a music list.
	//file: The filename of the music list file.
	//Returns: True if no error occurs.
	bool loadMusicList(const std::string &file);

	//This method will start playing a music file.
	//name: The name of the song.
	//fade: Boolean if it should fade the current one out or not.
	void playMusic(const std::string &name,bool fade=true);

	//Method for retrieving the current playing track.
	//Returns: the name of the music that is playing.
	std::string getCurrentMusic();

	//This method will pick music from the current music list.
	void pickMusic();

	//Method that will be called when a music stopped.
	void musicStopped();

	//Set the music list.
	//list: The name of the list.
	void setMusicList(const std::string &list);

	//Method for retrieving the current music list.
	//NOTE This returns the set music list, this doesn't mean the playing music IS from this list.
	//Returns: the name of the current music list.
	std::string getCurrentMusicList();

	//Method that will create credits text for the (loaded) music tracks.
	//NOTE: This is only used by the Credits screen.
	//Returns: A vector containing the lines of credits.
	std::vector<std::string> createCredits();
	private:
	//Boolean if the MusicManager is enabled or not.
	//The default value is false meaning that the MusicManager has to be enabled before the music starts.
	bool enabled;

	//Integer that is used to keep track of the last played song.
	int lastTime;

	//Pointer to the music struct that is currently playing.
	Music* playing;

	//String containing the name of the music to play when the previous one stopped.
	//This means that it will be checked in the musicStopped method.
	std::string nextMusic;

	//String containing the name of the current music list.
	std::string currentList;

	//Map containing the music.
	//The key is the name of the music and the value is a pointer to the Mix_Music.
	std::map<std::string,Music*> musicCollection;

	//Map containing the music lists.
	//The key is the name of the list and the value is an array of music names.
	std::map<std::string,std::vector<std::string> > musicLists;
	};

	#endif
	diff --git a/src/Player.cpp b/src/Player.cpp
	index ddd0245..507254a 100644
	--- a/src/Player.cpp
	+++ b/src/Player.cpp
	@@ -1,1653 +1,1653 @@
	/*
	* 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 "Player.h"
	#include "Game.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "InputManager.h"
	#include "StatisticsManager.h"
	#include "MD5.h"
	#include <iostream>
	#include <fstream>
	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_mixer.h>
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_mixer.h>
	+#include <SDL2/SDL_ttf.h>
	#endif
	using namespace std;

	#ifdef RECORD_FILE_DEBUG
	string recordKeyPressLog,recordKeyPressLog_saved;
	vector<SDL_Rect> recordPlayerPosition,recordPlayerPosition_saved;
	#endif

	//static internal array to store time of recent deaths for achievements
	static Uint32 recentDeaths[10]={0};
	static int loadAndDieTimes=0;

	//static internal function to add recent deaths and update achievements
	static inline void addRecentDeaths(Uint32 recentLoad){
	//Get current time in ms.
	//We added it by 5 seconds to avoid bug if you choose a level to play
	//and die in 5 seconds after the game has startup.
	Uint32 t=SDL_GetTicks()+5000;

	for(int i=9;i>0;i--){
	recentDeaths[i]=recentDeaths[i-1];
	}
	recentDeaths[0]=t;

	//Update achievements
	if(recentDeaths[4]+5000>t){
	statsMgr.newAchievement("die5in5");
	}
	if(recentDeaths[9]+5000>t){
	statsMgr.newAchievement("die10in5");
	}
	if(recentLoad+1000>t){
	statsMgr.newAchievement("loadAndDie");
	}
	}

	Player::Player(Game* objParent):xVelBase(0),yVelBase(0),objParent(objParent),recordSaved(false),
	inAirSaved(false),isJumpSaved(false),canMoveSaved(false),holdingOtherSaved(false){
	//Set the dimensions of the player.
	//The size of the player is 21x40.
	box.x=0;
	box.y=0;
	box.w=23;
	box.h=40;

	//Set the dimensions of the other equal to the player's.
	boxOther = box;

	//Set his velocity to zero.
	xVel=0;
	yVel=0;

	//Set the start position.
	fx=0;
	fy=0;

	//Set some default values.
	inAir=true;
	isJump=false;
	shadowCall=false;
	shadow=false;
	canMove=true;
	holdingOther=false;
	dead=false;
	record=false;
	downKeyPressed=false;
	spaceKeyPressed=false;
	onGroundSaved=false;

	recordIndex=-1;
	#ifdef RECORD_FILE_DEBUG
	recordKeyPressLog.clear();
	recordKeyPressLog_saved.clear();
	recordPlayerPosition.clear();
	recordPlayerPosition_saved.clear();
	#endif
	objNotificationBlock=objCurrentStandSave=objLastStandSave=NULL;

	//Some default values for animation variables.
	direction=0;
	jumpTime=0;

	state=stateSaved=0;

	//xVelSaved is used to store if there's a state saved or not.
	xVelSaved=yVelSaved=0x80000000;

	objCurrentStand=objLastStand=objLastTeleport=objShadowBlock=NULL;
	}

	Player::~Player(){
	//Do nothing here
	}

	bool Player::isPlayFromRecord(){
	return recordIndex>=0; // && recordIndex<(int)recordButton.size();
	}

	//get the game record object.
	std::vector<int>* Player::getRecord(){
	return &recordButton;
	}

	#ifdef RECORD_FILE_DEBUG
	string& Player::keyPressLog(){
	return recordKeyPressLog;
	}
	vector<SDL_Rect>& Player::playerPosition(){
	return recordPlayerPosition;
	}
	#endif

	//play the record.
	void Player::playRecord(){
	recordIndex=0;
	}

	void Player::spaceKeyDown(class Shadow* shadow){
	//Start recording or stop, depending on the recording state.
	if(record==false){
	//We start recording.
	if(shadow->called==true){
	//The shadow is still busy so first stop him before we can start recording.
	shadowCall=false;
	shadow->called=false;
	shadow->playerButton.clear();
	}else if(!dead){
	//Check if shadow is dead.
	if(shadow->dead){
	//Show tooltip.
	//Just reset the countdown (the shadow's jumptime).
	shadow->jumpTime=80;

	//Play the error sound.
	getSoundManager()->playSound("error");
	}else{
	//The shadow isn't moving and both player and shadow aren't dead so start recording.
	record=true;

	//We start a recording meaning we need to increase recordings by one.
	objParent->recordings++;

	//Update statistics.
	if(!dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	statsMgr.recordTimes++;

	if(statsMgr.recordTimes==100) statsMgr.newAchievement("record100");
	if(statsMgr.recordTimes==1000) statsMgr.newAchievement("record1k");
	}
	}
	}
	}else{
	//The player is recording so stop recording and call the shadow.
	record=false;
	shadowCall=true;
	}
	}

	void Player::handleInput(class Shadow* shadow){
	//Check if we should read the input from record file.
	//Actually, we read input from record file in
	//another function shadowSetState.
	bool readFromRecord=false;
	if(recordIndex>=0 && recordIndex<(int)recordButton.size()) readFromRecord=true;

	if(!readFromRecord){
	//Reset horizontal velocity.
	xVel=0;
	if(inputMgr.isKeyDown(INPUTMGR_RIGHT)){
	//Walking to the right.
	xVel+=7;
	}
	if(inputMgr.isKeyDown(INPUTMGR_LEFT)){
	//Walking to the left.
	if(xVel!=0 && !dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	//Horizontal confusion achievement :)
	statsMgr.newAchievement("horizontal");
	}
	xVel-=7;
	}

	//Check if the action key has been released.
	if(!inputMgr.isKeyDown(INPUTMGR_ACTION)){
	//It has so downKeyPressed can't be true.
	downKeyPressed=false;
	}
	/*
	//Don't reset spaceKeyPressed or when you press the space key
	//and release another key then the bug occurs. (ticket #44)
	if(event.type==SDL_KEYUP \|\| !inputMgr.isKeyDown(INPUTMGR_SPACE)){
	spaceKeyPressed=false;
	}*/
	}

	//Check if a key is pressed (down).
	if(inputMgr.isKeyDownEvent(INPUTMGR_JUMP) && !readFromRecord){
	//The up key, if we aren't in the air we start jumping.
	//Fixed a potential bug
	if(!inAir && !isJump){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Jump key pressed\n",objParent->time);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	isJump=true;
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_SPACE) && !readFromRecord){
	//Fixed a potential bug
	if(!spaceKeyPressed){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Space key pressed\n",objParent->time);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	spaceKeyDown(shadow);
	spaceKeyPressed=true;
	}
	}else if(inputMgr.isKeyUpEvent(INPUTMGR_SPACE) && !readFromRecord){
	if(record && getSettings()->getBoolValue("quickrecord")){
	spaceKeyDown(shadow);
	spaceKeyPressed=true;
	}
	}else if(record && !readFromRecord && inputMgr.isKeyDownEvent(INPUTMGR_CANCELRECORDING)){
	//Cancel current recording

	//Search the recorded button and clear the last space key press
	int i=recordButton.size()-1;
	for(;i>=0;i--){
	if(recordButton[i] & PlayerButtonSpace){
	recordButton[i] &= ~PlayerButtonSpace;
	break;
	}
	}

	if(i>=0){
	//Clear the recording at the player's side.
	playerButton.clear();
	line.clear();

	//reset the record flag
	record=false;

	//decrese the record count
	objParent->recordings--;
	}else{
	cout<<"Failed to find last recording"<<endl;
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_ACTION)){
	//Downkey is pressed.
	//Fixed a potential bug
	if(!downKeyPressed){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Action key pressed\n",objParent->time);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	downKeyPressed=true;
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_SAVE)){
	//F2 only works in the level editor.
	if(!(dead \|\| shadow->dead) && stateID==STATE_LEVEL_EDITOR){
	//Save the state. (delayed)
	if(objParent)
	objParent->saveStateNextTime=true;
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_LOAD) && !readFromRecord){
	//F3 is used to load the last state.
	if(objParent)
	objParent->loadStateNextTime=true;
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_SWAP)){
	//F4 will swap the player and the shadow, but only in the level editor.
	if(!(dead \|\| shadow->dead) && stateID==STATE_LEVEL_EDITOR){
	swapState(shadow);
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_TELEPORT)){
	//F5 will revive and teleoprt the player to the cursor. Only works in the level editor.
	//Shift+F5 teleports the shadow.
	if(stateID==STATE_LEVEL_EDITOR){
	//get the position of the cursor.
	int x,y;
	SDL_GetMouseState(&x,&y);
	x+=camera.x;
	y+=camera.y;

	if(inputMgr.isKeyDown(INPUTMGR_SHIFT)){
	//teleports the shadow.
	shadow->dead=false;
	shadow->box.x=x;
	shadow->box.y=y;
	}else{
	//teleports the player.
	dead=false;
	box.x=x;
	box.y=y;
	}

	//play sound?
	getSoundManager()->playSound("swap");
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_SUICIDE)){
	//F12 is suicide and only works in the leveleditor.
	if(stateID==STATE_LEVEL_EDITOR){
	die();
	shadow->die();
	}
	}
	}

	void Player::setLocation(int x,int y){
	box.x=x;
	box.y=y;
	}

	void Player::move(vector<Block*> &levelObjects){
	//Only move when the player isn't dead.
	//Fixed the bug that player/shadow can teleport or pull the switch even if died.
	//FIXME: Don't know if there will be any side-effects.
	if(dead) return;

	//Pointer to a checkpoint.
	Block* objCheckPoint=NULL;
	//Pointer to a swap.
	Block* objSwap=NULL;

	//Set the objShadowBlock to NULL.
	//Only for swapping to prevent the shadow from swapping in a shadow block.
	objShadowBlock=NULL;

	//Set the objNotificationBlock to NULL.
	objNotificationBlock=NULL;

	//Store the location.
	int lastX=box.x;
	int lastY=box.y;

	collision(levelObjects);

	bool canTeleport=true;
	bool isTraveling=true;

	//Now check the functional blocks.
	for(unsigned int o=0;o<levelObjects.size();o++){
	//Check for collision.
	if(checkCollision(box,levelObjects[o]->getBox())){
	//Now switch the type.
	switch(levelObjects[o]->type){
	case TYPE_CHECKPOINT:
	{
	//If we're not the shadow set the gameTip to Checkpoint.
	if(!shadow && objParent!=NULL)
	objParent->gameTipIndex=TYPE_CHECKPOINT;

	//And let objCheckPoint point to this object.
	objCheckPoint=levelObjects[o];
	break;
	}
	case TYPE_SWAP:
	{
	//If we're not the shadow set the gameTip to swap.
	if(!shadow && objParent!=NULL)
	objParent->gameTipIndex=TYPE_SWAP;

	//And let objSwap point to this object.
	objSwap=levelObjects[o];
	break;
	}
	case TYPE_EXIT:
	{
	//Make sure we're not in the leveleditor.
	if(stateID==STATE_LEVEL_EDITOR)
	break;

	//Check to see if we have enough keys to finish the level
	if(objParent->currentCollectables>=objParent->totalCollectables){
	//Update achievements
	if(!objParent->player.isPlayFromRecord() && !objParent->interlevel){
	if(objParent->player.dead \|\| objParent->shadow.dead){
	//Finish the level with player or shadow died.
	statsMgr.newAchievement("forget");
	}
	if(objParent->won){
	//Player and shadow come to exit simultaneously.
	statsMgr.newAchievement("jit");
	}
	}

	//We can't just handle the winning here (in the middle of the update cycle)/
	//So set won in Game true.
	objParent->won=true;
	}
	break;
	}
	case TYPE_PORTAL:
	{
	//Check if the teleport id isn't empty.
	if(levelObjects[o]->id.empty()){
	cerr<<"WARNING: Invalid teleport id!"<<endl;
	canTeleport=false;
	}

	//If we're not the shadow set the gameTip to portal.
	if(!shadow && objParent!=NULL)
	objParent->gameTipIndex=TYPE_PORTAL;

	//Check if we can teleport and should (downkey -or- auto).
	if(canTeleport && (downKeyPressed \|\| (levelObjects[o]->queryProperties(GameObjectProperty_Flags,this)&1))){
	canTeleport=false;
	if(downKeyPressed \|\| levelObjects[o]!=objLastTeleport){
	downKeyPressed=false;

	//Loop the levelobjects again to find the destination.
	for(unsigned int oo=o+1;;){
	//We started at our index+1.
	//Meaning that if we reach the end of the vector then we need to start at the beginning.
	if(oo>=levelObjects.size())
	oo-=(int)levelObjects.size();
	//It also means that if we reach the same index we need to stop.
	//If the for loop breaks this way then we have no succes.
	if(oo==o){
	//Couldn't teleport so play the error sound.
	getSoundManager()->playSound("error");
	break;
	}

	//Check if the second (oo) object is a portal.
	if(levelObjects[oo]->type==TYPE_PORTAL){
	//Check the id against the destination of the first portal.
	if(levelObjects[o]->destination==levelObjects[oo]->id){
	//Call the event.
	objParent->broadcastObjectEvent(GameObjectEvent_OnToggle,-1,NULL,levelObjects[o]);
	objLastTeleport=levelObjects[oo];

	//Get the destination location and teleport the player.
	SDL_Rect r=levelObjects[oo]->getBox();
	box.x=r.x+5;
	box.y=r.y+2;

	//We don't count it to traveling distance.
	isTraveling=false;

	//Play the swap sound.
	getSoundManager()->playSound("swap");
	break;
	}
	}

	//Increase oo.
	oo++;
	}
	}
	}
	break;
	}
	case TYPE_SWITCH:
	{
	//If we're not the shadow set the gameTip to switch.
	if(!shadow && objParent!=NULL)
	objParent->gameTipIndex=TYPE_SWITCH;

	//If the down key is pressed then invoke an event.
	if(downKeyPressed){
	//Play the animation.
	levelObjects[o]->playAnimation();

	//Play the toggle sound.
	getSoundManager()->playSound("toggle");

	//Update statistics.
	if(!dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	statsMgr.switchTimes++;

	//Update achievements
	switch(statsMgr.switchTimes){
	case 100:
	statsMgr.newAchievement("switch100");
	break;
	case 1000:
	statsMgr.newAchievement("switch1k");
	break;
	}
	}

	if(objParent!=NULL){
	//Make sure that the id isn't emtpy.
	if(!levelObjects[o]->id.empty()){
	objParent->broadcastObjectEvent(0x10000 \| (levelObjects[o]->queryProperties(GameObjectProperty_Flags,this)&3),
	-1,levelObjects[o]->id.c_str());
	}else{
	cerr<<"WARNING: invalid switch id!"<<endl;
	}
	}
	}
	break;
	}
	case TYPE_SHADOW_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	{
	//This only applies to the player.
	if(!shadow)
	objShadowBlock=levelObjects[o];
	break;
	}
	case TYPE_NOTIFICATION_BLOCK:
	{
	//This only applies to the player.
	if(!shadow)
	objNotificationBlock=levelObjects[o];
	break;
	}
	case TYPE_COLLECTABLE:
	{
	//Check if collectable is active (if it's not it's equal to 1(inactive))
	if(levelObjects[o]->queryProperties(GameObjectProperty_Flags, this)==0) {
	//Toggle an event
	objParent->broadcastObjectEvent(GameObjectEvent_OnToggle,-1,NULL,levelObjects[o]);
	//Increase the current number of collectables
	objParent->currentCollectables++;
	getSoundManager()->playSound("collect");
	//Open exit(s)
	if(objParent->currentCollectables>=objParent->totalCollectables){
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(levelObjects[i]->type==TYPE_EXIT){
	objParent->broadcastObjectEvent(GameObjectEvent_OnSwitchOn,-1,NULL,levelObjects[i]);
	}
	}
	}
	}
	break;
	}
	}

	//Now check for the spike property.
	if(levelObjects[o]->queryProperties(GameObjectProperty_IsSpikes,this)){
	//It is so get the collision box.
	SDL_Rect r=levelObjects[o]->getBox();

	//TODO: pixel-accuracy hit test.
	//For now we shrink the box.
	r.x+=2;
	r.y+=2;
	r.w-=4;
	r.h-=4;

	//Check collision, if the player collides then let him die.
	if(checkCollision(box,r)){
	die();
	}
	}
	}
	}

	//Check if the player can teleport.
	if(canTeleport)
	objLastTeleport=NULL;

	//Check the checkpoint pointer only if the downkey is pressed.
	//new: don't save the game if playing game record
	if(objParent!=NULL && downKeyPressed && objCheckPoint!=NULL && !isPlayFromRecord()){
	//Checkpoint thus save the state.
	if(objParent->canSaveState()){
	objParent->saveStateNextTime=true;
	objParent->objLastCheckPoint=objCheckPoint;
	}
	}
	//Check the swap pointer only if the down key is pressed.
	if(objSwap!=NULL && downKeyPressed && objParent!=NULL){
	//Now check if the shadow we're the shadow or not.
	if(shadow){
	if(!(dead \|\| objParent->player.dead)){
	//Check if the player isn't in front of a shadow block.
	if(!objParent->player.objShadowBlock){
	objParent->player.swapState(this);
	objSwap->playAnimation();
	//We don't count it to traveling distance.
	isTraveling=false;
	//NOTE: Statistics updated in swapState() function.
	}else{
	//We can't swap so play the error sound.
	getSoundManager()->playSound("error");
	}
	}
	}else{
	if(!(dead \|\| objParent->shadow.dead)){
	//Check if the player isn't in front of a shadow block.
	if(!objShadowBlock){
	swapState(&objParent->shadow);
	objSwap->playAnimation();
	//We don't count it to traveling distance.
	isTraveling=false;
	//NOTE: Statistics updated in swapState() function.
	}else{
	//We can't swap so play the error sound.
	getSoundManager()->playSound("error");
	}
	}
	}
	}

	//Determine the correct theme state.
	if(!dead){
	//Set the direction depending on the velocity.
	if(xVel>0)
	direction=0;
	else if(xVel<0)
	direction=1;

	//Check if the player is in the air.
	if(!inAir){
	//On the ground so check the direction and movement.
	if(xVel>0){
	if(appearance.currentStateName!="walkright"){
	appearance.changeState("walkright");
	}
	}else if(xVel<0){
	if(appearance.currentStateName!="walkleft"){
	appearance.changeState("walkleft");
	}
	}else if(xVel==0){
	if(direction==1){
	appearance.changeState("standleft");
	}else{
	appearance.changeState("standright");
	}
	}
	}else{
	//Check for jump appearance (inAir).
	if(direction==1){
	if(yVel>0){
	if(appearance.currentStateName!="fallleft")
	appearance.changeState("fallleft");
	}else{
	if(appearance.currentStateName!="jumpleft")
	appearance.changeState("jumpleft");
	}
	}else{
	if(yVel>0){
	if(appearance.currentStateName!="fallright")
	appearance.changeState("fallright");
	}else{
	if(appearance.currentStateName!="jumpright")
	appearance.changeState("jumpright");
	}
	}
	}
	}


	//Update traveling distance statistics.
	if(isTraveling && (lastX!=box.x \|\| lastY!=box.y) && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	float dx=float(lastX-box.x),dy=float(lastY-box.y);
	float d0=statsMgr.playerTravelingDistance+statsMgr.shadowTravelingDistance,
	d=sqrtf(dxdx+dydy)/50.0f;
	if(shadow) statsMgr.shadowTravelingDistance+=d;
	else statsMgr.playerTravelingDistance+=d;

	//Update achievement
	d+=d0;
	if(d0<=100.0f && d>=100.0f) statsMgr.newAchievement("travel100");
	if(d0<=1000.0f && d>=1000.0f) statsMgr.newAchievement("travel1k");
	if(d0<=10000.0f && d>=10000.0f) statsMgr.newAchievement("travel10k");
	if(d0<=42195.0f && d>=42195.0f) statsMgr.newAchievement("travel42k");
	}

	//Reset the downKeyPressed flag.
	downKeyPressed=false;
	}

	void Player::collision(vector<Block*> &levelObjects){
	//Only move when the player isn't dead.
	if(dead)
	return;

	//First sort out the velocity.
	//Add gravity acceleration to the vertical velocity.
	if(!canMove)
	//FIXME: xVel should be set to zero instead of substracting it from xVelBase.
	//This isn't done since xVel won't be set back every frame but in handleInput.
	xVelBase-=xVel;
	if(isJump)
	jump();
	if(inAir==true){
	yVel+=1;

	//Cap fall speed to 13.
	if(yVel>13)
	yVel=13;
	}
	if(objCurrentStand!=NULL){
	//Now get the velocity and delta of the object the player is standing on.
	SDL_Rect v=objCurrentStand->getBox(BoxType_Velocity);
	SDL_Rect delta=objCurrentStand->getBox(BoxType_Delta);

	switch(objCurrentStand->type){
	//For conveyor belts the velocity is transfered.
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	{
	xVelBase=v.x;
	}
	break;
	//In other cases, such as player on shadow, player on crate. the change in x position must be considered.
	default:
	{
	if(delta.x != 0)
	xVelBase+=delta.x;
	}
	break;
	}
	//NOTE: Only copy the velocity of the block when moving down.
	//Upwards is automatically resolved before the player is moved.
	if(delta.y>0){
	//Fixes the jitters when the player is on a pushable block on a downward moving box.
	box.y+=delta.y;
	yVelBase=v.y;
	}
	else
	yVelBase=0;
	}

	//Set the object the player is currently standing to NULL.
	objCurrentStand=NULL;

	//Store the location of the player.
	int lastX=box.x;
	int lastY=box.y;

	//An array that will hold all the GameObjects that are involved in the collision/movement.
	vector<Block*> objects;
	//All the blocks have moved so if there's collision with the player, the block moved into him.
	for(unsigned int o=0;o<levelObjects.size();o++){
	//Make sure to only check enabled blocks.
	if(!levelObjects[o]->enabled)
	continue;
	//Make sure the object is solid for the player.
	if(!levelObjects[o]->queryProperties(GameObjectProperty_PlayerCanWalkOn,this))
	continue;

	//Check for collision.
	if(checkCollision(box,levelObjects[o]->getBox()))
	objects.push_back(levelObjects[o]);
	}
	//There was collision so try to resolve it.
	if(!objects.empty()){
	//FIXME: When multiple moving blocks are overlapping the player can be "bounced" off depending on the block order.
	for(unsigned int o=0;o<objects.size();o++){
	SDL_Rect r=objects[o]->getBox();
	SDL_Rect delta=objects[o]->getBox(BoxType_Delta);

	//Check on which side of the box the player is.
	if(delta.x!=0){
	if(delta.x>0){
	if((r.x+r.w)-box.x<=delta.x)
	box.x=r.x+r.w;
	}else{
	if((box.x+box.w)-r.x<=-delta.x)
	box.x=r.x-box.w;
	}
	}
	if(delta.y!=0){
	if(delta.y>0){
	if((r.y+r.h)-box.y<=delta.y)
	box.y=r.y+r.h;
	}else{
	if((box.y+box.h)-r.y<=-delta.y)
	box.y=r.y-box.h;
	}
	}
	}

	//Check if the player is squashed.
	for(unsigned int o=0;o<levelObjects.size();o++){
	//Make sure the object is enabled.
	if(!levelObjects[o]->enabled)
	continue;
	//Make sure the object is solid for the player.
	if(!levelObjects[o]->queryProperties(GameObjectProperty_PlayerCanWalkOn,this))
	continue;

	if(checkCollision(box,levelObjects[o]->getBox())){
	//The player is squashed so first move him back.
	box.x=lastX;
	box.y=lastY;

	//Update statistics.
	if(!dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	if(shadow) statsMgr.shadowSquashed++;
	else statsMgr.playerSquashed++;

	switch(statsMgr.playerSquashed+statsMgr.shadowSquashed){
	case 1:
	statsMgr.newAchievement("squash1");
	break;
	case 50:
	statsMgr.newAchievement("squash50");
	break;
	}
	}

	//Now call the die method.
	die();
	return;
	}
	}
	}

	//Reuse the objects array, this time for blocks the player walks into.
	objects.clear();
	//Determine the collision frame.
	SDL_Rect frame={box.x,box.y,box.w,box.h};
	//Keep the horizontal movement of the player in mind.
	if(xVel+xVelBase>=0){
	frame.w+=(xVel+xVelBase);
	}else{
	frame.x+=(xVel+xVelBase);
	frame.w-=(xVel+xVelBase);
	}
	//And the vertical movement.
	if(yVel+yVelBase>=0){
	frame.h+=(yVel+yVelBase);
	}else{
	frame.y+=(yVel+yVelBase);
	frame.h-=(yVel+yVelBase);
	}
	//Loop through the game objects.
	for(unsigned int o=0; o<levelObjects.size(); o++){
	//Make sure the block isn't enabled.
	if(!levelObjects[o]->enabled)
	continue;
	//Check if the player can collide with this game object.
	if(!levelObjects[o]->queryProperties(GameObjectProperty_PlayerCanWalkOn,this))
	continue;

	//Check if the block is inside the frame.
	if(checkCollision(frame,levelObjects[o]->getBox()))
	objects.push_back(levelObjects[o]);
	}
	//Horizontal pass.
	if(xVel+xVelBase!=0){
	box.x+=xVel+xVelBase;
	for(unsigned int o=0;o<objects.size();o++){
	SDL_Rect r=objects[o]->getBox();
	if(!checkCollision(box,r))
	continue;

	//In case of a pushable block we give it velocity.
	if(objects[o]->type==TYPE_PUSHABLE){
	objects[o]->xVel+=(xVel+xVelBase)/2;
	}

	if(xVel+xVelBase>0){
	//We came from the left so the right edge of the player must be less or equal than xVel+xVelBase.
	if((box.x+box.w)-r.x<=xVel+xVelBase)
	box.x=r.x-box.w;
	}else{
	//We came from the left so the right edge of the player must be less or equal than xVel+xVelBase.
	if(box.x-(r.x+r.w)<=-(xVel+xVelBase))
	box.x=r.x+r.w;
	}
	}
	}
	//Some variables that are used in vertical movement.
	Block* lastStand=NULL;
	inAir=true;

	//Vertical pass.
	if(yVel+yVelBase!=0){
	box.y+=yVel+yVelBase;

	//Value containing the previous 'depth' of the collision.
	int prevDepth=0;

	for(unsigned int o=0;o<objects.size();o++){
	SDL_Rect r=objects[o]->getBox();
	if(!checkCollision(box,r))
	continue;

	//Now check how we entered the block (vertically or horizontally).
	if(yVel+yVelBase>0){
	//Calculate the number of pixels the player is in the block (vertically).
	int depth=(box.y+box.h)-r.y;

	//We came from the top so the bottom edge of the player must be less or equal than yVel+yVelBase.
	if(depth<=yVel+yVelBase){
	//NOTE: lastStand is handled later since the player can stand on only one block at the time.

	//Check if there's already a lastStand.
	if(lastStand){
	//Since the player fell he will stand on the highest block, meaning the highest 'depth'.
	if(depth>prevDepth){
	lastStand=objects[o];
	prevDepth=depth;
	}else if(depth==prevDepth){
	//Both blocks are at the same height so determine the block by the amount the player is standing on them.
	SDL_Rect r=objects[o]->getBox();
	int w=0;
	if(box.x+box.w>r.x+r.w)
	w=(r.x+r.w)-box.x;
	else
	w=(box.x+box.w)-r.x;

	//Do the same for the other box.
	r=lastStand->getBox();
	int w2=0;
	if(box.x+box.w>r.x+r.w)
	w2=(r.x+r.w)-box.x;
	else
	w2=(box.x+box.w)-r.x;

	//NOTE: It doesn't matter which block the player is on if they are both stationary.
	SDL_Rect v=objects[o]->getBox(BoxType_Velocity);
	SDL_Rect v2=lastStand->getBox(BoxType_Velocity);

	//Either the have the same (vertical) velocity so most pixel standing on is the lastStand...
	// ... OR one is moving slower down/faster up and that's the one the player is standing on.
	if((v.y==v2.y && w>w2) \|\| v.y<v2.y){
	lastStand=objects[o];
	prevDepth=depth;
	}
	}
	}else{
	//There isn't one so assume the current block for now.
	lastStand=objects[o];
	prevDepth=depth;
	}
	}
	}else{
	//We came from the bottom so the upper edge of the player must be less or equal than yVel+yVelBase.
	if(box.y-(r.y+r.h)<=-(yVel+yVelBase)){
	box.y=r.y+r.h;
	yVel=0;
	}
	}
	}
	}
	if(lastStand){
	inAir=false;
	yVel=1;
	SDL_Rect r=lastStand->getBox();
	box.y=r.y-box.h;
	}

	//Check if the player fell of the level, if so let him die but without animation.
	if(box.y>LEVEL_HEIGHT)
	die(false);

	//Check if the player changed blocks, meaning stepped onto a block.
	objCurrentStand=lastStand;
	if(lastStand!=objLastStand){
	//The player has changed block so call the playerleave event.
	if(objLastStand)
	objParent->broadcastObjectEvent(GameObjectEvent_PlayerLeave,-1,NULL,objLastStand);

	//Set the new lastStand.
	objLastStand=lastStand;
	if(lastStand){
	//Call the walk on event of the laststand.
	objParent->broadcastObjectEvent(GameObjectEvent_PlayerWalkOn,-1,NULL,lastStand);

	//Bugfix for Fragile blocks.
	if(lastStand->type==TYPE_FRAGILE && !lastStand->queryProperties(GameObjectProperty_PlayerCanWalkOn,this)){
	inAir=true;
	isJump=false;
	}
	}
	}
	//NOTE: The PlayerIsOn event must be handled here so that the script can change the location of a block without interfering with the collision detection.
	//Handlingin it here also guarantees that this event will only be called once for one block per update.
	if(objCurrentStand)
	objParent->broadcastObjectEvent(GameObjectEvent_PlayerIsOn,-1,NULL,objCurrentStand);

	//Reset the base velocity.
	xVelBase=yVelBase=0;
	canMove=true;
	}

	void Player::jump(int strength){
	//Check if the player can jump.
	if(inAir==false){
	//Set the jump velocity.
	yVel=-strength;
	inAir=true;
	isJump=false;
	jumpTime++;

	//Update statistics
	if(!objParent->player.isPlayFromRecord() && !objParent->interlevel){
	if(shadow) statsMgr.shadowJumps++;
	else statsMgr.playerJumps++;

	if(statsMgr.playerJumps+statsMgr.shadowJumps==1000) statsMgr.newAchievement("frog");
	}

	//Check if sound is enabled, if so play the jump sound.
	getSoundManager()->playSound("jump");
	}
	}

	-void Player::show(){
	+void Player::show(SDL_Renderer& renderer){
	//Check if we should render the recorded line.
	//Only do this when we're recording and we're not the shadow.
	if(shadow==false && record==true){
	//FIXME: Adding an entry not in update but in render?
	line.push_back(SDL_Rect());
	line[line.size()-1].x=box.x+11;
	line[line.size()-1].y=box.y+20;

	//Loop through the line dots and draw them.
	for(int l=0; l<(signed)line.size(); l++){
	- appearance.drawState("line",screen,line[l].x-camera.x,line[l].y-camera.y);
	+ appearance.drawState("line",renderer,line[l].x-camera.x,line[l].y-camera.y);
	}
	}

	//NOTE: We do logic here, because it's only needed by the appearance.
	appearance.updateAnimation();
	- appearance.draw(screen, box.x-camera.x, box.y-camera.y);
	+ appearance.draw(renderer, box.x-camera.x, box.y-camera.y);
	}

	void Player::shadowSetState(){
	int currentKey=0;

	/*//debug
	extern int block_test_count;
	extern bool block_test_only;
	if(SDL_GetKeyState(NULL)[SDLK_p]){
	block_test_count=recordButton.size();
	}
	if(block_test_count==(int)recordButton.size()){
	block_test_only=true;
	}*/

	//Check if we should read the input from record file.
	if(recordIndex>=0){ // && recordIndex<(int)recordButton.size()){
	//read the input from record file
	if(recordIndex<(int)recordButton.size()){
	currentKey=recordButton[recordIndex];
	recordIndex++;
	}

	//Reset horizontal velocity.
	xVel=0;
	if(currentKey&PlayerButtonRight){
	//Walking to the right.
	xVel+=7;
	}
	if(currentKey&PlayerButtonLeft){
	//Walking to the left.
	xVel-=7;
	}

	if(currentKey&PlayerButtonJump){
	//The up key, if we aren't in the air we start jumping.
	if(inAir==false){
	isJump=true;
	}else{
	//Shouldn't go here
	cout<<"Replay BUG"<<endl;
	}
	}

	//check the down key
	downKeyPressed=(currentKey&PlayerButtonDown)!=0;

	//check the space key
	if(currentKey&PlayerButtonSpace){
	spaceKeyDown(&objParent->shadow);
	}
	}else{
	//read the input from keyboard.
	recordIndex=-1;

	//Check for xvelocity.
	if(xVel>0)
	currentKey\|=PlayerButtonRight;
	if(xVel<0)
	currentKey\|=PlayerButtonLeft;

	//Check for jumping.
	if(isJump){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Jump key recorded\n",objParent->time-1);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	currentKey\|=PlayerButtonJump;
	}

	//Check if the downbutton is pressed.
	if(downKeyPressed){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Action key recorded\n",objParent->time-1);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	currentKey\|=PlayerButtonDown;
	}

	if(spaceKeyPressed){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Space key recorded\n",objParent->time-1);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	currentKey\|=PlayerButtonSpace;
	}

	//Record it.
	recordButton.push_back(currentKey);
	}

	#ifdef RECORD_FILE_DEBUG
	if(recordIndex>=0){
	if(recordIndex>0 && recordIndex<=int(recordPlayerPosition.size())/2){
	SDL_Rect &r1=recordPlayerPosition[recordIndex*2-2];
	SDL_Rect &r2=recordPlayerPosition[recordIndex*2-1];
	if(r1.x!=box.x \|\| r1.y!=box.y \|\| r2.x!=objParent->shadow.box.x \|\| r2.y!=objParent->shadow.box.y){
	char c[192];
	sprintf(c,"Replay ERROR [%05d] %d %d %d %d Expected: %d %d %d %d\n",
	objParent->time-1,box.x,box.y,objParent->shadow.box.x,objParent->shadow.box.y,r1.x,r1.y,r2.x,r2.y);
	cout<<c;
	}
	}
	}else{
	recordPlayerPosition.push_back(box);
	recordPlayerPosition.push_back(objParent->shadow.box);
	}
	#endif

	//reset spaceKeyPressed.
	spaceKeyPressed=false;

	//Only add an entry if the player is recording.
	if(record){
	//Add the action.
	if(!dead && !objParent->shadow.dead){
	playerButton.push_back(currentKey);

	//Change the state.
	state++;
	}else{
	//Either player or shadow is dead, stop recording.
	playerButton.clear();
	state=0;
	record=false;
	}
	}
	}

	void Player::shadowGiveState(Shadow* shadow){
	//Check if the player calls the shadow.
	if(shadowCall==true){
	//Clear any recording still with the shadow.
	shadow->playerButton.clear();

	//Loop the recorded moves and add them to the one of the shadow.
	for(unsigned int s=0;s<playerButton.size();s++){
	shadow->playerButton.push_back(playerButton[s]);
	}

	//Reset the state of both the player and the shadow.
	stateReset();
	shadow->stateReset();

	//Clear the recording at the player's side.
	playerButton.clear();
	line.clear();

	//Set shadowCall false
	shadowCall=false;
	//And let the shadow know that the player called him.
	shadow->meCall();
	}
	}

	void Player::stateReset(){
	//Reset the state by setting it to 0.
	state=0;
	}

	void Player::otherCheck(class Player* other){
	//Now check if the player is on the shadow.
	//First make sure they are both alive.
	if(!dead && !other->dead){
	//Get the box of the shadow.
	SDL_Rect boxShadow=other->getBox();

	//Check if the player is on top of the shadow.
	if(checkCollision(box,boxShadow)==true){
	//We have collision now check if the other is standing on top of you.
	if(box.y+box.h<=boxShadow.y+13 && !other->inAir){
	//Player is on shadow.
	int yVelocity=yVel-1;
	if(yVelocity>0){
	box.y-=yVel;
	box.y+=boxShadow.y-(box.y+box.h);
	inAir=false;
	canMove=false;
	//Reset the vertical velocity.
	yVel=2;
	other->holdingOther=true;
	other->appearance.changeState("holding");

	//Change our own appearance to standing.
	if(direction==1){
	appearance.changeState("standleft");
	}else{
	appearance.changeState("standright");
	}

	//Set the velocity things.
	objCurrentStand=NULL;
	if(other->objCurrentStand){
	SDL_Rect v=other->objCurrentStand->getBox(BoxType_Velocity);
	SDL_Rect delta=other->objCurrentStand->getBox(BoxType_Delta);

	//If the shadow has moved, then change the movement of the player.
	if(boxOther.x != boxShadow.x){
	switch(other->objCurrentStand->type){
	//For conveyor belts the velocity is transfered.
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	{
	xVelBase=v.x;
	}
	break;
	//In other cases, such as player on shadow, player on crate. the change in x position must be considered.
	default:
	{
	if(delta.x != 0)
	xVelBase+=delta.x;
	}
	break;
	}
	}
	yVelBase=v.y;
	}
	}
	}else if(boxShadow.y+boxShadow.h<=box.y+13 && !inAir){
	//Shadow is on player.
	int yVelocity=other->yVel-1;
	if(yVelocity>0){
	other->box.y-=other->yVel;
	other->box.y+=box.y-(other->box.y+other->box.h);
	other->inAir=false;
	other->canMove=false;
	//Reset the vertical velocity of the other.
	other->yVel=2;
	holdingOther=true;
	appearance.changeState("holding");

	//Change our own appearance to standing.
	if(other->direction==1){
	other->appearance.changeState("standleft");
	}else{
	other->appearance.changeState("standright");
	}

	//Set the velocity things.
	other->objCurrentStand=NULL;
	if(objCurrentStand){
	SDL_Rect v=objCurrentStand->getBox(BoxType_Velocity);
	SDL_Rect delta=objCurrentStand->getBox(BoxType_Delta);

	//If the player has moved, then change the movement of the shadow.
	if(other->boxOther.x != box.x){
	switch(objCurrentStand->type){
	//For conveyor belts the velocity is transfered.
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	{
	other->xVelBase=v.x;
	}
	break;
	//In other cases, such as player on shadow, player on crate. the change in x position must be considered.
	default:
	{
	if(delta.x != 0)
	other->xVelBase+=delta.x;
	}
	break;
	}
	}
	other->yVelBase=v.y;
	}
	}
	}
	}else{
	holdingOther=false;
	other->holdingOther=false;
	}
	boxOther=boxShadow;
	other->boxOther=box;
	}
	}

	SDL_Rect Player::getBox(){
	return box;
	}

	void Player::setMyCamera(){
	//Only change the camera when the player isn't dead.
	if(dead)
	return;

	//Check if the level fit's horizontally inside the camera.
	if(camera.w>LEVEL_WIDTH){
	camera.x=-(camera.w-LEVEL_WIDTH)/2;
	}else{
	//Check if the player is halfway pass the halfright of the screen.
	if(box.x>camera.x+(SCREEN_WIDTH/2+50)){
	//It is so ease the camera to the right.
	camera.x+=(box.x-camera.x-(SCREEN_WIDTH/2))>>4;

	//Check if the camera isn't going too far.
	if(box.x<camera.x+(SCREEN_WIDTH/2+50)){
	camera.x=box.x-(SCREEN_WIDTH/2+50);
	}
	}

	//Check if the player is halfway pass the halfleft of the screen.
	if(box.x<camera.x+(SCREEN_WIDTH/2-50)){
	//It is so ease the camera to the left.
	camera.x+=(box.x-camera.x-(SCREEN_WIDTH/2))>>4;

	//Check if the camera isn't going too far.
	if(box.x>camera.x+(SCREEN_WIDTH/2-50)){
	camera.x=box.x-(SCREEN_WIDTH/2-50);
	}
	}

	//If the camera is too far to the left we set it to 0.
	if(camera.x<0){
	camera.x=0;
	}
	//If the camera is too far to the right we set it to the max right.
	if(camera.x+camera.w>LEVEL_WIDTH){
	camera.x=LEVEL_WIDTH-camera.w;
	}
	}

	//Check if the level fit's vertically inside the camera.
	if(camera.h>LEVEL_HEIGHT){
	//We don't centre vertical because the bottom line of the level (deadly) will be mid air.
	camera.y=-(camera.h-LEVEL_HEIGHT);
	}else{
	//Check if the player is halfway pass the lower half of the screen.
	if(box.y>camera.y+(SCREEN_HEIGHT/2+50)){
	//If is so ease the camera down.
	camera.y+=(box.y-camera.y-(SCREEN_HEIGHT/2))>>4;

	//Check if the camera isn't going too far.
	if(box.y<camera.y+(SCREEN_HEIGHT/2+50)){
	camera.y=box.y-(SCREEN_HEIGHT/2+50);
	}
	}

	//Check if the player is halfway pass the upper half of the screen.
	if(box.y<camera.y+(SCREEN_HEIGHT/2-50)){
	//It is so ease the camera up.
	camera.y+=(box.y-camera.y-(SCREEN_HEIGHT/2))>>4;

	//Check if the camera isn't going too far.
	if(box.y>camera.y+(SCREEN_HEIGHT/2-50)){
	camera.y=box.y-(SCREEN_HEIGHT/2-50);
	}
	}

	//If the camera is too far up we set it to 0.
	if(camera.y<0){
	camera.y=0;
	}
	//If the camera is too far down we set it to the max down.
	if(camera.y+camera.h>LEVEL_HEIGHT){
	camera.y=LEVEL_HEIGHT-camera.h;
	}
	}
	}

	void Player::reset(bool save){
	//Set the location of the player to it's initial state.
	box.x=fx;
	box.y=fy;

	//Reset back to default value.
	inAir=true;
	isJump=false;
	shadowCall=false;
	canMove=true;
	holdingOther=false;
	dead=false;
	record=false;
	downKeyPressed=false;
	spaceKeyPressed=false;

	//Some animation variables.
	appearance.resetAnimation(save);
	appearance.changeState("standright");
	direction=0;

	state=0;
	xVel=0; //??? fixed a strange bug in game replay
	yVel=0;

	//Reset the gameObject pointers.
	objCurrentStand=objLastStand=objLastTeleport=objNotificationBlock=objShadowBlock=NULL;
	if(save)
	objCurrentStandSave=objLastStandSave=NULL;

	//Clear the recording.
	line.clear();
	playerButton.clear();
	recordButton.clear();
	recordIndex=-1;
	#ifdef RECORD_FILE_DEBUG
	recordKeyPressLog.clear();
	recordPlayerPosition.clear();
	#endif

	if(save){
	//xVelSaved is used to indicate if there's a state saved or not.
	xVelSaved=0x80000000;

	loadAndDieTimes=0;
	}
	}

	void Player::saveState(){
	//We can only save the state when the player isn't dead.
	if(!dead){
	boxSaved.x=box.x;
	boxSaved.y=box.y;
	xVelSaved=xVel;
	yVelSaved=yVel;
	inAirSaved=inAir;
	isJumpSaved=isJump;
	canMoveSaved=canMove;
	holdingOtherSaved=holdingOther;
	stateSaved=state;

	//Let the appearance save.
	appearance.saveAnimation();

	//Save the lastStand and currentStand pointers.
	objCurrentStandSave=objCurrentStand;
	objLastStandSave=objLastStand;

	//Save any recording stuff.
	recordSaved=record;
	playerButtonSaved=playerButton;
	lineSaved=line;

	//Save the record
	savedRecordButton=recordButton;
	#ifdef RECORD_FILE_DEBUG
	recordKeyPressLog_saved=recordKeyPressLog;
	recordPlayerPosition_saved=recordPlayerPosition;
	#endif

	//To prevent playing the sound twice, only the player can cause the sound.
	if(!shadow)
	getSoundManager()->playSound("checkpoint");

	//We saved a new state so reset the counter
	loadAndDieTimes=0;
	}
	}

	void Player::loadState(){
	//Check with xVelSaved if there's a saved state.
	if(xVelSaved==int(0x80000000)){
	//There isn't so reset the game to load the first initial state.
	//NOTE: There's no need in removing the saved state since there is none.
	reset(false);
	return;
	}

	//Restore the saved values.
	box.x=boxSaved.x;
	box.y=boxSaved.y;
	//xVel is set to 0 since it's saved counterpart is used to indicate a saved state.
	xVel=0;
	yVel=yVelSaved;

	//Restore the saved values.
	inAir=inAirSaved;
	isJump=isJumpSaved;
	canMove=canMoveSaved;
	holdingOther=holdingOtherSaved;
	dead=false;
	record=false;
	shadowCall=false;
	state=stateSaved;

	objCurrentStand=objCurrentStandSave;
	objLastStand=objLastStandSave;

	//Restore the appearance.
	appearance.loadAnimation();

	//Restore any recorded stuff.
	record=recordSaved;
	playerButton=playerButtonSaved;
	line=lineSaved;

	//Load the previously saved record
	recordButton=savedRecordButton;
	#ifdef RECORD_FILE_DEBUG
	recordKeyPressLog=recordKeyPressLog_saved;
	recordPlayerPosition=recordPlayerPosition_saved;
	#endif
	}

	void Player::swapState(Player* other){
	//We need to swap the values of the player with the ones of the given player.
	swap(box.x,other->box.x);
	swap(box.y,other->box.y);
	//NOTE: xVel isn't there since it's used for something else.
	swap(yVel,other->yVel);
	swap(inAir,other->inAir);
	swap(isJump,other->isJump);
	swap(canMove,other->canMove);
	swap(holdingOther,other->holdingOther);
	swap(dead,other->dead);

	//Also reset the state of the other.
	other->stateReset();

	//Play the swap sound.
	getSoundManager()->playSound("swap");

	//Update statistics.
	if(!dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	if(objParent->time < objParent->recentSwap + FPS){
	//Swap player and shadow twice in 1 senond.
	statsMgr.newAchievement("quickswap");
	}
	objParent->recentSwap=objParent->time;

	statsMgr.swapTimes++;

	//Update achievements
	switch(statsMgr.swapTimes){
	case 100:
	statsMgr.newAchievement("swap100");
	break;
	case 1000:
	statsMgr.newAchievement("swap1k");
	break;
	}
	}
	}

	bool Player::canSaveState(){
	//We can only save the state if the player isn't dead.
	return !dead;
	}

	bool Player::canLoadState(){
	//We use xVelSaved to indicate if a state is saved or not.
	return xVelSaved != int(0x80000000);
	}

	void Player::die(bool animation){
	//Make sure the player isn't already dead.
	if(!dead){
	dead=true;

	//If sound is enabled run the hit sound.
	getSoundManager()->playSound("hit");

	//Change the apearance to die (if animation is true).
	if(animation){
	if(direction==1){
	appearance.changeState("dieleft");
	}else{
	appearance.changeState("dieright");
	}
	}

	//Update statistics
	if(!objParent->player.isPlayFromRecord() && !objParent->interlevel){
	addRecentDeaths(objParent->recentLoad);

	if(shadow) statsMgr.shadowDies++;
	else statsMgr.playerDies++;

	switch(statsMgr.playerDies+statsMgr.shadowDies){
	case 1:
	statsMgr.newAchievement("die1");
	break;
	case 50:
	statsMgr.newAchievement("die50");
	break;
	case 1000:
	statsMgr.newAchievement("die1000");
	break;
	}

	if(canLoadState() && (++loadAndDieTimes)==100){
	statsMgr.newAchievement("loadAndDie100");
	}

	if(objParent->player.dead && objParent->shadow.dead) statsMgr.newAchievement("doubleKill");
	}
	}

	//We set the jumpTime to 80 when this is the shadow.
	//That's the countdown for the "Your shadow has died." message.
	if(shadow){
	jumpTime=80;
	}
	}
	diff --git a/src/Player.h b/src/Player.h
	index ef44093..632372d 100644
	--- a/src/Player.h
	+++ b/src/Player.h
	@@ -1,270 +1,270 @@
	/*
	* 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 PLAYER_H
	#define PLAYER_H

	#include "ThemeManager.h"
	#include <vector>
	#include <string>
	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	-#include <SDL/SDL_mixer.h>
	-#include <SDL/SDL_ttf.h>
	+#include <SDL2/SDL_mixer.h>
	+#include <SDL2/SDL_ttf.h>
	#endif

	//Debug the game record file.
	//#define RECORD_FILE_DEBUG

	class Block;
	class Game;

	//The different player buttons.
	//The right arrow.
	const int PlayerButtonRight=0x01;
	//The left arrow.
	const int PlayerButtonLeft=0x02;
	//The up arrow for jumping.
	const int PlayerButtonJump=0x04;
	//The down arrow for actions.
	const int PlayerButtonDown=0x08;
	//space bar for recording. (Only in recordButton)
	const int PlayerButtonSpace=0x10;

	class Player{
	protected:
	//Vector used to store the player actions in when recording.
	//These can be given to the shadow so he can execute them.
	std::vector<int> playerButton;
	//Vector used to store the playerButton vector when saving the player's state (checkpoint).
	std::vector<int> playerButtonSaved;

	private:
	//Vector used to record the whole game play.
	//And saved record in checkpoint.
	std::vector<int> recordButton,savedRecordButton;

	//record index. -1 means read input from keyboard,
	//otherwise read input from recordings (recordButton[recordIndex]).
	int recordIndex;

	//Vector containing squares along the path the player takes when recording.
	//It will be drawn as a trail of squares.
	std::vector<SDL_Rect> line;
	//Vector that will hold the line vector when saving the player's state (checkpoint).
	std::vector<SDL_Rect> lineSaved;

	//Boolean if the player called the shadow to copy his moves.
	bool shadowCall;
	//Boolean if the player is recording his moves.
	bool record,recordSaved;

	//The following variables are to store a state.
	//Rectangle containing the players location.
	SDL_Rect boxSaved;
	//Boolean if the player is in the air.
	bool inAirSaved;
	//Boolean if the player is (going to) jump(ing).
	bool isJumpSaved;
	//Boolean if the player is (still) on the ground.
	bool onGroundSaved;
	//Boolean if the player can move.
	bool canMoveSaved;
	//Boolean if the player is holding the other (shadow).
	bool holdingOtherSaved;
	//The x velocity.
	//NOTE: The x velocity is used to indicate that there's a state saved.
	int xVelSaved;
	//The y velocity.
	int yVelSaved;
	//The state.
	int stateSaved;

	protected:
	//Rectangle containing the player's location.
	SDL_Rect box;
	//Rectangle containing the other's last location.
	SDL_Rect boxOther;

	//The x and y velocity.
	int xVel, yVel;
	//The base x and y velocity, used for standing on moving blocks.
	int xVelBase, yVelBase;

	//Boolean if the player is in the air.
	bool inAir;
	//Boolean if the player is (going to) jump(ing).
	bool isJump;
	//Boolean if the player can move.
	bool canMove;
	//Boolean if the player is alive/
	bool dead;

	//The direction the player is walking, 0=right, 1=left.
	int direction;
	//Integer containing the state of the player.
	int state;
	//The time the player is in the air (jumping).
	int jumpTime;
	//Boolean if the player is in fact the shadow.
	bool shadow;

	//Pointer to the Game state.
	friend class Game;
	Game* objParent;

	//Boolean if the downkey is pressed.
	bool downKeyPressed;
	//Boolean if the space keu is pressed.
	bool spaceKeyPressed;
	//Pointer to the object that is currently been stand on by the player.
	//This is always a valid pointer.
	Block* objCurrentStand;
	//Pointer to the object the player stood last on.
	//NOTE: This is a weak reference only.
	Block* objLastStand;
	//Pointer to the teleporter the player last took.
	//NOTE: This is a weak reference only.
	Block* objLastTeleport;
	//Pointer to the notification block the player is in front of.
	//This is always a valid pointer.
	Block* objNotificationBlock;
	//Pointer to the shadow block the player is in front of.
	//This is always a valid pointer.
	Block* objShadowBlock;

	//The save variable for the GameObject pointers.
	//FIXME: Also save the other game object pointers?
	Block* objCurrentStandSave;
	Block* objLastStandSave;

	public:

	//X and y location where the player starts and gets when reseted.
	int fx, fy;
	//The appearance of the player.
	ThemeBlockInstance appearance;
	//Boolean if the player is holding the other.
	bool holdingOther;

	//Constructor.
	//objParent: Pointer to the Game state.
	Player(Game* objParent);
	//Destructor.
	~Player();

	//Method used to set the position of the player.
	//x: The new x location of the player.
	//y: The new y location of the player.
	void setLocation(int x,int y);

	//Method used to handle (key) input.
	//shadow: Pointer to the shadow used for recording/calling.
	void handleInput(class Shadow* shadow);
	//Method used to do the movement of the player.
	//levelObjects: Array containing the levelObjects, used to check collision.
	void move(std::vector<Block*> &levelObjects);
	//Method used to check if the player can jump and executes the jump.
	//strength: The strength of the jump.
	void jump(int strength=13);

	//This method will render the player to the screen.
	- void show();
	+ void show(SDL_Renderer &renderer);
	//Method that stores the actions if the player is recording.
	void shadowSetState();

	//Method that will reset the state to 0.
	virtual void stateReset();

	//This method checks the player against the other to see if they stand on eachother.
	//other: The shadow or the player.
	void otherCheck(class Player* other);

	//Method that will ease the camera so that the player is in the center.
	void setMyCamera();
	//This method will reset the player to it's initial position.
	//save: Boolean if the saved state should also be deleted.
	void reset(bool save);
	//Method used to retrieve the current location of the player.
	//Returns: SDL_Rect containing the player's location.
	SDL_Rect getBox();

	//This method will
	void shadowGiveState(class Shadow* shadow);

	//Method that will save the current state.
	//NOTE: The special <name>Saved variables will be used.
	virtual void saveState();
	//Method that will retrieve the last saved state.
	//If there is none it will reset the player.
	virtual void loadState();
	//Method that checks if the player can save the state.
	//Returns: True if the player can save his state.
	virtual bool canSaveState();
	//Method that checks if the player can load a state.
	//Returns: True if the player can load a state.
	virtual bool canLoadState();
	//Method that will swap the state of the player with the other.
	//other: The player or the shadow.
	void swapState(Player* other);

	//Check if this player is in fact the shadow.
	//Returns: True if this is the shadow.
	inline bool isShadow(){
	return shadow;
	}

	//Method for returning the objCurrentStand pointer.
	//Returns: Pointer to the gameobject the player is standing on.
	inline Block* getObjCurrentStand(){
	return objCurrentStand;
	}

	//Let the player die when he falls of or hits spikes.
	//animation: Boolean if the death animation should be played, default is true.
	void die(bool animation=true);

	//Check if currently it's play from record file.
	bool isPlayFromRecord();

	//get the game record object.
	std::vector<int>* getRecord();

	#ifdef RECORD_FILE_DEBUG
	std::string& keyPressLog();
	std::vector<SDL_Rect>& playerPosition();
	#endif

	//play the record.
	void playRecord();

	private:
	//The space key is down. call this function from handleInput and another function.
	void spaceKeyDown(class Shadow* shadow);

	//Method that will handle the actual movement.
	//levelObjects: Array containing the levelObjects, used to check collision.
	void collision(std::vector<Block*> &levelObjects);

	};

	#endif
	diff --git a/src/Render.cpp b/src/Render.cpp
	new file mode 100644
	index 0000000..c7cc1d2
	--- /dev/null
	+++ b/src/Render.cpp
	@@ -0,0 +1,56 @@
	+#include <SDL2/SDL_render.h>
	+#include <SDL2/SDL_ttf.h>
	+
	+#include <iostream>
	+
	+#include "Globals.h"
	+#include "Render.h"
	+
	+TexturePtr checkAndConvert(SDL_Renderer& renderer, SurfacePtr surface, const char* text) {
	+ if (!surface) {
	+ std::cerr << "Fatal error! Failed to render text \"" << text << "\" to texture! Error:"
	+ << TTF_GetError()
	+ << std::endl;
	+ std::terminate();
	+ }
	+ TexturePtr ret = TexturePtr(SDL_CreateTextureFromSurface(&renderer, surface.get()));
	+ if (!ret.get()) {
	+ std::cerr << "Fatal error! Failed to create texture from surface! (" << text << "):"
	+ << SDL_GetError()
	+ << std::endl;
	+ std::terminate();
	+ }
	+ return ret;
	+}
	+
	+TexturePtr textureFromText(SDL_Renderer &renderer,TTF_Font& font,const char *text,SDL_Color color) {
	+ if (!text \|\| !*text) {
	+ return nullptr;
	+ }
	+
	+ return checkAndConvert(renderer,SurfacePtr(TTF_RenderUTF8_Blended(&font, text, color)),text);
	+}
	+
	+TexturePtr textureFromTextShaded(SDL_Renderer &renderer,TTF_Font &font,const char *text,SDL_Color fg,SDL_Color bg) {
	+ if (!text \|\| !*text) {
	+ return nullptr;
	+ }
	+
	+ return checkAndConvert(renderer,SurfacePtr(TTF_RenderUTF8_Shaded(&font, text, fg,bg)),text);
	+}
	+
	+void applyTexture(int x, int y, SDL_Texture &texture, SDL_Renderer & renderer, const SDL_Rect *clip) {
	+ //Get width/height from the texture.
	+ const SDL_Rect dstRect = rectFromTexture(x, y, texture);
	+ SDL_RenderCopy(&renderer, &texture, clip, &dstRect);
	+}
	+
	+SurfacePtr createSurface(int width, int height) {
	+ return SurfacePtr(SDL_CreateRGBSurface(0, width, height, SCREEN_BPP, RMASK, GMASK, BMASK, AMASK));
	+}
	+
	+void drawTitleTexture(int screenWidth, SDL_Texture &texture, SDL_Renderer &renderer) {
	+ SDL_Rect dstRect = rectFromTexture(0,40-TITLE_FONT_RAISE, texture);
	+ dstRect.x = (screenWidth - dstRect.w) / 2;
	+ SDL_RenderCopy(&renderer, &texture, NULL, &dstRect);
	+}
	diff --git a/src/Render.h b/src/Render.h
	new file mode 100644
	index 0000000..f736568
	--- /dev/null
	+++ b/src/Render.h
	@@ -0,0 +1,129 @@
	+#ifndef RENDER_H
	+#define RENDER_H
	+
	+#include <memory>
	+
	+#include <SDL2/SDL_pixels.h>
	+#include <SDL2/SDL_ttf.h>
	+
	+#include "ImageManager.h"
	+
	+struct SDL_Texture;
	+struct SDL_Renderer;
	+
	+// Deleter functor for textures.
	+struct TextureDeleter {
	+ void operator()(SDL_Texture* t) {
	+ SDL_DestroyTexture(t);
	+ }
	+};
	+
	+struct SurfaceDeleter {
	+ void operator()(SDL_Surface* s) {
	+ SDL_FreeSurface(s);
	+ }
	+};
	+
	+using TexturePtr = std::unique_ptr<SDL_Texture, TextureDeleter>;
	+using SurfacePtr = std::unique_ptr<SDL_Surface, SurfaceDeleter>;
	+
	+//Create a texture from text.
	+//renderer: The SDL_Renderer instance.
	+//font: The wanted font.
	+//text: The text that should be rendered to the texture.
	+//color: The color the text should be rendered with.
	+TexturePtr textureFromText(SDL_Renderer& renderer, TTF_Font& font,const char* text,SDL_Color color);
	+inline SharedTexture textureFromTextShared(SDL_Renderer& renderer,TTF_Font& font,const char* text,SDL_Color color) {
	+ return SharedTexture(textureFromText(renderer, font, text, color));
	+}
	+
	+TexturePtr textureFromTextShaded(SDL_Renderer& renderer, TTF_Font& font, const char* text, SDL_Color fg,SDL_Color bg);
	+
	+inline SharedTexture textureFromSurface(SDL_Renderer& renderer, SurfacePtr surface) {
	+ return SharedTexture(SDL_CreateTextureFromSurface(&renderer,surface.get()), SDL_DestroyTexture);
	+}
	+
	+inline TexturePtr textureUniqueFromSurface(SDL_Renderer& renderer, SurfacePtr surface) {
	+ return TexturePtr(SDL_CreateTextureFromSurface(&renderer,surface.get()));
	+}
	+
	+SurfacePtr createSurface(int width, int height);
	+
	+//Convenience function to render a texture at default size to a renderer.
	+//x: The x location to draw the source on the desination.
	+//y: The y location to draw the source on the desination.
	+//renderer: The SDL_Renderer to render on.
	+//texture: The SDL_Texture to render.
	+//clip: Rectangle which part of the source should be drawn. (NULL for the whole source.
	+void applyTexture(int x,int y,SDL_Texture& texture, SDL_Renderer& renderer, const SDL_Rect* clip = NULL);
	+inline void applyTexture(int x,int y,TexturePtr& texture, SDL_Renderer& renderer, const SDL_Rect* clip = NULL) {
	+ applyTexture(x, y, *texture, renderer, clip);
	+}
	+inline void applyTexture(int x,int y,SharedTexture& texture, SDL_Renderer& renderer, const SDL_Rect* clip = NULL) {
	+ applyTexture(x, y, *texture, renderer, clip);
	+}
	+
	+//Draw the texture in the top middle, used for titles.
	+void drawTitleTexture(int screenWidth, SDL_Texture& texture, SDL_Renderer& renderer);
	+
	+//Convenience function to create a SDL_Rect with w/h equal to that of the provided texture.
	+inline SDL_Rect rectFromTexture(int x, int y, SDL_Texture& texture) {
	+ SDL_Rect r{x, y, 0, 0};
	+ SDL_QueryTexture(&texture, NULL, NULL, &r.w, &r.h);
	+ return r;
	+}
	+
	+inline SDL_Rect rectFromTexture(SDL_Texture& texture) {
	+ return rectFromTexture(0, 0, texture);
	+}
	+
	+template<typename T>
	+inline SDL_Rect rectFromTexture(int x, int y, T& texture) {
	+ SDL_Rect r{x, y, 0, 0};
	+ SDL_QueryTexture(texture.get(), NULL, NULL, &r.w, &r.h);
	+ return r;
	+}
	+
	+template<typename T>
	+inline SDL_Rect rectFromTexture(T& texture) {
	+ return rectFromTexture(0, 0, texture);
	+}
	+
	+inline int textureWidth(SDL_Texture& texture) {
	+ return rectFromTexture(texture).w;
	+}
	+
	+inline int textureHeight(SDL_Texture& texture) {
	+ return rectFromTexture(texture).h;
	+}
	+
	+template<typename T>
	+inline int textureHeight(T& texture) {
	+ if (texture) {
	+ return rectFromTexture(*texture.get()).h;
	+ } else {
	+ return 0;
	+ }
	+}
	+
	+template<typename T>
	+inline int textureWidth(T& texture) {
	+ if (texture) {
	+ return rectFromTexture(*texture.get()).w;
	+ } else {
	+ return 0;
	+ }
	+}
	+
	+template <class Func>
	+void withTexture(SDL_Texture& tex, Func f) {
	+ const SDL_Rect size = rectFromTexture(tex);
	+ f(size);
	+}
	+
	+inline void dimScreen(SDL_Renderer& renderer, Uint8 alpha=127) {
	+ SDL_SetRenderDrawColor(&renderer, 0,0,0,alpha);
	+ SDL_RenderFillRect(&renderer, NULL);
	+}
	+
	+#endif // RENDER_H
	diff --git a/src/Scenery.cpp b/src/Scenery.cpp
	index 83000ee..70bc6bc 100644
	--- a/src/Scenery.cpp
	+++ b/src/Scenery.cpp
	@@ -1,188 +1,188 @@
	/*
	* Copyright (C) 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 "GameObjects.h"
	#include "Game.h"
	#include "Scenery.h"
	#include "Functions.h"
	#include <iostream>
	#include <stdlib.h>
	#include <stdio.h>
	using namespace std;

	Scenery::Scenery(Game* parent):
	GameObject(parent),
	xSave(0),
	ySave(0),
	dx(0),
	dy(0)
	{}

	Scenery::~Scenery(){
	//Destroy the themeBlock since it isn't needed anymore.
	themeBlock.destroy();
	}

	-void Scenery::show(){
	+void Scenery::show(SDL_Renderer& renderer){
	//Check if the scenery is visible.
	if(checkCollision(camera,box)==true \|\| (stateID==STATE_LEVEL_EDITOR && checkCollision(camera,boxBase)==true)){
	//Now draw normal.
	- appearance.draw(screen, box.x - camera.x, box.y - camera.y);
	+ appearance.draw(renderer, box.x - camera.x, box.y - camera.y);
	}
	}

	SDL_Rect Scenery::getBox(int boxType){
	SDL_Rect r={0,0,0,0};
	switch(boxType){
	case BoxType_Base:
	return boxBase;
	case BoxType_Previous:
	r.x=box.x-dx;
	r.y=box.y-dy;
	r.w=box.w;
	r.h=box.h;
	return r;
	case BoxType_Delta:
	r.x=dx;
	r.y=dy;
	return r;
	case BoxType_Velocity:
	return r;
	case BoxType_Current:
	return box;
	}
	return r;
	}

	void Scenery::setLocation(int x,int y){
	//The scenery has moved so calculate the delta.
	dx=x-box.x;
	dy=y-box.y;

	//And set its new location.
	box.x=x;
	box.y=y;
	}

	void Scenery::saveState(){
	//Store the location.
	xSave=box.x-boxBase.x;
	ySave=box.y-boxBase.y;

	//And any animations.
	appearance.saveAnimation();
	}

	void Scenery::loadState(){
	//Restore the location.
	box.x=boxBase.x+xSave;
	box.y=boxBase.y+ySave;

	//And load the animation.
	appearance.loadAnimation();
	}

	void Scenery::reset(bool save){
	//Reset the scenery to its original location.
	box.x=boxBase.x;
	box.y=boxBase.y;

	if(save)
	xSave=ySave=0;

	//Also reset the appearance.
	appearance.resetAnimation(save);
	appearance.changeState("default");
	//NOTE: We load the animation right after changing it to prevent a transition.
	if(save)
	appearance.loadAnimation();
	}


	void Scenery::playAnimation(){}

	void Scenery::onEvent(int eventType){
	//NOTE: Scenery should not interact with the player or vice versa.
	}

	int Scenery::queryProperties(int propertyType,Player* obj){
	//NOTE: Scenery doesn't have any properties.
	return 0;
	}

	void Scenery::getEditorData(std::vector<std::pair<std::string,std::string> >& obj){

	}

	void Scenery::setEditorData(std::map<std::string,std::string>& obj){

	}

	std::string Scenery::getEditorProperty(std::string property){
	//First get the complete editor data.
	vector<pair<string,string> > objMap;
	vector<pair<string,string> >::iterator it;
	getEditorData(objMap);

	//Loop through the entries.
	for(it=objMap.begin();it!=objMap.end();++it){
	if(it->first==property)
	return it->second;
	}

	//Nothing found.
	return "";
	}

	void Scenery::setEditorProperty(std::string property,std::string value){
	//Create a map to hold the property.
	std::map<std::string,std::string> editorData;
	editorData[property]=value;

	//And call the setEditorData method.
	setEditorData(editorData);
	}

	-bool Scenery::loadFromNode(TreeStorageNode* objNode){
	+bool Scenery::loadFromNode(ImageManager& imageManager, SDL_Renderer& renderer, TreeStorageNode* objNode){
	//Make sure there are enough arguments.
	if(objNode->value.size()<4)
	return false;

	//Load position and size.
	box.x=boxBase.x=atoi(objNode->value[0].c_str());
	box.y=boxBase.y=atoi(objNode->value[1].c_str());
	box.w=boxBase.w=atoi(objNode->value[2].c_str());
	box.h=boxBase.h=atoi(objNode->value[3].c_str());

	//Load the appearance.
	- themeBlock.loadFromNode(objNode,levels->levelpackPath);
	+ themeBlock.loadFromNode(objNode,levels->levelpackPath,imageManager,renderer);
	themeBlock.createInstance(&appearance);

	return true;
	}

	void Scenery::prepareFrame(){
	//Reset the delta variables.
	dx=dy=0;
	}

	void Scenery::move(){
	//Update our appearance.
	appearance.updateAnimation();
	}
	diff --git a/src/Scenery.h b/src/Scenery.h
	index d0371a8..fe27809 100644
	--- a/src/Scenery.h
	+++ b/src/Scenery.h
	@@ -1,114 +1,114 @@
	/*
	* Copyright (C) 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 SCENERY_H
	#define SCENERY_H

	#include "GameObjects.h"
	#include "Globals.h"
	#include "ThemeManager.h"
	#include <vector>
	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>

	class Scenery: public GameObject{
	private:
	//Save variables for the current location of the scenery.
	int xSave,ySave;

	//Delta variables, if the scenery moves these must be set to the delta movement.
	int dx,dy;
	public:
	//The ThemeBlock, kept so it can be deleted later on.
	ThemeBlock themeBlock;
	//The Appearance of the scenery.
	//NOTE: We use a ThemeBlockInstance since it allows for all sorts of things like animations.
	ThemeBlockInstance appearance;

	//Constructor.
	//objParent: Pointer to the Game object.
	Scenery(Game* objParent);
	//Desturctor.
	~Scenery();

	//Method used to draw the scenery.
	- void show();
	+ void show(SDL_Renderer& renderer) override;

	//Returns the box of a given type.
	//boxType: The type of box that should be returned.
	//See GameObjects.h for the types.
	//Returns: The box.
	virtual SDL_Rect getBox(int boxType=BoxType_Current);

	//Method used to set the location of the scenery.
	//NOTE: The new location isn't stored as base location.
	//x: The new x location.
	//y: The new y location.
	virtual void setLocation(int x,int y);

	//Save the state of the scenery so we can load it later on.
	virtual void saveState();
	//Load the saved state of the scenery.
	virtual void loadState();
	//Reset the scenery.
	//save: Boolean if the saved state should also be deleted.
	virtual void reset(bool save);

	//Play an animation.
	virtual void playAnimation();

	//Method called when there's an event.
	//eventType: The type of event.
	//See GameObjects.h for the eventtypes.
	virtual void onEvent(int eventType);

	//Method used to retrieve a property from the scenery.
	//propertyType: The type of property requested.
	//See GameObjects.h for the properties.
	//obj: Pointer to the player.
	//Returns: Integer containing the value of the property.
	virtual int queryProperties(int propertyType,Player* obj);

	//Get the editor data of the scenery.
	//obj: The vector that will be filled with the editorData.
	virtual void getEditorData(std::vector<std::pair<std::string,std::string> >& obj);
	//Set the editor data of the scenery.
	//obj: The new editor data.
	virtual void setEditorData(std::map<std::string,std::string>& obj);

	//Get a single property of the scenery.
	//property: The property to return.
	//Returns: The value for the requested property.
	virtual std::string getEditorProperty(std::string property);
	//Set a single property of the scenery.
	//property: The property to set.
	//value: The new value for the property.
	virtual void setEditorProperty(std::string property,std::string value);

	//Method for loading the Scenery object from a node.
	//objNode: Pointer to the storage node to load from.
	//Returns: True if it succeeds without errors.
	- virtual bool loadFromNode(TreeStorageNode* objNode);
	+ virtual bool loadFromNode(ImageManager& imageManager,SDL_Renderer& renderer,TreeStorageNode* objNode) override;

	//Method used for resetting the dx/dy and xVel/yVel variables.
	virtual void prepareFrame();
	//Method used for updating any animations.
	virtual void move();
	};

	#endif
	diff --git a/src/Settings.cpp b/src/Settings.cpp
	index 7e00ff7..b0aa7af 100644
	--- a/src/Settings.cpp
	+++ b/src/Settings.cpp
	@@ -1,264 +1,264 @@
	/*
	* 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 "Settings.h"
	#include "FileManager.h"
	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#include <string>
	#include <stdio.h>
	using namespace std;

	Settings::Settings(const string fileName): fileName(fileName){
	char s[32];
	settings["sound"]="128";
	settings["music"]="128";
	settings["musiclist"]="default";
	settings["fullscreen"]="0";
	settings["width"]="800";
	settings["height"]="600";
	settings["resizable"]="1";
	#ifdef HARDWARE_ACCELERATION
	settings["gl"]="1";
	#else
	settings["gl"]="0";
	#endif
	settings["theme"]="%DATA%/themes/Cloudscape";
	settings["leveltheme"]="1";
	settings["levelmusic"]="1";
	settings["internet"]="1";
	settings["lastlevelpack"]="tutorial";
	settings["internet-proxy"]="";
	settings["lang"]="";
	settings["addon_url"]="http://sourceforge.net/p/meandmyshadow/addons/ci/HEAD/tree/addons05?format=raw";

	//The record mode.
	settings["quickrecord"]="0";

	//Boolean if fading between states is enabled.
	settings["fading"]="1";

	//Key settings.
	sprintf(s,"%d",(int)SDLK_UP);
	settings["key_up"]=settings["key_jump"]=s;

	sprintf(s,"%d",(int)SDLK_DOWN);
	settings["key_down"]=settings["key_action"]=s; //SDLK_DOWN

	sprintf(s,"%d",(int)SDLK_LEFT);
	settings["key_left"]=s; //SDLK_LEFT

	sprintf(s,"%d",(int)SDLK_RIGHT);
	settings["key_right"]=s; //SDLK_RIGHT

	sprintf(s,"%d",(int)SDLK_SPACE);
	settings["key_space"]=s; //SDLK_SPACE

	settings["key_cancelRecording"]="0"; //not set by default

	sprintf(s,"%d",(int)SDLK_ESCAPE);
	settings["key_escape"]=s; //SDLK_ESCAPE

	sprintf(s,"%d",(int)SDLK_r);
	settings["key_restart"]=s; //SDLK_r

	sprintf(s,"%d",(int)SDLK_TAB);
	settings["key_tab"]=s;

	sprintf(s,"%d",(int)SDLK_F2);
	settings["key_save"]=s; //SDLK_F2

	sprintf(s,"%d",(int)SDLK_F3);
	settings["key_load"]=s; //SDLK_F3

	sprintf(s,"%d",(int)SDLK_F4);
	settings["key_swap"]=s; //SDLK_F4

	sprintf(s,"%d",(int)SDLK_F5);
	settings["key_teleport"]=s; //SDLK_F5

	sprintf(s,"%d",(int)SDLK_F12);
	settings["key_suicide"]=s;

	sprintf(s,"%d",(int)SDLK_RSHIFT);
	settings["key_shift"]=s; //SDLK_RSHIFT

	sprintf(s,"%d",(int)SDLK_PAGEUP);
	settings["key_next"]=s; //SDLK_PAGEUP

	sprintf(s,"%d",(int)SDLK_PAGEDOWN);
	settings["key_previous"]=s; //SDLK_PAGEDOWN

	sprintf(s,"%d",(int)SDLK_RETURN);
	settings["key_select"]=s; //SDLK_RETURN

	settings["key_up2"]=settings["key_down2"]=settings["key_left2"]=settings["key_right2"]=
	settings["key_jump2"]=settings["key_action2"]=
	settings["key_space2"]=settings["key_cancelRecording2"]=
	settings["key_escape2"]=settings["key_restart2"]=settings["key_tab2"]=
	settings["key_save2"]=settings["key_load2"]=settings["key_swap2"]=settings["key_teleport2"]=
	settings["key_suicide2"]=settings["key_shift2"]=settings["key_next2"]=settings["key_previous2"]=
	settings["key_select2"]="0";
	}


	void Settings::parseFile(){
	//Open the config file for reading.
	ifstream file;
	file.open(fileName.c_str());
	if(!file){
	//Check if the file exists.
	if(fileExists(fileName.c_str())){
	cerr<<"ERROR: Unable to read config file, default values will be used!"<<endl;
	}else{
	cout<<"Creating a new config file."<<endl;
	createFile();
	}
	//No need to parse the unreadable or newly created config file.
	return;
	}

	//Read the config file line by line.
	string line;
	while(getline(file,line)){
	string temp = line;

	unComment(temp);
	if(temp.empty() \|\| empty(temp))
	continue;

	//The line is good so we parse it.
	parseLine(temp);
	}

	//And close the file.
	file.close();
	}

	void Settings::parseLine(const string &line){
	if((line.find('=') == line.npos) \|\| !validLine(line))
	cerr<<"WARNING: illegal line in config file!"<<endl;

	string temp = line;
	temp.erase(0, temp.find_first_not_of("\t "));
	int seperator = temp.find('=');

	//Get the key and trim it.
	string key, value;
	key = line.substr(0, seperator);
	if(key.find('\t')!=line.npos \|\| key.find(' ')!=line.npos)
	key.erase(key.find_first_of("\t "));

	//Get the value and trim it.
	value = line.substr(seperator + 1);
	value.erase(0, value.find_first_not_of("\t "));
	value.erase(value.find_last_not_of("\t ") + 1);

	//Add the setting to the settings map.
	setValue(key,value);
	}

	bool Settings::validLine(const string &line){
	string temp = line;
	temp.erase(0, temp.find_first_not_of("\t "));
	if(temp[0] == '=')
	return false;

	for(size_t i = temp.find('=') + 1; i < temp.length(); i++)
	return true;
	return false;
	}

	void Settings::unComment(string &line){
	if(line.find('#') != line.npos)
	line.erase(line.find('#'));
	}

	bool Settings::empty(const string &line){
	return (line.find_first_not_of(' ')==line.npos);
	}

	string Settings::getValue(const string &key){
	if(settings.find(key) == settings.end()){
	cerr<<"WARNING: Key "<<key<<" couldn't be found!"<<endl;
	return "";
	}
	return settings[key];
	}

	bool Settings::getBoolValue(const string &key){
	if(settings.find(key) == settings.end()){
	cerr<<"WARNING: Key "<<key<<" couldn't be found!"<<endl;
	return false;
	}
	return (settings[key] != "0");
	}

	void Settings::setValue(const string &key, const string &value){
	settings[key]=value;
	}

	void Settings::createFile(){
	ofstream file;
	file.open(fileName.c_str());

	//Default Config file.
	file<<"#MeAndMyShadow config file. Created on "<<endl;

	map<string, string>::iterator iter;
	for(iter = settings.begin(); iter != settings.end(); ++iter){
	file << iter->first << " = " << iter->second << endl;
	}

	//And close the file.
	file.close();
	}

	bool Settings::save(){
	//Open the settings file.
	ofstream file;
	file.open(fileName.c_str());

	//Check if the file could be opened.
	if(!file)
	return false;

	//First get the date and time.
	time_t rawtime;
	struct tm* timedate;
	char str_time[80];

	time(&rawtime);
	timedate=localtime(&rawtime);

	//NOTE: Function asctime() is marked obsolete in POSIX. So we're using strftime() instead.
	strftime(str_time,80,"%a %b %d %H:%M:%S %Y",timedate);

	//Now write it to the first line of the config file.
	file<<"#MeAndMyShadow config file. Created on "<<str_time<<endl;

	//Loop through the settings and save them.
	map<string,string>::const_iterator iter;
	for(iter=settings.begin(); iter!=settings.end(); ++iter){
	file<<iter->first<<" = "<<iter->second<<endl;
	}
	file.close();

	//No errors so return true.
	return true;
	}
	diff --git a/src/SoundManager.h b/src/SoundManager.h
	index e40ead8..a87d3e9 100644
	--- a/src/SoundManager.h
	+++ b/src/SoundManager.h
	@@ -1,67 +1,67 @@
	/*
	* Copyright (C) 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 SOUNDMANAGER_H
	#define SOUNDMANAGER_H

	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#else
	-#include <SDL/SDL_mixer.h>
	+#include <SDL2/SDL_mixer.h>
	#endif
	#include <string>
	#include <map>
	#include <vector>

	//Class for loading and playing sound effects.
	class SoundManager{
	private:
	//Map containing the sfx chunk by name.
	std::map<std::string,Mix_Chunk*> sounds;

	//Array that holds the name of the sfx that is playing on each channel.
	std::string playing[MIX_CHANNELS];
	public:
	//Constructor.
	SoundManager();
	//Destructor.
	~SoundManager();

	//Destroys the sound chunks.
	void destroy();

	//This method will load one sfx file and add it to the collection.
	//file: The filename of the sfx file.
	//name: The name the sfx should have.
	void loadSound(const std::string &file,const std::string &name);

	//This method will start playing a sfx.
	//name: The name of the sfx to play.
	//concurrent: Integer containing the number of times the same sfx can be played at once, -1 is unlimited.
	//force: Boolean if the sound must get
	void playSound(const std::string &name,const int concurrent=1,const bool force=false);

	//Method that is called when a sfx is done playing.
	//channel: The channel number.
	void channelFinished(int channel);

	};

	#endif
	diff --git a/src/StatisticsManager.cpp b/src/StatisticsManager.cpp
	index ca3b0f0..ab1dbc1 100644
	--- a/src/StatisticsManager.cpp
	+++ b/src/StatisticsManager.cpp
	@@ -1,778 +1,789 @@
	/*
	* 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 "StatisticsManager.h"
	#include "FileManager.h"
	#include "TreeStorageNode.h"
	#include "POASerializer.h"
	#include "Functions.h"
	#include "LevelPackManager.h"
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <time.h>
	#include <iostream>
	#include <fstream>
	#include <sstream>
	#include <vector>
	#include <map>
	#include "libs/tinyformat/tinyformat.h"
	#ifdef __APPLE__
	#include <SDL_gfx/SDL_gfxPrimitives.h>
	#else
	-#include <SDL/SDL_gfxPrimitives.h>
	+#include <SDL2/SDL2_gfxPrimitives.h>
	#endif

	using namespace std;

	StatisticsManager statsMgr;

	static const int achievementDisplayTime=(FPS*4500)/1000;
	static const int achievementIntervalTime=achievementDisplayTime+(FPS*500)/1000;

	#include "AchievementList.h"

	static map<string,AchievementInfo*> avaliableAchievements;

	//================================================================

	StatisticsManager::StatisticsManager(){
	bmDropShadow=NULL;
	bmQuestionMark=NULL;
	bmAchievement=NULL;

	startTime=time(NULL);

	tutorialLevels=0;

	clear();
	}

	-StatisticsManager::~StatisticsManager(){
	- if(bmAchievement){
	- SDL_FreeSurface(bmAchievement);
	- bmAchievement=NULL;
	- }
	-}
	-
	void StatisticsManager::clear(){
	playerTravelingDistance=shadowTravelingDistance=0.0f;
	playerJumps=shadowJumps
	=playerDies=shadowDies
	=playerSquashed=shadowSquashed
	=completedLevels=silverLevels=goldLevels
	=recordTimes=switchTimes=swapTimes=saveTimes=loadTimes
	=playTime=levelEditTime
	=createdLevels=tutorialCompleted=tutorialGold=0;

	achievements.clear();
	queuedAchievements.clear();

	achievementTime=0;
	currentAchievement=0;
	if(bmAchievement){
	- SDL_FreeSurface(bmAchievement);
	- bmAchievement=NULL;
	+ bmAchievement.reset();
	}
	}

	#define LOAD_STATS(var,func) { \
	vector<string> &v=node.attributes[ #var ]; \
	if(!v.empty() && !v[0].empty()) \
	var=func(v[0].c_str()); \
	}

	void StatisticsManager::loadFile(const std::string& fileName){
	clear();

	ifstream file(fileName.c_str());
	if(!file) return;

	TreeStorageNode node;
	POASerializer serializer;
	if(!serializer.readNode(file,&node,true)) return;

	//load statistics
	LOAD_STATS(playerTravelingDistance,atof);
	LOAD_STATS(shadowTravelingDistance,atof);
	LOAD_STATS(playerJumps,atoi);
	LOAD_STATS(shadowJumps,atoi);
	LOAD_STATS(playerDies,atoi);
	LOAD_STATS(shadowDies,atoi);
	LOAD_STATS(playerSquashed,atoi);
	LOAD_STATS(shadowSquashed,atoi);
	LOAD_STATS(recordTimes,atoi);
	LOAD_STATS(switchTimes,atoi);
	LOAD_STATS(swapTimes,atoi);
	LOAD_STATS(saveTimes,atoi);
	LOAD_STATS(loadTimes,atoi);
	LOAD_STATS(playTime,atoi);
	LOAD_STATS(levelEditTime,atoi);
	LOAD_STATS(createdLevels,atoi);

	//load achievements.
	//format is: name;time,name;time,...
	{
	vector<string> &v=node.attributes["achievements"];
	for(unsigned int i=0;i<v.size();i++){
	string s=v[i];
	time_t t=0;

	string::size_type lps=s.find(';');
	if(lps!=string::npos){
	string s1=s.substr(lps+1);
	s=s.substr(0,lps);

	long long n;
	sscanf(s1.c_str(),
	#ifdef WIN32
	"%I64d",
	#else
	"%Ld",
	#endif
	&n);

	t=(time_t)n;
	}

	map<string,AchievementInfo*>::iterator it=avaliableAchievements.find(s);
	if(it!=avaliableAchievements.end()){
	OwnedAchievement ach={t,it->second};
	achievements[it->first]=ach;
	}
	}
	}
	}

	//Call when level edit is start
	void StatisticsManager::startLevelEdit(){
	levelEditStartTime=time(NULL);
	}

	//Call when level edit is end
	void StatisticsManager::endLevelEdit(){
	levelEditTime+=time(NULL)-levelEditStartTime;
	}

	//update in-game time
	void StatisticsManager::updatePlayTime(){
	time_t endTime=time(NULL);
	playTime+=endTime-startTime;
	startTime=endTime;
	}

	#define SAVE_STATS(var,pattern) { \
	sprintf(s,pattern,var); \
	node.attributes[ #var ].push_back(s); \
	}

	void StatisticsManager::saveFile(const std::string& fileName){
	char s[64];

	//update in-game time
	updatePlayTime();

	ofstream file(fileName.c_str());
	if(!file) return;

	TreeStorageNode node;

	//save statistics
	SAVE_STATS(playerTravelingDistance,"%.2f");
	SAVE_STATS(shadowTravelingDistance,"%.2f");
	SAVE_STATS(playerJumps,"%d");
	SAVE_STATS(shadowJumps,"%d");
	SAVE_STATS(playerDies,"%d");
	SAVE_STATS(shadowDies,"%d");
	SAVE_STATS(playerSquashed,"%d");
	SAVE_STATS(shadowSquashed,"%d");
	SAVE_STATS(recordTimes,"%d");
	SAVE_STATS(switchTimes,"%d");
	SAVE_STATS(swapTimes,"%d");
	SAVE_STATS(saveTimes,"%d");
	SAVE_STATS(loadTimes,"%d");
	SAVE_STATS(playTime,"%d");
	SAVE_STATS(levelEditTime,"%d");
	SAVE_STATS(createdLevels,"%d");

	//save achievements.
	//format is: name;time,name;time,...
	{
	vector<string>& v=node.attributes["achievements"];

	for(map<string,OwnedAchievement>::iterator it=achievements.begin();it!=achievements.end();++it){
	stringstream strm;
	char s[32];

	long long n=it->second.achievedTime;
	sprintf(s,
	#ifdef WIN32
	"%I64d",
	#else
	"%Ld",
	#endif
	n);
	strm<<it->first<<";"<<s;

	v.push_back(strm.str());
	}
	}

	POASerializer serializer;
	serializer.writeNode(&node,file,true,true);
	}

	-void StatisticsManager::loadPicture(){
	+void StatisticsManager::loadPicture(SDL_Renderer& renderer, ImageManager& imageManager){
	//Load drop shadow picture
	- bmDropShadow=loadImage(getDataPath()+"gfx/dropshadow.png");
	- bmQuestionMark=loadImage(getDataPath()+"gfx/menu/questionmark.png");
	+ bmDropShadow=imageManager.loadTexture(getDataPath()+"gfx/dropshadow.png", renderer);
	+ bmQuestionMark=imageManager.loadImage(getDataPath()+"gfx/menu/questionmark.png");
	}

	-void StatisticsManager::registerAchievements(){
	+void StatisticsManager::registerAchievements(ImageManager& imageManager){
	if(!avaliableAchievements.empty()) return;

	for(int i=0;achievementList[i].id!=NULL;i++){
	avaliableAchievements[achievementList[i].id]=&achievementList[i];
	if(achievementList[i].imageFile!=NULL){
	- achievementList[i].imageSurface=loadImage(getDataPath()+achievementList[i].imageFile);
	+ achievementList[i].imageSurface = imageManager.loadImage(getDataPath()+achievementList[i].imageFile);
	}
	}
	}

	-void StatisticsManager::render(){
	- if(achievementTime==0 && bmAchievement==NULL && currentAchievement<(int)queuedAchievements.size()){
	+void StatisticsManager::render(ImageManager&,SDL_Renderer &renderer){
	+ if(achievementTime==0 && !bmAchievement && currentAchievement<(int)queuedAchievements.size()){
	//create surface
	- bmAchievement=createAchievementSurface(queuedAchievements[currentAchievement++]);
	- drawGUIBox(0,0,bmAchievement->w,bmAchievement->h,bmAchievement,0xFFFFFF00);
	+ bmAchievement=createAchievementSurface(renderer, queuedAchievements[currentAchievement++]);
	+ //FIXME: Draw the box.
	+ //drawGUIBox(0,0,bmAchievement->w,bmAchievement->h,bmAchievement,0xFFFFFF00);

	//check if queue is empty
	if(currentAchievement>=(int)queuedAchievements.size()){
	queuedAchievements.clear();
	currentAchievement=0;
	}

	//play a sound
	getSoundManager()->playSound("achievement");
	}

	//check if we need to display achievements
	if(bmAchievement){
	achievementTime++;
	if(achievementTime<=0){
	return;
	}else if(achievementTime<=5){
	- drawAchievement(achievementTime);
	+ drawAchievement(renderer,achievementTime);
	}else if(achievementTime<=achievementDisplayTime-5){
	- drawAchievement(5);
	+ drawAchievement(renderer,5);
	}else if(achievementTime<achievementDisplayTime){
	- drawAchievement(achievementDisplayTime-achievementTime);
	+ drawAchievement(renderer,achievementDisplayTime-achievementTime);
	}else if(achievementTime>=achievementIntervalTime){
	if(bmAchievement){
	- SDL_FreeSurface(bmAchievement);
	- bmAchievement=NULL;
	+ bmAchievement.reset();
	}
	achievementTime=0;
	}
	}
	}

	void StatisticsManager::newAchievement(const std::string& id,bool save){
	//check avaliable achievements
	map<string,AchievementInfo*>::iterator it=avaliableAchievements.find(id);
	if(it==avaliableAchievements.end()) return;

	//check if already have this achievement
	if(save){
	map<string,OwnedAchievement>::iterator it2=achievements.find(id);
	if(it2!=achievements.end()) return;

	OwnedAchievement ach={time(NULL),it->second};
	achievements[id]=ach;
	}

	//add it to queue
	queuedAchievements.push_back(it->second);
	}

	float StatisticsManager::getAchievementProgress(AchievementInfo* info){
	if(!strcmp(info->id,"experienced")){
	return float(completedLevels)/50.0f*100.0f;
	}
	if(!strcmp(info->id,"expert")){
	return float(goldLevels)/50.0f*100.0f;
	}
	if(!strcmp(info->id,"tutorial")){
	if(tutorialLevels>0)
	return float(tutorialCompleted)/float(tutorialLevels)*100.0f;
	else
	return 0.0f;
	}
	if(!strcmp(info->id,"tutorialGold")){
	if(tutorialLevels>0)
	return float(tutorialGold)/float(tutorialLevels)*100.0f;
	else
	return 0.0f;
	}
	if(!strcmp(info->id,"create50")){
	return float(createdLevels)/50.0f*100.0f;
	}
	if(!strcmp(info->id,"frog")){
	return float(playerJumps+shadowJumps)/1000.0f*100.0f;
	}
	if(!strcmp(info->id,"die50")){
	return float(playerDies+shadowDies)/50.0f*100.0f;
	}
	if(!strcmp(info->id,"die1000")){
	return float(playerDies+shadowDies)/1000.0f*100.0f;
	}
	if(!strcmp(info->id,"suqash50")){
	return float(playerSquashed+shadowSquashed)/50.0f*100.0f;
	}
	if(!strcmp(info->id,"travel100")){
	return (playerTravelingDistance+shadowTravelingDistance)/100.0f*100.0f;
	}
	if(!strcmp(info->id,"travel1k")){
	return (playerTravelingDistance+shadowTravelingDistance)/1000.0f*100.0f;
	}
	if(!strcmp(info->id,"travel10k")){
	return (playerTravelingDistance+shadowTravelingDistance)/10000.0f*100.0f;
	}
	if(!strcmp(info->id,"travel42k")){
	return (playerTravelingDistance+shadowTravelingDistance)/42195.0f*100.0f;
	}
	if(!strcmp(info->id,"record100")){
	return float(recordTimes)/100.0f*100.0f;
	}
	if(!strcmp(info->id,"record1k")){
	return float(recordTimes)/1000.0f*100.0f;
	}
	if(!strcmp(info->id,"switch100")){
	return float(switchTimes)/100.0f*100.0f;
	}
	if(!strcmp(info->id,"switch1k")){
	return float(switchTimes)/1000.0f*100.0f;
	}
	if(!strcmp(info->id,"swap100")){
	return float(swapTimes)/100.0f*100.0f;
	}
	if(!strcmp(info->id,"swap1k")){
	return float(swapTimes)/1000.0f*100.0f;
	}

	//not found
	return 0.0f;
	}

	-SDL_Surface* StatisticsManager::createAchievementSurface(AchievementInfo* info,SDL_Surface* surface,SDL_Rect* rect,bool showTip,const time_t *achievedTime){
	+SharedTexture StatisticsManager::createAchievementSurface(SDL_Renderer& renderer, AchievementInfo* info,SDL_Rect* rect,bool showTip,const time_t *achievedTime){
	if(info==NULL \|\| info->id==NULL) return NULL;

	//prepare text
	- SDL_Surface title0=NULL,title1=NULL;
	+ SurfacePtr title0(nullptr);
	+ SurfacePtr title1(nullptr);
	vector<SDL_Surface*> descSurfaces;
	SDL_Color fg={0,0,0};
	int fontHeight=TTF_FontLineSkip(fontText);

	bool showDescription=false;
	bool showImage=false;
	float achievementProgress=0.0f;

	if(showTip){
	- title0=TTF_RenderUTF8_Blended(fontText,_("New achievement:"),fg);
	- title1=TTF_RenderUTF8_Blended(fontGUISmall,_(info->name),fg);
	+ title0.reset(TTF_RenderUTF8_Blended(fontText,_("New achievement:"),fg));
	+ title1.reset(TTF_RenderUTF8_Blended(fontGUISmall,_(info->name),fg));
	showDescription=showImage=true;
	}else if(achievedTime){
	char s[128];
	strftime(s,sizeof(s),"%c",localtime(achievedTime));

	stringstream strm;
	tinyformat::format(strm,_("Achieved on %s"),s);
	-
	- title1=TTF_RenderUTF8_Blended(fontText,strm.str().c_str(),fg);
	- title0=TTF_RenderUTF8_Blended(fontGUISmall,_(info->name),fg);
	+
	+ title0.reset(TTF_RenderUTF8_Blended(fontGUISmall,_(info->name),fg));
	+ title1.reset(TTF_RenderUTF8_Blended(fontText,strm.str().c_str(),fg));
	showDescription=showImage=true;
	}else if(info->displayStyle==ACHIEVEMENT_HIDDEN){
	- title0=TTF_RenderUTF8_Blended(fontGUISmall,_("Unknown achievement"),fg);
	+ title0.reset(TTF_RenderUTF8_Blended(fontGUISmall,_("Unknown achievement"),fg));
	}else{
	if(info->displayStyle==ACHIEVEMENT_PROGRESS){
	achievementProgress=getAchievementProgress(info);

	stringstream strm;
	tinyformat::format(strm,_("Achieved %1.0f%%"),achievementProgress);

	- title1=TTF_RenderUTF8_Blended(fontText,strm.str().c_str(),fg);
	+ title1.reset(TTF_RenderUTF8_Blended(fontText,strm.str().c_str(),fg));
	}else{
	- title1=TTF_RenderUTF8_Blended(fontText,_("Not achieved"),fg);
	+ title1.reset(TTF_RenderUTF8_Blended(fontText,_("Not achieved"),fg));
	}

	- title0=TTF_RenderUTF8_Blended(fontGUISmall,_(info->name),fg);
	+ title0.reset(TTF_RenderUTF8_Blended(fontGUISmall,_(info->name),fg));

	showDescription= info->displayStyle==ACHIEVEMENT_ALL \|\| info->displayStyle==ACHIEVEMENT_PROGRESS;
	showImage=true;
	}

	if(info->description!=NULL && showDescription){
	string description=_(info->description);
	string::size_type lps=0,lpe;
	for(;;){
	lpe=description.find('\n',lps);
	if(lpe==string::npos){
	descSurfaces.push_back(TTF_RenderUTF8_Blended(fontText,(description.substr(lps)+' ').c_str(),fg));
	break;
	}else{
	descSurfaces.push_back(TTF_RenderUTF8_Blended(fontText,(description.substr(lps,lpe-lps)+' ').c_str(),fg));
	lps=lpe+1;
	}
	}
	}

	//calculate the size
	int w=0,h=0,w1=8,h1=0;

	if(title0!=NULL){
	if(title0->w>w) w=title0->w;
	h1+=title0->h;
	}
	if(title1!=NULL){
	if(title1->w>w) w=title1->w;
	h1+=title1->h;
	- /*//calc progress bar size
	+ /*//calc progress bar size
	if(!showTip && !achievedTime && info->displayStyle==ACHIEVEMENT_PROGRESS){
	h1+=4;
	- }*/
	+ }*/
	}

	if(showImage){
	if(info->imageSurface!=NULL){
	w1+=info->r.w+8;
	w+=info->r.w+8;
	if(info->r.h>h1) h1=info->r.h;
	}
	}else{
	- w1+=bmQuestionMark->w+8;
	- w+=bmQuestionMark->w+8;
	- if(bmQuestionMark->h>h1) h1=bmQuestionMark->h;
	+ w1+=bmQuestionMark->w+8;
	+ w+=bmQuestionMark->w+8;
	+ if(bmQuestionMark->h>h1) h1=bmQuestionMark->h;
	}

	h=h1+8;
	for(unsigned int i=0;i<descSurfaces.size();i++){
	if(descSurfaces[i]!=NULL){
	if(descSurfaces[i]->w>w) w=descSurfaces[i]->w;
	}
	}
	h+=descSurfaces.size()*fontHeight;
	w+=16;
	h+=16;

	//check if size is specified
	int left=0,top=0;
	if(rect!=NULL){
	- if(surface!=NULL){
	+ //NOTE: SDL2 port. This was never used.
	+/* if(surface!=NULL){
	left=rect->x;
	top=rect->y;
	- }
	+ }*/
	if(rect->w>0) w=rect->w;
	else rect->w=w;
	rect->h=h;
	}

	//create surface if necessary
	- if(surface==NULL){
	- surface=SDL_CreateRGBSurface(SCREEN_FLAGS,w,h,
	- screen->format->BitsPerPixel,screen->format->Rmask,screen->format->Gmask,screen->format->Bmask,0);
	- }
	+ SurfacePtr surface = createSurface(w, h);
	+ std::unique_ptr<SDL_Renderer,decltype(&SDL_DestroyRenderer)> surfaceRenderer(
	+ SDL_CreateSoftwareRenderer(surface.get()), &SDL_DestroyRenderer);

	//draw background
	- SDL_Rect r={left,top,w,h};
	+ const SDL_Rect r={left,top,w,h};
	if(showTip \|\| achievedTime){
	- SDL_FillRect(surface,&r,SDL_MapRGB(surface->format,255,255,255));
	+ SDL_FillRect(surface.get(),&r,SDL_MapRGB(surface->format,255,255,255));
	}else{
	- SDL_FillRect(surface,&r,SDL_MapRGB(surface->format,192,192,192));
	+ SDL_FillRect(surface.get(),&r,SDL_MapRGB(surface->format,192,192,192));
	}

	+ std::cout << info->imageSurface->h << std::endl;
	+
	//draw picture
	- if(showImage){
	- if(info->imageSurface!=NULL){
	+ if(showImage){
	+ if(info->imageSurface){
	SDL_Rect r={left+8,top+8+(h1-info->r.h)/2,0,0};
	- SDL_BlitSurface(info->imageSurface,&info->r,surface,&r);
	- }
	- }else{
	- SDL_Rect r={left+8,top+8+(h1-bmQuestionMark->h)/2,0,0};
	- SDL_BlitSurface(bmQuestionMark,NULL,surface,&r);
	+ SDL_BlitSurface(info->imageSurface,&info->r,surface.get(),&r);
	+ }
	+ }else{
	+ SDL_Rect r={left+8,top+8+(h1-bmQuestionMark->h)/2,0,0};
	+ SDL_BlitSurface(bmQuestionMark,NULL,surface.get(),&r);
	}

	//draw text
	h=8;
	- if(title0!=NULL){
	+ if(title0){
	SDL_Rect r={left+w1,top+h,0,0};
	- SDL_BlitSurface(title0,NULL,surface,&r);
	+ SDL_BlitSurface(title0.get(),NULL,surface.get(),&r);
	h+=title0->h;
	}
	- if(title1!=NULL){
	+ if(title1){
	SDL_Rect r={left+w1,top+h,0,0};

	//Draw progress bar.
	if(!showTip && !achievedTime && info->displayStyle==ACHIEVEMENT_PROGRESS){
	//Draw borders.
	SDL_Rect r1={r.x,r.y,w-8-r.x,title1->h};
	- drawGUIBox(r1.x,r1.y,r1.w,r1.h,surface,0x1D);
	+ //FIXME, draws directly to screen, fix params.
	+ //drawGUIBox(r1.x,r1.y,r1.w,r1.h,surface.get(),0x1D);
	+ drawGUIBox(r1.x,r1.y,r1.w,r1.h,*surfaceRenderer,0x1D);

	//Draw progress.
	r1.x++;
	r1.y++;
	r1.w=int(achievementProgress/100.0f*float(r1.w));
	r1.h-=3;
	- boxRGBA(surface,r1.x,r1.y,r1.x+r1.w,r1.y+r1.h,0,0,0,100);
	+ //FIXME: Disabled for SDL2
	+ boxRGBA(surfaceRenderer.get(),r1.x,r1.y,r1.x+r1.w,r1.y+r1.h,0,0,0,100);

	//???
	r.x+=2;
	r.y+=2;
	}

	//Draw text.
	- SDL_BlitSurface(title1,NULL,surface,&r);
	+ SDL_BlitSurface(title1.get(),NULL,surface.get(),&r);
	}
	h=h1+16;
	for(unsigned int i=0;i<descSurfaces.size();i++){
	if(descSurfaces[i]!=NULL){
	- SDL_Rect r={left+8,top+h+i*fontHeight,0,0};
	- SDL_BlitSurface(descSurfaces[i],NULL,surface,&r);
	+ SDL_Rect r={left+8,top+h+static_cast<int>(i)*fontHeight,0,0};
	+ SDL_BlitSurface(descSurfaces[i],NULL,surface.get(),&r);
	}
	}

	//clean up
	- if(title0) SDL_FreeSurface(title0);
	- if(title1) SDL_FreeSurface(title1);
	for(unsigned int i=0;i<descSurfaces.size();i++){
	if(descSurfaces[i]!=NULL){
	SDL_FreeSurface(descSurfaces[i]);
	}
	}
	+ //FIXME: Should we clear the vector here?
	+
	+

	//over
	- return surface;
	+ return textureFromSurface(renderer, std::move(surface));
	}

	-void StatisticsManager::drawAchievement(int alpha){
	- if(bmAchievement==NULL) return;
	- if(alpha<=0) return;
	+void StatisticsManager::drawAchievement(SDL_Renderer& renderer,int alpha){
	+ if(!bmAchievement \|\| alpha<=0) {
	+ return;
	+ }
	if(alpha>5) alpha=5;

	- SDL_Rect r={screen->w-32-bmAchievement->w,32,
	- bmAchievement->w,bmAchievement->h};
	+ SDL_Rect r = rectFromTexture(*bmAchievement);
	+ int w=0,h=0;
	+ SDL_GetRendererOutputSize(&renderer, &w, &h);
	+ r.x = w-32-r.w;
	+ r.y = 32;

	- //draw the surface
	- SDL_SetAlpha(bmAchievement,SDL_SRCALPHA,alpha*40);
	- SDL_BlitSurface(bmAchievement,NULL,screen,&r);
	+ SDL_SetTextureAlphaMod(bmAchievement.get(), alpha*40);
	+ applyTexture(r.x, r.y,bmAchievement, renderer);
	+
	+ if(!bmDropShadow) {
	+ return;
	+ }

	//draw drop shadow - corner
	{
	int w1=r.w/2,w2=r.w-w1,h1=r.h/2,h2=r.h-h1;
	if(w1>16) w1=16;
	if(w2>16) w2=16;
	if(h1>16) h1=16;
	if(h2>16) h2=16;

	- int x=(5-alpha)*64;
	+ const int x=(5-alpha)*64;
	+
	//top-left
	- SDL_Rect r1={x,0,w1+16,h1+16},r2={r.x-16,r.y-16,0,0};
	- SDL_BlitSurface(bmDropShadow,&r1,screen,&r2);
	+ SDL_Rect r1={x,0,w1+16,h1+16};//),r2={r.x-16,r.y-16,0,0};
	+ SDL_Rect r2 ={r.x-16, r.y-16, r1.w, r1.h};
	+ //SDL_BlitSurface(bmDropShadow,&r1,screen,&r2);
	+ SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//top-right
	- r1.x=x+48-w2;r1.w=w2+16;r2.x=r.x+r.w-w2;
	- SDL_BlitSurface(bmDropShadow,&r1,screen,&r2);
	+ r1.x=x+48-w2;r2.w=r1.w =w2+16;r2.x=r.x+r.w-w2;
	+ SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//bottom-right
	- r1.y=48-h2;r1.h=h2+16;r2.y=r.y+r.h-h2;
	- SDL_BlitSurface(bmDropShadow,&r1,screen,&r2);
	+ r1.y=48-h2;r2.h=r1.h=h2+16;r2.y=r.y+r.h-h2;
	+ SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//bottom-left
	- r1.x=x;r1.w=w1+16;r2.x=r.x-16;
	- SDL_BlitSurface(bmDropShadow,&r1,screen,&r2);
	+ r1.x=x;r2.w=r1.w=w1+16;r2.x=r.x-16;
	+ SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	}
	//draw drop shadow - border
	int i=r.w-32;
	while(i>0){
	- int ii=i>128?128:i;
	+ const int ii=i>128?128:i;

	//top
	- SDL_Rect r1={0,256-alpha*16,ii,16},r2={r.x+r.w-16-i,r.y-16,0,0};
	- SDL_BlitSurface(bmDropShadow,&r1,screen,&r2);
	+ SDL_Rect r1={0,256-alpha*16,ii,16};
	+ SDL_Rect r2={r.x+r.w-16-i,r.y-16,r1.w,r1.h};
	+ SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//bottom
	r1.x=128;r2.y=r.y+r.h;
	- SDL_BlitSurface(bmDropShadow,&r1,screen,&r2);
	+ SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);

	i-=ii;
	}
	i=r.h-32;
	while(i>0){
	- int ii=i>128?128:i;
	+ const int ii=i>128?128:i;

	//top
	- SDL_Rect r1={512-alpha*16,0,16,ii},r2={r.x-16,r.y+r.h-16-i,0,0};
	- SDL_BlitSurface(bmDropShadow,&r1,screen,&r2);
	+ SDL_Rect r1={512-alpha*16,0,16,ii};
	+ SDL_Rect r2={r.x-16,r.y+r.h-16-i, r1.w, r1.h};
	+ SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//bottom
	r1.y=128;r2.x=r.x+r.w;
	- SDL_BlitSurface(bmDropShadow,&r1,screen,&r2);
	+ SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);

	i-=ii;
	}
	}

	void StatisticsManager::reloadCompletedLevelsAndAchievements(){
	completedLevels=silverLevels=goldLevels=0;

	LevelPackManager *lpm=getLevelPackManager();
	vector<pair<string,string> > v=lpm->enumLevelPacks();

	bool tutorial=false,tutorialIsGold=false;

	for(unsigned int i=0;i<v.size();i++){
	string& s=v[i].first;
	LevelPack *levels=lpm->getLevelPack(s);
	levels->loadProgress();

	bool b=false;
	if(s==lpm->tutorialLevelPackPath){
	tutorialLevels=levels->getLevelCount();
	tutorialCompleted=tutorialGold=0;
	b=tutorial=tutorialIsGold=true;
	}

	for(int n=0,m=levels->getLevelCount();n<m;n++){
	LevelPack::Level *lv=levels->getLevel(n);
	int medal=lv->won;
	if(medal){
	if(lv->targetTime<0 \|\| lv->time<=lv->targetTime)
	medal++;
	if(lv->targetRecordings<0 \|\| lv->recordings<=lv->targetRecordings)
	medal++;

	completedLevels++;
	if(b) tutorialCompleted++;
	if(medal==2) silverLevels++;
	if(medal==3){
	goldLevels++;
	if(b) tutorialGold++;
	}

	if(medal!=3 && b) tutorialIsGold=false;
	}else if(b){
	tutorial=tutorialIsGold=false;
	}
	}
	}

	//upadte achievements
	updateLevelAchievements();
	updateTutorialAchievementsInternal((tutorial?1:0)\|(tutorialIsGold?2:0));
	}

	void StatisticsManager::reloadOtherAchievements(){
	int i;

	if(playTime>=7200) newAchievement("addicted");
	if(playTime>=86400) newAchievement("loyalFan");

	if(levelEditTime>=7200) newAchievement("constructor");
	if(levelEditTime>=86400) newAchievement("constructor2");

	if(createdLevels>=1) newAchievement("create1");
	if(createdLevels>=50) newAchievement("create50");

	i=playerJumps+shadowJumps;
	if(i>=1000) newAchievement("frog");

	i=playerDies+shadowDies;
	if(i>=1) newAchievement("die1");
	if(i>=50) newAchievement("die50");
	if(i>=1000) newAchievement("die1000");

	i=playerSquashed+shadowSquashed;
	if(i>=1) newAchievement("squash1");
	if(i>=50) newAchievement("squash50");

	float d=playerTravelingDistance+shadowTravelingDistance;
	if(d>=100.0f) newAchievement("travel100");
	if(d>=1000.0f) newAchievement("travel1k");
	if(d>=10000.0f) newAchievement("travel10k");
	if(d>=42195.0f) newAchievement("travel42k");

	if(recordTimes>=100) newAchievement("record100");
	if(recordTimes>=1000) newAchievement("record1k");

	if(switchTimes>=100) newAchievement("switch100");
	if(switchTimes>=1000) newAchievement("switch1k");

	if(swapTimes>=100) newAchievement("swap100");
	if(swapTimes>=1000) newAchievement("swap1k");

	if(saveTimes>=1000) newAchievement("save1k");

	if(loadTimes>=1000) newAchievement("load1k");

	if(version.find("Development")!=string::npos) newAchievement("programmer");
	}

	//Update level specified achievements.
	//Make sure the completed level count is correct.
	void StatisticsManager::updateLevelAchievements(){
	if(completedLevels>=1) newAchievement("newbie");
	if(goldLevels>=1) newAchievement("goodjob");
	if(completedLevels>=50) newAchievement("experienced");
	if(goldLevels>=50) newAchievement("expert");
	}

	//Update tutorial specified achievements.
	//Make sure the level progress of tutorial is correct.
	void StatisticsManager::updateTutorialAchievements(){
	//find tutorial level pack
	LevelPackManager *lpm=getLevelPackManager();
	LevelPack *levels=lpm->getTutorialLevelPack();
	if(levels==NULL) return;

	bool tutorial=true,tutorialIsGold=true;
	tutorialLevels=levels->getLevelCount();
	tutorialCompleted=tutorialGold=0;

	for(int n=0,m=levels->getLevelCount();n<m;n++){
	LevelPack::Level *lv=levels->getLevel(n);
	int medal=lv->won;
	if(medal){
	if(lv->targetTime<0 \|\| lv->time<=lv->targetTime)
	medal++;
	if(lv->targetRecordings<0 \|\| lv->recordings<=lv->targetRecordings)
	medal++;

	tutorialCompleted++;

	if(medal!=3) tutorialIsGold=false;
	else tutorialGold++;
	}else{
	tutorial=tutorialIsGold=false;
	break;
	}
	}

	//upadte achievements
	updateTutorialAchievementsInternal((tutorial?1:0)\|(tutorialIsGold?2:0));
	}

	//internal function
	//flags: a bit-field value indicates which achievements we have.
	void StatisticsManager::updateTutorialAchievementsInternal(int flags){
	if(flags&1) newAchievement("tutorial");
	if(flags&2) newAchievement("tutorialGold");
	}
	diff --git a/src/StatisticsManager.h b/src/StatisticsManager.h
	index f86bb61..a5c6003 100644
	--- a/src/StatisticsManager.h
	+++ b/src/StatisticsManager.h
	@@ -1,179 +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/SDL.h>
	+#include <SDL2/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;
	+ SDL_Surface* imageSurface = nullptr;
	};

	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
	- SDL_Surface bmDropShadow,bmQuestionMark;
	+ SharedTexture bmDropShadow;
	+ SDL_Surface* bmQuestionMark;
	//SDL_Surface for current achievement (excluding drop shadow)
	- SDL_Surface *bmAchievement;
	+ //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();
	- ~StatisticsManager();

	//clear the statistics and achievements.
	void clear();
	//load needed picture
	- void loadPicture();
	+ void loadPicture(SDL_Renderer &renderer, ImageManager &imageManager);
	//register avaliable achievements
	- static void registerAchievements();
	+ 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();
	+ 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 SDL_Surface contains specified achievements or draw to existing surface.
	+ //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.
	+ //(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: SDL_Surface contains specified achievements or NULL if any error occured.
	- SDL_Surface* createAchievementSurface(AchievementInfo* info,SDL_Surface* surface=NULL,SDL_Rect* rect=NULL,bool showTip=true,const time_t *achievedTime=NULL);
	+ //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(int alpha);
	+ 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
	\ No newline at end of file
	+#endif
	diff --git a/src/StatisticsScreen.cpp b/src/StatisticsScreen.cpp
	index d9d7e42..faa4ea6 100644
	--- a/src/StatisticsScreen.cpp
	+++ b/src/StatisticsScreen.cpp
	@@ -1,353 +1,356 @@
	/*
	* 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"
	#ifdef __APPLE__
	-#include <SDL_image/SDL_image.h>
	-#include <SDL_gfx/SDL_gfxPrimitives.h>
	+#include <SDL2_image/SDL2_image.h>
	+#include <SDL2_gfx/SDL2_gfxPrimitives.h>
	#else
	-#include <SDL/SDL_image.h>
	-#include <SDL/SDL_gfxPrimitives.h>
	+#include <SDL2/SDL_image.h>
	+#include <SDL2/SDL2_gfxPrimitives.h>
	#endif

	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(std::string name,GUIObject* obj,int eventType){
	+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(){
	+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=TTF_RenderUTF8_Blended(fontTitle,_("Achievements and Statistics"),themeTextColor);
	+ title = textureFromText(renderer, *fontTitle,_("Achievements and Statistics"),themeTextColor);
	+

	//Create GUI.
	- createGUI();
	+ createGUI(imageManager, renderer);
	}

	//Destructor.
	StatisticsScreen::~StatisticsScreen(){
	//Delete the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	-
	- //Free images.
	- SDL_FreeSurface(title);
	}

	//we are so lazy that we just use height of the first text, ignore the others
	#define DRAW_PLAYER_STATISTICS(name,var,fmt) { \
	- surface=TTF_RenderUTF8_Blended(fontGUISmall,name,themeTextColor); \
	- stats=SDL_CreateRGBSurface(SCREEN_FLAGS,w,surface->h, /* create new surface */ \
	- screen->format->BitsPerPixel,screen->format->Rmask,screen->format->Gmask,screen->format->Bmask,0); \
	- SDL_FillRect(stats,NULL,-1); \
	- applySurface(4,0,surface,stats,NULL); \
	- y=surface->h; \
	- SDL_FreeSurface(surface); \
	- sprintf(s,fmt,statsMgr.player##var+statsMgr.shadow##var); \
	- surface=TTF_RenderUTF8_Blended(fontText,s,themeTextColor); \
	- applySurface(w-260-surface->w,(y-surface->h)/2,surface,stats,NULL); \
	- SDL_FreeSurface(surface); \
	- sprintf(s,fmt,statsMgr.player##var); \
	- surface=TTF_RenderUTF8_Blended(fontText,s,themeTextColor); \
	- applySurface(w-140-surface->w,(y-surface->h)/2,surface,stats,NULL); \
	- SDL_FreeSurface(surface); \
	- sprintf(s,fmt,statsMgr.shadow##var); \
	- surface=TTF_RenderUTF8_Blended(fontText,s,themeTextColor); \
	- applySurface(w-20-surface->w,(y-surface->h)/2,surface,stats,NULL); \
	- SDL_FreeSurface(surface); \
	- list->addItem("",stats); /* add it to list box */ \
	+ 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 SDL_Surface* drawMiscStatistics1(int w,GUIListBox list,const char name1,const T1 var1,const char* format1){
	+static void drawMiscStatistics1(SDL_Renderer& renderer, int w,GUIListBox list,const char name1,const T1 var1,const char* format1){
	//create new surface
	- SDL_Surface* surface=TTF_RenderUTF8_Blended(fontGUISmall,name1,themeTextColor);
	+ SurfacePtr nameSurface(TTF_RenderUTF8_Blended(fontGUISmall,name1,themeTextColor));

	- SDL_Surface* stats=SDL_CreateRGBSurface(SCREEN_FLAGS,w,surface->h,
	- screen->format->BitsPerPixel,screen->format->Rmask,screen->format->Gmask,screen->format->Bmask,0);
	- SDL_FillRect(stats,NULL,-1);
	+ SurfacePtr stats=createSurface(w, nameSurface->h);
	+ SDL_FillRect(stats.get(),NULL,-1);

	- applySurface(4,0,surface,stats,NULL);
	- int x=surface->w+8;
	- int y=surface->h;
	- SDL_FreeSurface(surface);
	+ applySurface(4,0,nameSurface.get(),stats.get(),NULL);
	+ const int x=nameSurface->w+8;
	+ const int y=nameSurface->h;

	//draw value
	- char s[1024];
	- sprintf(s,format1,var1);
	- surface=TTF_RenderUTF8_Blended(fontText,s,themeTextColor);
	- applySurface(x,(y-surface->h)/2,surface,stats,NULL);
	- SDL_FreeSurface(surface);
	+ //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("",stats);
	+ list->addItem(renderer, "",textureFromSurface(renderer, std::move(stats)));

	//over
	- return stats;
	+ //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>
	+/*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(){
	+void StatisticsScreen::createGUI(ImageManager& imageManager, SDL_Renderer &renderer){
	//Create the root element of the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	- GUIObjectRoot=new GUIObject(0,0,SCREEN_WIDTH,SCREEN_HEIGHT);
	+ GUIObjectRoot=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

	//Create back button.
	- GUIObject* obj=new GUIButton(SCREEN_WIDTH*0.5,SCREEN_HEIGHT-60,-1,36,_("Back"),0,true,true,GUIGravityCenter);
	+ 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((SCREEN_WIDTH-500)/2,104,500,32);
	+ 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(64,150,SCREEN_WIDTH-128,SCREEN_HEIGHT-150-72);
	+ 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;
	- SDL_Surface *surface=statsMgr.createAchievementSurface(&achievementList[idx],NULL,&r,false,lpt);
	+ auto surface= statsMgr.createAchievementSurface(renderer, &achievementList[idx],&r,false,lpt);

	- if(surface!=NULL){
	- hlineRGBA(surface,0,surface->w,0,0,0,0,32);
	+ 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("",surface);
	+ 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(64,150,SCREEN_WIDTH-128,SCREEN_HEIGHT-150-72,true,false);
	+ 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
	- SDL_Surface* bmPlayer=loadImage(getDataPath()+"themes/Cloudscape/characters/player.png");
	- SDL_Surface* bmShadow=loadImage(getDataPath()+"themes/Cloudscape/characters/shadow.png");
	- SDL_Surface* bmMedal=loadImage(getDataPath()+"gfx/medals.png");
	+ //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];
	- SDL_Surface stats,surface,*h_bar;
	+ //char s[64],s2[64];
	+ std::array<char, 64> formatString;
	+
	SDL_Rect r;
	int x,y,w=SCREEN_WIDTH-128;
	- Uint32 clr=SDL_MapRGB(screen->format,themeTextColor.r,themeTextColor.g,themeTextColor.b);
	-
	- //The horizontal bar.
	- h_bar=SDL_CreateRGBSurface(SDL_SWSURFACE,w,2,
	- screen->format->BitsPerPixel,screen->format->Rmask,screen->format->Gmask,screen->format->Bmask,0);
	- SDL_FillRect(h_bar,NULL,clr);
	+ 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.
	- stats=SDL_CreateRGBSurface(SCREEN_FLAGS,w,44,
	- screen->format->BitsPerPixel,screen->format->Rmask,screen->format->Gmask,screen->format->Bmask,0);
	- SDL_FillRect(stats,NULL,-1);
	+ {
	+ SurfacePtr stats = createSurface(w, 44);
	+ SDL_FillRect(stats.get(),NULL,-1);

	- surface=TTF_RenderUTF8_Blended(fontGUISmall,_("Total"),themeTextColor);
	- applySurface(w-260-surface->w,stats->h-surface->h,surface,stats,NULL);
	- SDL_FreeSurface(surface);
	- //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->h-40,bmPlayer,stats,&r);
	- applySurface(w-20-r.w,stats->h-40,bmShadow,stats,&r);
	+ 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("",stats);
	+ 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");
	+ {
	+ 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("",SDL_DisplayFormat(h_bar));
	+ list->addItem(renderer, "",h_bar);
	+
	+ auto drawMiscStats = [&](const char* name1,const int var1,const char* format1) {
	+ drawMiscStatistics1(renderer, w, list, name1, var1, format1);
	+ };

	- drawMiscStatistics2(w,list,_("Recordings:"),statsMgr.recordTimes,"%d",_("Switch pulled times:"),statsMgr.switchTimes,"%d");
	- drawMiscStatistics1(w,list,_("Swap times:"),statsMgr.swapTimes,"%d");
	- drawMiscStatistics2(w,list,_("Save times:"),statsMgr.saveTimes,"%d",_("Load times:"),statsMgr.loadTimes,"%d");
	+ 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("",SDL_DisplayFormat(h_bar));
	-
	- surface=TTF_RenderUTF8_Blended(fontGUISmall,_("Completed levels:"),themeTextColor);
	- stats=SDL_CreateRGBSurface(SCREEN_FLAGS,w,surface->h,
	- screen->format->BitsPerPixel,screen->format->Rmask,screen->format->Gmask,screen->format->Bmask,0);
	- SDL_FillRect(stats,NULL,-1);
	-
	- applySurface(4,0,surface,stats,NULL);
	- x=surface->w+8;
	- y=surface->h;
	- SDL_FreeSurface(surface);
	-
	- sprintf(s,"%d",statsMgr.completedLevels);
	- surface=TTF_RenderUTF8_Blended(fontText,s,themeTextColor);
	- applySurface(x,(y-surface->h)/2,surface,stats,NULL);
	- SDL_FreeSurface(surface);
	-
	- sprintf(s,"%d",statsMgr.completedLevels-statsMgr.goldLevels-statsMgr.silverLevels);
	- surface=TTF_RenderUTF8_Blended(fontText,s,themeTextColor);
	- applySurface(w-260-surface->w,(y-surface->h)/2,surface,stats,NULL);
	- r.x=0;r.y=0;r.w=30;r.h=30;
	- applySurface(w-260-surface->w-30,(y-30)/2,bmMedal,stats,&r);
	- SDL_FreeSurface(surface);
	-
	- sprintf(s,"%d",statsMgr.silverLevels);
	- surface=TTF_RenderUTF8_Blended(fontText,s,themeTextColor);
	- applySurface(w-140-surface->w,(y-surface->h)/2,surface,stats,NULL);
	- r.x+=30;
	- applySurface(w-140-surface->w-30,(y-30)/2,bmMedal,stats,&r);
	- SDL_FreeSurface(surface);
	-
	- sprintf(s,"%d",statsMgr.goldLevels);
	- surface=TTF_RenderUTF8_Blended(fontText,s,themeTextColor);
	- applySurface(w-20-surface->w,(y-surface->h)/2,surface,stats,NULL);
	- r.x+=30;
	- applySurface(w-20-surface->w-30,(y-30)/2,bmMedal,stats,&r);
	- SDL_FreeSurface(surface);
	-
	- list->addItem("",stats);
	+ 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)/2,surface.get(),stats.get(),NULL);
	+ 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("",SDL_DisplayFormat(h_bar));
	-
	- sprintf(s,"%02d:%02d:%02d",statsMgr.playTime/3600,(statsMgr.playTime/60)%60,statsMgr.playTime%60);
	- sprintf(s2,"%02d:%02d:%02d",statsMgr.levelEditTime/3600,(statsMgr.levelEditTime/60)%60,statsMgr.levelEditTime%60);
	- drawMiscStatistics2(w,list,_("In-game time:"),s,"%s",_("Level editing time:"),s2,"%s");
	+ list->addItem(renderer, "",h_bar);

	- drawMiscStatistics1(w,list,_("Created levels:"),statsMgr.createdLevels,"%d");
	+ 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");

	- //Clean up
	- SDL_FreeSurface(h_bar);
	+ 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(){
	+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(){
	+void StatisticsScreen::logic(ImageManager&, SDL_Renderer&){
	}

	//This method handles all the rendering.
	-void StatisticsScreen::render(){
	+void StatisticsScreen::render(ImageManager&, SDL_Renderer& renderer){
	//Draw background.
	- objThemes.getBackground(true)->draw(screen);
	+ objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();

	//Draw title.
	- applySurface((SCREEN_WIDTH-title->w)/2,40-TITLE_FONT_RAISE,title,screen,NULL);
	+ 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(){
	+void StatisticsScreen::resize(ImageManager &imageManager, SDL_Renderer &renderer){
	//Recreate the gui to fit the new resolution.
	- createGUI();
	+ createGUI(imageManager, renderer);
	}
	diff --git a/src/StatisticsScreen.h b/src/StatisticsScreen.h
	index 7614fb6..43e9450 100644
	--- a/src/StatisticsScreen.h
	+++ b/src/StatisticsScreen.h
	@@ -1,67 +1,69 @@
	/*
	* 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 STATISTICSSCREEN_H
	#define STATISTICSSCREEN_H

	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>
	#include "GameState.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	+#include "Render.h"

	class StatisticsScreen:public GameState, private GUIEventCallback{
	private:
	//Contains title.
	- SDL_Surface* title;
	+ //SDL_Surface* title;
	+ TexturePtr title;

	//The list box used to switch between statistics and achievements.
	GUISingleLineListBox* listBox;

	//The list widgets used for achievements and statistics.
	std::vector<GUIListBox*> lists;

	//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 GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType);
	+ void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType);
	public:
	//Constructor.
	- StatisticsScreen();
	+ StatisticsScreen(ImageManager &imageManager, SDL_Renderer& renderer);
	//Destructor.
	virtual ~StatisticsScreen();

	//Method that will create the GUI for the options menu.
	- void createGUI();
	+ void createGUI(ImageManager &imageManager, SDL_Renderer& renderer);

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

	//All the logic that needs to be done should go in this method.
	- virtual void logic();
	+ virtual void logic(ImageManager&, SDL_Renderer&) override;

	//This method handles all the rendering.
	- virtual void render();
	+ virtual void render(ImageManager&, SDL_Renderer& renderer) override;

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

	#endif
	diff --git a/src/ThemeManager.cpp b/src/ThemeManager.cpp
	index 041903d..2a05634 100644
	--- a/src/ThemeManager.cpp
	+++ b/src/ThemeManager.cpp
	@@ -1,991 +1,979 @@
	/*
	* 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 "ThemeManager.h"
	#include "POASerializer.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Game.h"
	+#include "ImageManager.h"
	+
	#ifdef __APPLE__
	#include <SDL_gfx/SDL_rotozoom.h>
	#else
	-#include <SDL/SDL_rotozoom.h>
	+#include <SDL2/SDL2_rotozoom.h>
	#endif
	#include <string.h>
	#include <iostream>
	using namespace std;

	//The ThemeStack that is be used by the GameState.
	ThemeStack objThemes;

	-bool ThemeManager::loadFile(const string& fileName){
	+bool ThemeManager::loadFile(const string& fileName, ImageManager &imageManager, SDL_Renderer &renderer){
	POASerializer objSerializer;
	TreeStorageNode objNode;

	//First we destroy the current ThemeManager.
	destroy();

	//Now we try to load the file, if it fails we return false.
	if(!objSerializer.loadNodeFromFile(fileName.c_str(),&objNode,true)){
	cerr<<"ERROR: Unable to open theme file: "<<fileName<<endl;
	return false;
	}

	//Set the themePath.
	themePath=pathFromFileName(fileName);

	//Retrieve the name of the theme from the file.
	{
	vector<string> &v=objNode.attributes["name"];
	if(!v.empty()) themeName=v[0];
	}

	//Reset themeable colors to default
	themeTextColor.r=themeTextColor.g=themeTextColor.b=0;
	themeTextColorDialog.r=themeTextColorDialog.g=themeTextColorDialog.b=0;

	//Read themeable colors if any
	vector<string> &ct=objNode.attributes["textColor"];
	if(!ct.empty()){
	themeTextColor.r=atoi(ct[0].c_str());
	themeTextColor.g=atoi(ct[1].c_str());
	themeTextColor.b=atoi(ct[2].c_str());
	}

	vector<string> &ct2=objNode.attributes["textColorDialog"];
	if(!ct2.empty()){
	themeTextColorDialog.r=atoi(ct2[0].c_str());
	themeTextColorDialog.g=atoi(ct2[1].c_str());
	themeTextColorDialog.b=atoi(ct2[2].c_str());
	}

	//Loop the subnodes of the theme.
	for(unsigned int i=0;i<objNode.subNodes.size();i++){
	TreeStorageNode *obj=objNode.subNodes[i];

	//Check if it's a block or a background.
	if(obj->name=="block" && !obj->value.empty()){
	map<string,int>::iterator it=Game::blockNameMap.find(obj->value[0]);
	if(it!=Game::blockNameMap.end()){
	int idx=it->second;
	if(!objBlocks[idx]) objBlocks[idx]=new ThemeBlock;
	- if(!objBlocks[idx]->loadFromNode(obj,themePath)){
	+ if(!objBlocks[idx]->loadFromNode(obj,themePath, imageManager, renderer)){
	cerr<<"ERROR: Unable to load "<<Game::blockName[idx]<<" for theme "<<fileName<<endl;
	delete objBlocks[idx];
	objBlocks[idx]=NULL;
	return false;
	}
	}
	}else if(obj->name=="background" && !obj->value.empty()){
	if(!objBackground) objBackground=new ThemeBackground();
	- if(!objBackground->addPictureFromNode(obj,themePath)){
	+ if(!objBackground->addPictureFromNode(obj,themePath, imageManager, renderer)){
	cerr<<"ERROR: Unable to load background for theme "<<fileName<<endl;
	delete objBackground;
	objBackground=NULL;
	return false;
	}
	}else if(obj->name=="character" && !obj->value.empty()){
	if(obj->value[0]=="Shadow"){
	if(!shadow) shadow=new ThemeBlock();
	- if(!shadow->loadFromNode(obj,themePath)){
	+ if(!shadow->loadFromNode(obj,themePath, imageManager, renderer)){
	cerr<<"ERROR: Unable to load shadow for theme "<<fileName<<endl;
	delete shadow;
	shadow=NULL;
	return false;
	}
	}else if(obj->value[0]=="Player"){
	if(!player) player=new ThemeBlock();
	- if(!player->loadFromNode(obj,themePath)){
	+ if(!player->loadFromNode(obj,themePath, imageManager, renderer)){
	cerr<<"ERROR: Unable to load player for theme "<<fileName<<endl;
	delete player;
	player=NULL;
	return false;
	}
	}
	}else if(obj->name=="menuBackground" && !obj->value.empty()){
	if(!menuBackground) menuBackground=new ThemeBackground();
	- if(!menuBackground->addPictureFromNode(obj,themePath)){
	+ if(!menuBackground->addPictureFromNode(obj,themePath, imageManager, renderer)){
	cerr<<"ERROR: Unable to load background for theme "<<fileName<<endl;
	delete menuBackground;
	menuBackground=NULL;
	return false;
	}
	}else if(obj->name=="menu" && obj->value[0]=="Block"){
	if(!menuBlock) menuBlock=new ThemeBlock;
	- if(!menuBlock->loadFromNode(obj,themePath)){
	+ if(!menuBlock->loadFromNode(obj,themePath, imageManager, renderer)){
	cerr<<"ERROR: Unable to load menu block for theme "<<fileName<<endl;
	delete menuBlock;
	menuBlock=NULL;
	return false;
	}
	}
	}

	//Done and nothing went wrong so return true.
	return true;
	}

	-bool ThemeBlock::loadFromNode(TreeStorageNode* objNode, string themePath){
	+bool ThemeBlock::loadFromNode(TreeStorageNode* objNode, string themePath, ImageManager &imageManager, SDL_Renderer &renderer){
	destroy();

	//Loop the subNodes.
	for(unsigned int i=0;i<objNode->subNodes.size();i++){
	TreeStorageNode *obj=objNode->subNodes[i];

	//Check if the subnode is an editorPicture or a blockState.
	if(obj->name=="editorPicture"){
	- if(!editorPicture.loadFromNode(obj,themePath)) return false;
	+ if(!editorPicture.loadFromNode(obj,themePath, imageManager, renderer)) return false;
	//NOTE: blockState and characterState are for backwards compatability, use state instead.
	}else if((obj->name=="blockState" \|\| obj->name=="characterState" \|\| obj->name=="state") && !obj->value.empty()){
	string& s=obj->value[0];
	map<string,ThemeBlockState*>::iterator it=blockStates.find(s);
	if(it==blockStates.end()) blockStates[s]=new ThemeBlockState;
	- if(!blockStates[s]->loadFromNode(obj,themePath)) return false;
	+ if(!blockStates[s]->loadFromNode(obj,themePath, imageManager, renderer)) return false;
	}else if(obj->name=="transitionState" && obj->value.size()==2){
	pair<string,string> s=pair<string,string>(obj->value[0],obj->value[1]);
	map<pair<string,string>,ThemeBlockState*>::iterator it=transitions.find(s);
	if(it==transitions.end()) transitions[s]=new ThemeBlockState;
	- if(!transitions[s]->loadFromNode(obj,themePath)) return false;
	+ if(!transitions[s]->loadFromNode(obj,themePath, imageManager, renderer)) return false;
	}
	}

	//Done and nothing went wrong so return true.
	return true;
	}

	-bool ThemeBlockState::loadFromNode(TreeStorageNode* objNode, string themePath){
	+bool ThemeBlockState::loadFromNode(TreeStorageNode* objNode, string themePath, ImageManager& imageManager, SDL_Renderer& renderer){
	destroy();

	//Retrieve the oneTimeAnimation attribute.
	{
	vector<string> &v=objNode->attributes["oneTimeAnimation"];

	//Check if there are enough values for the oneTimeAnimation attribute.
	if(v.size()>=2 && !v[0].empty()){
	oneTimeAnimationLength=atoi(v[0].c_str());
	nextState=v[1];
	}
	}

	//Loop the subNodes.
	for(unsigned int i=0;i<objNode->subNodes.size();i++){
	TreeStorageNode *obj=objNode->subNodes[i];
	if(obj->name=="object"){
	ThemeObject *obj1=new ThemeObject();
	- if(!obj1->loadFromNode(obj,themePath)){
	+ if(!obj1->loadFromNode(obj,themePath, imageManager, renderer)){
	delete obj1;
	return false;
	}
	themeObjects.push_back(obj1);
	}
	}

	//Done and nothing went wrong so return true.
	return true;
	}

	-bool ThemeObject::loadFromNode(TreeStorageNode* objNode,string themePath){
	+bool ThemeObject::loadFromNode(TreeStorageNode* objNode,string themePath, ImageManager& imageManager, SDL_Renderer& renderer){
	destroy();

	//Retrieve the animation attribute.
	{
	vector<string> &v=objNode->attributes["animation"];
	if(v.size()>=2){
	animationLength=atoi(v[0].c_str());
	animationLoopPoint=atoi(v[1].c_str());
	}
	}
	//Retrieve the oneTimeAnimation attribute.
	{
	vector<string> &v=objNode->attributes["oneTimeAnimation"];
	if(v.size()>=2){
	animationLength=atoi(v[0].c_str());
	animationLoopPoint=atoi(v[1].c_str())\|0x80000000;
	}
	}
	//Retrieve the invisibleAtRunTime attribute.
	{
	vector<string> &v=objNode->attributes["invisibleAtRunTime"];
	if(!v.empty() && !v[0].empty()){
	invisibleAtRunTime=atoi(v[0].c_str())?true:false;
	}
	}
	//Retrieve the invisibleAtDesignTime attribute.
	{
	vector<string> &v=objNode->attributes["invisibleAtDesignTime"];
	if(!v.empty() && !v[0].empty()){
	invisibleAtDesignTime=atoi(v[0].c_str())?true:false;
	}
	}

	//Loop the subnodes.
	for(unsigned int i=0;i<objNode->subNodes.size();i++){
	TreeStorageNode *obj=objNode->subNodes[i];
	if(obj->name=="picture" \|\| obj->name=="pictureAnimation"){
	- if(!picture.loadFromNode(obj,themePath)){
	+ if(!picture.loadFromNode(obj,themePath, imageManager, renderer)){
	return false;
	}
	}else if(obj->name=="editorPicture"){
	- if(!editorPicture.loadFromNode(obj,themePath)){
	+ if(!editorPicture.loadFromNode(obj,themePath, imageManager, renderer)){
	return false;
	}
	}else if(obj->name=="optionalPicture" && obj->value.size()>=6){
	ThemePicture *objPic=new ThemePicture();
	double f=atof(obj->value[5].c_str());
	- if(!objPic->loadFromNode(obj,themePath)){
	+ if(!objPic->loadFromNode(obj,themePath, imageManager, renderer)){
	delete objPic;
	return false;
	}
	optionalPicture.push_back(pair<double,ThemePicture*>(f,objPic));
	}else if(obj->name=="offset" \|\| obj->name=="offsetAnimation"){
	if(!offset.loadFromNode(obj)) return false;
	}else if(obj->name=="positioning"){
	if(!positioning.loadFromNode(obj)) return false;
	}
	}

	//Done and nothing went wrong so return true.
	return true;
	}

	-bool ThemePicture::loadFromNode(TreeStorageNode* objNode,string themePath){
	+bool ThemePicture::loadFromNode(TreeStorageNode* objNode, string themePath, ImageManager &imageManager, SDL_Renderer &renderer){
	destroy();

	//Check if the node has enough values.
	if(!objNode->value.empty()){
	- //Load the picture.
	- picture=loadImage(themePath+objNode->value[0]);
	- if(picture==NULL) return false;
	+ //Load the texture.
	+ texture=imageManager.loadTexture(themePath+objNode->value[0], renderer);
	+ if(!texture) {
	+ return false;
	+ }

	//Check if it's an animation.
	if(objNode->name=="pictureAnimation"){
	if(!offset.loadFromNode(objNode)) return false;
	return true;
	}else if(objNode->value.size()>=5){
	typeOffsetPoint r={atoi(objNode->value[1].c_str()),
	atoi(objNode->value[2].c_str()),
	atoi(objNode->value[3].c_str()),
	atoi(objNode->value[4].c_str()),0,0};
	offset.offsetData.push_back(r);
	offset.length=0;
	return true;
	}
	}

	//Done and nothing went wrong so return true.
	return false;
	}

	bool ThemeOffsetData::loadFromNode(TreeStorageNode* objNode){
	destroy();

	//Check what kind of offset it is.
	if(objNode->name=="pictureAnimation"){
	for(unsigned int i=0;i<objNode->subNodes.size();i++){
	TreeStorageNode* obj=objNode->subNodes[i];
	if(obj->name=="point" && obj->value.size()>=4){
	typeOffsetPoint r={atoi(obj->value[0].c_str()),
	atoi(obj->value[1].c_str()),
	atoi(obj->value[2].c_str()),
	atoi(obj->value[3].c_str()),1,1};
	if(obj->value.size()>=5) r.frameCount=atoi(obj->value[4].c_str());
	if(obj->value.size()>=6) r.frameDisplayTime=atoi(obj->value[5].c_str());
	offsetData.push_back(r);
	length+=r.frameCount*r.frameDisplayTime;
	}
	}
	return true;
	}else if(objNode->name=="offsetAnimation"){
	for(unsigned int i=0;i<objNode->subNodes.size();i++){
	TreeStorageNode* obj=objNode->subNodes[i];
	if(obj->name=="point" && obj->value.size()>=2){
	typeOffsetPoint r={atoi(obj->value[0].c_str()),
	atoi(obj->value[1].c_str()),0,0,1,1};
	if(obj->value.size()>=3) r.frameCount=atoi(obj->value[2].c_str());
	if(obj->value.size()>=4) r.frameDisplayTime=atoi(obj->value[3].c_str());
	offsetData.push_back(r);
	length+=r.frameCount*r.frameDisplayTime;
	}
	}
	return true;
	}else if(objNode->name=="offset" && objNode->value.size()>=2){
	typeOffsetPoint r={atoi(objNode->value[0].c_str()),
	atoi(objNode->value[1].c_str()),0,0,0,0};
	if(objNode->value.size()>2)
	r.w=atoi(objNode->value[2].c_str());
	if(objNode->value.size()>3)
	r.h=atoi(objNode->value[3].c_str());
	offsetData.push_back(r);
	length=0;
	return true;
	}

	//Done and nothing went wrong so return true.
	return false;
	}

	bool ThemePositioningData::loadFromNode(TreeStorageNode* objNode){
	destroy();

	//Check if enough values are set.
	if(objNode->value.size()>=2){
	//Check horizontal alignment.
	if(objNode->value[0]=="left"){
	horizontalAlign=LEFT;
	}else if(objNode->value[0]=="centre"){
	horizontalAlign=CENTRE;
	}else if(objNode->value[0]=="right"){
	horizontalAlign=RIGHT;
	}else if(objNode->value[0]=="repeat"){
	horizontalAlign=REPEAT;
	}
	//Check vertical alignment.
	if(objNode->value[1]=="top"){
	verticalAlign=TOP;
	}else if(objNode->value[1]=="middle"){
	verticalAlign=MIDDLE;
	}else if(objNode->value[1]=="bottom"){
	verticalAlign=BOTTOM;
	}else if(objNode->value[1]=="repeat"){
	verticalAlign=REPEAT;
	}
	//Done and nothing went wrong so return true.
	return true;
	}

	return false;
	}

	-void ThemeObjectInstance::draw(SDL_Surface dest,int x,int y,int w,int h,SDL_Rect clipRect){
	+void ThemeObjectInstance::draw(SDL_Renderer& renderer,int x,int y,int w,int h,SDL_Rect *clipRect){
	//Get the picture.
	- SDL_Surface *src=picture->picture;
	+ //SDL_Surface *src=picture->picture;
	+ SDL_Texture* src = picture->texture.get();
	if(src==NULL) return;
	int ex=0,ey=0,ew=0,eh=0;
	int xx=0,yy=0,ww=0,hh=0;
	int animationNew=animation&0x7FFFFFFF;
	{
	- vector<typeOffsetPoint> &v=picture->offset.offsetData;
	+ const vector<typeOffsetPoint> &v=picture->offset.offsetData;
	if(picture->offset.length==0 \|\| animationNew<v[0].frameDisplayTime){
	xx=v[0].x;
	yy=v[0].y;
	ww=v[0].w;
	hh=v[0].h;
	}else if(animationNew>=picture->offset.length){
	int i=v.size()-1;
	xx=v[i].x;
	yy=v[i].y;
	ww=v[i].w;
	hh=v[i].h;
	}else{
	int t=animationNew-v[0].frameDisplayTime;
	for(unsigned int i=1;i<v.size();i++){
	int tt=t/v[i].frameDisplayTime;
	if(tt>=0 && tt<v[i].frameCount){
	xx=(int)((float)v[i-1].x+(float)(v[i].x-v[i-1].x)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	yy=(int)((float)v[i-1].y+(float)(v[i].y-v[i-1].y)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	ww=(int)((float)v[i-1].w+(float)(v[i].w-v[i-1].w)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	hh=(int)((float)v[i-1].h+(float)(v[i].h-v[i-1].h)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	break;
	}else{
	t-=v[i].frameCount*v[i].frameDisplayTime;
	}
	}
	}
	}
	//Get the offset.
	{
	vector<typeOffsetPoint> &v=parent->offset.offsetData;
	if(v.empty()){
	ex=0;
	ey=0;
	}else if(parent->offset.length==0 \|\| animationNew<v[0].frameDisplayTime){
	ex=v[0].x;
	ey=v[0].y;
	ew=v[0].w;
	eh=v[0].h;
	}else if(animationNew>=parent->offset.length){
	int i=v.size()-1;
	ex=v[i].x;
	ey=v[i].y;
	ew=v[i].w;
	eh=v[i].h;
	}else{
	int t=animationNew-v[0].frameDisplayTime;
	for(unsigned int i=1;i<v.size();i++){
	int tt=t/v[i].frameDisplayTime;
	if(tt>=0 && tt<v[i].frameCount){
	ex=(int)((float)v[i-1].x+(float)(v[i].x-v[i-1].x)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	ey=(int)((float)v[i-1].y+(float)(v[i].y-v[i-1].y)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	ew=(int)((float)v[i-1].w+(float)(v[i].w-v[i-1].w)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	eh=(int)((float)v[i-1].h+(float)(v[i].h-v[i-1].h)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	break;
	}else{
	t-=v[i].frameCount*v[i].frameDisplayTime;
	}
	}
	}
	}

	//And finally draw the ThemeObjectInstance.
	if(clipRect){
	int d;
	d=clipRect->x-ex;
	if(d>0){
	ex+=d;
	xx+=d;
	ww-=d;
	}
	d=clipRect->y-ey;
	if(d>0){
	ey+=d;
	yy+=d;
	hh-=d;
	}
	if(ww>clipRect->w) ww=clipRect->w;
	if(hh>clipRect->h) hh=clipRect->h;
	}
	if(ww>0&&hh>0){
	SDL_Rect r1={xx,yy,ww,hh};
	SDL_Rect r2={x+ex,y+ey,0,0};
	//Only align horizontally when there's a width.
	if(w!=0){
	switch(parent->positioning.horizontalAlign){
	case LEFT:
	//NOTE: No need to change the x location, left is default.
	break;
	case CENTRE:
	r2.x+=(w-r1.w)/2;
	break;
	case RIGHT:
	r2.x+=w-ww;
	break;
	}
	}
	//Only align vertically when there's a height.
	if(h!=0){
	switch(parent->positioning.verticalAlign){
	case TOP:
	//NOTE: No need to change the y location, top is default.
	break;
	case MIDDLE:
	r2.y+=(h-r1.h)/2;
	break;
	case BOTTOM:
	r2.y+=h-hh;
	break;
	}
	}
	//Set the targets to the draw location plus one to ensure it gets drawn at least once.
	int targetX=r2.x+1;
	int targetY=r2.y+1;
	if(w!=0 && parent->positioning.horizontalAlign==REPEAT)
	targetX=x+w-ew;
	if(h!=0 && parent->positioning.verticalAlign==REPEAT)
	targetY=y+h-eh;

	//As long as we haven't exceeded the horizontal target keep drawing.
	while(r2.x<targetX){
	//Store the y position for when more than one column has to be drawn.
	- int y2=r2.y;
	+ const int y2=r2.y;
	//As long as we haven't exceeded the vertical target keep drawing.
	while(r2.y<targetY){
	//Check if we should clip.
	SDL_Rect srcrect={r1.x,r1.y,r1.w,r1.h};
	if(w!=0 && r2.x+r1.w>x+w-ew)
	srcrect.w-=(r2.x+r1.w)-(x+w-ew);
	if(h!=0 && r2.y+r1.h>y+h-eh)
	srcrect.h-=(r2.y+r1.h)-(y+h-eh);

	//NOTE: dstrect will hold the blit rectangle after calling SDL_BlitSurface, so we can't use r2.
	- SDL_Rect dstrect={r2.x,r2.y,0,0};
	- SDL_BlitSurface(src,&srcrect,dest,&dstrect);
	+ const SDL_Rect dstrect={r2.x,r2.y,srcrect.w,srcrect.h};
	+ //SDL_BlitSurface(src,&srcrect,dest,&dstrect);
	+ SDL_RenderCopy(&renderer, src, &srcrect, &dstrect);
	r2.y+=r1.h;
	}
	r2.x+=r1.w;

	//Reset the y position before drawing a new column.
	r2.y=y2;
	}

	}
	}

	void ThemeObjectInstance::updateAnimation(){
	//First get the animation length.
	int m;
	m=parent->animationLength;

	//If it's higher than 0 then we have an animation.
	if(m>0 && animation>=0){
	//Increase the animation frame.
	animation++;
	//Check if the animation is beyond the length, if so set it to the looppoint.
	if(animation>=m)
	animation=parent->animationLoopPoint;
	}
	}

	void ThemeBlockInstance::updateAnimation(){
	//Make sure the currentState isn't null.
	if(currentState!=NULL){
	//Call the updateAnimation method of the currentState.
	currentState->updateAnimation();

	//Get the length of the animation.
	int m=currentState->parent->oneTimeAnimationLength;

	//If it's higher than 0 then we have an animation.
	//Also check if it's past the lenght, meaning done.
	if(m>0 && currentState->animation>=m){
	//Now we can change the state to the nextState.
	changeState(currentState->parent->nextState);
	}
	}
	}

	void ThemeBlock::createInstance(ThemeBlockInstance* obj){
	//Make sure the given ThemeBlockInstance is ready.
	obj->blockStates.clear();
	obj->transitions.clear();
	obj->currentState=NULL;

	//Loop through the blockstates.
	for(map<string,ThemeBlockState*>::iterator it=blockStates.begin();it!=blockStates.end();++it){
	//Get the themeBlockStateInstance of the given ThemeBlockInstance.
	ThemeBlockStateInstance &obj1=obj->blockStates[it->first];
	//Set the parent of the state instance.
	obj1.parent=it->second;

	//Create the state instance.
	createStateInstance(&obj1);
	}

	//Loop through the transitions.
	for(map<pair<string,string>,ThemeBlockState*>::iterator it=transitions.begin();it!=transitions.end();++it){
	//Get the themeBlockStateInstance of the given ThemeBlockInstance.
	ThemeBlockStateInstance &obj1=obj->transitions[it->first];
	//Set the parent of the state instance.
	obj1.parent=it->second;

	//Create the state instance.
	createStateInstance(&obj1);
	}

	//Change the state to the default one.
	//FIXME: Is that needed?
	obj->changeState("default");
	}

	void ThemeBlock::createStateInstance(ThemeBlockStateInstance* obj){
	//Get the vector with themeObjects.
	vector<ThemeObject*> &v=obj->parent->themeObjects;

	//Loop through them.
	for(unsigned int i=0;i<v.size();i++){
	//Create an instance for every one.
	ThemeObjectInstance p;
	//Set the parent.
	p.parent=v[i];

	//Choose the picture.
	if(stateID==STATE_LEVEL_EDITOR){
	if(p.parent->invisibleAtDesignTime)
	continue;
	- if(p.parent->editorPicture.picture!=NULL)
	+ if(p.parent->editorPicture.texture!=NULL)
	p.picture=&p.parent->editorPicture;
	}else{
	if(p.parent->invisibleAtRunTime)
	continue;
	}

	//Get the number of optional Pictures.
	int m=p.parent->optionalPicture.size();
	//If p.picture is null, not an editor picture, and there are optional pictures then give one random.
	if(p.picture==NULL && m>0){
	double f=0.0,f1=1.0/256.0;
	for(int j=0;j<8;j++){
	f+=f1*(double)(rand()&0xff);
	f1*=(1.0/256.0);
	}
	for(int j=0;j<m;j++){
	f-=p.parent->optionalPicture[j].first;
	if(f<0.0){
	p.picture=p.parent->optionalPicture[j].second;
	break;
	}
	}
	}

	//If random turned out to give nothing then give the non optional picture.
	- if(p.picture==NULL && p.parent->picture.picture!=NULL)
	+ if(p.picture==NULL && p.parent->picture.texture!=NULL)
	p.picture=&p.parent->picture;
	//If the picture isn't null then can we give it to the ThemeBlockStateInstance.
	if(p.picture!=NULL)
	obj->objects.push_back(p);
	}
	}

	-void ThemePicture::draw(SDL_Surface dest,int x,int y,int animation,SDL_Rect clipRect){
	+void ThemePicture::draw(SDL_Renderer& renderer,int x,int y,int animation,SDL_Rect *clipRect){
	//Get the Picture.
	- if(picture==NULL) return;
	+ if(texture==NULL) return;
	int ex=0,ey=0,xx,yy,ww,hh;
	{
	- vector<typeOffsetPoint> &v=offset.offsetData;
	+ const vector<typeOffsetPoint> &v=offset.offsetData;
	if(offset.length==0 \|\| animation<v[0].frameDisplayTime){
	xx=v[0].x;
	yy=v[0].y;
	ww=v[0].w;
	hh=v[0].h;
	}else if(animation>=offset.length){
	int i=v.size()-1;
	xx=v[i].x;
	yy=v[i].y;
	ww=v[i].w;
	hh=v[i].h;
	}else{
	int t=animation-v[0].frameDisplayTime;
	for(unsigned int i=1;i<v.size();i++){
	int tt=t/v[i].frameDisplayTime;
	if(tt>=0 && tt<v[i].frameCount){
	xx=(int)((float)v[i-1].x+(float)(v[i].x-v[i-1].x)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	yy=(int)((float)v[i-1].y+(float)(v[i].y-v[i-1].y)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	ww=(int)((float)v[i-1].w+(float)(v[i].w-v[i-1].w)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	hh=(int)((float)v[i-1].h+(float)(v[i].h-v[i-1].h)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	break;
	}else{
	t-=v[i].frameCount*v[i].frameDisplayTime;
	}
	}
	}
	}

	//Draw the Picture.
	if(clipRect){
	int d;
	d=clipRect->x-ex;
	if(d>0){
	ex+=d;
	xx+=d;
	ww-=d;
	}
	d=clipRect->y-ey;
	if(d>0){
	ey+=d;
	yy+=d;
	hh-=d;
	}
	if(ww>clipRect->w) ww=clipRect->w;
	if(hh>clipRect->h) hh=clipRect->h;
	}
	if(ww>0&&hh>0){
	SDL_Rect r1={xx,yy,ww,hh};
	- SDL_Rect r2={x+ex,y+ey,0,0};
	- SDL_BlitSurface(picture,&r1,dest,&r2);
	+ SDL_Rect r2={x+ex,y+ey,ww,hh};
	+ //SDL_BlitSurface(picture,&r1,dest,&r2);
	+ SDL_RenderCopy(&renderer, texture.get(), &r1, &r2);
	}
	}

	//This method will scale the background picture (if needed and configured) to the current SCREEN_WIDTH and SCREEN_HEIGHT.
	void ThemeBackgroundPicture::scaleToScreen(){
	//Only scale if needed.
	if(scale){
	- //Free the surface of the scaled picture, if scaled.
	- if(picture!=cachedPicture)
	- SDL_FreeSurface(picture);
	- //Set src and destSize back to the initial cached value.
	- srcSize=cachedSrcSize;
	- destSize=cachedDestSize;
	-
	- //Scale the image.
	- //Calculate the x and y factors.
	- double xFactor=double(SCREEN_WIDTH)/double(100);
	- double yFactor=double(SCREEN_HEIGHT)/double(100);
	-
	- //The default scaling method is chosen (destSize in precentages).
	- destSize.x*=xFactor;
	- destSize.w*=xFactor;
	-
	- destSize.y*=yFactor;
	- destSize.h*=yFactor;
	-
	- //Now update the image.
	- xFactor=(double(destSize.w)/double(srcSize.w));
	- yFactor=(double(destSize.h)/double(srcSize.h));
	- if(xFactor!=1 \|\| yFactor!=1){
	- picture=zoomSurface(cachedPicture,xFactor,yFactor,0);
	- //Also update the source size.
	- srcSize.x*=xFactor;
	- srcSize.y*=yFactor;
	- srcSize.w*=xFactor;
	- srcSize.h*=yFactor;
	- }else{
	- //We don't need to scale the image
	- picture=cachedPicture;
	- }
	+ // SDL2 allows us to scale the texture when rendering, so
	+ // we only need to adjust the size of the destination rect.
	+ destSize.w = SCREEN_WIDTH;
	+ destSize.h = SCREEN_HEIGHT;
	}
	}

	-void ThemeBackgroundPicture::draw(SDL_Surface *dest){
	+void ThemeBackgroundPicture::draw(SDL_Renderer &dest){
	//Check if the picture is visible.
	- if(!(picture&&srcSize.w>0&&srcSize.h>0&&destSize.w>0&&destSize.h>0))
	+ if(!(texture&&srcSize.w>0&&srcSize.h>0&&destSize.w>0&&destSize.h>0))
	return;

	//Calculate the draw area.
	int sx=(int)((float)destSize.x+currentX-cameraX*(float)camera.x+0.5f);
	int sy=(int)((float)destSize.y+currentY-cameraY*(float)camera.y+0.5f);
	int ex,ey;

	//Include repeating.
	if(repeatX){
	sx%=destSize.w;
	if(sx>0) sx-=destSize.w;
	ex=SCREEN_WIDTH;
	}else{
	if(sx<=-(int)destSize.w \|\| sx>=SCREEN_WIDTH) return;
	ex=sx+1;
	}
	if(repeatY){
	sy%=destSize.h;
	if(sy>0) sy-=destSize.h;
	ey=SCREEN_HEIGHT;
	}else{
	if(sy<=-(int)destSize.h \|\| sy>=SCREEN_HEIGHT) return;
	ey=sy+1;
	}

	//And finally draw the ThemeBackgroundPicture.
	for(int x=sx;x<ex;x+=destSize.w){
	for(int y=sy;y<ey;y+=destSize.h){
	- SDL_Rect r={x,y,0,0};
	- SDL_BlitSurface(picture,&srcSize,dest,&r);
	+ // NOTE: Rendercopy cares about w/h here
	+ // so had to add it for SDL2 port.
	+ SDL_Rect r={x,y,destSize.w,destSize.h};
	+ //SDL_BlitSurface(picture,&srcSize,dest,&r);
	+ SDL_RenderCopy(&dest, texture.get(), &srcSize, &r);
	}
	}
	}

	-bool ThemeBackgroundPicture::loadFromNode(TreeStorageNode* objNode,string themePath){
	- //Load the picture.
	- picture=loadImage(themePath+objNode->value[0]);
	- //Store pointer to the cached picture.
	- cachedPicture=picture;
	- if(picture==NULL) return false;
	-
	+bool ThemeBackgroundPicture::loadFromNode(TreeStorageNode* objNode, string themePath, ImageManager &imageManager, SDL_Renderer& renderer){
	+ //FIXME
	+ // CHeck if a picture exists already.
	+
	+ //Load the picture directly into a texture.
	+ texture = imageManager.loadTexture(themePath+objNode->value[0], renderer); //SDL_CreateTextureFromSurface(sdlRenderer, picture);
	+ if (!texture) {
	+ std::cout << "Failed to create texture!" << std::endl;
	+ } else {
	+ std::cout << "Created texture from " << themePath << std::endl;
	+ }
	+
	//Retrieve the source size.
	{
	vector<string> &v=objNode->attributes["srcSize"];
	if(v.size()>=4){
	srcSize.x=atoi(v[0].c_str());
	srcSize.y=atoi(v[1].c_str());
	srcSize.w=atoi(v[2].c_str());
	srcSize.h=atoi(v[3].c_str());
	}else{
	srcSize.x=0;
	srcSize.y=0;
	- srcSize.w=picture->w;
	- srcSize.h=picture->h;
	+ // This gets the width and height of the texture.
	+ SDL_QueryTexture(texture.get(), NULL, NULL, &srcSize.w, &srcSize.h);
	+// srcSize.w=picture->w;
	+// srcSize.h=picture->h;
	}

	//Cache the sourcesize.
	cachedSrcSize=srcSize;
	}

	//Retrieve the destination size.
	{
	vector<string> &v=objNode->attributes["destSize"];
	if(v.size()>=4){
	destSize.x=atoi(v[0].c_str());
	destSize.y=atoi(v[1].c_str());
	destSize.w=atoi(v[2].c_str());
	destSize.h=atoi(v[3].c_str());
	}else{
	destSize.x=0;
	destSize.y=0;
	- destSize.w=100;
	- destSize.h=100;
	+ destSize.w=SCREEN_WIDTH;
	+ destSize.h=SCREEN_HEIGHT;
	}

	//Cache the destsize.
	cachedDestSize=destSize;
	}

	//Retrieve if we should scale to screen.
	{
	//Get scaleToScreen.
	vector<string> &v=objNode->attributes["scaleToScreen"];
	//Boolean if the image should be scaled, default is true.
	scale=true;
	if(!v.empty()){
	scale=atoi(v[0].c_str());
	}

	//Now scaleToScreen.
	//NOTE: We don't check if scaleToScreen is true or false since that is done in scaleToScreen();
	scaleToScreen();
	}

	//Retrieve if it should be repeated.
	{
	vector<string> &v=objNode->attributes["repeat"];
	if(v.size()>=2){
	repeatX=atoi(v[0].c_str())?true:false;
	repeatY=atoi(v[1].c_str())?true:false;
	}else{
	repeatX=true;
	repeatY=true;
	}
	}

	//Retrieve the speed.
	{
	vector<string> &v=objNode->attributes["speed"];
	if(v.size()>=2){
	speedX=atof(v[0].c_str());
	speedY=atof(v[1].c_str());
	}else{
	speedX=0.0f;
	speedY=0.0f;
	}
	}

	//Retrieve the camera speed.
	{
	vector<string> &v=objNode->attributes["cameraSpeed"];
	if(v.size()>=2){
	cameraX=atof(v[0].c_str());
	cameraY=atof(v[1].c_str());
	}else{
	cameraX=0.0f;
	cameraY=0.0f;
	}
	}

	//Done and nothing went wrong so return true.
	return true;
	}

	//Constructor.
	ThemeStack::ThemeStack(){
	}

	//Destructor.
	ThemeStack::~ThemeStack(){
	//Loop through the themes and delete them.
	for(unsigned int i=0;i<objThemes.size();i++)
	delete objThemes[i];
	}

	//Method that will destroy the ThemeStack.
	void ThemeStack::destroy(){
	//Loop through the themes and delete them.
	for(unsigned int i=0;i<objThemes.size();i++)
	delete objThemes[i];
	//Clear the vector to prevent dangling pointers.
	objThemes.clear();
	}

	//Method that will append a theme to the stack.
	//obj: The ThemeManager to add.
	void ThemeStack::appendTheme(ThemeManager* obj){
	objThemes.push_back(obj);
	//debug
	#if defined(DEBUG) \|\| defined(_DEBUG)
	cout<<"ThemeStack::appendTheme(): theme count="<<objThemes.size()<<endl;
	#endif
	}
	//Method that will remove the last theme added to the stack.
	void ThemeStack::removeTheme(){
	//Make sure that the stack isn't empty.
	if(!objThemes.empty()){
	delete objThemes.back();
	objThemes.pop_back();
	}
	}

	//Method that will append a theme that will be loaded from file.
	//fileName: The file to load the theme from.
	//Returns: Pointer to the newly added theme, NULL if failed.
	-ThemeManager* ThemeStack::appendThemeFromFile(const string& fileName){
	+ThemeManager* ThemeStack::appendThemeFromFile(const string& fileName, ImageManager &imageManager, SDL_Renderer &renderer){
	//Create a new themeManager.
	ThemeManager* obj=new ThemeManager();

	//Let it load from the given file.
	- if(!obj->loadFile(fileName)){
	+ if(!obj->loadFile(fileName, imageManager, renderer)){
	//Failed thus delete the theme and return null.
	cerr<<"ERROR: Failed loading theme "<<fileName<<endl;
	delete obj;
	return NULL;
	}else{
	//Succeeded, add it to the stack and return it.
	objThemes.push_back(obj);
	return obj;
	}
	}

	//Method that is used to let the themes scale.
	void ThemeStack::scaleToScreen(){
	//Loop through the themes and call their scaleToScreen method.
	for(unsigned int i=0;i<objThemes.size();i++)
	objThemes[i]->scaleToScreen();
	}

	//Get a pointer to the ThemeBlock of a given block type.
	//index: The type of block.
	//Returns: Pointer to the ThemeBlock.
	ThemeBlock* ThemeStack::getBlock(int index,bool menu){
	//Loop through the themes from top to bottom.
	for(int i=objThemes.size()-1;i>=0;i--){
	//Get the block from the theme.
	ThemeBlock* obj=objThemes[i]->getBlock(index,menu);
	//Check if it isn't null.
	if(obj)
	return obj;
	}

	//Nothing found.
	return NULL;
	}
	//Get a pointer to the ThemeBlock of the shadow or the player.
	//isShadow: Boolean if it's the shadow
	//Returns: Pointer to the ThemeBlock.
	ThemeBlock* ThemeStack::getCharacter(bool isShadow){
	//Loop through the themes from top to bottom.
	for(int i=objThemes.size()-1;i>=0;i--){
	//Get the ThemeBlock from the theme.
	ThemeBlock* obj=objThemes[i]->getCharacter(isShadow);
	//Check if it isn't null.
	if(obj)
	return obj;
	}

	//Nothing found.
	return NULL;
	}
	//Get a pointer to the ThemeBackground of the theme.
	//Returns: Pointer to the ThemeBackground.
	ThemeBackground* ThemeStack::getBackground(bool menu){
	//Loop through the themes from top to bottom.
	for(int i=objThemes.size()-1;i>=0;i--){
	//Get the ThemeBackground from the theme.
	ThemeBackground* obj=objThemes[i]->getBackground(menu);
	//Check if it isn't null.
	if(obj)
	return obj;
	}

	//Nothing found.
	return NULL;
	}
	diff --git a/src/ThemeManager.h b/src/ThemeManager.h
	index e3c7ff5..ee76430 100644
	--- a/src/ThemeManager.h
	+++ b/src/ThemeManager.h
	@@ -1,917 +1,918 @@
	/*
	* 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 THEMEMANAGER_H
	#define THEMEMANAGER_H

	#include "Globals.h"
	#include "TreeStorageNode.h"
	+#include "ImageManager.h"
	#ifdef __APPLE__
	-#include <SDL_gfx/SDL_rotozoom.h>
	+//TODO don't know if this works
	+#include <SDL2_gfx/SDL2_rotozoom.h>
	#else
	-#include <SDL/SDL_rotozoom.h>
	+#include <SDL2/SDL2_rotozoom.h>
	#endif
	#include <string.h>
	#include <math.h>
	#include <string>
	#include <vector>
	#include <utility>
	#include <iostream>
	using namespace std;

	//Structure containing offset data for one frame.
	struct typeOffsetPoint{
	//The location (x,y) and size (w,h).
	int x,y,w,h;
	//The frame to which this offset applies.
	int frameCount;
	//The number of frames this offset is shown.
	int frameDisplayTime;
	};

	//We already need the classes so declare them here.
	class ThemeOffsetData;
	class ThemePicture;
	class ThemeObject;
	class ThemeBlockState;
	class ThemeBlock;

	//Instance class of a ThemeObject, this is used by the other Instance classes.
	class ThemeObjectInstance{
	public:
	//Pointer to the picture.
	ThemePicture* picture;
	//Pointer to the parent the object an instance os is.
	ThemeObject* parent;

	//Integer containing the current animation frame.
	int animation;
	//Integer containing the saved animation frame.
	int savedAnimation;
	public:
	//Constructor.
	ThemeObjectInstance():picture(NULL),parent(NULL),animation(0),savedAnimation(0){}

	//Method used to draw the ThemeObject.
	//dest: The destination surface to draw the ThemeObject on.
	//x: The x location of the area to draw in.
	//y: The y location of the area to draw in.
	//w: The width of the area to draw in.
	//h: The height of the area to draw in.
	//clipRect: Rectangle used to clip.
	- void draw(SDL_Surface* dest,int x,int y,int w=0,int h=0,SDL_Rect* clipRect=NULL);
	+ void draw(SDL_Renderer& renderer,int x,int y,int w=0,int h=0,SDL_Rect* clipRect=NULL);

	//Method that will update the animation.
	void updateAnimation();

	//Method that will reset the animation.
	//save: Boolean if the saved animation should be deleted.
	void resetAnimation(bool save){
	animation=0;
	if(save){
	savedAnimation=0;
	}
	}
	//Method that will save the animation.
	void saveAnimation(){
	savedAnimation=animation;
	}
	//Method that will load a saved animation.
	void loadAnimation(){
	animation=savedAnimation;
	}
	};

	//Instance class of a ThemeBlockState, this is used by the ThemeBlockInstance.
	class ThemeBlockStateInstance{
	public:
	//Pointer to the parent the state an instance of is.
	ThemeBlockState *parent;
	//Vector containing the ThemeObjectInstances.
	vector<ThemeObjectInstance> objects;

	//Integer containing the current animation frame.
	int animation;
	//Integer containing the saved animation frame.
	int savedAnimation;
	public:
	//Constructor.
	ThemeBlockStateInstance():parent(NULL),animation(0),savedAnimation(0){}

	//Method used to draw the ThemeBlockState.
	//dest: The destination surface to draw the ThemeBlockState on.
	//x: The x location of the area to draw in.
	//y: The y location of the area to draw in.
	//w: The width of the area to draw in.
	//h: The height of the area to draw in.
	//clipRect: Rectangle used to clip.
	- void draw(SDL_Surface dest,int x,int y,int w=0,int h=0,SDL_Rect clipRect=NULL){
	+ void draw(SDL_Renderer& renderer,int x,int y,int w=0,int h=0,SDL_Rect *clipRect=NULL){
	for(unsigned int i=0;i<objects.size();i++){
	- objects[i].draw(dest,x,y,w,h,clipRect);
	+ objects[i].draw(renderer,x,y,w,h,clipRect);
	}
	}

	//Method that will update the animation.
	void updateAnimation(){
	for(unsigned int i=0;i<objects.size();i++){
	objects[i].updateAnimation();
	}
	animation++;
	}
	//Method that will reset the animation.
	//save: Boolean if the saved state should be deleted.
	void resetAnimation(bool save){
	for(unsigned int i=0;i<objects.size();i++){
	objects[i].resetAnimation(save);
	}
	animation=0;
	if(save){
	savedAnimation=0;
	}
	}
	//Method that will save the animation.
	void saveAnimation(){
	for(unsigned int i=0;i<objects.size();i++){
	objects[i].saveAnimation();
	}
	savedAnimation=animation;
	}
	//Method that will load a saved animation.
	void loadAnimation(){
	for(unsigned int i=0;i<objects.size();i++){
	objects[i].loadAnimation();
	}
	animation=savedAnimation;
	}
	};

	//Instance of a ThemeBlock, this is used by blocks in the game to prevent changing the theme in game.
	//It also allows animation to run independently.
	class ThemeBlockInstance{
	public:
	//Pointer to the current state.
	ThemeBlockStateInstance* currentState;
	//The name of the current state.
	string currentStateName;

	//Map containing the blockStates.
	map<string,ThemeBlockStateInstance> blockStates;
	//Map containing the blockTransitionStates.
	map<pair<string,string>,ThemeBlockStateInstance> transitions;
	//String containing the name of the saved state.
	string savedStateName;
	public:
	//Constructor.
	ThemeBlockInstance():currentState(NULL){}

	//Method used to draw the ThemeBlock.
	- //dest: The destination surface to draw the ThemeBlock on.
	+ //renderer: The destination renderer to draw the ThemeBlock on.
	//x: The x location of the area to draw in.
	//y: The y location of the area to draw in.
	//w: The width of the area to draw in.
	//h: The height of the area to draw in.
	//clipRect: Rectangle used to clip.
	//Returns: True if it succeeds.
	- bool draw(SDL_Surface dest,int x,int y,int w=0,int h=0,SDL_Rect clipRect=NULL){
	- if(currentState!=NULL){
	- currentState->draw(dest,x,y,w,h,clipRect);
	- return true;
	- }
	- return false;
	- }
	+ bool draw(SDL_Renderer& renderer,int x,int y,int w=0,int h=0,SDL_Rect *clipRect=NULL){
	+ if(currentState!=NULL){
	+ currentState->draw(renderer,x,y,w,h,clipRect);
	+ return true;
	+ }
	+ return false;
	+ }
	//Method that will draw a specific state.
	//s: The name of the state to draw.
	//dest: The destination surface to draw the ThemeBlock on.
	//x: The x location of the area to draw in.
	//y: The y location of the area to draw in.
	//w: The width of the area to draw in.
	//h: The height of the area to draw in.
	//clipRect: Rectangle used to clip.
	//Returns: True if it succeeds.
	- bool drawState(const string& s,SDL_Surface dest,int x,int y,int w=0,int h=0,SDL_Rect clipRect=NULL){
	+ bool drawState(const string& s,SDL_Renderer& renderer,int x,int y,int w=0,int h=0,SDL_Rect *clipRect=NULL){
	map<string,ThemeBlockStateInstance>::iterator it=blockStates.find(s);
	if(it!=blockStates.end()){
	- it->second.draw(dest,x,y,w,h,clipRect);
	+ it->second.draw(renderer,x,y,w,h,clipRect);
	return true;
	}
	return false;
	}

	//Method that will change the current state.
	//s: The name of the state to change to.
	//reset: Boolean if the animation should reset.
	//Returns: True if it succeeds (exists).
	bool changeState(const string& s,bool reset=true){
	bool newState=false;

	//First check if there's a transition.
	{
	pair<string,string> s1=pair<string,string>(currentStateName,s);
	map<pair<string,string>,ThemeBlockStateInstance>::iterator it=transitions.find(s1);
	if(it!=transitions.end()){
	currentState=&it->second;
	//NOTE: We set the currentState name to target state name.
	//Worst case senario is that the animation is skipped when saving/loading at a checkpoint.
	currentStateName=s;
	newState=true;
	}
	}

	//If there isn't a transition go directly to the state.
	if(!newState){
	//Get the new state.
	map<string,ThemeBlockStateInstance>::iterator it=blockStates.find(s);
	//Check if it exists.
	if(it!=blockStates.end()){
	currentState=&it->second;
	currentStateName=it->first;
	newState=true;
	}
	}

	//Check if a state has been found.
	if(newState){
	//FIXME: Is it needed to set the savedStateName here?
	if(savedStateName.empty())
	savedStateName=currentStateName;

	//If reset then reset the animation.
	if(reset)
	currentState->resetAnimation(true);
	return true;
	}

	//It doesn't so return false.
	return false;
	}

	//Method that will update the animation.
	void updateAnimation();
	//Method that will reset the animation.
	//save: Boolean if the saved state should be deleted.
	void resetAnimation(bool save){
	for(map<string,ThemeBlockStateInstance>::iterator it=blockStates.begin();it!=blockStates.end();++it){
	it->second.resetAnimation(save);
	}
	if(save){
	savedStateName.clear();
	}
	}
	//Method that will save the animation.
	void saveAnimation(){
	for(map<string,ThemeBlockStateInstance>::iterator it=blockStates.begin();it!=blockStates.end();++it){
	it->second.saveAnimation();
	}
	savedStateName=currentStateName;
	}
	//Method that will restore a saved animation.
	void loadAnimation(){
	for(map<string,ThemeBlockStateInstance>::iterator it=blockStates.begin();it!=blockStates.end();++it){
	it->second.loadAnimation();
	}
	changeState(savedStateName,false);
	}
	};

	//Class containing the offset data.
	class ThemeOffsetData{
	public:
	//Vector containing the offsetDatas.
	vector<typeOffsetPoint> offsetData;
	//The length of the "animation" in frames.
	int length;
	public:
	//Constructor.
	ThemeOffsetData():length(0){}
	//Destructor.
	~ThemeOffsetData(){}

	//Method used to destroy the offsetData.
	void destroy(){
	//Set length to zero.
	length=0;
	//And clear the offsetData vector.
	offsetData.clear();
	}

	//Method that will load the offsetData from a node.
	//objNode: Pointer to the TreeStorageNode to read the data from.
	//Returns: True if it succeeds without errors.
	bool loadFromNode(TreeStorageNode* objNode);
	};

	enum Alignment{
	//Horizontal alignments
	LEFT,
	CENTRE,
	RIGHT,

	//Vertical alignments
	TOP,
	MIDDLE,
	BOTTOM,

	//NOTE: Repeat can be used for both horizontal and vertical alignments.
	REPEAT
	};

	//Class containing the positioning and repeat data.
	class ThemePositioningData{
	public:
	//Horizontal and vertical alignment data.
	Alignment horizontalAlign,verticalAlign;
	public:
	//Constructor.
	ThemePositioningData(){}
	//Destructor.
	~ThemePositioningData(){}

	//Method used to destroy the positioningData.
	void destroy(){
	horizontalAlign=REPEAT;
	verticalAlign=REPEAT;
	}

	//Method that will load the positioningData from a node.
	//objNode: Pointer to the TreeStorageNode to read the data from.
	//Returns: True if it succeeds without errors.
	bool loadFromNode(TreeStorageNode* objNode);
	};

	//This is the lowest level of the theme system.
	//It's a picture with offset data.
	class ThemePicture{
	public:
	- //The SDL_Surface containing the picture.
	- SDL_Surface* picture;
	+ //Pointer to actual texture. Handled by ImageManager.
	+ SharedTexture texture;
	//Offset data for the picture.
	ThemeOffsetData offset;
	+ int x;
	+ int y;
	public:
	//Constructor.
	- ThemePicture():picture(NULL){}
	+ ThemePicture():texture(NULL), x(0), y(0){}
	//Destructor.
	~ThemePicture(){}

	//Method used to destroy the picture.
	void destroy(){
	- //FIXME: Shouldn't the image be freed? (ImageManager)
	- picture=NULL;
	+ //Freeing handled by ImageManager.
	+ //TODO: Unload unused images
	+ texture=NULL;
	//Destroy the offset data.
	offset.destroy();
	}
	- bool loadFromNode(TreeStorageNode* objNode, string themePath);
	+ bool loadFromNode(TreeStorageNode* objNode, string themePath, ImageManager& imageManager, SDL_Renderer& renderer);

	//Method that will draw the ThemePicture.
	//dest: The destination surface.
	//x: The x location on the dest to draw the picture.
	//y: The y location on the dest to draw the picture.
	//animation: The frame of the animation to draw.
	//clipRect: Rectangle to clip the picture.
	- void draw(SDL_Surface* dest,int x,int y,int animation=0,SDL_Rect* clipRect=NULL);
	+ void draw(SDL_Renderer& renderer,int x,int y,int animation=0, SDL_Rect* clipRect=NULL);
	};

	//The ThemeObject class is used to contain a basic theme element.
	//Contains the picture, animation information, etc...
	class ThemeObject{
	public:
	//Integer containing the length of the animation.
	int animationLength;
	//Integer containing the frame from where the animation is going to loop.
	int animationLoopPoint;

	//Boolean if the animation is invisible at run time (Game state).
	bool invisibleAtRunTime;
	//Boolean if the animation is invisible at design time (Level editor).
	bool invisibleAtDesignTime;

	//Picture of the ThemeObject.
	ThemePicture picture;
	//Picture of the ThemeObject shown when in the level editor.
	ThemePicture editorPicture;

	//Vector containing optionalPicture for the ThemeObject.
	vector<pair<double,ThemePicture*> > optionalPicture;

	//ThemeOffsetData for the ThemeObject.
	ThemeOffsetData offset;
	//ThemePositionData for the ThemeObject.
	ThemePositioningData positioning;
	public:
	//Constructor.
	ThemeObject():animationLength(0),animationLoopPoint(0),invisibleAtRunTime(false),invisibleAtDesignTime(false){}
	//Destructor.
	~ThemeObject(){
	//Loop through the optionalPicture and delete them.
	for(unsigned int i=0;i<optionalPicture.size();i++){
	delete optionalPicture[i].second;
	}
	}

	//Method that will destroy the ThemeObject.
	void destroy(){
	//Loop through the optionalPicture and delete them.
	for(unsigned int i=0;i<optionalPicture.size();i++){
	delete optionalPicture[i].second;
	}
	optionalPicture.clear();
	animationLength=0;
	animationLoopPoint=0;
	invisibleAtRunTime=false;
	invisibleAtDesignTime=false;
	picture.destroy();
	editorPicture.destroy();
	offset.destroy();
	positioning.destroy();
	}

	//Method that will load a ThemeObject from a node.
	//objNode: The TreeStorageNode to read the object from.
	//themePath: Path to the theme.
	//Returns: True if it succeeds.
	- bool loadFromNode(TreeStorageNode* objNode,string themePath);
	+ bool loadFromNode(TreeStorageNode* objNode,string themePath, ImageManager& imageManager, SDL_Renderer& renderer);
	};

	//Class containing a single state of a themed block.
	class ThemeBlockState{
	public:
	//The length in frames of the oneTimeAnimation.
	int oneTimeAnimationLength;
	//String containing the name of the next state.
	string nextState;
	//Vector containing the themeObjects that make up this state.
	vector<ThemeObject*> themeObjects;
	public:
	//Constructor.
	ThemeBlockState():oneTimeAnimationLength(0){}
	//Destructor.
	~ThemeBlockState(){
	//Loop through the ThemeObjects and delete them.
	for(unsigned int i=0;i<themeObjects.size();i++){
	delete themeObjects[i];
	}
	}

	//Method that will destroy the ThemeBlockState.
	void destroy(){
	//Loop through the ThemeObjects and delete them.
	for(unsigned int i=0;i<themeObjects.size();i++){
	delete themeObjects[i];
	}
	//Clear the themeObjects vector.
	themeObjects.clear();
	//Set the length to 0.
	oneTimeAnimationLength=0;
	//Clear the nextState string.
	nextState.clear();
	}

	//Method that will load a ThemeBlockState from a node.
	//objNode: The TreeStorageNode to read the state from.
	//themePath: Path to the theme.
	//Returns: True if it succeeds.
	- bool loadFromNode(TreeStorageNode* objNode,string themePath);
	+ bool loadFromNode(TreeStorageNode* objNode,string themePath, ImageManager& imageManager, SDL_Renderer& renderer);
	};

	//Class containing the needed things for a themed block.
	class ThemeBlock{
	public:
	//Picture that is shown only in the level editor.
	ThemePicture editorPicture;

	//Map containing ThemeBlockStates for the different states of a block.
	map<string,ThemeBlockState*> blockStates;
	//Map containing the transition states between blocks states.
	map<pair<string,string>,ThemeBlockState*> transitions;
	public:
	//Constructor.
	ThemeBlock(){}
	//Destructor/
	~ThemeBlock(){
	//Loop through the ThemeBlockStates and delete them,
	for(map<string,ThemeBlockState*>::iterator i=blockStates.begin();i!=blockStates.end();++i){
	delete i->second;
	}
	//Loop through the ThemeBlockStates and delete them,
	for(map<pair<string,string>,ThemeBlockState*>::iterator i=transitions.begin();i!=transitions.end();++i){
	delete i->second;
	}
	}

	//Method that will destroy the ThemeBlock.
	void destroy(){
	//Loop through the ThemeBlockStates and delete them,
	for(map<string,ThemeBlockState*>::iterator i=blockStates.begin();i!=blockStates.end();++i){
	delete i->second;
	}
	//Loop through the ThemeBlockStates transitions and delete them,
	for(map<pair<string,string>,ThemeBlockState*>::iterator i=transitions.begin();i!=transitions.end();++i){
	delete i->second;
	}
	//Clear the blockStates map.
	blockStates.clear();
	transitions.clear();
	editorPicture.destroy();
	}

	//Method that will load a ThemeBlock from a node.
	//objNode: The TreeStorageNode to load the ThemeBlock from.
	//themePath: The path to the theme.
	//Returns: True if it succeeds.
	- bool loadFromNode(TreeStorageNode* objNode,string themePath);
	+ bool loadFromNode(TreeStorageNode* objNode,string themePath, ImageManager& imageManager, SDL_Renderer& renderer);

	//Method that will create a ThemeBlockInstance.
	//obj: Pointer that will be filled with the instance.
	void createInstance(ThemeBlockInstance* obj);
	private:
	//Method that will create a ThemeBlockStateInstance.
	//obj: Pointer that will be filled with the instance.
	void createStateInstance(ThemeBlockStateInstance* obj);
	};

	//ThemeBackgroundPicture is a class containing the picture for the background.
	class ThemeBackgroundPicture{
	private:
	- //Pointer to the SDL_Surface cached by the ImageManager.
	- //This is used to rescale the theme.
	- SDL_Surface* cachedPicture;
	//Rectangle that should be taken from the picture.
	//NOTE The size is pixels of the image.
	SDL_Rect cachedSrcSize;
	//Rectangle with the size it will have on the destination (screen).
	//NOTE The size is in pixels or in precentages (if scaleToScreen is true).
	SDL_Rect cachedDestSize;

	- //SDL_Surface containing the picture.
	- //NOTE: This could point to the same surface as cachedPicture.
	- SDL_Surface* picture;
	+ //Pointer to the SDL_Texture containing the picture. (Creation/destruction handled by ImageManager)
	+ SharedTexture texture;
	//Rectangle that should be taken from the picture.
	//NOTE The size is pixels of the image.
	SDL_Rect srcSize;
	//Rectangle with the size it will have on the destination (screen).
	//NOTE The size is in pixels even though the loaded value from the theme description file can be in precentages (if scaleToScreen is true).
	SDL_Rect destSize;

	//Boolean if the background picture should be scaled to screen.
	bool scale;

	//Boolean if the image should be repeated over the x-axis.
	bool repeatX;
	//Boolean if the image should be repeated over the y-axis.
	bool repeatY;

	//Float containing the speed the background picture moves along the x-axis.
	float speedX;
	//Float containing the speed the background picture moves along the y-axis.
	float speedY;

	//Float containing the horizontal speed the picture will have when moving the camera (horizontally).
	float cameraX;
	//Float containing the vertical speed the picture will have when moving the camera (vertically).
	float cameraY;
	private:
	//Float with the current x position.
	float currentX;
	//Float with the current y position.
	float currentY;

	//Stored x location for when loading a state.
	float savedX;
	//Stored y location for when loading a state.
	float savedY;
	public:
	//Constructor.
	ThemeBackgroundPicture(){
	//Set some default values.
	- picture=NULL;
	- cachedPicture=NULL;
	+ texture=NULL;
	memset(&srcSize,0,sizeof(srcSize));
	memset(&destSize,0,sizeof(destSize));
	memset(&cachedSrcSize,0,sizeof(cachedSrcSize));
	memset(&cachedDestSize,0,sizeof(cachedDestSize));
	scale=true;
	repeatX=true;
	repeatY=true;
	speedX=0.0f;
	speedY=0.0f;
	cameraX=0.0f;
	cameraY=0.0f;
	currentX=0.0f;
	currentY=0.0f;
	savedX=0.0f;
	savedY=0.0f;
	}

	//Method that will update the animation.
	void updateAnimation(){
	//Move the picture along the x-axis.
	currentX+=speedX;
	if(repeatX && destSize.w>0){
	float f=(float)destSize.w;
	if(currentX>f \|\| currentX<-f) currentX-=f*floor(currentX/f);
	}

	//Move the picture along the y-axis.
	currentY+=speedY;
	if(repeatY && destSize.h>0){
	float f=(float)destSize.h;
	if(currentY>f \|\| currentY<-f) currentY-=f*floor(currentY/f);
	}
	}

	//Method that will reset the animation.
	//save: Boolean if the saved state should be deleted.
	void resetAnimation(bool save){
	currentX=0.0f;
	currentY=0.0f;
	if(save){
	savedX=0.0f;
	savedY=0.0f;
	}
	}
	//Method that will save the animation.
	void saveAnimation(){
	savedX=currentX;
	savedY=currentY;
	}
	//Method that will load the animation.
	void loadAnimation(){
	currentX=savedX;
	currentY=savedY;
	}

	//Method used to draw the ThemeBackgroundPicture.
	- //dest: Pointer to the SDL_Surface the picture should be drawn.
	- void draw(SDL_Surface *dest);
	-
	+ //dest: Pointer to the SDL_Renderer the picture should be drawn on.
	+ void draw(SDL_Renderer& dest);
	+
	+
	//Method used to load the ThemeBackgroundPicture from a node.
	//objNode: The TreeStorageNode to load the picture from.
	//themePath: The path to the theme.
	- bool loadFromNode(TreeStorageNode* objNode,string themePath);
	+ bool loadFromNode(TreeStorageNode* objNode,string themePath, ImageManager& imageManager, SDL_Renderer& renderer);

	//This method will scale the background picture (if needed and configured) to the current SCREEN_WIDTH and SCREEN_HEIGHT.
	void scaleToScreen();
	};

	//Class that forms the complete background of a theme.
	//It is in fact nothing more than a vector containing multiple ThemeBackgroundPictures.
	class ThemeBackground{
	private:
	//Vector containing the ThemeBackgroundPictures.
	vector<ThemeBackgroundPicture> picture;
	public:
	//Method that will update the animation of all the background pictures.
	void updateAnimation(){
	for(unsigned int i=0;i<picture.size();i++){
	picture[i].updateAnimation();
	}
	}

	//Method that will reset the animation of all the background pictures.
	//save: Boolean if the saved state should be deleted.
	void resetAnimation(bool save){
	for(unsigned int i=0;i<picture.size();i++){
	picture[i].resetAnimation(save);
	}
	}

	//Method that will save the animation of all the background pictures.
	void saveAnimation(){
	for(unsigned int i=0;i<picture.size();i++){
	picture[i].saveAnimation();
	}
	}
	//Method that will load the animation of all the background pictures.
	void loadAnimation(){
	for(unsigned int i=0;i<picture.size();i++){
	picture[i].loadAnimation();
	}
	}

	//Method that will scale the background pictures (if set) to the current screen resolution.
	void scaleToScreen(){
	for(unsigned int i=0;i<picture.size();i++){
	picture[i].scaleToScreen();
	}
	}

	//This method will draw all the background pictures.
	- //dest: Pointer to the SDL_Surface to draw them on.
	- void draw(SDL_Surface* dest){
	+ //dest: Pointer to the SDL_Renderer to draw them on.
	+ void draw(SDL_Renderer& renderer){
	for(unsigned int i=0;i<picture.size();i++){
	- picture[i].draw(dest);
	+ picture[i].draw(renderer);
	}
	}

	//Method that will add a ThemeBackgroundPicture to the ThemeBackground.
	//objNode: The treeStorageNode to read from.
	//themePath: The path to the theme.
	//Returns: True if it succeeds.
	- bool addPictureFromNode(TreeStorageNode* objNode,string themePath){
	+ bool addPictureFromNode(TreeStorageNode* objNode,string themePath, ImageManager& imageManager, SDL_Renderer& renderer){
	picture.push_back(ThemeBackgroundPicture());
	- return picture.back().loadFromNode(objNode,themePath);
	+ return picture.back().loadFromNode(objNode,themePath, imageManager, renderer);
	}
	};

	//The ThemeManager is actually a whole theme, filled with ThemeBlocks and ThemeBackground.
	class ThemeManager{
	private:
	//The ThemeBlock of the shadow.
	ThemeBlock* shadow;
	//The ThemeBlock of the player.
	ThemeBlock* player;

	//Array containing a ThemeBlock for every block type.
	ThemeBlock* objBlocks[TYPE_MAX];

	//The ThemeBackground.
	ThemeBackground* objBackground;

	//ThemeBackground for menu.
	ThemeBackground* menuBackground;
	//Level selection background block.
	ThemeBlock* menuBlock;
	public:
	//String containing the path to the string.
	string themePath;
	//String containing the theme name.
	string themeName;
	public:
	//Constructor.
	ThemeManager(){
	//Make sure the pointers are set to NULL.
	objBackground=NULL;
	//Reserve enough memory for the ThemeBlocks.
	memset(objBlocks,0,sizeof(objBlocks));
	shadow=NULL;
	player=NULL;
	menuBackground=NULL;
	menuBlock=NULL;
	}
	//Destructor.
	~ThemeManager(){
	//Delete the ThemeBlock of the shadow.
	if(shadow)
	delete shadow;
	//Delete the ThemeBlock of the player.
	if(player)
	delete player;
	//Loop through the ThemeBlocks and delete them.
	for(int i=0;i<TYPE_MAX;i++){
	if(objBlocks[i])
	delete objBlocks[i];
	}
	//Delete the ThemeBackgrounds.
	if(objBackground)
	delete objBackground;
	if(menuBackground)
	delete menuBackground;
	if(menuBlock)
	delete menuBlock;
	}

	//Method used to destroy the ThemeManager.
	void destroy(){
	//Delete the ThemeBlock of the shadow.
	if(shadow)
	delete shadow;
	//Delete the ThemeBlock of the player.
	if(player)
	delete player;
	//Loop through the ThemeBlocks and delete them.
	for(int i=0;i<TYPE_MAX;i++){
	if(objBlocks[i])
	delete objBlocks[i];
	}
	//Delete the ThemeBackground.
	if(objBackground)
	delete objBackground;

	//And clear the themeName.
	themeName.clear();
	}

	//Method that will load the theme from a file.
	//fileName: The file to load the theme from.
	//Returns: True if it succeeds.
	- bool loadFile(const string& fileName);
	+ bool loadFile(const string& fileName, ImageManager& imageManager, SDL_Renderer& renderer);

	//Method that will scale the theme to the current SCREEN_WIDTH and SCREEN_HEIGHT.
	void scaleToScreen(){
	//We only need to scale the background.
	if(objBackground)
	objBackground->scaleToScreen();
	}

	//Get a pointer to the ThemeBlock of a given block type.
	//index: The type of block.
	//menu: Boolean if get spefial blocks for menu
	//Returns: Pointer to the ThemeBlock.
	ThemeBlock* getBlock(int index,bool menu){
	if(!menu)
	return objBlocks[index];
	else
	if(index==TYPE_BLOCK)
	if(menuBlock)
	return menuBlock;
	else
	return objBlocks[TYPE_BLOCK];
	else if(index==TYPE_SHADOW_BLOCK)
	if(menuBlock)
	return menuBlock;
	else
	return objBlocks[TYPE_SHADOW_BLOCK];
	else
	return objBlocks[index];
	}
	//Get a pointer to the ThemeBlock of the shadow or the player.
	//isShadow: Boolean if it's the shadow
	//Returns: Pointer to the ThemeBlock.
	ThemeBlock* getCharacter(bool isShadow){
	if(isShadow)
	return shadow;
	return player;
	}
	//Get a pointer to the ThemeBackground of the theme.
	//bool: Boolean if get menu background
	//Returns: Pointer to the ThemeBackground.
	ThemeBackground* getBackground(bool menu){
	if(menu&&menuBackground)
	return menuBackground;
	else
	return objBackground;
	}
	};

	//Class that combines multiple ThemeManager into one stack.
	//If a file is not in a certain theme it will use one of a lower theme.
	class ThemeStack{
	private:
	//Vector containing the themes in the stack.
	vector<ThemeManager*> objThemes;
	public:
	//Constructor.
	ThemeStack();
	//Destructor.
	~ThemeStack();

	//Method that will destroy the ThemeStack.
	void destroy();

	//Method that will append a theme to the stack.
	//obj: The ThemeManager to add.
	void appendTheme(ThemeManager* obj);
	//Method that will remove the last theme added to the stack.
	void removeTheme();

	//Method that will append a theme that will be loaded from file.
	//fileName: The file to load the theme from.
	//Returns: Pointer to the newly added theme, NULL if failed.
	- ThemeManager* appendThemeFromFile(const string& fileName);
	+ ThemeManager* appendThemeFromFile(const string& fileName, ImageManager& imageManager, SDL_Renderer& renderer);

	//Method that is used to let the themes scale.
	void scaleToScreen();

	//Get the number of themes in the stack.
	//Returns: The theme count.
	int themeCount(){
	return (int)objThemes.size();
	}

	//Operator overloading so that the themes can be accesed using the [] operator.
	//i: The index.
	ThemeManager* operator[](int i){
	return objThemes[i];
	}
	//Get a pointer to the ThemeBlock of a given block type.
	//index: The type of block.
	//Returns: Pointer to the ThemeBlock.
	ThemeBlock* getBlock(int index,bool menu=false);
	//Get a pointer to the ThemeBlock of the shadow or the player.
	//isShadow: Boolean if it's the shadow
	//Returns: Pointer to the ThemeBlock.
	ThemeBlock* getCharacter(bool isShadow);
	//Get a pointer to the ThemeBackground of the theme.
	//Returns: Pointer to the ThemeBackground.
	ThemeBackground* getBackground(bool menu);
	};

	//The ThemeStack that is be used by the GameState.
	extern ThemeStack objThemes;

	#endif
	diff --git a/src/Timer.cpp b/src/Timer.cpp
	index 8b6c679..932d9f8 100644
	--- a/src/Timer.cpp
	+++ b/src/Timer.cpp
	@@ -1,31 +1,31 @@
	/*
	* 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 "Timer.h"
	-#include <SDL/SDL.h>
	+#include <SDL2/SDL.h>

	void Timer::start(){
	//Store the current number of ticks (start time).
	ticks=SDL_GetTicks();
	}

	int Timer::getTicks(){
	//Return the differents with the current ticks and the start time.
	return (SDL_GetTicks()-ticks);
	}
	diff --git a/src/TitleMenu.cpp b/src/TitleMenu.cpp
	index 678496b..5e095fb 100644
	--- a/src/TitleMenu.cpp
	+++ b/src/TitleMenu.cpp
	@@ -1,838 +1,873 @@
	/*
	* 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 "Globals.h"
	#include "TitleMenu.h"
	#include "GUIListBox.h"
	#include "GUITextArea.h"
	#include "InputManager.h"
	#include "StatisticsManager.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(){
	+Menu::Menu(ImageManager &imageManager, SDL_Renderer& renderer){
	animation=highlight=0;

	//Load the title image.
	- title=loadImage(getDataPath()+"gfx/menu/title.png");
	-
	- //Now render the five entries.
	- entries[0]=TTF_RenderUTF8_Blended(fontTitle,_("Play"),themeTextColor);
	- entries[1]=TTF_RenderUTF8_Blended(fontTitle,_("Options"),themeTextColor);
	- entries[2]=TTF_RenderUTF8_Blended(fontTitle,_("Map Editor"),themeTextColor);
	- entries[3]=TTF_RenderUTF8_Blended(fontTitle,_("Addons"),themeTextColor);
	- entries[4]=TTF_RenderUTF8_Blended(fontTitle,_("Quit"),themeTextColor);
	- entries[5]=TTF_RenderUTF8_Blended(fontTitle,">",themeTextColor);
	- entries[6]=TTF_RenderUTF8_Blended(fontTitle,"<",themeTextColor);
	-
	- //Load the credits icon.
	- creditsIcon=loadImage(getDataPath()+"gfx/menu/credits.png");
	- statisticsIcon=loadImage(getDataPath()+"gfx/menu/statistics.png");
	+ //title=loadImage(getDataPath()+"gfx/menu/title.png");
	+ 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(){
	- //We need to free the five text surfaces.
	- for(unsigned int i=0;i<7;i++)
	- SDL_FreeSurface(entries[i]);
	}


	-void Menu::handleEvents(){
	+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(_("Enable internet in order to install addons."),MsgBoxOKOnly,_("Internet disabled"));
	+ 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(){
	+void Menu::logic(ImageManager&, SDL_Renderer&){
	animation++;
	if(animation>10)
	animation=-10;
	}

	-void Menu::render(){
	+void Menu::render(ImageManager&, SDL_Renderer& renderer){
	//Draw background.
	- objThemes.getBackground(true)->draw(screen);
	+ objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();

	//Draw the title.
	- applySurface((SCREEN_WIDTH-title->w)/2,40,title,screen,NULL);
	-
	+ {
	+ 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++){
	- applySurface((SCREEN_WIDTH-entries[i]->w)/2,(SCREEN_HEIGHT-200)/2+64*i+(64-entries[i]->h)/2,entries[i],screen,NULL);
	+ 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=(SCREEN_WIDTH-entries[highlight-1]->w)/2-(25-abs(animation)/2)-entries[5]->w;
	- int y=(SCREEN_HEIGHT-200)/2-64+64*highlight+(64-entries[5]->h)/2;
	- applySurface(x,y,entries[5],screen,NULL);
	-
	+ 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=(SCREEN_WIDTH-entries[highlight-1]->w)/2+entries[highlight-1]->w+(25-abs(animation)/2);
	- y=(SCREEN_HEIGHT-200)/2-64+64*highlight+(64-entries[6]->h)/2;
	- applySurface(x,y,entries[6],screen,NULL);
	+ 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_Color fg={0,0,0};
	- SDL_Surface *surface=NULL;
	- if(highlight==6)
	- surface=TTF_RenderUTF8_Blended(fontText,_("Credits"),fg);
	- else
	- surface=TTF_RenderUTF8_Blended(fontText,_("Achievements and Statistics"),fg);
	- drawGUIBox(-2,SCREEN_HEIGHT-surface->h-2,surface->w+4,surface->h+4,screen,0xFFFFFFFF);
	- applySurface(0,SCREEN_HEIGHT-surface->h,surface,screen,NULL);
	- SDL_FreeSurface(surface);
	+ 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.
	- applySurface(SCREEN_WIDTH-96,SCREEN_HEIGHT-48,creditsIcon,screen,NULL);
	- applySurface(SCREEN_WIDTH-48,SCREEN_HEIGHT-48,statisticsIcon,screen,NULL);
	+ applyTexture(SCREEN_WIDTH-96,SCREEN_HEIGHT-48,*creditsIcon,renderer);
	+ applyTexture(SCREEN_WIDTH-48,SCREEN_HEIGHT-48,*statisticsIcon,renderer);
	}

	-void Menu::resize(){}
	+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(){
	+Options::Options(ImageManager& imageManager,SDL_Renderer& renderer){
	//Render the title.
	- title=TTF_RenderUTF8_Blended(fontTitle,_("Settings"),themeTextColor);
	+ title=textureFromText(renderer, *fontTitle, _("Settings"), themeTextColor);

	//Initialize variables.
	lastJumpSound=0;
	clearIconHower=false;

	- //Load icon image.
	- clearIcon=loadImage(getDataPath()+"gfx/menu/clear-progress.png");
	-
	+ //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();
	+ createGUI(imageManager,renderer);
	}

	Options::~Options(){
	//Delete the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	-
	- //Free the title image.
	- SDL_FreeSurface(title);
	}

	-void Options::createGUI(){
	+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(0,0,SCREEN_WIDTH,SCREEN_HEIGHT);
	+ GUIObjectRoot=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

	//Single line list for different tabs.
	- GUISingleLineListBox* listBox=new GUISingleLineListBox((SCREEN_WIDTH-500)/2,104,500,32);
	+ 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(0,150,SCREEN_WIDTH,SCREEN_HEIGHT);
	+ 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(column1X,0,columnW,36,_("Music"));
	+ GUIObject* obj=new GUILabel(imageManager,renderer,column1X,0,columnW,36,_("Music"));
	tabGeneral->addChild(obj);

	- musicSlider=new GUISlider(column2X,0,columnW,36,atoi(getSettings()->getValue("music").c_str()),0,128,15);
	+ 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(column1X,lineHeight,columnW,36,_("Sound"));
	+ obj=new GUILabel(imageManager,renderer,column1X,lineHeight,columnW,36,_("Sound"));
	tabGeneral->addChild(obj);

	- soundSlider=new GUISlider(column2X,lineHeight,columnW,36,atoi(getSettings()->getValue("sound").c_str()),0,128,15);
	+ 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(column1X,2*lineHeight,columnW,36,_("Resolution"));
	+ 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(column2X,2*lineHeight,columnW,36);
	+ 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(column1X,3*lineHeight,columnW,36,_("Language"));
	+ obj=new GUILabel(imageManager,renderer,column1X,3*lineHeight,columnW,36,_("Language"));
	tabGeneral->addChild(obj);

	//Create GUI list with available languages.
	- langs = new GUISingleLineListBox(column2X,3*lineHeight,columnW,36);
	+ 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(column1X,4*lineHeight,columnW,36,_("Theme"));
	+ 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(column2X,4*lineHeight,columnW,36);
	+ 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("lstTheme",theme,GUIEventChange);
	+ GUIEventCallback_OnEvent(imageManager,renderer,"lstTheme",theme,GUIEventChange);
	theme->eventCallback=this;
	tabGeneral->addChild(theme);

	//Proxy settings.
	- obj=new GUILabel(column1X,5*lineHeight,columnW,36,_("Internet proxy"));
	+ obj=new GUILabel(imageManager,renderer,column1X,5*lineHeight,columnW,36,_("Internet proxy"));
	obj->name="chkProxy";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);
	- obj=new GUITextBox(column2X,5*lineHeight,columnW,36,internetProxy.c_str());
	+ 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(column1X,6*lineHeight,columnW,36,_("Fullscreen"),fullscreen?1:0);
	+ 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(column1X,7*lineHeight,columnW,36,_("Level themes"),leveltheme?1:0);
	+ 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(column2X,6*lineHeight,columnW,36,_("Internet"),internet?1:0);
	+ 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(column2X,7*lineHeight,columnW,36,_("Fade transition"),fade?1:0);
	+ 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(column1X,8*lineHeight,columnW,36,_("Quick record"),quickrec?1:0);
	+ 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(SCREEN_HEIGHT-210);
	+ 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(SCREEN_WIDTH0.3,SCREEN_HEIGHT-60,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	+ 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(SCREEN_WIDTH*0.7,SCREEN_HEIGHT-60,-1,36,_("Save Changes"),0,true,true,GUIGravityCenter);
	+ 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(std::string name,GUIObject* obj,int eventType){
	+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(themeName);
	+ 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("")){
	+ 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(){
	+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(_("Do you really want to reset level progress?"),MsgBoxYesNo,_("Warning"))==MsgBoxYes){
	+ 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(){
	+void Options::logic(ImageManager&, SDL_Renderer&){
	//Increase the lastJumpSound variable if needed.
	if(lastJumpSound!=0){
	lastJumpSound--;
	}
	}

	-void Options::render(){
	+void Options::render(ImageManager&, SDL_Renderer& renderer){
	//Draw background.
	- objThemes.getBackground(true)->draw(screen);
	+ objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();

	//Now render the title.
	- applySurface((SCREEN_WIDTH-title->w)/2,40-TITLE_FONT_RAISE,title,screen,NULL);
	-
	+ drawTitleTexture(SCREEN_WIDTH, *title, renderer);
	+
	//Check if an icon is selected/highlighted and draw tooltip
	if(clearIconHower){
	- SDL_Color fg={0,0,0};
	- /// TRANSLATORS: Used for button which clear any level progress like unlocked levels and highscores.
	- SDL_Surface *surface=TTF_RenderUTF8_Blended(fontText,_("Clear Progress"),fg);
	- drawGUIBox(-2,SCREEN_HEIGHT-surface->h-2,surface->w+4,surface->h+4,screen,0xFFFFFFFF);
	- applySurface(0,SCREEN_HEIGHT-surface->h,surface,screen,NULL);
	- SDL_FreeSurface(surface);
	+ 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.
	- applySurface(SCREEN_WIDTH-48,SCREEN_HEIGHT-48,clearIcon,screen,NULL);
	-
	+ applyTexture(SCREEN_WIDTH-48,SCREEN_HEIGHT-48,*clearIcon,renderer);
	+
	//NOTE: The rendering of the GUI is done in Main.
	}

	-void Options::resize(){
	+void Options::resize(ImageManager& imageManager, SDL_Renderer& renderer){
	//Recreate the gui to fit the new resolution.
	- createGUI();
	+ createGUI(imageManager,renderer);
	}

	/////////////////////////CREDITS_MENU//////////////////////////////////

	-Credits::Credits(){
	+Credits::Credits(ImageManager& imageManager,SDL_Renderer& renderer){
	//Render the title.
	- title=TTF_RenderUTF8_Blended(fontTitle,_("Credits"),themeTextColor);
	+ 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(0,0,SCREEN_WIDTH,SCREEN_HEIGHT);
	+ GUIObjectRoot=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

	//Create back button.
	- backButton=new GUIButton(SCREEN_WIDTH*0.5,SCREEN_HEIGHT-60,-1,36,_("Back"),0,true,true,GUIGravityCenter);
	+ 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(SCREEN_WIDTH0.05,114,SCREEN_WIDTH0.9,SCREEN_HEIGHT-200);
	+ textArea=new GUITextArea(imageManager,renderer,SCREEN_WIDTH0.05,114,SCREEN_WIDTH0.9,SCREEN_HEIGHT-200);
	textArea->setFont(fontMono);
	- textArea->setStringArray(credits);
	+ textArea->setStringArray(renderer, std::move(credits));
	textArea->editable=false;
	GUIObjectRoot->addChild(textArea);
	}

	Credits::~Credits(){
	//Delete the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	-
	- //Free images
	- SDL_FreeSurface(title);
	}

	-void Credits::GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	+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(){
	+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(){
	-
	-}
	+void Credits::logic(ImageManager&, SDL_Renderer&){}

	-void Credits::render(){
	+void Credits::render(ImageManager&,SDL_Renderer &renderer){
	//Draw background.
	- objThemes.getBackground(true)->draw(screen);
	+ objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();

	//Now render the title.
	- applySurface((SCREEN_WIDTH-title->w)/2,40-TITLE_FONT_RAISE,title,screen,NULL);
	-
	+ //applySurface((SCREEN_WIDTH-title->w)/2,40-TITLE_FONT_RAISE,title,screen,NULL);
	+ drawTitleTexture(SCREEN_WIDTH, *title, renderer);
	+
	//NOTE: The rendering of the GUI is done in Main.
	}

	-void Credits::resize(){
	+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->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/TitleMenu.h b/src/TitleMenu.h
	index f108db7..8ed260b 100644
	--- a/src/TitleMenu.h
	+++ b/src/TitleMenu.h
	@@ -1,153 +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 TITLE_MENU_H
	#define TITLE_MENU_H

	-#include <SDL/SDL.h>
	+#include <array>
	+
	+#include <SDL2/SDL.h>
	#include "GameState.h"

	//Included for the Options menu.
	+#include "Render.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "GUISlider.h"
	#include "GUITextArea.h"
	#include "InputManager.h"
	+#include "ImageManager.h"

	//The Main menu.
	class Menu : public GameState{
	private:
	- //The title of the main menu.
	- SDL_Surface* title;
	+ //The title of the main menu.
	+ SharedTexture titleTexture;

	- //Array containg pointers to the five main menu entries.
	+ //Array containg pointers the five main menu entries.
	//The last two are the '>' and '<' characters.
	- SDL_Surface* entries[7];
	+ std::array<TexturePtr, 7> entries;

	- //The icon for the statistics menu.
	- SDL_Surface* statisticsIcon;
	+ //The icon and for the statistics menu.
	+ SharedTexture statisticsIcon;
	+ TexturePtr statisticsTooltip;

	//The icon for the credits menu.
	- SDL_Surface* creditsIcon;
	+ SharedTexture creditsIcon;
	+ TexturePtr creditsTooltip;

	//Integer used for animations.
	int animation;

	//Integer containing the highlighted/selected menu option.
	int highlight;
	public:
	//Constructor.
	- Menu();
	+ Menu(ImageManager& imageManager, SDL_Renderer &renderer);
	//Destructor.
	~Menu();

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

	//The Options menu.
	class Options : public GameState, private GUIEventCallback{
	private:
	//The title of the options menu.
	- SDL_Surface* title;
	-
	+ TexturePtr title;
	+
	//Icon.
	- SDL_Surface* clearIcon;
	+ SharedTexture clearIcon;
	bool clearIconHower;
	+ TexturePtr clearTooltip;

	//Slider used to set the music volume
	GUISlider* musicSlider;
	//Slider used to set the sound volume
	GUISlider* soundSlider;

	//Integer to keep track of the time passed since last playing the test sound.
	int lastJumpSound;

	//ListBox containing the themes the user can choose out.
	GUISingleLineListBox* theme;

	//Available languages
	GUISingleLineListBox* langs;

	//Resolution list
	GUISingleLineListBox* resolutions;

	//Containers for different tabs.
	GUIObject* tabGeneral;
	GUIObject* tabControls;

	//Keys.
	int tmpKeys[INPUTMGR_MAX];
	int tmpAlternativeKeys[INPUTMGR_MAX];

	//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 GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType);
	+ void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType);

	public:
	//Constructor.
	- Options();
	+ Options(ImageManager& imageManager,SDL_Renderer& renderer);
	//Destructor.
	~Options();

	//Method that will create the GUI for the options menu.
	- void createGUI();
	+ void createGUI(ImageManager &imageManager, SDL_Renderer &renderer);

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

	//The Credits menu.
	class Credits : public GameState, private GUIEventCallback{
	private:
	//The title of the credits menu.
	- SDL_Surface* title;
	-
	+ TexturePtr title;
	+
	//Widgets.
	GUITextArea* textArea;
	GUIObject* backButton;

	//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 GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType);
	+ void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType);

	public:
	//Constructor.
	- Credits();
	+ Credits(ImageManager& imageManager, SDL_Renderer &renderer);
	//Destructor.
	~Credits();

	//Inherited from GameState.
	- void handleEvents();
	- void logic();
	- void render();
	- void resize();
	+ 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;
	};

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Sat, Jun 13, 2:13 AM (3 w, 2 h ago)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 2f/02/32fdb8a600782df4c4f139954246
Default Alt Text: (1017 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions