No OneTemporary
Actions

Authored By

Unknown

Size

133 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/Functions.cpp b/src/Functions.cpp
	index cf99121..29c878f 100644
	--- a/src/Functions.cpp
	+++ b/src/Functions.cpp
	@@ -1,1610 +1,1626 @@
	/*
	* 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 <string.h>
	#include <algorithm>
	#include <SDL.h>
	#include <SDL_mixer.h>
	#include <SDL_syswm.h>
	#include <SDL_ttf.h>
	#include <string>
	#include "Globals.h"
	#include "Functions.h"
	#include "FontManager.h"
	#include "FileManager.h"
	#include "GameObjects.h"
	#include "LevelPack.h"
	#include "TitleMenu.h"
	#include "OptionsMenu.h"
	#include "CreditsMenu.h"
	#include "LevelEditSelect.h"
	#include "LevelEditor.h"
	#include "Game.h"
	#include "LevelPlaySelect.h"
	#include "Addons.h"
	#include "InputManager.h"
	#include "ImageManager.h"
	#include "MusicManager.h"
	#include "SoundManager.h"
	#include "ScriptExecutor.h"
	#include "LevelPackManager.h"
	#include "ThemeManager.h"
	#include "GUIListBox.h"
	#include "GUIOverlay.h"
	#include "StatisticsManager.h"
	#include "StatisticsScreen.h"
	#include "Cursors.h"
	#include "ScriptAPI.h"

	#include "libs/tinyformat/tinyformat.h"
	#include "libs/tinygettext/tinygettext.hpp"
	#include "libs/tinygettext/log.hpp"
	#include "libs/findlocale/findlocale.h"

	using namespace std;

	#ifdef WIN32
	#include <windows.h>
	#include <shellapi.h>
	#include <shlobj.h>
	#define TO_UTF8(SRC, DEST) WideCharToMultiByte(CP_UTF8, 0, SRC, -1, DEST, sizeof(DEST), NULL, NULL)
	#define TO_UTF16(SRC, DEST) MultiByteToWideChar(CP_UTF8, 0, SRC, -1, DEST, sizeof(DEST)/sizeof(DEST[0]))
	#else
	#include <strings.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include <dirent.h>
	#endif

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

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

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

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

	SDL_Renderer* sdlRenderer=nullptr;

	+std::string pgettext(const std::string& context, const std::string& message) {
	+ if (dictionaryManager) {
	+ return dictionaryManager->get_dictionary().translate_ctxt(context, message);
	+ } else {
	+ return message;
	+ }
	+}
	+
	std::string ngettext(const std::string& message,const std::string& messageplural,int num) {
	if (dictionaryManager) {
	return dictionaryManager->get_dictionary().translate_plural(message, messageplural, num);
	} else {
	//Assume it's of English plural rule
	return (num != 1) ? messageplural : message;
	}
	}

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

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

	void drawRect(int x,int y,int w,int h,SDL_Renderer& renderer,Uint32 color){
	//NOTE: We let SDL_gfx render it.
	SDL_SetRenderDrawColor(&renderer,color >> 24,color >> 16,color >> 8,255);
	//rectangleRGBA(&renderer,x,y,x+w,y+h,color >> 24,color >> 16,color >> 8,255);
	const SDL_Rect r{x,y,w,h};
	SDL_RenderDrawRect(&renderer,&r);
	}

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

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

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

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

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

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

	void drawLineWithArrow(int x1,int y1,int x2,int y2,SDL_Renderer& renderer,Uint32 color,int spacing,int offset,int xsize,int ysize){
	//Draw line first
	drawLine(x1,y1,x2,y2,renderer,color);

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

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

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

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

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

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

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

	//Set the flags.
	Uint32 flags = 0;
	Uint32 currentFlags = SDL_GetWindowFlags(sdlWindow);

	//#if !defined(ANDROID)
	// flags \|= SDL_DOUBLEBUF;
	//#endif
	if(settings->getBoolValue("fullscreen")) {
	flags\|=SDL_WINDOW_FULLSCREEN; //TODO with SDL2 we can also do SDL_WINDOW_FULLSCREEN_DESKTOP
	}
	else if(settings->getBoolValue("resizable"))
	flags\|=SDL_WINDOW_RESIZABLE;

	//Create the window and renderer if they don't exist and check if there weren't any errors.
	if (!sdlWindow && !sdlRenderer) {
	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);
	} else if (sdlWindow) {
	// Try changing to/from fullscreen
	if(SDL_SetWindowFullscreen(sdlWindow, flags & SDL_WINDOW_FULLSCREEN) != 0) {
	std::cerr << "WARNING: Failed to switch to fullscreen: " << SDL_GetError() << std::endl;
	};
	currentFlags = SDL_GetWindowFlags(sdlWindow);

	// Change fullscreen resolution
	if((currentFlags & SDL_WINDOW_FULLSCREEN ) \|\| (currentFlags & SDL_WINDOW_FULLSCREEN_DESKTOP)) {
	SDL_DisplayMode m{0,0,0,0,nullptr};
	SDL_GetWindowDisplayMode(sdlWindow,&m);
	m.w = SCREEN_WIDTH;
	m.h = SCREEN_HEIGHT;
	if(SDL_SetWindowDisplayMode(sdlWindow, &m) != 0) {
	std::cerr << "WARNING: Failed to set display mode: " << SDL_GetError() << std::endl;
	}
	} else {
	SDL_SetWindowSize(sdlWindow, SCREEN_WIDTH, SCREEN_HEIGHT);
	}
	}

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

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

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

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

	//Enumerate available resolutions using SDL_ListModes()
	//NOTE: we enumerate fullscreen resolutions because
	// windowed resolutions always can be arbitrary
	if(resolutionList.empty()){
	// SDL_Rect **modes=SDL_ListModes(NULL,SDL_FULLSCREEN\|SCREEN_FLAGS\|SDL_ANYFORMAT);
	//NOTe - currently only using the first display (0)
	int numDisplayModes = SDL_GetNumDisplayModes(0);

	if(numDisplayModes < 1){
	cerr<<"ERROR: Can't enumerate available screen resolutions."
	" Use predefined screen resolutions list instead."<<endl;

	static const SDL_Point 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(SDL_Point); i++){
	resolutionList.push_back(predefinedResolutionList[i]);
	}
	}else{
	//Fill the resolutionList.

	for(int i=0;i < numDisplayModes; ++i){
	SDL_DisplayMode mode;
	int error = SDL_GetDisplayMode(0, i, &mode);
	if(error < 0) {
	//We failed to get a display mode. Should we crash here?
	std::cerr << "ERROR: Failed to get display mode " << i << " " << std::endl;
	}
	//Check if the resolution is higher than the minimum (800x600).
	if(mode.w >= 800 && mode.h >= 600){
	SDL_Point 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<SDL_Point> resolutionList=getResolutionList();

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

	//Now loop through the resolutionList.
	for (int i = 0; i < (int)resolutionList.size(); i++){
	int dx = width - resolutionList[i].x;
	if (dx < 0) dx = -dx;
	int dy = height - resolutionList[i].y;
	if (dy < 0) dy = -dy;

	if (dx + dy < delta){
	delta = dx + dy;
	closestMatch.x = resolutionList[i].x;
	closestMatch.y = resolutionList[i].y;
	}
	}

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

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

	//We use a new function in SDL2 to restrict minimum window size
	SDL_SetWindowMinimumSize(sdlWindow, 800, 600);
	}

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

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

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

	char s[32];

	//Set the new width and height.
	SDL_snprintf(s,32,"%d",event.window.data1);
	getSettings()->setValue("width",s);
	SDL_snprintf(s,32,"%d",event.window.data2);
	getSettings()->setValue("height",s);
	//FIXME: THIS doesn't work properly.
	//Do resizing.
	SCREEN_WIDTH = event.window.data1;
	SCREEN_HEIGHT = event.window.data2;
	//Update the camera.
	camera.w=SCREEN_WIDTH;
	camera.h=SCREEN_HEIGHT;

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

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

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

	//Initialze SDL_mixer (audio).
	//Note for SDL2 port: Changed frequency from 22050 to 44100.
	//22050 caused some sound artifacts on my system, and I'm not sure
	//why one would use it in this day and age anyhow.
	//unless it's for compatability with some legacy system.
	if(Mix_OpenAudio(44100,MIX_DEFAULT_FORMAT,2,1024)==-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()));

	//Increase the number of channels.
	soundManager.setNumberOfChannels(48);

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

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

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

	//Init tinygettext for translations for the right language
	dictionaryManager = new tinygettext::DictionaryManager();
	dictionaryManager->set_use_fuzzy(false);
	dictionaryManager->add_directory(getDataPath()+"locale");
	dictionaryManager->set_charset("UTF-8");
	-
	+
	+ //Disable annoying 'Couldn't translate: blah blah blah'
	+ tinygettext::Log::set_log_info_callback(NULL);
	+
	//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));

	#ifdef WIN32
	//Some ad-hoc fix for Windows since it accepts "zh-CN" but not "zh_CN"
	std::string language2;
	for (auto c : language) {
	if (isalnum(c)) language2.push_back(c);
	else if (c == '_') language2.push_back('-');
	else break;
	}
	const char* languagePtr = language2.c_str();
	#else
	const char* languagePtr = language.c_str();
	#endif

	- //Also set the language for tinyformat.
	- tfm::setLocale(languagePtr);
	-
	//Set time format.
	setlocale(LC_TIME, languagePtr);

	- //Disable annoying 'Couldn't translate: blah blah blah'
	- tinygettext::Log::set_log_info_callback(NULL);
	+ //Also set the numeric format for tinyformat.
	+ tfm::setNumericFormat(
	+ /// TRANSLATORS: This is the decimal point character in your language.
	+ pgettext("numeric", "."),
	+ /// TRANSLATORS: This is the thousands separator character in your language.
	+ pgettext("numeric", ","),
	+ /// TRANSLATORS: This is the grouping of digits in your language,
	+ /// see <http://www.cplusplus.com/reference/locale/numpunct/grouping/>
	+ /// for more information.
	+ pgettext("numeric", "\03")
	+ );

	//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_OnPlayerInteraction, "onPlayerInteraction" },
	{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"},
	{0,NULL}
	};
	for(int i=0;types[i].name;i++){
	Game::levelEventNameMap[types[i].name]=types[i].type;
	Game::levelEventTypeMap[types[i].type]=types[i].name;
	}
	}

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

	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.
	//NOTE2: Since the font fallback is implemented, the font will not be loaded again if call loadFonts() twice.

	if (fontMgr) {
	return true;
	}

	fontMgr = new FontManager;
	fontMgr->loadFonts();

	fontTitle = fontMgr->getFont("fontTitle");
	fontGUI = fontMgr->getFont("fontGUI");
	fontGUISmall = fontMgr->getFont("fontGUISmall");
	fontText = fontMgr->getFont("fontText");
	fontMono = fontMgr->getFont("fontMono");

	if (fontTitle == NULL \|\| fontGUI == NULL \|\| fontGUISmall == NULL \|\| fontText == NULL \|\| fontMono == NULL){
	printf("FATAL ERROR: Unable to load fonts!\n");
	return false;
	}

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

	//Generate small arrows used for some GUI widgets.
	static void generateArrows(SDL_Renderer& renderer){
	TTF_Font* fontArrow = fontMgr->getFont("fontArrow");

	arrowLeft1=textureFromText(renderer,*fontArrow,"<",objThemes.getTextColor(false));
	arrowRight1=textureFromText(renderer,*fontArrow,">",objThemes.getTextColor(false));
	arrowLeft2=textureFromText(renderer,*fontArrow,"<",objThemes.getTextColor(true));
	arrowRight2=textureFromText(renderer,*fontArrow,">",objThemes.getTextColor(true));
	}

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

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

	generateArrows(renderer);

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

	static SDL_Cursor* loadCursor(const char* image[]){
	int i,row,col;
	//The array that holds the data (0=white 1=black)
	Uint8 data[4*32];
	//The array that holds the alpha mask (0=transparent 1=visible)
	Uint8 mask[4*32];
	//The coordinates of the hotspot of the cursor.
	int hotspotX, hotspotY;

	i=-1;
	//Loop through the rows and columns.
	//NOTE: We assume a cursor size of 32x32.
	for(row=0;row<32;++row){
	for(col=0; col<32;++col){
	if(col % 8) {
	data[i]<<=1;
	mask[i]<<=1;
	}else{
	++i;
	data[i]=mask[i]=0;
	}
	switch(image[4+row][col]){
	case '+':
	data[i] \|= 0x01;
	mask[i] \|= 0x01;
	break;
	case '.':
	mask[i] \|= 0x01;
	break;
	default:
	break;
	}
	}
	}
	//Get the hotspot x and y locations from the last line of the cursor.
	sscanf(image[4+row],"%d,%d",&hotspotX,&hotspotY);
	return SDL_CreateCursor(data,mask,32,32,hotspotX,hotspotY);
	}

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

	//Show a loading screen
	{
	int w = 0,h = 0;
	SDL_GetRendererOutputSize(&renderer, &w, &h);
	SDL_Color fg={255,255,255,0};
	TexturePtr loadingTexture = titleTextureFromText(renderer, _("Loading..."), fg, w);
	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.ogg").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);
	cursors[CURSOR_POINTING_HAND] = loadCursor(pointing_hand);
	//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_PATH;
	levelsPack->type=COLLECTION;
	LevelPack* customLevelsPack=new LevelPack;
	customLevelsPack->levelpackName="Custom Levels";
	customLevelsPack->levelpackPath=CUSTOM_LEVELS_PATH;
	customLevelsPack->type=COLLECTION;

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

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

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

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

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

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

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

	bool loadSettings(){
	//Check the version of config file.
	int version = 0;
	std::string cfgV05 = getUserPath(USER_CONFIG) + "meandmyshadow_V0.5.cfg";
	std::string cfgV04 = getUserPath(USER_CONFIG) + "meandmyshadow.cfg";

	if (fileExists(cfgV05.c_str())) {
	//We find a config file of current version.
	version = 0x000500;
	} else if (fileExists(cfgV04.c_str())) {
	//We find a config file of V0.4 version or earlier.
	copyFile(cfgV04.c_str(), cfgV05.c_str());
	version = 0x000400;
	} else {
	//No config file found, just create a new one.
	version = 0x000500;
	}
	settings=new Settings(cfgV05);
	settings->parseFile(version);

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

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

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

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

	//Delete dictionaryManager.
	delete dictionaryManager;

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

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

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

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

	//Destroy all sounds
	soundManager.destroy();

	//Destroy the cursors.
	for(int i=0;i<CURSOR_MAX;i++){
	SDL_FreeCursor(cursors[i]);
	cursors[i]=NULL;
	}

	//Destroy the levelPackManager.
	levelPackManager.destroy();
	levels=NULL;

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

	//Close the fonts and quit SDL_ttf.
	delete fontMgr;
	fontMgr = NULL;
	TTF_Quit();

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

	//Stop audio.and quit
	Mix_CloseAudio();
	//SDL2 porting note. Not sure why this was only done on apple.
	//#ifndef __APPLE__
	Mix_Quit();
	//#endif
	//And finally quit SDL.
	SDL_Quit();
	}

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

	void changeState(ImageManager& imageManager, SDL_Renderer& renderer, int fade){

	//Check if there's a nextState.
	if(nextState!=STATE_NULL){
	//Fade out, if fading is enabled.
	if (currentState && settings->getBoolValue("fading")) {
	for (; fade >= 0; fade -= 17) {
	currentState->render(imageManager, renderer);
	//TODO: Shouldn't the gamestate take care of rendering the GUI?
	if (GUIObjectRoot) GUIObjectRoot->render(renderer);

	dimScreen(renderer, static_cast<Uint8>(255 - fade));

	//draw new achievements (if any) as overlay
	statsMgr.render(imageManager, renderer);

	flipScreen(renderer);

	SDL_Delay(1000/FPS);
	}
	}

	//Delete the currentState.
	delete currentState;
	currentState=NULL;

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

	//Init the state.
	switch(stateID){
	case STATE_GAME:
	{
	currentState=NULL;
	Game* game=new Game(renderer, imageManager);
	currentState=game;
	//Check if we should load record file or a level.
	if(!Game::recordFile.empty()){
	game->loadRecord(imageManager,renderer,Game::recordFile.c_str());
	Game::recordFile.clear();
	}else{
	game->loadLevel(imageManager,renderer,levels->getLevelFile());
	levels->saveLevelProgress();
	}
	}
	break;
	case STATE_MENU:
	currentState=new Menu(imageManager, renderer);
	break;
	case STATE_LEVEL_SELECT:
	currentState=new LevelPlaySelect(imageManager, renderer);
	break;
	case STATE_LEVEL_EDIT_SELECT:
	currentState=new LevelEditSelect(imageManager, renderer);
	break;
	case STATE_LEVEL_EDITOR:
	{
	currentState=NULL;
	LevelEditor* levelEditor=new LevelEditor(renderer, imageManager);
	currentState=levelEditor;
	//Load the selected level.
	levelEditor->loadLevel(imageManager,renderer,levels->getLevelFile());
	}
	break;
	case STATE_OPTIONS:
	currentState=new Options(imageManager, renderer);
	break;
	case STATE_ADDONS:
	currentState=new Addons(renderer, imageManager);
	break;
	case STATE_CREDITS:
	currentState=new Credits(imageManager,renderer);
	break;
	case STATE_STATISTICS:
	currentState=new StatisticsScreen(imageManager,renderer);
	break;
	}
	//NOTE: STATE_EXIT isn't mentioned, meaning that currentState is null.
	//This way the game loop will break and the program will exit.
	}
	}

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

	bool pointOnRect(const SDL_Rect& point, const SDL_Rect& rect) {
	if(point.x >= rect.x && point.x < rect.x + rect.w
	&& point.y >= rect.y && point.y < rect.y + rect.h) {
	return true;
	}
	return false;
	}

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

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

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

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

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

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

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

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

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

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

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

	msgBoxResult msgBox(ImageManager& imageManager,SDL_Renderer& renderer, const string& prompt,msgBoxButtons buttons,const string& title){
	//Create the event handler.
	msgBoxHandler objHandler;

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

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

	//Now process the prompt.
	{
	//NOTE: We shouldn't modify the cotents in the c_str() of a string,
	//since it's said that at least in g++ the std::string is copy-on-write
	//hence if we modify the content it may break

	//The copy of the prompt.
	std::vector<char> copyOfPrompt(prompt.begin(), prompt.end());

	//Append another '\0' to it.
	copyOfPrompt.push_back(0);

	//Pointer to the string.
	char* lps = &(copyOfPrompt[0]);
	//Pointer to a character.
	char* lp=NULL;

	//The list of labels.
	std::vector<GUIObject*> labels;

	//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.
	GUIObject *label = new GUILabel(imageManager, renderer, 0, y, root->width, 25, lps, 0, true, true, GUIGravityCenter);
	labels.push_back(label);
	root->addChild(label);

	//Calculate the width of the text.
	int w = 0;
	TTF_SizeUTF8(fontText, lps, &w, NULL);
	w += 20;
	if (w > root->width) root->width = w;

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

	//Shrink the dialog if it's too big.
	if (root->width > SCREEN_WIDTH - 20) root->width = SCREEN_WIDTH - 20;
	root->left = (SCREEN_WIDTH - root->width) / 2;

	//Move labels to their correct locations.
	for (auto label : labels) {
	label->width = root->width;
	}
	}

	//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.35;
	places[1]=0.65;
	}else if(count==3){
	places[0]=0.25;
	places[1]=0.5;
	places[2]=0.75;
	}

	std::vector<GUIButton*> buttons;

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

	//Update widgets
	for (int i = 0; i < count; i++) {
	buttons[i]->render(renderer, 0, 0, false);
	}

	bool overlap = false;

	//Check if they overlap
	if (buttons[0]->left - buttons[0]->gravityX < 5 \|\|
	buttons[count - 1]->left - buttons[count - 1]->gravityX + buttons[count - 1]->width > root->width - 5)
	{
	overlap = true;
	} else {
	for (int i = 0; i < count - 1; i++) {
	if (buttons[i]->left - buttons[i]->gravityX + buttons[i]->width >= buttons[i + 1]->left - buttons[i + 1]->gravityX) {
	overlap = true;
	break;
	}
	}
	}

	//Shrink the font size if any buttons are overlap
	if (overlap) {
	for (int i = 0; i < count; i++) {
	buttons[i]->smallFont = true;
	buttons[i]->width = -1;
	}
	}
	}

	//Now we dim the screen and keep the GUI rendering/updating.
	GUIOverlay* overlay=new GUIOverlay(renderer,root);
	overlay->keyboardNavigationMode = LeftRightFocus \| UpDownFocus \| TabFocus \| ((count == 1) ? 0 : ReturnControls);
	overlay->enterLoop(imageManager, renderer, true, count == 1);

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

	// A helper function to read a character from utf8 string
	// s: the string
	// p [in,out]: the position
	// return value: the character readed, in utf32 format, 0 means end of string, -1 means error
	int utf8ReadForward(const char* s, int& p) {
	int ch = (unsigned char)s[p];
	if (ch < 0x80){
	if (ch) p++;
	return ch;
	} else if (ch < 0xC0){
	// skip invalid characters
	while (((unsigned char)s[p] & 0xC0) == 0x80) p++;
	return -1;
	} else if (ch < 0xE0){
	int c2 = (unsigned char)s[++p];
	if ((c2 & 0xC0) != 0x80) return -1;

	ch = ((ch & 0x1F) << 6) \| (c2 & 0x3F);
	p++;
	return ch;
	} else if (ch < 0xF0){
	int c2 = (unsigned char)s[++p];
	if ((c2 & 0xC0) != 0x80) return -1;
	int c3 = (unsigned char)s[++p];
	if ((c3 & 0xC0) != 0x80) return -1;

	ch = ((ch & 0xF) << 12) \| ((c2 & 0x3F) << 6) \| (c3 & 0x3F);
	p++;
	return ch;
	} else if (ch < 0xF8){
	int c2 = (unsigned char)s[++p];
	if ((c2 & 0xC0) != 0x80) return -1;
	int c3 = (unsigned char)s[++p];
	if ((c3 & 0xC0) != 0x80) return -1;
	int c4 = (unsigned char)s[++p];
	if ((c4 & 0xC0) != 0x80) return -1;

	ch = ((ch & 0x7) << 18) \| ((c2 & 0x3F) << 12) \| ((c3 & 0x3F) << 6) \| (c4 & 0x3F);
	if (ch >= 0x110000) ch = -1;
	p++;
	return ch;
	} else {
	p++;
	return -1;
	}
	}

	// A helper function to read a character backward from utf8 string (experimental)
	// s: the string
	// p [in,out]: the position
	// return value: the character readed, in utf32 format, 0 means end of string, -1 means error
	int utf8ReadBackward(const char* s, int& p) {
	if (p <= 0) return 0;

	do {
	p--;
	} while (p > 0 && ((unsigned char)s[p] & 0xC0) == 0x80);

	int tmp = p;
	return utf8ReadForward(s, tmp);
	}

	#ifndef WIN32

	// ad-hoc function to check if a program is installed
	static bool programExists(const std::string& program) {
	std::string p = tfm::format("which \"%s\" 2>&1", program);

	const int BUFSIZE = 128;

	char buf[BUFSIZE];
	FILE *fp;

	if ((fp = popen(p.c_str(), "r")) == NULL) {
	return false;
	}

	while (fgets(buf, BUFSIZE, fp) != NULL) {
	// Drop all outputs since 'which' returns -1 when the program is not found
	}

	if (pclose(fp)) {
	return false;
	}

	return true;
	}

	#endif

	void openWebsite(const std::string& url) {
	#ifdef WIN32
	wchar_t ws[4096];
	TO_UTF16(url.c_str(), ws);
	SDL_SysWMinfo info = {};
	SDL_VERSION(&info.version);
	SDL_GetWindowWMInfo(sdlWindow, &info);
	ShellExecuteW(info.info.win.window, L"open", ws, NULL, NULL, SW_SHOW);
	#else
	static int method = -1;

	// Some of these methods are copied from https://stackoverflow.com/questions/5116473/

	const char* methods[] = {
	"xdg-open", "xdg-open \"%s\"",
	"gnome-open", "gnome-open \"%s\"",
	"kde-open", "kde-open \"%s\"",
	"open", "open \"%s\"",
	"python", "python -m webbrowser \"%s\"",
	"sensible-browser", "sensible-browser \"%s\"",
	"x-www-browser", "x-www-browser \"%s\"",
	NULL,
	};

	if (method < 0) {
	for (method = 0; methods[method]; method += 2) {
	if (programExists(methods[method])) break;
	}
	}

	if (methods[method]) {
	std::string p = tfm::format(methods[method + 1], url);
	system(p.c_str());
	} else {
	fprintf(stderr, "TODO: openWebsite is not implemented on your system\n");
	}
	#endif
	}

	std::string appendURLToLicense(const std::string& license) {
	// if the license doesn't include url, try to detect it from a predefined list
	if (license.find("://") == std::string::npos) {
	std::string normalized;
	for (char c : license) {
	if ((c >= '0' && c <= '9') \|\| (c >= 'A' && c <= 'Z')) {
	normalized.push_back(c);
	} else if (c >= 'a' && c <= 'z') {
	normalized.push_back(c + ('A' - 'a'));
	}
	}

	const char* licenses[] = {
	// AGPL
	"AGPL1", "AGPLV1", NULL, "http://www.affero.org/oagpl.html",
	"AGPL2", "AGPLV2", NULL, "http://www.affero.org/agpl2.html",
	"AGPL", NULL, "https://gnu.org/licenses/agpl.html",
	// LGPL
	"LGPL21", "LGPLV21", NULL, "https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html",
	"LGPL2", "LGPLV2", NULL, "https://www.gnu.org/licenses/old-licenses/lgpl-2.0.html",
	"LGPL", NULL, "https://www.gnu.org/copyleft/lesser.html",
	// GPL
	"GPL1", "GPLV1", NULL, "https://www.gnu.org/licenses/old-licenses/gpl-1.0.html",
	"GPL2", "GPLV2", NULL, "https://www.gnu.org/licenses/old-licenses/gpl-2.0.html",
	"GPL", NULL, "https://gnu.org/licenses/gpl.html",
	// CC BY-NC-ND
	"CCBYNCND1", "CCBYNDNC1", NULL, "https://creativecommons.org/licenses/by-nd-nc/1.0",
	"CCBYNCND25", "CCBYNDNC25", NULL, "https://creativecommons.org/licenses/by-nc-nd/2.5",
	"CCBYNCND2", "CCBYNDNC2", NULL, "https://creativecommons.org/licenses/by-nc-nd/2.0",
	"CCBYNCND3", "CCBYNDNC3", NULL, "https://creativecommons.org/licenses/by-nc-nd/3.0",
	"CCBYNCND", "CCBYNDNC", NULL, "https://creativecommons.org/licenses/by-nc-nd/4.0",
	// CC BY-NC-SA
	"CCBYNCSA1", NULL, "https://creativecommons.org/licenses/by-nc-sa/1.0",
	"CCBYNCSA25", NULL, "https://creativecommons.org/licenses/by-nc-sa/2.5",
	"CCBYNCSA2", NULL, "https://creativecommons.org/licenses/by-nc-sa/2.0",
	"CCBYNCSA3", NULL, "https://creativecommons.org/licenses/by-nc-sa/3.0",
	"CCBYNCSA", NULL, "https://creativecommons.org/licenses/by-nc-sa/4.0",
	// CC BY-ND
	"CCBYND1", NULL, "https://creativecommons.org/licenses/by-nd/1.0",
	"CCBYND25", NULL, "https://creativecommons.org/licenses/by-nd/2.5",
	"CCBYND2", NULL, "https://creativecommons.org/licenses/by-nd/2.0",
	"CCBYND3", NULL, "https://creativecommons.org/licenses/by-nd/3.0",
	"CCBYND", NULL, "https://creativecommons.org/licenses/by-nd/4.0",
	// CC BY-NC
	"CCBYNC1", NULL, "https://creativecommons.org/licenses/by-nc/1.0",
	"CCBYNC25", NULL, "https://creativecommons.org/licenses/by-nc/2.5",
	"CCBYNC2", NULL, "https://creativecommons.org/licenses/by-nc/2.0",
	"CCBYNC3", NULL, "https://creativecommons.org/licenses/by-nc/3.0",
	"CCBYNC", NULL, "https://creativecommons.org/licenses/by-nc/4.0",
	// CC BY-SA
	"CCBYSA1", NULL, "https://creativecommons.org/licenses/by-sa/1.0",
	"CCBYSA25", NULL, "https://creativecommons.org/licenses/by-sa/2.5",
	"CCBYSA2", NULL, "https://creativecommons.org/licenses/by-sa/2.0",
	"CCBYSA3", NULL, "https://creativecommons.org/licenses/by-sa/3.0",
	"CCBYSA", NULL, "https://creativecommons.org/licenses/by-sa/4.0",
	// CC BY
	"CCBY1", NULL, "https://creativecommons.org/licenses/by/1.0",
	"CCBY25", NULL, "https://creativecommons.org/licenses/by/2.5",
	"CCBY2", NULL, "https://creativecommons.org/licenses/by/2.0",
	"CCBY3", NULL, "https://creativecommons.org/licenses/by/3.0",
	"CCBY", NULL, "https://creativecommons.org/licenses/by/4.0",
	// CC0
	"CC0", NULL, "https://creativecommons.org/publicdomain/zero/1.0",
	// WTFPL
	"WTFPL", NULL, "http://www.wtfpl.net/",
	// end
	NULL,
	};

	for (int i = 0; licenses[i]; i++) {
	bool found = false;
	for (; licenses[i]; i++) {
	if (normalized.find(licenses[i]) != std::string::npos) found = true;
	}
	i++;
	if (found) {
	return license + tfm::format(" <%s>", licenses[i]);
	}
	}
	}

	return license;
	}

	int getKeyboardRepeatDelay() {
	static int ret = -1;

	if (ret < 0) {
	#ifdef WIN32
	int i = 0;
	SystemParametersInfoW(SPI_GETKEYBOARDDELAY, 0, &i, 0);
	// NOTE: these weird numbers are derived from Microsoft's documentation explaining the return value of SystemParametersInfo.
	i = clamp(i, 0, 3);
	ret = (i + 1) * 10;
	#else
	// TODO: platform-dependent code
	// Assume it's 250ms, i.e. 10 frames
	ret = 10;
	#endif
	// Debug
	#ifdef _DEBUG
	printf("getKeyboardRepeatDelay() = %d\n", ret);
	#endif
	}

	return ret;
	}

	int getKeyboardRepeatInterval() {
	static int ret = -1;

	if (ret < 0) {
	#ifdef WIN32
	int i = 0;
	SystemParametersInfoW(SPI_GETKEYBOARDSPEED, 0, &i, 0);
	// NOTE: these weird numbers are derived from Microsoft's documentation explaining the return value of SystemParametersInfo.
	i = clamp(i, 0, 31);
	ret = (int)floor(40.0f / (2.5f + 0.887097f * (float)i) + 0.5f);
	#else
	// TODO: platform-dependent code
	// Assume it's 25ms, i.e. 1 frame
	ret = 1;
	#endif
	// Debug
	#ifdef _DEBUG
	printf("getKeyboardRepeatInterval() = %d\n", ret);
	#endif
	}

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

	#ifndef FUNCTIONS_H
	#define FUNCTIONS_H

	#include "Settings.h"

	#include "Globals.h"

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

	class MusicManager;
	class SoundManager;

	//gettext function
	//message: The message to translate.
	//Returns: The translated string or the original string if there is not translation available.
	#define _(message) (dictionaryManager!=NULL?dictionaryManager->get_dictionary().translate(message).c_str():std::string(message).c_str())
	//gettext function
	//NOTE: "_C" is conflict to some Android macros so we change its name.
	//dictionaryManager: Pointer to the dictionaryManager to use for the translation.
	//message: The message to translate.
	//Returns: The translated string or the original string if there is not translation available.
	#define _CC(dictionaryManager, message) ((dictionaryManager)!=NULL?(dictionaryManager)->get_dictionary().translate(message).c_str():std::string(message).c_str())
	//dummy function for xgettext
	//message: The message to translate.
	//Returns: message parameter
	#define __(message) (message)

	class ImageManager;
	struct SDL_Texture;
	class LevelPackManager;

	+//gettext function for contexts
	+//context: The context of the message.
	+//message: The message to translate.
	+//Returns: The translated string or the original string if there are no translations available.
	+std::string pgettext(const std::string& context, const std::string& message);
	+
	//gettext function for plural forms
	//message: The singular version of the message to translate.
	//messageplural: The plural version of the message to translate.
	//num: The number to fetch the plural form for
	//Returns: The translated string or the original string if there are no translations available.
	std::string ngettext(const std::string& message, const std::string& messageplural, int num);

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

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

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

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

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

	//Method that will load the fonts needed for the game.
	//NOTE: It's separate from loadFiles(), since it might get called separatly from the code when changing the language.
	bool loadFonts();
	//Method that will load the default theme again.
	//name: name of the theme to load or empty for scaling background
	//NOTE: It's separate from loadFiles(), since it might get called separatly from the code when changing resolution.
	bool loadTheme(ImageManager& imageManager, SDL_Renderer& renderer, std::string name);

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

	//This method will attempt to create the screen/window.
	//NOTE: It's separate from init(), since it might get called separatly from the code when changing resolution.
	ScreenData createScreen();

	//Method for retrieving a list of resolutions.
	std::vector<SDL_Point> getResolutionList();
	//Method that is called when a fullscreen window is created.
	//It will choose the resolution that is closest to the configured one.
	void pickFullscreenResolution();

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

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

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

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

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

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

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

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

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

	//Sets what the nextState will be.
	//newstate: Integer containing the id of the newstate.
	void setNextState(int newstate);
	//Method that will perform the state change.
	//It will fade out (but not fade in).
	void changeState(ImageManager &imageManager, SDL_Renderer &renderer, int fade = 255);

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

	//Checks if a given point lays on an SDL_Rect
	//point: The point to check.
	//rect: The rectangle to check.
	//Returns: True if the point is on the rectangle.
	bool pointOnRect(const SDL_Rect& a,const SDL_Rect& b);

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

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

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

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

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

	// A helper function to read a character from utf8 string
	// s: the string
	// p [in,out]: the position
	// return value: the character readed, in utf32 format, 0 means end of string, -1 means error
	int utf8ReadForward(const char* s, int& p);

	// A helper function to read a character backward from utf8 string (experimental)
	// s: the string
	// p [in,out]: the position
	// return value: the character readed, in utf32 format, 0 means end of string, -1 means error
	int utf8ReadBackward(const char* s, int& p);

	// Open the website using default web browser.
	// url: The url of the website. Currently only http and https are supported.
	// Also we assume that the url only contains ASCII characters.
	// WARNING: Passing other url may result in arbitrary behavior (esp. passing '*.exe' on Windows).
	void openWebsite(const std::string& url);

	// Append a URL to a license if the license doesn't include URL (try to detect it from a predefined list).
	// license: The license.
	// Return value: The license appended with a URL if we detect the license successfully.
	std::string appendURLToLicense(const std::string& license);

	// Retrieves the (approximate) keyboard repeat delay time, in frames (NOTE: frame rate is hardcoded as 40).
	int getKeyboardRepeatDelay();

	// Retrieves the (approximate) keyboard repeat interval time, in frames (NOTE: frame rate is hardcoded as 40).
	int getKeyboardRepeatInterval();

	#endif
	diff --git a/src/OptionsMenu.cpp b/src/OptionsMenu.cpp
	index 6eda36f..dbf647f 100644
	--- a/src/OptionsMenu.cpp
	+++ b/src/OptionsMenu.cpp
	@@ -1,610 +1,615 @@
	/*
	* 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 "OptionsMenu.h"
	#include "ThemeManager.h"
	#include "GUIListBox.h"
	#include "GUISlider.h"
	#include "InputManager.h"
	#include "LevelPackManager.h"
	#include "StatisticsManager.h"
	#include "MusicManager.h"
	#include "SoundManager.h"
	#include <iostream>
	#include <sstream>

	#include "libs/tinyformat/tinyformat.h"
	#include "libs/tinygettext/tinygettext.hpp"
	#include "libs/findlocale/findlocale.h"

	using namespace std;

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

	//Some variables for the options.
	static bool fullscreen,internet,fade,quickrec;
	static string themeName,languageName;
	static int lastLang,lastRes;

	static bool useProxy;
	static string internetProxy;

	static bool restartFlag;

	static SDL_Point currentRes;
	static vector<SDL_Point> resolutionList;

	Options::Options(ImageManager& imageManager,SDL_Renderer& renderer){
	//Render the title.
	title = titleTextureFromText(renderer, _("Settings"), objThemes.getTextColor(false), SCREEN_WIDTH);

	//Initialize variables.
	lastJumpSound=0;
	clearIconHower=false;
	section = 2;
	section2 = 1;

	//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"), objThemes.getTextColor(true));

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

	//Set the restartFlag false.
	restartFlag=false;

	//Now create the gui.
	createGUI(imageManager,renderer);
	}

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

	void Options::createGUI(ImageManager& imageManager,SDL_Renderer& renderer){
	//Variables for positioning
	const int columnW=SCREEN_WIDTH*0.3;
	const int column1X=SCREEN_WIDTH*0.15;
	const int column2X=SCREEN_WIDTH*0.55;
	const int lineHeight=40;

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

	//Single line list for different tabs.
	GUISingleLineListBox* listBox=new GUISingleLineListBox(imageManager,renderer,(SCREEN_WIDTH-500)/2,104,500,32);
	listBox->addItem(_("General"));
	listBox->addItem(_("Controls"));
	listBox->value=0;
	listBox->name="lstTabs";
	listBox->eventCallback=this;
	GUIObjectRoot->addChild(listBox);

	//Create general tab.
	tabGeneral=new GUIObject(imageManager,renderer,0,150,SCREEN_WIDTH,SCREEN_HEIGHT);
	GUIObjectRoot->addChild(tabGeneral);

	//Now we create GUIObjects for every option.
	GUIObject* obj=new GUILabel(imageManager,renderer,column1X,0,columnW,36,_("Music"));
	tabGeneral->addChild(obj);

	musicSlider=new GUISlider(imageManager,renderer,column2X,0,columnW,36,atoi(getSettings()->getValue("music").c_str()),0,128,15);
	musicSlider->name="sldMusic";
	musicSlider->eventCallback=this;
	tabGeneral->addChild(musicSlider);

	obj=new GUILabel(imageManager,renderer,column1X,lineHeight,columnW,36,_("Sound"));
	tabGeneral->addChild(obj);

	soundSlider=new GUISlider(imageManager,renderer,column2X,lineHeight,columnW,36,atoi(getSettings()->getValue("sound").c_str()),0,128,15);
	soundSlider->name="sldSound";
	soundSlider->eventCallback=this;
	tabGeneral->addChild(soundSlider);

	obj=new GUILabel(imageManager,renderer,column1X,2*lineHeight,columnW,36,_("Resolution"));
	obj->name="lstResolution";
	tabGeneral->addChild(obj);

	//Create list with many different resolutions.
	resolutions = new GUISingleLineListBox(imageManager,renderer,column2X,2*lineHeight,columnW,36);
	resolutions->value=-1;

	//Only get the resolution list if it hasn't been done before.
	if(resolutionList.empty()){
	resolutionList=getResolutionList();
	}

	//Get current resolution from config file. Thus it can be user defined.
	currentRes.x=atoi(getSettings()->getValue("width").c_str());
	currentRes.y=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].x << "x" << resolutionList[i].y;
	resolutions->addItem(out.str());

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

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

	tabGeneral->addChild(resolutions);

	obj=new GUILabel(imageManager,renderer,column1X,3*lineHeight,columnW,36,_("Language"));
	tabGeneral->addChild(obj);

	//Create GUI list with available languages.
	langs = new GUISingleLineListBox(imageManager,renderer,column2X,3*lineHeight,columnW,36);
	langs->name="lstLanguages";

	/// TRANSLATORS: as detect user's language automatically
	langs->addItem("",_("Auto-Detect"));
	langs->addItem("en","English");

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

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

	langs->value=lastLang;
	tabGeneral->addChild(langs);

	obj=new GUILabel(imageManager,renderer,column1X,4*lineHeight,columnW,36,_("Theme"));
	obj->name="theme";
	tabGeneral->addChild(obj);

	//Create the theme option gui element.
	theme=new GUISingleLineListBox(imageManager,renderer,column2X,4*lineHeight,columnW,36);
	theme->name="lstTheme";

	//Vector containing the theme locations and names.
	vector<pair<string,string> > themes;
	vector<string> v=enumAllDirs(getUserPath(USER_DATA)+"themes/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	string location=getUserPath(USER_DATA)+"themes/"+*i;
	themes.push_back(pair<string,string>(location,*i));
	}
	vector<string> v2=enumAllDirs(getDataPath()+"themes/");
	for(vector<string>::iterator i=v2.begin(); i!=v2.end(); ++i){
	string location=getDataPath()+"themes/"+*i;
	themes.push_back(pair<string,string>(location,*i));
	}

	//Try to find the configured theme so we can display it.
	int value=-1;
	for(vector<pair<string,string> >::iterator i=themes.begin(); i!=themes.end(); ++i){
	if(i->first==themeName) {
	value=i-themes.begin();
	}
	}
	theme->addItems(themes);
	if(value==-1)
	value=theme->item.size()-1;
	theme->value=value;
	//NOTE: We call the event handling method to correctly set the themename.
	GUIEventCallback_OnEvent(imageManager,renderer,"lstTheme",theme,GUIEventChange);
	theme->eventCallback=this;
	tabGeneral->addChild(theme);

	//Proxy settings.
	obj=new GUILabel(imageManager,renderer,column1X,5*lineHeight,columnW,36,_("Internet proxy"));
	obj->name="chkProxy";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);
	obj=new GUITextBox(imageManager,renderer,column2X,5*lineHeight,columnW,36,internetProxy.c_str());
	obj->name="txtProxy";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column1X,6*lineHeight,columnW,36,_("Fullscreen"),fullscreen?1:0);
	obj->name="chkFullscreen";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj = new GUICheckBox(imageManager, renderer, column1X, 7 * lineHeight, columnW, 36, _("Quick record"), quickrec ? 1 : 0);
	obj->name = "chkQuickRec";
	obj->eventCallback = this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column2X,6*lineHeight,columnW,36,_("Internet"),internet?1:0);
	obj->name="chkInternet";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column2X,7*lineHeight,columnW,36,_("Fade transition"),fade?1:0);
	obj->name="chkFade";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	//Create the controls tab.
	tabControls=inputMgr.showConfig(imageManager,renderer,SCREEN_HEIGHT-210);
	tabControls->top=140;
	tabControls->visible=false;
	GUIObjectRoot->addChild(tabControls);

	//Save original keys.
	for(int i=0;i<INPUTMGR_MAX;i++){
	tmpKeys[i]=inputMgr.getKeyCode((InputManagerKeys)i,false);
	tmpAlternativeKeys[i]=inputMgr.getKeyCode((InputManagerKeys)i,true);
	}

	//Create buttons.
	cmdBack = new GUIButton(imageManager, renderer, SCREEN_WIDTH*0.3, SCREEN_HEIGHT - 60, -1, 36, _("Cancel"), 0, true, true, GUIGravityCenter);
	cmdBack->name = "cmdBack";
	cmdBack->eventCallback = this;
	GUIObjectRoot->addChild(cmdBack);

	cmdSave = new GUIButton(imageManager, renderer, SCREEN_WIDTH*0.7, SCREEN_HEIGHT - 60, -1, 36, _("Save Changes"), 0, true, true, GUIGravityCenter);
	cmdSave->name = "cmdSave";
	cmdSave->eventCallback = this;
	GUIObjectRoot->addChild(cmdSave);
	}

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

	void Options::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Check what type of event it was.
	if(eventType==GUIEventClick){
	if(name=="cmdBack"){
	//Reset the key changes.
	for(int i=0;i<INPUTMGR_MAX;i++){
	inputMgr.setKeyCode((InputManagerKeys)i,tmpKeys[i],false);
	inputMgr.setKeyCode((InputManagerKeys)i,tmpAlternativeKeys[i],true);
	}

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

	//And goto the main menu.
	setNextState(STATE_MENU);
	}else if(name=="cmdSave"){
	//Save is pressed thus save
	char s[64];
	sprintf(s,"%d",soundSlider->value);
	getSettings()->setValue("sound",s);
	sprintf(s,"%d",musicSlider->value);
	getSettings()->setValue("music",s);
	getMusicManager()->setEnabled(musicSlider->value>0);
	Mix_Volume(-1,soundSlider->value);
	getSettings()->setValue("fullscreen",fullscreen?"1":"0");
	getSettings()->setValue("internet",internet?"1":"0");
	getSettings()->setValue("theme",themeName);
	getSettings()->setValue("fading",fade?"1":"0");
	getSettings()->setValue("quickrecord",quickrec?"1":"0");
	//Before loading the theme remove the previous one from the stack.
	objThemes.removeTheme();
	loadTheme(imageManager,renderer,themeName);
	if(!useProxy)
	internetProxy.clear();
	getSettings()->setValue("internet-proxy",internetProxy);
	getSettings()->setValue("lang",langs->getName());

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

	//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].x));
	getSettings()->setValue("height",convertInt(resolutionList[lastRes].y));

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

	//The screen is created, now load the (menu) theme.
	if(!loadTheme(imageManager,renderer,"")){
	//Loading the theme failed so quit.
	setNextState(STATE_EXIT);
	return;
	}
	}

	if(langs->value!=lastLang){
	//We set the language.
	language=langs->getName();

	if (language.empty()) {
	// The language is set to auto-detect.
	FL_Locale *locale;
	FL_FindLocale(&locale, FL_MESSAGES);

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

	FL_FreeLocale(&locale);
	}

	dictionaryManager->set_language(tinygettext::Language::from_name(language));

	#ifdef WIN32
	//Some ad-hoc fix for Windows since it accepts "zh-CN" but not "zh_CN"
	std::string language2;
	for (auto c : language) {
	if (isalnum(c)) language2.push_back(c);
	else if (c == '_') language2.push_back('-');
	else break;
	}
	const char* languagePtr = language2.c_str();
	#else
	const char* languagePtr = language.c_str();
	#endif

	- tfm::setLocale(languagePtr);
	setlocale(LC_TIME, languagePtr);

	+ tfm::setNumericFormat(
	+ pgettext("numeric", "."),
	+ pgettext("numeric", ","),
	+ pgettext("numeric", "\03")
	+ );
	+
	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=="chkInternet"){
	internet=obj->value?true:false;
	}else if(name=="chkProxy"){
	useProxy=obj->value?true:false;
	}else if(name=="chkFade"){
	fade=obj->value?true:false;
	}else if(name=="chkQuickRec"){
	quickrec=obj->value?true:false;
	}
	}
	if(name=="lstTheme"){
	if(theme!=NULL && theme->value>=0 && theme->value<(int)theme->item.size()){
	//Convert the themeName to contain %DATA%, etc...
	themeName=compressFileName(theme->item[theme->value].first);
	}
	}else if(name=="txtProxy"){
	internetProxy=obj->caption;

	//Check if the internetProxy field is empty.
	useProxy=!internetProxy.empty();
	}else if(name=="sldMusic"){
	getMusicManager()->setEnabled(musicSlider->value>0);
	getMusicManager()->setVolume(musicSlider->value);
	}else if(name=="sldSound"){
	Mix_Volume(-1,soundSlider->value);
	if(lastJumpSound==0){
	getSoundManager()->playSound("jump");
	lastJumpSound=15;
	}
	}
	if(name=="lstTabs"){
	if(obj->value==0){
	tabGeneral->visible=true;
	tabControls->visible=false;
	}else{
	tabGeneral->visible=false;
	tabControls->visible=true;
	}
	}
	}

	void Options::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//Check keyboard navigation.
	if (tabGeneral && tabGeneral->visible) {
	if (inputMgr.isKeyDownEvent(INPUTMGR_TAB)) {
	isKeyboardOnly = true;
	section = (section == 2) ? 3 : 2;

	//Update selection.
	if (section == 2) {
	tabGeneral->selectNextControl(1, -1);
	} else {
	tabGeneral->setSelectedControl(-1);
	}
	}
	if (section == 2) {
	tabGeneral->handleKeyboardNavigationEvents(imageManager, renderer, UpDownFocus \| ReturnControls \| LeftRightControls);
	} else if (section == 3) {
	if (inputMgr.isKeyDownEvent(INPUTMGR_DOWN) \|\| inputMgr.isKeyDownEvent(INPUTMGR_RIGHT)) {
	isKeyboardOnly = true;
	section2++;
	if (section2 > 3) section2 = 1;
	} else if (inputMgr.isKeyDownEvent(INPUTMGR_UP) \|\| inputMgr.isKeyDownEvent(INPUTMGR_LEFT)) {
	isKeyboardOnly = true;
	section2--;
	if (section2 < 1) section2 = 3;
	}
	if (isKeyboardOnly && inputMgr.isKeyDownEvent(INPUTMGR_SELECT) && section == 3) {
	if (section2 == 1) {
	GUIEventCallback_OnEvent(imageManager, renderer, cmdBack->name, cmdBack, GUIEventClick);
	} else if (section2 == 2) {
	GUIEventCallback_OnEvent(imageManager, renderer, cmdSave->name, cmdSave, GUIEventClick);
	}
	}
	}
	}

	//Process mouse event only when it's not keyboard only mode.
	if (!isKeyboardOnly) {
	//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;
	}
	}

	//Update highlight on keyboard only mode.
	if (isKeyboardOnly) {
	cmdBack->state = (section == 3 && section2 == 1) ? 1 : 0;
	cmdSave->state = (section == 3 && section2 == 2) ? 1 : 0;
	clearIconHower = (section == 3 && section2 == 3);
	}

	if ((isKeyboardOnly ? inputMgr.isKeyDownEvent(INPUTMGR_SELECT) :
	(event.type == SDL_MOUSEBUTTONUP && event.button.button == SDL_BUTTON_LEFT)) && clearIconHower)
	{
	if(msgBox(imageManager,renderer,_("Do you really want to reset level progress?"),MsgBoxYesNo,_("Warning"))==MsgBoxYes){
	//We delete the progress folder.
	#ifdef WIN32
	removeDirectory((getUserPath()+"progress").c_str());
	createDirectory((getUserPath()+"progress").c_str());
	#else
	removeDirectory((getUserPath(USER_DATA)+"/progress").c_str());
	createDirectory((getUserPath(USER_DATA)+"/progress").c_str());
	#endif
	//Reset statistics.
	statsMgr.reloadCompletedLevelsAndAchievements();
	}
	}

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

	//Check if the escape button is pressed, if so go back to the main menu.
	if (inputMgr.isKeyDownEvent(INPUTMGR_ESCAPE) && (tabControls == NULL \|\| !tabControls->visible)) {
	setNextState(STATE_MENU);
	}
	}

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

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

	//Now render the title.
	drawTitleTexture(SCREEN_WIDTH, *title, renderer);

	//Check if an icon is selected/highlighted and draw tooltip
	if(clearIconHower){
	const SDL_Rect texSize = rectFromTexture(*clearTooltip);
	drawGUIBox(-2,SCREEN_HEIGHT-texSize.h-2,texSize.w+4,texSize.h+4,renderer,0xFFFFFFFF);
	applyTexture(0,SCREEN_HEIGHT-texSize.h,clearTooltip,renderer);
	}

	//Draw border of icon if it's keyboard only mode.
	if (isKeyboardOnly && clearIconHower) {
	drawGUIBox(SCREEN_WIDTH - 52, SCREEN_HEIGHT - 52, 40, 40, renderer, 0xFFFFFF40);
	}

	//Draw icon.
	applyTexture(SCREEN_WIDTH-48,SCREEN_HEIGHT-48,*clearIcon,renderer);

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

	void Options::resize(ImageManager& imageManager, SDL_Renderer& renderer){
	//Recreate the gui to fit the new resolution.
	createGUI(imageManager,renderer);
	}
	diff --git a/src/libs/tinyformat/tinyformat.cpp b/src/libs/tinyformat/tinyformat.cpp
	index 6392833..7a19381 100644
	--- a/src/libs/tinyformat/tinyformat.cpp
	+++ b/src/libs/tinyformat/tinyformat.cpp
	@@ -1,21 +1,79 @@
	#include "tinyformat.h"
	#include <locale>

	+namespace {
	+
	+char decimal_point_1 = '.';
	+char thousands_sep_1 = ',';
	+std::string decimal_point_2;
	+std::string thousands_sep_2;
	+std::string grouping_1;
	+
	+struct my_numpunct : std::numpunct<char> {
	+ char do_decimal_point() const override {
	+ return decimal_point_1;
	+ }
	+ char do_thousands_sep() const override {
	+ return thousands_sep_1;
	+ }
	+ std::string do_grouping() const override {
	+ return grouping_1;
	+ }
	+};
	+
	+std::locale locale_1(std::locale::classic(), new my_numpunct);
	+
	+}
	+
	namespace tinyformat {

	-std::locale locale = std::locale::classic();
	+void setNumericFormat(const std::string& decimal_point, const std::string& thousands_sep, const std::string& grouping) {
	+ if (decimal_point.size() == 1) {
	+ decimal_point_1 = decimal_point[0];
	+ decimal_point_2.clear();
	+ } else {
	+ decimal_point_1 = 1; // ad-hoc
	+ decimal_point_2 = decimal_point;
	+ }

	-void setLocale(const char* std_name) {
	- try {
	- tfm::locale = std::locale(std_name);
	- } catch (...) {
	- std::cerr << "ERROR: Failed to create std::locale for '" << std_name << "'!" << std::endl;
	- tfm::locale = std::locale::classic();
	+ if (thousands_sep.empty() \|\| grouping.empty() \|\| (grouping.size() == 1 && grouping[0] == 1)) {
	+ thousands_sep_1 = ',';
	+ thousands_sep_2.clear();
	+ grouping_1.clear();
	+ } else {
	+ if (thousands_sep.size() == 1) {
	+ thousands_sep_1 = thousands_sep[0];
	+ thousands_sep_2.clear();
	+ } else {
	+ thousands_sep_1 = 2; // ad-hoc
	+ thousands_sep_2 = thousands_sep;
	+ }
	+ grouping_1 = grouping;
	}
	}

	+namespace detail {
	+
	void imbue(std::ostream& o) {
	- o.imbue(tfm::locale);
	+ o.imbue(locale_1);
	+}
	+
	+bool needReplace() {
	+ return !decimal_point_2.empty() \|\| !thousands_sep_2.empty();
	+}
	+
	+std::string doReplace(const std::string& src) {
	+ std::string ret;
	+
	+ for (auto c : src) {
	+ if (c == 1) ret += decimal_point_2; // ad-hoc
	+ else if (c == 2) ret += thousands_sep_2; // ad-hoc
	+ else ret.push_back(c);
	+ }
	+
	+ return ret;
	+}
	+
	}

	}
	diff --git a/src/libs/tinyformat/tinyformat.h b/src/libs/tinyformat/tinyformat.h
	index aa95a01..d1fb62b 100644
	--- a/src/libs/tinyformat/tinyformat.h
	+++ b/src/libs/tinyformat/tinyformat.h
	@@ -1,1050 +1,1060 @@
	// tinyformat.h
	// Copyright (C) 2011, Chris Foster [chris42f (at) gmail (d0t) com]
	//
	// Boost Software License - Version 1.0
	//
	// Permission is hereby granted, free of charge, to any person or organization
	// obtaining a copy of the software and accompanying documentation covered by
	// this license (the "Software") to use, reproduce, display, distribute,
	// execute, and transmit the Software, and to prepare derivative works of the
	// Software, and to permit third-parties to whom the Software is furnished to
	// do so, all subject to the following:
	//
	// The copyright notices in the Software and this entire statement, including
	// the above license grant, this restriction and the following disclaimer,
	// must be included in all copies of the Software, in whole or in part, and
	// all derivative works of the Software, unless such copies or derivative
	// works are solely in the form of machine-executable object code generated by
	// a source language processor.
	//
	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
	// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
	// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
	// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	// DEALINGS IN THE SOFTWARE.

	//------------------------------------------------------------------------------
	// Tinyformat: A minimal type safe printf replacement
	//
	// tinyformat.h is a type safe printf replacement library in a single C++
	// header file. Design goals include:
	//
	// * Type safety and extensibility for user defined types.
	// * C99 printf() compatibility, to the extent possible using std::ostream
	// * Simplicity and minimalism. A single header file to include and distribute
	// with your projects.
	// * Augment rather than replace the standard stream formatting mechanism
	// * C++98 support, with optional C++11 niceties
	//
	//
	// Main interface example usage
	// ----------------------------
	//
	// To print a date to std::cout:
	//
	// std::string weekday = "Wednesday";
	// const char* month = "July";
	// size_t day = 27;
	// long hour = 14;
	// int min = 44;
	//
	// tfm::printf("%s, %s %d, %.2d:%.2d\n", weekday, month, day, hour, min);
	//
	// The strange types here emphasize the type safety of the interface; it is
	// possible to print a std::string using the "%s" conversion, and a
	// size_t using the "%d" conversion. A similar result could be achieved
	// using either of the tfm::format() functions. One prints on a user provided
	// stream:
	//
	// tfm::format(std::cerr, "%s, %s %d, %.2d:%.2d\n",
	// weekday, month, day, hour, min);
	//
	// The other returns a std::string:
	//
	// std::string date = tfm::format("%s, %s %d, %.2d:%.2d\n",
	// weekday, month, day, hour, min);
	// std::cout << date;
	//
	// These are the three primary interface functions. There is also a
	// convenience function printfln() which appends a newline to the usual result
	// of printf() for super simple logging.
	//
	//
	// User defined format functions
	// -----------------------------
	//
	// Simulating variadic templates in C++98 is pretty painful since it requires
	// writing out the same function for each desired number of arguments. To make
	// this bearable tinyformat comes with a set of macros which are used
	// internally to generate the API, but which may also be used in user code.
	//
	// The three macros TINYFORMAT_ARGTYPES(n), TINYFORMAT_VARARGS(n) and
	// TINYFORMAT_PASSARGS(n) will generate a list of n argument types,
	// type/name pairs and argument names respectively when called with an integer
	// n between 1 and 16. We can use these to define a macro which generates the
	// desired user defined function with n arguments. To generate all 16 user
	// defined function bodies, use the macro TINYFORMAT_FOREACH_ARGNUM. For an
	// example, see the implementation of printf() at the end of the source file.
	//
	// Sometimes it's useful to be able to pass a list of format arguments through
	// to a non-template function. The FormatList class is provided as a way to do
	// this by storing the argument list in a type-opaque way. Continuing the
	// example from above, we construct a FormatList using makeFormatList():
	//
	// FormatListRef formatList = tfm::makeFormatList(weekday, month, day, hour, min);
	//
	// The format list can now be passed into any non-template function and used
	// via a call to the vformat() function:
	//
	// tfm::vformat(std::cout, "%s, %s %d, %.2d:%.2d\n", formatList);
	//
	//
	// Additional API information
	// --------------------------
	//
	// Error handling: Define TINYFORMAT_ERROR to customize the error handling for
	// format strings which are unsupported or have the wrong number of format
	// specifiers (calls assert() by default).
	//
	// User defined types: Uses operator<< for user defined types by default.
	// Overload formatValue() for more control.


	#ifndef TINYFORMAT_H_INCLUDED
	#define TINYFORMAT_H_INCLUDED

	namespace tinyformat {}
	//------------------------------------------------------------------------------
	// Config section. Customize to your liking!

	// Namespace alias to encourage brevity
	namespace tfm = tinyformat;

	// Error handling; calls assert() by default.
	// #define TINYFORMAT_ERROR(reasonString) your_error_handler(reasonString)

	// Define for C++11 variadic templates which make the code shorter & more
	// general. If you don't define this, C++11 support is autodetected below.
	// #define TINYFORMAT_USE_VARIADIC_TEMPLATES


	//------------------------------------------------------------------------------
	// Implementation details.
	#include <algorithm>
	#include <cassert>
	#include <iostream>
	#include <sstream>

	#ifndef TINYFORMAT_ERROR
	# define TINYFORMAT_ERROR(reason) assert(0 && reason)
	#endif

	#if !defined(TINYFORMAT_USE_VARIADIC_TEMPLATES) && !defined(TINYFORMAT_NO_VARIADIC_TEMPLATES)
	# ifdef __GXX_EXPERIMENTAL_CXX0X__
	# define TINYFORMAT_USE_VARIADIC_TEMPLATES
	# endif
	#endif

	#if defined(__GLIBCXX__) && __GLIBCXX__ < 20080201
	// std::showpos is broken on old libstdc++ as provided with OSX. See
	// http://gcc.gnu.org/ml/libstdc++/2007-11/msg00075.html
	# define TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
	#endif

	#ifdef __APPLE__
	// Workaround OSX linker warning: xcode uses different default symbol
	// visibilities for static libs vs executables (see issue #25)
	# define TINYFORMAT_HIDDEN __attribute__((visibility("hidden")))
	#else
	# define TINYFORMAT_HIDDEN
	#endif

	namespace tinyformat {

	-// Set the locale for tinyformat which is mainly used to format float numbers.
	-void setLocale(const char* std_name);
	+// Set the numeric format.
	+// decimal_point: The decimal point character.
	+// thousands_sep: The thousands separator character.
	+// grouping: The grouping of digits, see <http://www.cplusplus.com/reference/locale/numpunct/grouping/> for more information.
	+void setNumericFormat(const std::string& decimal_point, const std::string& thousands_sep, const std::string& grouping);
	+
	+//------------------------------------------------------------------------------
	+namespace detail {

	// Internal function.
	void imbue(std::ostream& o);

	-//------------------------------------------------------------------------------
	-namespace detail {
	+// Internal function.
	+bool needReplace();
	+
	+// Internal function.
	+std::string doReplace(const std::string& src);

	// Test whether type T1 is convertible to type T2
	template <typename T1, typename T2>
	struct is_convertible
	{
	private:
	// two types of different size
	struct fail { char dummy[2]; };
	struct succeed { char dummy; };
	// Try to convert a T1 to a T2 by plugging into tryConvert
	static fail tryConvert(...);
	static succeed tryConvert(const T2&);
	static const T1& makeT1();
	public:
	# ifdef _MSC_VER
	// Disable spurious loss of precision warnings in tryConvert(makeT1())
	# pragma warning(push)
	# pragma warning(disable:4244)
	# pragma warning(disable:4267)
	# endif
	// Standard trick: the (...) version of tryConvert will be chosen from
	// the overload set only if the version taking a T2 doesn't match.
	// Then we compare the sizes of the return types to check which
	// function matched. Very neat, in a disgusting kind of way :)
	static const bool value =
	sizeof(tryConvert(makeT1())) == sizeof(succeed);
	# ifdef _MSC_VER
	# pragma warning(pop)
	# endif
	};


	// Detect when a type is not a wchar_t string
	template<typename T> struct is_wchar { typedef int tinyformat_wchar_is_not_supported; };
	template<> struct is_wchar<wchar_t*> {};
	template<> struct is_wchar<const wchar_t*> {};
	template<int n> struct is_wchar<const wchar_t[n]> {};
	template<int n> struct is_wchar<wchar_t[n]> {};


	// Format the value by casting to type fmtT. This default implementation
	// should never be called.
	template<typename T, typename fmtT, bool convertible = is_convertible<T, fmtT>::value>
	struct formatValueAsType
	{
	static void invoke(std::ostream& /out/, const T& /value/) { assert(0); }
	};
	// Specialized version for types that can actually be converted to fmtT, as
	// indicated by the "convertible" template parameter.
	template<typename T, typename fmtT>
	struct formatValueAsType<T,fmtT,true>
	{
	static void invoke(std::ostream& out, const T& value)
	{ out << static_cast<fmtT>(value); }
	};

	#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
	template<typename T, bool convertible = is_convertible<T, int>::value>
	struct formatZeroIntegerWorkaround
	{
	static bool invoke(std::ostream& //, const T& //) { return false; }
	};
	template<typename T>
	struct formatZeroIntegerWorkaround<T,true>
	{
	static bool invoke(std::ostream& out, const T& value)
	{
	if (static_cast<int>(value) == 0 && out.flags() & std::ios::showpos)
	{
	out << "+0";
	return true;
	}
	return false;
	}
	};
	#endif // TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND

	// Convert an arbitrary type to integer. The version with convertible=false
	// throws an error.
	template<typename T, bool convertible = is_convertible<T,int>::value>
	struct convertToInt
	{
	static int invoke(const T& /value/)
	{
	TINYFORMAT_ERROR("tinyformat: Cannot convert from argument type to "
	"integer for use as variable width or precision");
	return 0;
	}
	};
	// Specialization for convertToInt when conversion is possible
	template<typename T>
	struct convertToInt<T,true>
	{
	static int invoke(const T& value) { return static_cast<int>(value); }
	};

	// Format at most ntrunc characters to the given stream.
	template<typename T>
	inline void formatTruncated(std::ostream& out, const T& value, int ntrunc)
	{
	std::ostringstream tmp;
	- tfm::imbue(tmp);
	+ tfm::detail::imbue(tmp);
	tmp << value;
	- std::string result = tmp.str();
	+ std::string result = tfm::detail::needReplace() ? tfm::detail::doReplace(tmp.str()) : tmp.str();
	out.write(result.c_str(), (std::min)(ntrunc, static_cast<int>(result.size())));
	}
	#define TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(type) \
	inline void formatTruncated(std::ostream& out, type* value, int ntrunc) \
	{ \
	std::streamsize len = 0; \
	while(len < ntrunc && value[len] != 0) \
	++len; \
	out.write(value, len); \
	}
	// Overload for const char* and char*. Could overload for signed & unsigned
	// char too, but these are technically unneeded for printf compatibility.
	TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(const char)
	TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(char)
	#undef TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR

	} // namespace detail


	//------------------------------------------------------------------------------
	// Variable formatting functions. May be overridden for user-defined types if
	// desired.


	/// Format a value into a stream, delegating to operator<< by default.
	///
	/// Users may override this for their own types. When this function is called,
	/// the stream flags will have been modified according to the format string.
	/// The format specification is provided in the range [fmtBegin, fmtEnd). For
	/// truncating conversions, ntrunc is set to the desired maximum number of
	/// characters, for example "%.7s" calls formatValue with ntrunc = 7.
	///
	/// By default, formatValue() uses the usual stream insertion operator
	/// operator<< to format the type T, with special cases for the %c and %p
	/// conversions.
	template<typename T>
	inline void formatValue(std::ostream& out, const char* /fmtBegin/,
	const char* fmtEnd, int ntrunc, const T& value)
	{
	#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
	// Since we don't support printing of wchar_t using "%ls", make it fail at
	// compile time in preference to printing as a void* at runtime.
	typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
	(void) DummyType(); // avoid unused type warning with gcc-4.8
	#endif
	// The mess here is to support the %c and %p conversions: if these
	// conversions are active we try to convert the type to a char or const
	// void* respectively and format that instead of the value itself. For the
	// %p conversion it's important to avoid dereferencing the pointer, which
	// could otherwise lead to a crash when printing a dangling (const char*).
	const bool canConvertToChar = detail::is_convertible<T,char>::value;
	const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
	if(canConvertToChar && *(fmtEnd-1) == 'c')
	detail::formatValueAsType<T, char>::invoke(out, value);
	else if(canConvertToVoidPtr && *(fmtEnd-1) == 'p')
	detail::formatValueAsType<T, const void*>::invoke(out, value);
	#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
	else if(detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
	#endif
	else if(ntrunc >= 0)
	{
	// Take care not to overread C strings in truncating conversions like
	// "%.4s" where at most 4 characters may be read.
	detail::formatTruncated(out, value, ntrunc);
	}
	else
	out << value;
	}


	// Overloaded version for char types to support printing as an integer
	#define TINYFORMAT_DEFINE_FORMATVALUE_CHAR(charType) \
	inline void formatValue(std::ostream& out, const char* /fmtBegin/, \
	const char* fmtEnd, int /**/, charType value) \
	{ \
	switch(*(fmtEnd-1)) \
	{ \
	case 'u': case 'd': case 'i': case 'o': case 'X': case 'x': \
	out << static_cast<int>(value); break; \
	default: \
	out << value; break; \
	} \
	}
	// per 3.9.1: char, signed char and unsigned char are all distinct types
	TINYFORMAT_DEFINE_FORMATVALUE_CHAR(char)
	TINYFORMAT_DEFINE_FORMATVALUE_CHAR(signed char)
	TINYFORMAT_DEFINE_FORMATVALUE_CHAR(unsigned char)
	#undef TINYFORMAT_DEFINE_FORMATVALUE_CHAR


	//------------------------------------------------------------------------------
	// Tools for emulating variadic templates in C++98. The basic idea here is
	// stolen from the boost preprocessor metaprogramming library and cut down to
	// be just general enough for what we need.

	#define TINYFORMAT_ARGTYPES(n) TINYFORMAT_ARGTYPES_ ## n
	#define TINYFORMAT_VARARGS(n) TINYFORMAT_VARARGS_ ## n
	#define TINYFORMAT_PASSARGS(n) TINYFORMAT_PASSARGS_ ## n
	#define TINYFORMAT_PASSARGS_TAIL(n) TINYFORMAT_PASSARGS_TAIL_ ## n

	// To keep it as transparent as possible, the macros below have been generated
	// using python via the excellent cog.py code generation script. This avoids
	// the need for a bunch of complex (but more general) preprocessor tricks as
	// used in boost.preprocessor.
	//
	// To rerun the code generation in place, use `cog.py -r tinyformat.h`
	// (see http://nedbatchelder.com/code/cog). Alternatively you can just create
	// extra versions by hand.

	/*[[[cog
	maxParams = 16

	def makeCommaSepLists(lineTemplate, elemTemplate, startInd=1):
	for j in range(startInd,maxParams+1):
	list = ', '.join([elemTemplate % {'i':i} for i in range(startInd,j+1)])
	cog.outl(lineTemplate % {'j':j, 'list':list})

	makeCommaSepLists('#define TINYFORMAT_ARGTYPES_%(j)d %(list)s',
	'class T%(i)d')

	cog.outl()
	makeCommaSepLists('#define TINYFORMAT_VARARGS_%(j)d %(list)s',
	'const T%(i)d& v%(i)d')

	cog.outl()
	makeCommaSepLists('#define TINYFORMAT_PASSARGS_%(j)d %(list)s', 'v%(i)d')

	cog.outl()
	cog.outl('#define TINYFORMAT_PASSARGS_TAIL_1')
	makeCommaSepLists('#define TINYFORMAT_PASSARGS_TAIL_%(j)d , %(list)s',
	'v%(i)d', startInd = 2)

	cog.outl()
	cog.outl('#define TINYFORMAT_FOREACH_ARGNUM(m) \\\n ' +
	' '.join(['m(%d)' % (j,) for j in range(1,maxParams+1)]))
	]]]*/
	#define TINYFORMAT_ARGTYPES_1 class T1
	#define TINYFORMAT_ARGTYPES_2 class T1, class T2
	#define TINYFORMAT_ARGTYPES_3 class T1, class T2, class T3
	#define TINYFORMAT_ARGTYPES_4 class T1, class T2, class T3, class T4
	#define TINYFORMAT_ARGTYPES_5 class T1, class T2, class T3, class T4, class T5
	#define TINYFORMAT_ARGTYPES_6 class T1, class T2, class T3, class T4, class T5, class T6
	#define TINYFORMAT_ARGTYPES_7 class T1, class T2, class T3, class T4, class T5, class T6, class T7
	#define TINYFORMAT_ARGTYPES_8 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8
	#define TINYFORMAT_ARGTYPES_9 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9
	#define TINYFORMAT_ARGTYPES_10 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10
	#define TINYFORMAT_ARGTYPES_11 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11
	#define TINYFORMAT_ARGTYPES_12 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12
	#define TINYFORMAT_ARGTYPES_13 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13
	#define TINYFORMAT_ARGTYPES_14 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14
	#define TINYFORMAT_ARGTYPES_15 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15
	#define TINYFORMAT_ARGTYPES_16 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16

	#define TINYFORMAT_VARARGS_1 const T1& v1
	#define TINYFORMAT_VARARGS_2 const T1& v1, const T2& v2
	#define TINYFORMAT_VARARGS_3 const T1& v1, const T2& v2, const T3& v3
	#define TINYFORMAT_VARARGS_4 const T1& v1, const T2& v2, const T3& v3, const T4& v4
	#define TINYFORMAT_VARARGS_5 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5
	#define TINYFORMAT_VARARGS_6 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6
	#define TINYFORMAT_VARARGS_7 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7
	#define TINYFORMAT_VARARGS_8 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8
	#define TINYFORMAT_VARARGS_9 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9
	#define TINYFORMAT_VARARGS_10 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10
	#define TINYFORMAT_VARARGS_11 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11
	#define TINYFORMAT_VARARGS_12 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12
	#define TINYFORMAT_VARARGS_13 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13
	#define TINYFORMAT_VARARGS_14 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14
	#define TINYFORMAT_VARARGS_15 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14, const T15& v15
	#define TINYFORMAT_VARARGS_16 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14, const T15& v15, const T16& v16

	#define TINYFORMAT_PASSARGS_1 v1
	#define TINYFORMAT_PASSARGS_2 v1, v2
	#define TINYFORMAT_PASSARGS_3 v1, v2, v3
	#define TINYFORMAT_PASSARGS_4 v1, v2, v3, v4
	#define TINYFORMAT_PASSARGS_5 v1, v2, v3, v4, v5
	#define TINYFORMAT_PASSARGS_6 v1, v2, v3, v4, v5, v6
	#define TINYFORMAT_PASSARGS_7 v1, v2, v3, v4, v5, v6, v7
	#define TINYFORMAT_PASSARGS_8 v1, v2, v3, v4, v5, v6, v7, v8
	#define TINYFORMAT_PASSARGS_9 v1, v2, v3, v4, v5, v6, v7, v8, v9
	#define TINYFORMAT_PASSARGS_10 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10
	#define TINYFORMAT_PASSARGS_11 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
	#define TINYFORMAT_PASSARGS_12 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
	#define TINYFORMAT_PASSARGS_13 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
	#define TINYFORMAT_PASSARGS_14 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
	#define TINYFORMAT_PASSARGS_15 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
	#define TINYFORMAT_PASSARGS_16 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16

	#define TINYFORMAT_PASSARGS_TAIL_1
	#define TINYFORMAT_PASSARGS_TAIL_2 , v2
	#define TINYFORMAT_PASSARGS_TAIL_3 , v2, v3
	#define TINYFORMAT_PASSARGS_TAIL_4 , v2, v3, v4
	#define TINYFORMAT_PASSARGS_TAIL_5 , v2, v3, v4, v5
	#define TINYFORMAT_PASSARGS_TAIL_6 , v2, v3, v4, v5, v6
	#define TINYFORMAT_PASSARGS_TAIL_7 , v2, v3, v4, v5, v6, v7
	#define TINYFORMAT_PASSARGS_TAIL_8 , v2, v3, v4, v5, v6, v7, v8
	#define TINYFORMAT_PASSARGS_TAIL_9 , v2, v3, v4, v5, v6, v7, v8, v9
	#define TINYFORMAT_PASSARGS_TAIL_10 , v2, v3, v4, v5, v6, v7, v8, v9, v10
	#define TINYFORMAT_PASSARGS_TAIL_11 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
	#define TINYFORMAT_PASSARGS_TAIL_12 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
	#define TINYFORMAT_PASSARGS_TAIL_13 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
	#define TINYFORMAT_PASSARGS_TAIL_14 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
	#define TINYFORMAT_PASSARGS_TAIL_15 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
	#define TINYFORMAT_PASSARGS_TAIL_16 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16

	#define TINYFORMAT_FOREACH_ARGNUM(m) \
	m(1) m(2) m(3) m(4) m(5) m(6) m(7) m(8) m(9) m(10) m(11) m(12) m(13) m(14) m(15) m(16)
	//[[[end]]]



	namespace detail {

	// Type-opaque holder for an argument to format(), with associated actions on
	// the type held as explicit function pointers. This allows FormatArg's for
	// each argument to be allocated as a homogenous array inside FormatList
	// whereas a naive implementation based on inheritance does not.
	class FormatArg
	{
	public:
	FormatArg() {}

	template<typename T>
	FormatArg(const T& value)
	: m_value(static_cast<const void*>(&value)),
	m_formatImpl(&formatImpl<T>),
	m_toIntImpl(&toIntImpl<T>)
	{ }

	void format(std::ostream& out, const char* fmtBegin,
	const char* fmtEnd, int ntrunc) const
	{
	m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
	}

	int toInt() const
	{
	return m_toIntImpl(m_value);
	}

	private:
	template<typename T>
	TINYFORMAT_HIDDEN static void formatImpl(std::ostream& out, const char* fmtBegin,
	const char* fmtEnd, int ntrunc, const void* value)
	{
	formatValue(out, fmtBegin, fmtEnd, ntrunc, static_cast<const T>(value));
	}

	template<typename T>
	TINYFORMAT_HIDDEN static int toIntImpl(const void* value)
	{
	return convertToInt<T>::invoke(static_cast<const T>(value));
	}

	const void* m_value;
	void (m_formatImpl)(std::ostream& out, const char fmtBegin,
	const char* fmtEnd, int ntrunc, const void* value);
	int (m_toIntImpl)(const void value);
	};


	// Parse and return an integer from the string c, as atoi()
	// On return, c is set to one past the end of the integer.
	inline int parseIntAndAdvance(const char*& c)
	{
	int i = 0;
	for(;c >= '0' && c <= '9'; ++c)
	i = 10i + (c - '0');
	return i;
	}

	// Print literal part of format string and return next format spec
	// position.
	//
	// Skips over any occurrences of '%%', printing a literal '%' to the
	// output. The position of the first % character of the next
	// nontrivial format spec is returned, or the end of string.
	inline const char* printFormatStringLiteral(std::ostream& out, const char* fmt)
	{
	const char* c = fmt;
	for(;; ++c)
	{
	switch(*c)
	{
	case '\0':
	out.write(fmt, c - fmt);
	return c;
	case '%':
	out.write(fmt, c - fmt);
	if(*(c+1) != '%')
	return c;
	// for "%%", tack trailing % onto next literal section.
	fmt = ++c;
	break;
	default:
	break;
	}
	}
	}


	// Parse a format string and set the stream state accordingly.
	//
	// The format mini-language recognized here is meant to be the one from C99,
	// with the form "%[flags][width][.precision][length]type".
	//
	// Formatting options which can't be natively represented using the ostream
	// state are returned in spacePadPositive (for space padded positive numbers)
	// and ntrunc (for truncating conversions). argIndex is incremented if
	// necessary to pull out variable width and precision . The function returns a
	// pointer to the character after the end of the current format spec.
	inline const char* streamStateFromFormat(std::ostream& out, bool& spacePadPositive,
	int& ntrunc, const char* fmtStart,
	const detail::FormatArg* formatters,
	int& argIndex, int numFormatters)
	{
	if(*fmtStart != '%')
	{
	TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string");
	return fmtStart;
	}
	// Reset stream state to defaults.
	out.width(0);
	out.precision(6);
	out.fill(' ');
	// Reset most flags; ignore irrelevant unitbuf & skipws.
	out.unsetf(std::ios::adjustfield \| std::ios::basefield \|
	std::ios::floatfield \| std::ios::showbase \| std::ios::boolalpha \|
	std::ios::showpoint \| std::ios::showpos \| std::ios::uppercase);
	bool precisionSet = false;
	bool widthSet = false;
	int widthExtra = 0;
	const char* c = fmtStart + 1;
	// 1) Parse flags
	for(;; ++c)
	{
	switch(*c)
	{
	case '#':
	out.setf(std::ios::showpoint \| std::ios::showbase);
	continue;
	case '0':
	// overridden by left alignment ('-' flag)
	if(!(out.flags() & std::ios::left))
	{
	// Use internal padding so that numeric values are
	// formatted correctly, eg -00010 rather than 000-10
	out.fill('0');
	out.setf(std::ios::internal, std::ios::adjustfield);
	}
	continue;
	case '-':
	out.fill(' ');
	out.setf(std::ios::left, std::ios::adjustfield);
	continue;
	case ' ':
	// overridden by show positive sign, '+' flag.
	if(!(out.flags() & std::ios::showpos))
	spacePadPositive = true;
	continue;
	case '+':
	out.setf(std::ios::showpos);
	spacePadPositive = false;
	widthExtra = 1;
	continue;
	default:
	break;
	}
	break;
	}
	// 2) Parse width
	if(c >= '0' && c <= '9')
	{
	widthSet = true;
	out.width(parseIntAndAdvance(c));
	}
	if(c == '')
	{
	widthSet = true;
	int width = 0;
	if(argIndex < numFormatters)
	width = formatters[argIndex++].toInt();
	else
	TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable width");
	if(width < 0)
	{
	// negative widths correspond to '-' flag set
	out.fill(' ');
	out.setf(std::ios::left, std::ios::adjustfield);
	width = -width;
	}
	out.width(width);
	++c;
	}
	// 3) Parse precision
	if(*c == '.')
	{
	++c;
	int precision = 0;
	if(c == '')
	{
	++c;
	if(argIndex < numFormatters)
	precision = formatters[argIndex++].toInt();
	else
	TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable precision");
	}
	else
	{
	if(c >= '0' && c <= '9')
	precision = parseIntAndAdvance(c);
	else if(*c == '-') // negative precisions ignored, treated as zero.
	parseIntAndAdvance(++c);
	}
	out.precision(precision);
	precisionSet = true;
	}
	// 4) Ignore any C99 length modifier
	while(c == 'l' \|\| c == 'h' \|\| *c == 'L' \|\|
	c == 'j' \|\| c == 'z' \|\| *c == 't')
	++c;
	// 5) We're up to the conversion specifier character.
	// Set stream flags based on conversion specifier (thanks to the
	// boost::format class for forging the way here).
	bool intConversion = false;
	switch(*c)
	{
	case 'u': case 'd': case 'i':
	out.setf(std::ios::dec, std::ios::basefield);
	intConversion = true;
	break;
	case 'o':
	out.setf(std::ios::oct, std::ios::basefield);
	intConversion = true;
	break;
	case 'X':
	out.setf(std::ios::uppercase);
	case 'x': case 'p':
	out.setf(std::ios::hex, std::ios::basefield);
	intConversion = true;
	break;
	case 'E':
	out.setf(std::ios::uppercase);
	case 'e':
	out.setf(std::ios::scientific, std::ios::floatfield);
	out.setf(std::ios::dec, std::ios::basefield);
	break;
	case 'F':
	out.setf(std::ios::uppercase);
	case 'f':
	out.setf(std::ios::fixed, std::ios::floatfield);
	break;
	case 'G':
	out.setf(std::ios::uppercase);
	case 'g':
	out.setf(std::ios::dec, std::ios::basefield);
	// As in boost::format, let stream decide float format.
	out.flags(out.flags() & ~std::ios::floatfield);
	break;
	case 'a': case 'A':
	TINYFORMAT_ERROR("tinyformat: the %a and %A conversion specs "
	"are not supported");
	break;
	case 'c':
	// Handled as special case inside formatValue()
	break;
	case 's':
	if(precisionSet)
	ntrunc = static_cast<int>(out.precision());
	// Make %s print booleans as "true" and "false"
	out.setf(std::ios::boolalpha);
	break;
	case 'n':
	// Not supported - will cause problems!
	TINYFORMAT_ERROR("tinyformat: %n conversion spec not supported");
	break;
	case '\0':
	TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly "
	"terminated by end of string");
	return c;
	default:
	break;
	}
	if(intConversion && precisionSet && !widthSet)
	{
	// "precision" for integers gives the minimum number of digits (to be
	// padded with zeros on the left). This isn't really supported by the
	// iostreams, but we can approximately simulate it with the width if
	// the width isn't otherwise used.
	out.width(out.precision() + widthExtra);
	out.setf(std::ios::internal, std::ios::adjustfield);
	out.fill('0');
	}
	return c+1;
	}


	//------------------------------------------------------------------------------
	inline void formatImpl(std::ostream& out, const char* fmt,
	const detail::FormatArg* formatters,
	int numFormatters)
	{
	// Saved stream state
	std::streamsize origWidth = out.width();
	std::streamsize origPrecision = out.precision();
	std::ios::fmtflags origFlags = out.flags();
	char origFill = out.fill();

	for (int argIndex = 0; argIndex < numFormatters; ++argIndex)
	{
	// Parse the format string
	fmt = printFormatStringLiteral(out, fmt);
	bool spacePadPositive = false;
	int ntrunc = -1;
	const char* fmtEnd = streamStateFromFormat(out, spacePadPositive, ntrunc, fmt,
	formatters, argIndex, numFormatters);
	if (argIndex >= numFormatters)
	{
	// Check args remain after reading any variable width/precision
	TINYFORMAT_ERROR("tinyformat: Not enough format arguments");
	return;
	}
	const FormatArg& arg = formatters[argIndex];
	// Format the arg into the stream.
	if(!spacePadPositive)
	arg.format(out, fmt, fmtEnd, ntrunc);
	else
	{
	// The following is a special case with no direct correspondence
	// between stream formatting and the printf() behaviour. Simulate
	// it crudely by formatting into a temporary string stream and
	// munging the resulting string.
	std::ostringstream tmpStream;
	- tfm::imbue(tmpStream);
	+ tfm::detail::imbue(tmpStream);
	tmpStream.copyfmt(out);
	tmpStream.setf(std::ios::showpos);
	arg.format(tmpStream, fmt, fmtEnd, ntrunc);
	- std::string result = tmpStream.str(); // allocates... yuck.
	+ std::string result = tfm::detail::needReplace() ? tfm::detail::doReplace(tmpStream.str()) : tmpStream.str(); // allocates... yuck.
	for(size_t i = 0, iend = result.size(); i < iend; ++i)
	if(result[i] == '+') result[i] = ' ';
	out << result;
	}
	fmt = fmtEnd;
	}

	// Print remaining part of format string.
	fmt = printFormatStringLiteral(out, fmt);
	if(*fmt != '\0')
	TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string");

	// Restore stream state
	out.width(origWidth);
	out.precision(origPrecision);
	out.flags(origFlags);
	out.fill(origFill);
	}

	} // namespace detail


	/// List of template arguments format(), held in a type-opaque way.
	///
	/// A const reference to FormatList (typedef'd as FormatListRef) may be
	/// conveniently used to pass arguments to non-template functions: All type
	/// information has been stripped from the arguments, leaving just enough of a
	/// common interface to perform formatting as required.
	class FormatList
	{
	public:
	FormatList(detail::FormatArg* formatters, int N)
	: m_formatters(formatters), m_N(N) { }

	friend void vformat(std::ostream& out, const char* fmt,
	const FormatList& list);

	private:
	const detail::FormatArg* m_formatters;
	int m_N;
	};

	/// Reference to type-opaque format list for passing to vformat()
	typedef const FormatList& FormatListRef;


	namespace detail {

	// Format list subclass with fixed storage to avoid dynamic allocation
	template<int N>
	class FormatListN : public FormatList
	{
	public:
	#ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
	template<typename... Args>
	FormatListN(const Args&... args)
	: FormatList(&m_formatterStore[0], N),
	m_formatterStore { FormatArg(args)... }
	{ static_assert(sizeof...(args) == N, "Number of args must be N"); }
	#else // C++98 version
	void init(int) {}
	# define TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR(n) \
	\
	template<TINYFORMAT_ARGTYPES(n)> \
	FormatListN(TINYFORMAT_VARARGS(n)) \
	: FormatList(&m_formatterStore[0], n) \
	{ assert(n == N); init(0, TINYFORMAT_PASSARGS(n)); } \
	\
	template<TINYFORMAT_ARGTYPES(n)> \
	void init(int i, TINYFORMAT_VARARGS(n)) \
	{ \
	m_formatterStore[i] = FormatArg(v1); \
	init(i+1 TINYFORMAT_PASSARGS_TAIL(n)); \
	}

	TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR)
	# undef TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR
	#endif

	private:
	FormatArg m_formatterStore[N];
	};

	// Special 0-arg version - MSVC says zero-sized C array in struct is nonstandard
	template<> class FormatListN<0> : public FormatList
	{
	public: FormatListN() : FormatList(0, 0) {}
	};

	} // namespace detail


	//------------------------------------------------------------------------------
	// Primary API functions

	#ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES

	/// Make type-agnostic format list from list of template arguments.
	///
	/// The exact return type of this function is an implementation detail and
	/// shouldn't be relied upon. Instead it should be stored as a FormatListRef:
	///
	/// FormatListRef formatList = makeFormatList( /.../ );
	template<typename... Args>
	detail::FormatListN<sizeof...(Args)> makeFormatList(const Args&... args)
	{
	return detail::FormatListN<sizeof...(args)>(args...);
	}

	#else // C++98 version

	inline detail::FormatListN<0> makeFormatList()
	{
	return detail::FormatListN<0>();
	}
	#define TINYFORMAT_MAKE_MAKEFORMATLIST(n) \
	template<TINYFORMAT_ARGTYPES(n)> \
	detail::FormatListN<n> makeFormatList(TINYFORMAT_VARARGS(n)) \
	{ \
	return detail::FormatListN<n>(TINYFORMAT_PASSARGS(n)); \
	}
	TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_MAKEFORMATLIST)
	#undef TINYFORMAT_MAKE_MAKEFORMATLIST

	#endif

	/// Format list of arguments to the stream according to the given format string.
	///
	/// The name vformat() is chosen for the semantic similarity to vprintf(): the
	/// list of format arguments is held in a single function argument.
	inline void vformat(std::ostream& out, const char* fmt, FormatListRef list)
	{
	detail::formatImpl(out, fmt, list.m_formatters, list.m_N);
	}


	#ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES

	/// Format list of arguments to the stream according to given format string.
	template<typename... Args>
	void format(std::ostream& out, const char* fmt, const Args&... args)
	{
	vformat(out, fmt, makeFormatList(args...));
	}

	/// Format list of arguments according to the given format string and return
	/// the result as a string.
	template<typename... Args>
	std::string format(const char* fmt, const Args&... args)
	{
	std::ostringstream oss;
	- tfm::imbue(oss);
	+ tfm::detail::imbue(oss);
	format(oss, fmt, args...);
	- return oss.str();
	+ return tfm::detail::needReplace() ? tfm::detail::doReplace(oss.str()) : oss.str();
	}

	/// Format list of arguments to std::cout, according to the given format string
	template<typename... Args>
	void printf(const char* fmt, const Args&... args)
	{
	format(std::cout, fmt, args...);
	}

	template<typename... Args>
	void printfln(const char* fmt, const Args&... args)
	{
	format(std::cout, fmt, args...);
	std::cout << '\n';
	}


	#else // C++98 version

	inline void format(std::ostream& out, const char* fmt)
	{
	vformat(out, fmt, makeFormatList());
	}

	inline std::string format(const char* fmt)
	{
	std::ostringstream oss;
	- tfm::imbue(oss);
	+ tfm::detail::imbue(oss);
	format(oss, fmt);
	- return oss.str();
	+ return tfm::detail::needReplace() ? tfm::detail::doReplace(oss.str()) : oss.str();
	}

	inline void printf(const char* fmt)
	{
	format(std::cout, fmt);
	}

	inline void printfln(const char* fmt)
	{
	format(std::cout, fmt);
	std::cout << '\n';
	}

	#define TINYFORMAT_MAKE_FORMAT_FUNCS(n) \
	\
	template<TINYFORMAT_ARGTYPES(n)> \
	void format(std::ostream& out, const char* fmt, TINYFORMAT_VARARGS(n)) \
	{ \
	vformat(out, fmt, makeFormatList(TINYFORMAT_PASSARGS(n))); \
	} \
	\
	template<TINYFORMAT_ARGTYPES(n)> \
	std::string format(const char* fmt, TINYFORMAT_VARARGS(n)) \
	{ \
	std::ostringstream oss; \
	- tfm::imbue(oss); \
	+ tfm::detail::imbue(oss); \
	format(oss, fmt, TINYFORMAT_PASSARGS(n)); \
	- return oss.str(); \
	+ return tfm::detail::needReplace() ? \
	+ tfm::detail::doReplace(oss.str()) : oss.str(); \
	} \
	\
	template<TINYFORMAT_ARGTYPES(n)> \
	void printf(const char* fmt, TINYFORMAT_VARARGS(n)) \
	{ \
	format(std::cout, fmt, TINYFORMAT_PASSARGS(n)); \
	} \
	\
	template<TINYFORMAT_ARGTYPES(n)> \
	void printfln(const char* fmt, TINYFORMAT_VARARGS(n)) \
	{ \
	format(std::cout, fmt, TINYFORMAT_PASSARGS(n)); \
	std::cout << '\n'; \
	}

	TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMAT_FUNCS)
	#undef TINYFORMAT_MAKE_FORMAT_FUNCS

	#endif


	} // namespace tinyformat

	#endif // TINYFORMAT_H_INCLUDED

File Metadata

Mime Type: text/x-diff
Expires: Sat, May 16, 7:12 PM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 63209
Default Alt Text: (133 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions