No OneTemporary
Actions

Authored By

Unknown

Size

105 KB

Referenced Files

None

Subscribers

None

View Options

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

	#include "Functions.h"
	#include "GUIListBox.h"
	#include "ThemeManager.h"
	using namespace std;

	namespace {
	inline int tHeight(const SharedTexture& t) {
	if(t) {
	return rectFromTexture(*t).h;
	} else {
	return 0;
	}
	}
	inline int tWidth(const SharedTexture& t) {
	if(t) {
	return rectFromTexture(*t).w;
	} else {
	return 0;
	}
	}
	}

	GUIListBox::GUIListBox(ImageManager& imageManager, SDL_Renderer& renderer,int left,int top,int width,int height,bool enabled,bool visible,int gravity):
	GUIObject(imageManager,renderer,left,top,width,height,NULL,-1,enabled,visible,gravity),selectable(true),clickEvents(false){
	//Set the state -1.
	state=-1;

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

	GUIListBox::~GUIListBox(){
	//Remove all items and cache.
	clearItems();
	//We need to delete every child we have.
	for(unsigned int i=0;i<childControls.size();i++){
	delete childControls[i];
	}
	//Deleted the childs now empty the childControls vector.
	childControls.clear();
	}

	+void GUIListBox::scrollScrollbar(int dy) {
	+ if (scrollBar->enabled && dy) {
	+ scrollBar->value = clamp(scrollBar->value + dy, 0, scrollBar->maxValue);
	+ }
	+}
	+
	bool GUIListBox::handleEvents(SDL_Renderer& renderer,int x,int y,bool enabled,bool visible,bool processed){
	//Boolean if the event is processed.
	bool b=processed;

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

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

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

	//Set state negative.
	state=-1;

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

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

	//Check if the mouse is inside the GUIListBox.
	if(i>=0&&i<width-4&&j>=0&&j<height-4){
	//Calculate selected item.
	int idx=-1;
	int yPos=-firstItemY;
	int i=scrollBar->value;
	if(yPos!=0) i--;
	for(;i<images.size();++i){
	const SharedTexture& tex = images.at(i);
	if(tex){
	yPos+=tHeight(tex);
	}
	if(j<yPos){
	idx=i;
	break;
	}
	}

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

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

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

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

	//Check for mouse wheel scrolling.
	- if(event.type==SDL_MOUSEWHEEL && event.wheel.y < 0 && scrollBar->enabled){
	- scrollBar->value++;
	- if(scrollBar->value>scrollBar->maxValue)
	- scrollBar->value=scrollBar->maxValue;
	- }else if(event.type==SDL_MOUSEWHEEL && event.wheel.y > 0 && scrollBar->enabled){
	- scrollBar->value--;
	- if(scrollBar->value<0)
	- scrollBar->value=0;
	+ if (event.type == SDL_MOUSEWHEEL && event.wheel.y && scrollBar->enabled) {
	+ scrollScrollbar(event.wheel.y < 0 ? 1 : -1);
	}
	}
	}

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

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

	void GUIListBox::render(SDL_Renderer& renderer, int x,int y,bool draw){
	if(updateScrollbar){
	//Calculate the height of the content.
	int maxY=0;
	for(const SharedTexture& t: images){
	if(t){
	maxY+=textureHeight(*t);
	} else {
	std::cerr << "WARNING: Null texture in GUIListBox!" << std::endl;
	}
	}

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

	//Rectangle the size of the GUIObject, used to draw borders.
	//SDL_Rect r; //Unused local variable :/
	//There's no need drawing the GUIObject when it's invisible.
	if(!visible\|\|!draw)
	return;

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

	//Draw the background box.
	const SDL_Rect r={x,y,width,height};
	SDL_SetRenderDrawColor(&renderer,255,255,255,220);
	SDL_RenderFillRect(&renderer, &r);

	firstItemY=0;

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

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

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

	applyTexture(x,y+lowNumber,*currentTexture,renderer);
	}else{
	// This is the top item that is partially obscured.
	if(selectable){
	//Check if the mouse is hovering on current entry. If so draw borders around it.
	if(state==currentItem)
	drawGUIBox(x,y,width,tHeight(currentTexture)+lowNumber+1,renderer,0x00000000);

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

	firstItemY=-lowNumber;

	const SDL_Rect clip{ 0, -lowNumber, textureWidth(currentTexture), textureHeight(currentTexture) + lowNumber };
	const SDL_Rect dstRect{x, y, clip.w, clip.h};
	if (clip.w > 0 && clip.h > 0) SDL_RenderCopy(&renderer, currentTexture.get(), &clip, &dstRect);
	break;
	}

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

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

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

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

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

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

	void GUIListBox::clearItems(){
	item.clear();
	images.clear();
	}

	void GUIListBox::addItem(SDL_Renderer &renderer, std::string name, SharedTexture texture) {


	if(texture){
	images.push_back(texture);
	}else if(!texture&&!name.empty()){
	auto tex=SharedTexture(textureFromText(renderer, *fontText, name.c_str(), objThemes.getTextColor(true)));
	// Make sure we don't create any empty textures.
	if(!tex) {
	std::cerr << "WARNING: Failed to create texture from text: \"" << name << "\"" << std::endl;
	return;
	}
	images.push_back(tex);
	} else {
	// If nothing was added, ignore it.
	return;
	}
	item.push_back(name);
	updateScrollbar=true;
	}

	void GUIListBox::updateItem(SDL_Renderer &renderer, int index, string newText, SharedTexture newTexture) {
	if(newTexture) {
	images.at(index) = newTexture;
	} else if (!newTexture&&!newText.empty()) {
	auto tex=SharedTexture(textureFromText(renderer, *fontText, newText.c_str(), objThemes.getTextColor(true)));
	// Make sure we don't create any empty textures.
	if(!tex) {
	std::cerr << "WARNING: Failed to update texture at index" << index << " \"" << newText << "\"" << std::endl;
	return;
	}
	images.at(index)=tex;
	} else {
	return;
	}
	item.at(index)=newText;
	updateScrollbar=true;
	}

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

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

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

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

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

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

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

	return item[index].first;
	}

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

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

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

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

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

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

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

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

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

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

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

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

	return b;
	}

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

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

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

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

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

	x-=gravityX;

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

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

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

	//Check if the text is empty or not.
	if(!lp.empty()){
	if(!cacheTex){
	SDL_Color color = objThemes.getTextColor(inDialog);

	cacheTex=textureFromText(renderer, *fontGUI, lp.c_str(), color);

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

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

	//Draw the text.
	applyTexture(r.x, r.y, cacheTex, renderer);
	}
	}
	}

	if(draw){
	//Draw the arrows.
	r.x=x;
	if((state&0xF)==0x1)
	r.x+=abs(animation/2);
	r.y=y+4;
	if(inDialog)
	applyTexture(r.x,r.y,*arrowLeft2,renderer);
	else
	applyTexture(r.x,r.y,*arrowLeft1,renderer);

	r.x=x+width-16;
	if((state&0xF)==0x2)
	r.x-=abs(animation/2);
	if(inDialog)
	applyTexture(r.x,r.y,*arrowRight2,renderer);
	else
	applyTexture(r.x,r.y,*arrowRight1,renderer);
	}
	}
	diff --git a/src/GUIListBox.h b/src/GUIListBox.h
	index ce5238c..3a45a15 100644
	--- a/src/GUIListBox.h
	+++ b/src/GUIListBox.h
	@@ -1,142 +1,146 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef GUILISTBOX_H
	#define GUILISTBOX_H

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

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

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

	int firstItemY;

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

	//Destructor
	~GUIListBox();

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

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

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

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

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


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

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

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

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

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

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

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

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

	#include "Functions.h"
	#include "GUITextArea.h"
	#include "ThemeManager.h"
	#include <cmath>
	#include <algorithm>
	#include <ctype.h>
	#include <SDL_ttf.h>

	using namespace std;

	#define SPACE_PER_TAB 2

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

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

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

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

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

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

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

	void GUITextArea::inputText(SDL_Renderer &renderer, const char* s) {
	if (s && s[0]) {
	//Split into lines.
	vector<string> newLines;
	newLines.push_back(std::string());
	for (int i = 0; s[i]; i++) {
	if (s[i] == '\r') continue;
	if (s[i] == '\n') {
	newLines.push_back(std::string());
	continue;
	}
	if (s[i] == '\t') {
	// Replace tabs by spaces.
	newLines.back() += std::string(SPACE_PER_TAB, ' ');
	continue;
	}
	newLines.back().push_back(s[i]);
	}

	const int m = newLines.size();

	if (m == 1 && newLines[0].empty()) return;

	//Remove selected text.
	removeHighlight(renderer);

	//Calculate the width of the last line.
	int advance = 0;
	{
	const char* lastLine = newLines[m - 1].c_str();
	for (int i = 0;;) {
	int a = 0;
	int ch = utf8ReadForward(lastLine, i);
	if (ch <= 0) break;
	TTF_GlyphMetrics(widgetFont, ch, NULL, NULL, NULL, NULL, &a);
	advance += a;
	}
	}

	if (m > 1) {
	//Multiple lines.
	highlightEnd = newLines[m - 1].size();
	highlightStartX = highlightEndX = advance;

	newLines[m - 1] += lines[highlightLineStart].substr(highlightStart);
	lines[highlightLineStart] = lines[highlightLineStart].substr(0, highlightStart) + newLines[0];

	lines.insert(lines.begin() + (highlightLineStart + 1), newLines.begin() + 1, newLines.end());
	for (int i = 0; i < m - 1; i++) {
	linesCache.insert(linesCache.begin() + (highlightLineStart + 1), nullptr);
	}

	highlightStart = highlightEnd;
	} else {
	//Single line.
	highlightEnd = highlightStart + newLines[0].size();

	lines[highlightLineStart].insert(highlightStart, newLines[0]);

	highlightStart = highlightEnd;
	highlightStartX = highlightEndX = highlightStartX + advance;
	}

	//Update cache.
	highlightLineEnd = highlightLineStart + m - 1;
	for (int i = highlightLineStart; i <= highlightLineEnd; i++) {
	linesCache[i] = textureFromText(renderer, *widgetFont, lines[i].c_str(), objThemes.getTextColor(true));
	}
	highlightLineStart = highlightLineEnd;

	//Update view if needed.
	adjustView();

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

	+void GUITextArea::scrollScrollbar(int dx, int dy) {
	+ if (dx && scrollBarH->visible){
	+ scrollBarH->value = clamp(scrollBarH->value + dx, 0, scrollBarH->maxValue);
	+ }
	+ if (dy) {
	+ scrollBar->value = clamp(scrollBar->value + dy, 0, scrollBar->maxValue);
	+ }
	+}
	+
	bool GUITextArea::handleEvents(SDL_Renderer& renderer,int x,int y,bool enabled,bool visible,bool processed){
	//Boolean if the event is processed.
	bool b=processed;

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

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

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

	//NOTE: We don't reset the state to have a "focus" effect.
	//Only check for events when the object is both enabled and visible.
	if(enabled&&visible){
	//Check if there's a key press and the event hasn't been already processed.
	if(state==2 && event.type==SDL_KEYDOWN && !b && editable){
	if ((event.key.keysym.mod & KMOD_CTRL) == 0) {
	//Check if the key is supported.
	if (event.key.keysym.sym == SDLK_BACKSPACE){
	//Delete one character direct to prevent a lag.
	backspaceChar(renderer);
	} else if (event.key.keysym.sym == SDLK_DELETE){
	//Delete one character direct to prevent a lag.
	deleteChar(renderer);
	} else if (event.key.keysym.sym == SDLK_RETURN){
	removeHighlight(renderer);
	//Split the current line and update.
	string str2 = lines.at(highlightLineEnd).substr(highlightStart);
	lines.at(highlightLineStart) = lines.at(highlightLineStart).substr(0, highlightStart);

	linesCache.at(highlightLineStart) =
	textureFromText(renderer, *widgetFont, lines.at(highlightLineStart).c_str(), objThemes.getTextColor(true));

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

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

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

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

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


	adjustView();

	//If there is an event callback then call it.
	if (eventCallback){
	GUIEvent e = { eventCallback, name, this, GUIEventChange };
	GUIEventQueue.push_back(e);
	}
	} else if (event.key.keysym.sym == SDLK_TAB){
	//Calculate the width of a space.
	int advance;
	TTF_GlyphMetrics(widgetFont, ' ', NULL, NULL, NULL, NULL, &advance);

	int start = highlightLineStart, end = highlightLineEnd;
	if (start > end) std::swap(start, end);

	for (int line = start; line <= end; line++) {
	int count = 0;
	std::string &s = lines[line];
	if (event.key.keysym.mod & KMOD_SHIFT) {
	// remove spaces
	for (; count < SPACE_PER_TAB; count++) {
	if (s.c_str()[count] != ' ') break;
	}
	if (count > 0) {
	s.erase(0, count);
	count = -count;
	}
	} else {
	// add spaces
	count = SPACE_PER_TAB;
	s.insert(0, count, ' ');
	}

	//Update cache.
	if (count) {
	linesCache.at(line) = textureFromText(renderer, *widgetFont, s.c_str(), objThemes.getTextColor(true));
	}

	//Update selection.
	if (line == highlightLineStart) {
	highlightStart += count;
	highlightStartX += count*advance;
	if (highlightStart <= 0) {
	highlightStart = 0;
	highlightStartX = 0;
	}
	}
	if (line == highlightLineEnd) {
	highlightEnd += count;
	highlightEndX += count*advance;
	if (highlightEnd <= 0) {
	highlightEnd = 0;
	highlightEndX = 0;
	}
	}
	}

	adjustView();
	} else if (event.key.keysym.sym == SDLK_RIGHT){
	//Move the carrot once to prevent a lag.
	moveCarrotRight();
	} else if (event.key.keysym.sym == SDLK_LEFT){
	//Move the carrot once to prevent a lag.
	moveCarrotLeft();
	} else if (event.key.keysym.sym == SDLK_DOWN){
	//Move the carrot once to prevent a lag.
	moveCarrotDown();
	} else if (event.key.keysym.sym == SDLK_UP){
	//Move the carrot once to prevent a lag.
	moveCarrotUp();
	}
	} else {
	//Check hotkey.
	if (event.key.keysym.sym == SDLK_a) {
	//Select all.
	highlightLineStart = 0;
	highlightStart = 0;
	highlightStartX = 0;
	highlightLineEnd = lines.size() - 1;
	highlightEnd = lines.back().size();
	highlightEndX = 0;
	if (highlightEnd > 0) {
	TTF_SizeUTF8(widgetFont, lines.back().c_str(), &highlightEndX, NULL);
	}
	} else if (event.key.keysym.sym == SDLK_x \|\| event.key.keysym.sym == SDLK_c) {
	//Cut or copy.
	int startLine = highlightLineStart, endLine = highlightLineEnd;
	int start = highlightStart, end = highlightEnd;
	if (startLine > endLine \|\| (startLine == endLine && start > end)) {
	std::swap(startLine, endLine);
	std::swap(start, end);
	}

	std::string s;

	if (startLine < endLine) {
	//Multiple lines.
	s = lines[startLine].substr(start);
	s.push_back('\n');
	for (int i = startLine + 1; i < endLine; i++) {
	s += lines[i];
	s.push_back('\n');
	}
	s += lines[endLine].substr(0, end);
	} else {
	//Single line.
	s = lines[startLine].substr(start, end - start);
	}

	if (!s.empty()) {
	SDL_SetClipboardText(s.c_str());
	if (event.key.keysym.sym == SDLK_x) {
	//Cut.
	removeHighlight(renderer);

	//If there is an event callback then call it.
	if (eventCallback){
	GUIEvent e = { eventCallback, name, this, GUIEventChange };
	GUIEventQueue.push_back(e);
	}
	}
	}
	} else if (event.key.keysym.sym == SDLK_v) {
	//Paste.
	if (SDL_HasClipboardText()) {
	char *s = SDL_GetClipboardText();
	inputText(renderer, s);
	SDL_free(s);
	}
	}
	}

	//The event has been processed.
	b=true;
	} else if (state == 2 && event.type == SDL_TEXTINPUT && !b && editable){
	inputText(renderer, event.text.text);
	} else if (state == 2 && event.type == SDL_TEXTEDITING && !b && editable){
	// TODO: process SDL_TEXTEDITING event
	}

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

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

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

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

	if (((event.type == SDL_MOUSEBUTTONUP \|\| event.type == SDL_MOUSEBUTTONDOWN) && event.button.button == 1)
	\|\| (event.type == SDL_MOUSEMOTION && (k & SDL_BUTTON(1))))
	{
	//Move carrot to the place clicked.
	const int mouseLine = clamp((int)floor(float(j - y) / float(fontHeight)) + scrollBar->value, 0, lines.size() - 1);

	string* str = &lines.at(mouseLine);
	value = str->length();

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

	for (int i = 0;;){
	int advance = 0;

	int i0 = i;
	int ch = utf8ReadForward(str->c_str(), i);
	if (ch <= 0) break;
	TTF_GlyphMetrics(widgetFont, ch, NULL, NULL, NULL, NULL, &advance);
	finalX += advance;

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

	if (event.type == SDL_MOUSEBUTTONUP){
	state = 2;
	highlightEnd = finalPos;
	highlightEndX = finalX;
	highlightLineEnd = mouseLine;
	} else if (event.type == SDL_MOUSEBUTTONDOWN){
	state = 2;
	highlightStart = highlightEnd = finalPos;
	highlightStartX = highlightEndX = finalX;
	highlightLineStart = highlightLineEnd = mouseLine;
	} else if (event.type == SDL_MOUSEMOTION){
	state = 2;
	highlightEnd = finalPos;
	highlightEndX = finalX;
	highlightLineEnd = mouseLine;
	}
	}
	} else {
	const int mouseLine = (int)floor(float(j - y) / float(fontHeight)) + scrollBar->value;
	if (mouseLine >= 0 && mouseLine < (int)hyperlinks.size()) {
	const int clickX = i - x + scrollBarH->value;
	for (const Hyperlink& lnk : hyperlinks[mouseLine]) {
	if (clickX >= lnk.startX && clickX < lnk.endX) {
	currentCursor = CURSOR_POINTING_HAND;
	if (event.type == SDL_MOUSEBUTTONDOWN && event.button.button == 1) {
	openWebsite(lnk.url);
	}
	break;
	}
	}
	}
	}
	}
	}else{
	//The mouse is outside the TextBox.
	//If we don't have focus but only hover we lose it.
	if(state==1){
	state=0;
	}

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

	if(!editable)
	highlightLineStart=scrollBar->value;

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

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

	void GUITextArea::removeHighlight(SDL_Renderer& renderer){
	if (highlightLineStart==highlightLineEnd) {
	if (highlightStart == highlightEnd) return;
	int start=highlightStart, end=highlightEnd, startx=highlightStartX;
	if(highlightStart>highlightEnd){
	start=highlightEnd;
	end=highlightStart;
	startx=highlightEndX;
	}
	std::string& str=lines.at(highlightLineStart);
	str.erase(start,end-start);

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

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

	lines[startLine] = lines[startLine].substr(0, start) + lines[endLine].substr(end);

	lines.erase(lines.begin() + startLine + 1, lines.begin() + endLine + 1);
	linesCache.erase(linesCache.begin() + startLine + 1, linesCache.begin() + endLine + 1);

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

	// Update cache.
	linesCache.at(startLine) = textureFromText(renderer, *widgetFont, lines[startLine].c_str(), objThemes.getTextColor(true));
	}
	adjustView();
	}

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

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

	int ch = utf8ReadBackward(lines.at(highlightLineStart).c_str(), highlightStart);
	if (ch > 0) TTF_GlyphMetrics(widgetFont, ch, NULL, NULL, NULL, NULL, &advance);

	highlightStartX -= advance;
	}
	}
	removeHighlight(renderer);

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

	void GUITextArea::moveCarrotRight(){
	if (highlightEnd>=(int)lines.at(highlightLineEnd).length()){
	if (highlightLineEnd<(int)lines.size()-1){
	highlightEnd=0;
	highlightEndX=0;
	highlightLineEnd++;
	}
	}else{
	int advance = 0;

	int ch = utf8ReadForward(lines.at(highlightLineEnd).c_str(), highlightEnd);
	if (ch > 0) TTF_GlyphMetrics(widgetFont, ch, NULL, NULL, NULL, NULL, &advance);

	highlightEndX += advance;
	}
	if((SDL_GetModState()&KMOD_SHIFT)==0){
	highlightLineStart=highlightLineEnd;
	highlightStart=highlightEnd;
	highlightStartX=highlightEndX;
	}
	adjustView();
	}

	void GUITextArea::moveCarrotLeft(){
	if (highlightEnd<=0){
	if (highlightLineEnd==0){
	highlightEnd=0;
	}else{
	highlightLineEnd--;
	highlightEnd=lines.at(highlightLineEnd).length();
	highlightEndX=0;
	if (highlightEnd > 0) {
	TexturePtr& t = linesCache.at(highlightLineEnd);
	if (t) highlightEndX = textureWidth(*t);
	}
	}
	}else{
	int advance = 0;

	int ch = utf8ReadBackward(lines.at(highlightLineEnd).c_str(), highlightEnd);
	if (ch > 0) TTF_GlyphMetrics(widgetFont, ch, NULL, NULL, NULL, NULL, &advance);

	highlightEndX -= advance;
	}
	if((SDL_GetModState()&KMOD_SHIFT)==0){
	highlightLineStart=highlightLineEnd;
	highlightStart=highlightEnd;
	highlightStartX=highlightEndX;
	}
	adjustView();
	}

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

	//Find out closest match.
	int xPos=0;
	int i=0;
	for (;;){
	int advance = 0;

	int i0 = i;
	int ch = utf8ReadForward(str.c_str(), i);
	if (ch <= 0) break;
	TTF_GlyphMetrics(widgetFont, ch, NULL, NULL, NULL, NULL, &advance);
	xPos += advance;

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

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

	//Find out closest match.
	int xPos=0;
	int i = 0;
	for (;;){
	int advance = 0;

	int i0 = i;
	int ch = utf8ReadForward(str->c_str(), i);
	if (ch <= 0) break;
	TTF_GlyphMetrics(widgetFont, ch, NULL, NULL, NULL, NULL, &advance);
	xPos += advance;

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

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

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

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

	//Adjust the horizontal view.
	int carrotX=0;
	for(int n=0;n<highlightEnd;){
	int advance = 0;

	int ch = utf8ReadForward(lines.at(highlightLineEnd).c_str(), n);
	if (ch <= 0) break;
	TTF_GlyphMetrics(widgetFont, ch, NULL, NULL, NULL, NULL, &advance);
	carrotX += advance;
	}
	if(carrotX>width-24)
	scrollBarH->value=scrollBarH->maxValue;
	else
	scrollBarH->value=0;

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

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

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

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

	{
	//Draw the box.
	const Uint32 color=0xFFFFFFFF;
	drawGUIBox(x,y,width,height,renderer,color);
	}

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

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

	// draw hyperlinks
	if (!editable && line<(int)hyperlinks.size()) {
	r.y = lineY + fontHeight - 1;
	if (r.y < height){
	r.y += y + 1;
	r.h = 1;
	for (const Hyperlink& lnk : hyperlinks[line]) {
	r.x = clamp(lnk.startX - scrollBarH->value, 0, width - 17);
	r.w = clamp(lnk.endX - scrollBarH->value, 0, width - 17);
	if (r.w > r.x) {
	r.w -= r.x;
	r.x += x + 1;
	SDL_SetRenderDrawColor(&renderer, 0, 0, 0, 255);
	SDL_RenderFillRect(&renderer, &r);
	}
	}
	}
	}
	}else{
	break;
	}
	}
	lineY+=fontHeight;
	}

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

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

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

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

	size_t linePos=0,lineLen=0;

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

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

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

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

	adjustView();
	}

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

	//Copy values.
	lines=input;

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

	adjustView();
	}

	void GUITextArea::extractHyperlinks() {
	const int lm = lines.size();
	hyperlinks.clear();

	if (lm <= 0) return;
	hyperlinks.resize(lm);

	for (int l = 0; l < lm; l++) {
	const char* s = lines[l].c_str();
	for (int i = 0, m = lines[l].size(); i < m; i++) {
	const int lps = i;
	std::string url;

	// we only support http or https
	if ((s[i] == 'H' \|\| s[i] == 'h')
	&& (s[i + 1] == 'T' \|\| s[i + 1] == 't')
	&& (s[i + 2] == 'T' \|\| s[i + 2] == 't')
	&& (s[i + 3] == 'P' \|\| s[i + 3] == 'p'))
	{
	if (s[i + 4] == ':' && s[i + 5] == '/' && s[i + 6] == '/') {
	// http
	i += 7;
	url = "http://";
	} else if ((s[i + 4] == 'S' \|\| s[i + 4] == 's') && s[i + 5] == ':' && s[i + 6] == '/' && s[i + 7] == '/') {
	// https
	i += 8;
	url = "https://";
	} else {
	continue;
	}
	for (; i < m; i++) {
	char c = s[i];
	// url ends with following character
	if (c == '\0' \|\| c == ' ' \|\| c == ')' \|\| c == ']' \|\| c == '}' \|\| c == '>' \|\| c == '\r' \|\| c == '\n' \|\| c == '\t') {
	break;
	}
	url.push_back(c);
	}
	} else {
	continue;
	}

	const int lpe = i;

	Hyperlink hyperlink = {};
	TTF_SizeUTF8(widgetFont, lines[l].substr(0, lps).c_str(), &hyperlink.startX, NULL);
	TTF_SizeUTF8(widgetFont, lines[l].substr(0, lpe).c_str(), &hyperlink.endX, NULL);
	hyperlink.url = lines[l].substr(lps, lpe - lps);

	hyperlinks[l].push_back(hyperlink);
	}
	}
	}

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

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

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

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

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

	#ifndef GUITEXTAREA_H
	#define GUITEXTAREA_H

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

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

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

	// Remove all highlighted text.
	void removeHighlight(SDL_Renderer &renderer);

	// Input new text.
	void inputText(SDL_Renderer &renderer, const char* s);

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

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

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

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

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

	//Height of the font.
	int fontHeight;

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

	//A struct to save hyperlink.
	struct Hyperlink {
	int startX, endX;
	std::string url;
	};

	//Hyperlinks.
	std::vector<std::vector<Hyperlink> > hyperlinks;

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

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

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

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

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

	//Extract hyperlinks from text.
	//Currently only http and https links are extracted.
	void extractHyperlinks();

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

	//Method used to handle mouse and/or key events.
	//x: The x mouse location.
	//y: The y mouse location.
	//enabled: Boolean if the parent is enabled or not.
	//visible: Boolean if the parent is visible or not.
	//processed: Boolean if the event has been processed (by the parent) or not.
	//Returns: Boolean if the event is processed by the child.
	virtual bool handleEvents(SDL_Renderer&renderer, int x=0, int y=0, bool enabled=true, bool visible=true, bool processed=false);
	//Method that will render the GUITextArea.
	//x: The x location to draw the GUITextArea. (x+left)
	//y: The y location to draw the GUITextArea. (y+top)
	virtual void render(SDL_Renderer &renderer, int x=0, int y=0, bool draw=true);
	+
	+ //Scroll the scrollbar.
	+ //dx: horizontal scroll (in pixels), typically multiple of 20
	+ //dy: vertical scroll (in lines)
	+ void scrollScrollbar(int dx, int dy);
	};

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

	#include <stdio.h>
	#include <string>
	#include <vector>
	#include <map>
	#include "StatisticsManager.h"
	#include "StatisticsScreen.h"
	#include "Globals.h"
	#include "Functions.h"
	#include "ThemeManager.h"
	#include "InputManager.h"
	#include "GUIListBox.h"
	#include "GUIScrollBar.h"
	#include <SDL_ttf.h>
	#include <array>

	using namespace std;

	//GUI events are handled here.
	//name: The name of the element that invoked the event.
	//obj: Pointer to the object that invoked the event.
	//eventType: Integer containing the type of event.
	void StatisticsScreen::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Check what type of event it was.
	if(eventType==GUIEventClick){
	if(name=="cmdBack"){
	//Goto the main menu.
	setNextState(STATE_MENU);
	}
	}
	}

	//Constructor.
	StatisticsScreen::StatisticsScreen(ImageManager& imageManager, SDL_Renderer& renderer){
	//Update in-game time.
	statsMgr.updatePlayTime();

	//Render the title.
	//title=TTF_RenderUTF8_Blended(fontTitle,_("Achievements and Statistics"),objThemes.getTextColor(false));
	title = textureFromText(renderer, *fontTitle,_("Achievements and Statistics"),objThemes.getTextColor(false));


	//Create GUI.
	createGUI(imageManager, renderer);
	}

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

	//we are so lazy that we just use height of the first text, ignore the others
	#define DRAW_PLAYER_STATISTICS(name,var,fmt) { \
	SurfacePtr surface(TTF_RenderUTF8_Blended(fontGUISmall,name,objThemes.getTextColor(true))); \
	SurfacePtr stats = createSurface(w,surface->h); \
	SDL_FillRect(stats.get(),NULL,-1); \
	applySurface(4,0,surface.get(),stats.get(),NULL); \
	y=surface->h; \
	SDL_snprintf(formatString.data(),formatString.size(),fmt,statsMgr.player##var+statsMgr.shadow##var); \
	surface.reset(TTF_RenderUTF8_Blended(fontText,formatString.data(),objThemes.getTextColor(true))); \
	applySurface(w-260-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL); \
	SDL_snprintf(formatString.data(),formatString.size(),fmt,statsMgr.player##var); \
	surface.reset(TTF_RenderUTF8_Blended(fontText,formatString.data(),objThemes.getTextColor(true))); \
	applySurface(w-140-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL); \
	SDL_snprintf(formatString.data(),formatString.size(),fmt,statsMgr.shadow##var); \
	surface.reset(TTF_RenderUTF8_Blended(fontText,formatString.data(),objThemes.getTextColor(true))); \
	applySurface(w-20-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL); \
	list->addItem(renderer,"",textureFromSurface(renderer, std::move(stats))); /* add it to list box */ \
	}

	//Add an item to the listbox, that displays "name1", and "var1" formatted with "format"
	//we are so lazy that we just use height of the first text, ignore the others
	template <class T1>
	static void drawMiscStatistics1(SDL_Renderer& renderer, int w,GUIListBox list,const char name1,const T1 var1,const char* format1){
	//create new surface
	SurfacePtr nameSurface(TTF_RenderUTF8_Blended(fontGUISmall,name1,objThemes.getTextColor(true)));

	SurfacePtr stats=createSurface(w, nameSurface->h);
	SDL_FillRect(stats.get(),NULL,-1);

	applySurface(4,0,nameSurface.get(),stats.get(),NULL);
	const int x=nameSurface->w+8;
	const int y=nameSurface->h;

	//draw value
	//char s[1024];
	std::array<char, 1024> s;
	SDL_snprintf(s.data(),s.size(),format1,var1);
	SurfacePtr formatSurface(TTF_RenderUTF8_Blended(fontText,s.data(),objThemes.getTextColor(true)));
	//NOTE: SDL2 port. Not halving the y value here as this ends up looking better.
	applySurface(x,y-formatSurface->h,formatSurface.get(),stats.get(),NULL);

	//add it to list box
	list->addItem(renderer, "",textureFromSurface(renderer, std::move(stats)));

	//over
	//return stats;
	}

	//NOTE: Disabled this for the SDL2 port for now. It looks a bit off anyhow.
	//Might want to make a more general method that draws as many "cells" as there is space.
	//Draws two stats on one line if there is space.
	//we are so lazy that we just use height of the first text, ignore the others
	/*template <class T1,class T2>
	static void drawMiscStatistics2(int w,GUIListBox list,const char name1,const T1 var1,const char* format1,const char* name2,const T2 var2,const char* format2){
	SDL_Surface* stats=drawMiscStatistics1(w,list,name1,var1,format1);

	//Check if the width is enough
	if(w>=800){
	//draw name
	SDL_Surface* surface=TTF_RenderUTF8_Blended(fontGUISmall,name2,objThemes.getTextColor(true));
	applySurface(w/2-8,stats->h-surface->h,surface,stats,NULL);
	int x=surface->w+w/2;
	SDL_FreeSurface(surface);

	//draw value
	char s[1024];
	sprintf(s,format2,var2);
	surface=TTF_RenderUTF8_Blended(fontText,s,objThemes.getTextColor(true));
	applySurface(x,(stats->h-surface->h)/2,surface,stats,NULL);
	SDL_FreeSurface(surface);
	}else{
	//Split into two rows
	drawMiscStatistics1(w,list,name2,var2,format2);
	}
	}*/

	//Method that will create the GUI.
	void StatisticsScreen::createGUI(ImageManager& imageManager, SDL_Renderer &renderer){
	//Create the root element of the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	GUIObjectRoot=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

	//Create back button.
	GUIObject* obj=new GUIButton(imageManager,renderer,SCREEN_WIDTH*0.5,SCREEN_HEIGHT-60,-1,36,_("Back"),0,true,true,GUIGravityCenter);
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->addChild(obj);

	//Create list box.
	listBox=new GUISingleLineListBox(imageManager,renderer,(SCREEN_WIDTH-500)/2,104,500,32);
	listBox->addItem(_("Achievements"));
	listBox->addItem(_("Statistics"));
	listBox->value=0;
	GUIObjectRoot->addChild(listBox);

	//Create list box for achievements.
	GUIListBox *list=new GUIListBox(imageManager,renderer,64,150,SCREEN_WIDTH-128,SCREEN_HEIGHT-150-72);
	list->selectable=false;
	GUIObjectRoot->addChild(list);
	lists.clear();
	lists.push_back(list);

	for(int idx=0;achievementList[idx].id!=NULL;++idx){
	time_t *lpt=NULL;

	map<string,OwnedAchievement>::iterator it=statsMgr.achievements.find(achievementList[idx].id);
	if(it!=statsMgr.achievements.end()){
	lpt=&it->second.achievedTime;
	}

	SDL_Rect r;
	r.x=r.y=0;
	r.w=list->width-16;
	auto surface= statsMgr.createAchievementSurface(renderer, &achievementList[idx],&r,false,lpt);

	if(surface){
	//FIXME - this is broken with SDL2 as the function now operates on a renderer, not sure how best to fix it
	/* hlineRGBA(surface,0,surface->w,0,0,0,0,32);
	hlineRGBA(surface,0,surface->w,surface->h-1,0,0,0,128);
	hlineRGBA(surface,0,surface->w,surface->h-2,0,0,0,32);*/
	list->addItem(renderer, "",surface);
	}
	}

	//Now create list box for statistics.
	list=new GUIListBox(imageManager,renderer,64,150,SCREEN_WIDTH-128,SCREEN_HEIGHT-150-72,true,false);
	list->selectable=false;
	GUIObjectRoot->addChild(list);
	lists.push_back(list);

	//Load needed pictures.
	//FIXME: hard-coded image path
	//TODO: Might want to consider not caching these as most other stuff use textures now.
	SDL_Surface* bmPlayer=imageManager.loadImage(getDataPath()+"themes/Cloudscape/characters/player.png");
	SDL_Surface* bmShadow=imageManager.loadImage(getDataPath()+"themes/Cloudscape/characters/shadow.png");
	SDL_Surface* bmMedal=imageManager.loadImage(getDataPath()+"gfx/medals.png");

	//Render stats.
	//char s[64],s2[64];
	std::array<char, 64> formatString;

	SDL_Rect r;
	int x,y,w=SCREEN_WIDTH-128;
	SharedTexture h_bar = [&](){
	//The horizontal bar.
	SurfacePtr h_bar(createSurface(w,2));
	SDL_Color c = objThemes.getTextColor(true);
	Uint32 clr=SDL_MapRGB(h_bar->format,c.r,c.g,c.b);
	SDL_FillRect(h_bar.get(),NULL,clr);
	return textureFromSurface(renderer, std::move(h_bar));
	}();

	//Player and shadow specific statistics
	//The header.
	{
	SurfacePtr stats = createSurface(w, 44);
	SDL_FillRect(stats.get(),NULL,-1);

	SurfacePtr surface(TTF_RenderUTF8_Blended(fontGUISmall,_("Total"),objThemes.getTextColor(true)));
	applySurface(w-260-surface->w,stats->h-surface->h,surface.get(),stats.get(),NULL);
	//FIXME: hard-coded player and shadow images
	r.x=0;r.y=0;r.w=23;r.h=40;
	applySurface(w-140-r.w,stats.get()->h-40,bmPlayer,stats.get(),&r);
	applySurface(w-20-r.w,stats.get()->h-40,bmShadow,stats.get(),&r);

	list->addItem(renderer, "",textureFromSurface(renderer, std::move(stats)));
	}

	//Each items.
	{
	DRAW_PLAYER_STATISTICS(_("Traveling distance (m)"),TravelingDistance,"%0.1f");
	DRAW_PLAYER_STATISTICS(_("Jump times"),Jumps,"%d");
	DRAW_PLAYER_STATISTICS(_("Die times"),Dies,"%d");
	DRAW_PLAYER_STATISTICS(_("Squashed times"),Squashed,"%d");
	}

	//Game specific statistics.
	list->addItem(renderer, "",h_bar);

	auto drawMiscStats = [&](const char* name1,const int var1,const char* format1) {
	drawMiscStatistics1(renderer, w, list, name1, var1, format1);
	};

	drawMiscStats(_("Recordings:"),statsMgr.recordTimes,"%d");
	drawMiscStats(_("Switch pulled times:"),statsMgr.switchTimes,"%d");
	drawMiscStats(_("Swap times:"),statsMgr.swapTimes,"%d");
	drawMiscStats(_("Save times:"),statsMgr.saveTimes,"%d");
	drawMiscStats(_("Load times:"),statsMgr.loadTimes,"%d");

	//Level specific statistics
	list->addItem(renderer, "",h_bar);
	{
	SurfacePtr surface(TTF_RenderUTF8_Blended(fontGUISmall,_("Completed levels:"),objThemes.getTextColor(true)));
	SurfacePtr stats = createSurface(w, surface->h);
	SDL_FillRect(stats.get(),NULL,-1);

	applySurface(4,0,surface.get(),stats.get(),NULL);
	x=surface->w+8;
	y=surface->h;

	SDL_snprintf(formatString.data(), formatString.size(),"%d",statsMgr.completedLevels);
	surface.reset(TTF_RenderUTF8_Blended(fontText,formatString.data(),objThemes.getTextColor(true)));

	applySurface(x,(y-surface->h),surface.get(),stats.get(),NULL);

	SDL_snprintf(formatString.data(), formatString.size(),"%d",statsMgr.completedLevels-statsMgr.goldLevels-statsMgr.silverLevels);
	surface.reset(TTF_RenderUTF8_Blended(fontText,formatString.data(),objThemes.getTextColor(true)));
	applySurface(w-260-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL);
	r.x=0;r.y=0;r.w=30;r.h=30;
	applySurface(w-260-surface->w-30,(y-30)/2,bmMedal,stats.get(),&r);

	SDL_snprintf(formatString.data(), formatString.size(),"%d",statsMgr.silverLevels);
	surface.reset(TTF_RenderUTF8_Blended(fontText,formatString.data(),objThemes.getTextColor(true)));
	applySurface(w-140-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL);
	r.x+=30;
	applySurface(w-140-surface->w-30,(y-30)/2,bmMedal,stats.get(),&r);

	SDL_snprintf(formatString.data(), formatString.size(),"%d",statsMgr.goldLevels);
	surface.reset(TTF_RenderUTF8_Blended(fontText,formatString.data(),objThemes.getTextColor(true)));
	applySurface(w-20-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL);
	r.x+=30;
	applySurface(w-20-surface->w-30,(y-30)/2,bmMedal,stats.get(),&r);

	list->addItem(renderer,"",textureFromSurface(renderer, std::move(stats)));
	}

	//Other statistics.
	list->addItem(renderer, "",h_bar);

	SDL_snprintf(formatString.data(), formatString.size(),"%02d:%02d:%02d",statsMgr.playTime/3600,(statsMgr.playTime/60)%60,statsMgr.playTime%60);
	drawMiscStatistics1(renderer,w,list,_("In-game time:"),formatString.data(),"%s");
	SDL_snprintf(formatString.data(), formatString.size(),"%02d:%02d:%02d",statsMgr.levelEditTime/3600,(statsMgr.levelEditTime/60)%60,statsMgr.levelEditTime%60);
	drawMiscStatistics1(renderer,w,list,_("Level editing time:"),formatString.data(),"%s");

	drawMiscStats(_("Created levels:"),statsMgr.createdLevels,"%d");
	}

	//In this method all the key and mouse events should be handled.
	//NOTE: The GUIEvents won't be handled here.
	void StatisticsScreen::handleEvents(ImageManager&, SDL_Renderer&){
	//Check if we need to quit, if so enter the exit state.
	if(event.type==SDL_QUIT){
	setNextState(STATE_EXIT);
	}

	+ //Check horizontal movement
	+ int value = listBox->value;
	+ if (inputMgr.isKeyDownEvent(INPUTMGR_RIGHT)){
	+ isKeyboardOnly = true;
	+ value++;
	+ if (value >= (int)listBox->item.size()) value = 0;
	+ } else if (inputMgr.isKeyDownEvent(INPUTMGR_LEFT)){
	+ isKeyboardOnly = true;
	+ value--;
	+ if (value < 0) value = listBox->item.size() - 1;
	+ }
	+ listBox->value = value;
	+
	+ //Check vertical movement
	+ if (value >= 0 && value < (int)lists.size()) {
	+ if (inputMgr.isKeyDownEvent(INPUTMGR_UP)){
	+ isKeyboardOnly = true;
	+ lists[value]->scrollScrollbar(-1);
	+ } else if (inputMgr.isKeyDownEvent(INPUTMGR_DOWN)){
	+ isKeyboardOnly = true;
	+ lists[value]->scrollScrollbar(1);
	+ }
	+ }
	+
	//Check if the escape button is pressed, if so go back to the main menu.
	if(inputMgr.isKeyUpEvent(INPUTMGR_ESCAPE)){
	setNextState(STATE_MENU);
	}
	}

	//All the logic that needs to be done should go in this method.
	void StatisticsScreen::logic(ImageManager&, SDL_Renderer&){
	}

	//This method handles all the rendering.
	void StatisticsScreen::render(ImageManager&, SDL_Renderer& renderer){
	//Draw background.
	objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();

	//Draw title.
	drawTitleTexture(SCREEN_WIDTH, *title, renderer);

	//Draw statistics.
	int value=listBox->value;
	for(unsigned int i=0;i<lists.size();i++){
	lists[i]->visible=(i==value);
	}
	}

	//Method that will be called when the screen size has been changed in runtime.
	void StatisticsScreen::resize(ImageManager &imageManager, SDL_Renderer &renderer){
	//Recreate the gui to fit the new resolution.
	createGUI(imageManager, renderer);
	}
	diff --git a/src/TitleMenu.cpp b/src/TitleMenu.cpp
	index ce94a83..6bb2c93 100644
	--- a/src/TitleMenu.cpp
	+++ b/src/TitleMenu.cpp
	@@ -1,869 +1,884 @@
	/*
	* Copyright (C) 2011-2013 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "Functions.h"
	#include "GameState.h"
	#include "TitleMenu.h"
	#include "ThemeManager.h"
	#include "GUIListBox.h"
	#include "GUITextArea.h"
	#include "InputManager.h"
	#include "LevelPackManager.h"
	#include "StatisticsManager.h"
	#include "MusicManager.h"
	#include "SoundManager.h"
	#include <iostream>
	#include <algorithm>
	#include <sstream>

	#include "libs/tinygettext/tinygettext.hpp"

	using namespace std;

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

	Menu::Menu(ImageManager &imageManager, SDL_Renderer& renderer){
	animation=highlight=0;

	//Load the title image.
	titleTexture=imageManager.loadTexture(getDataPath()+"gfx/menu/title.png",renderer);


	auto tft = [&](const char* text){
	return textureFromText(renderer, *fontTitle, text, objThemes.getTextColor(false));
	};

	//Now render the five entries.
	entries[0]=tft(_("Play"));
	entries[1]=tft(_("Options"));
	entries[2]=tft(_("Map Editor"));
	entries[3]=tft(_("Addons"));
	entries[4]=tft(_("Quit"));
	entries[5]=tft(">");
	entries[6]=tft("<");

	//Load the textures for the credits and statistics buttons and their tooltips.
	creditsIcon=imageManager.loadTexture(getDataPath()+"gfx/menu/credits.png", renderer);
	creditsTooltip=textureFromText(renderer, *fontText, _("Credits"), objThemes.getTextColor(true));
	statisticsIcon=imageManager.loadTexture(getDataPath()+"gfx/menu/statistics.png", renderer);
	statisticsTooltip=textureFromText(renderer, *fontText, _("Achievements and Statistics"), objThemes.getTextColor(true));

	// Check if textures were loaded.
	//TODO: Handle this better.
	if(!titleTexture \|\| !creditsIcon \|\| !statisticsIcon) {
	std::cerr << "Failed to load one or more images for the main menu, exiting. : " << SDL_GetError() << std::endl;
	std::terminate();
	}
	}

	Menu::~Menu(){
	}


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

	//Calculate which option is highlighted using the location of the mouse.
	//Only if mouse is 'doing something'
	if(event.type==SDL_MOUSEMOTION \|\| event.type==SDL_MOUSEBUTTONDOWN){
	highlight=0;

	if(x>=200&&x<SCREEN_WIDTH-200&&y>=(SCREEN_HEIGHT-250)/2&&y<(SCREEN_HEIGHT-200)/2+320){
	highlight=(y-((SCREEN_HEIGHT-200)/2-64))/64;
	if(highlight>5) highlight=0;
	}

	//Also check the icons.
	if(y>=SCREEN_HEIGHT-56&&y<SCREEN_HEIGHT-8){
	if(x>=SCREEN_WIDTH-8){
	//do nothing
	}else if(x>=SCREEN_WIDTH-56){
	highlight=7;
	}else if(x>=SCREEN_WIDTH-104){
	highlight=6;
	}
	}
	}

	//Down/Up -arrows move highlight
	int mod = SDL_GetModState();
	if (inputMgr.isKeyDownEvent(INPUTMGR_DOWN) \|\| inputMgr.isKeyDownEvent(INPUTMGR_RIGHT) \|\| (inputMgr.isKeyDownEvent(INPUTMGR_TAB) && (mod & KMOD_SHIFT) == 0)) {
	isKeyboardOnly = true;
	highlight++;
	if(highlight>7)
	highlight=0;
	} else if (inputMgr.isKeyDownEvent(INPUTMGR_UP) \|\| inputMgr.isKeyDownEvent(INPUTMGR_LEFT) \|\| (inputMgr.isKeyDownEvent(INPUTMGR_TAB) && (mod & KMOD_SHIFT) != 0)) {
	isKeyboardOnly = true;
	highlight--;
	if(highlight<0)
	highlight=7;
	}

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

	//Enter the addons state.
	setNextState(STATE_ADDONS);
	break;
	case 5:
	//We quit, so we enter the exit state.
	setNextState(STATE_EXIT);
	break;
	case 6:
	//Show the credits screen.
	setNextState(STATE_CREDITS);
	break;
	case 7:
	//Show the statistics screen.
	setNextState(STATE_STATISTICS);
	break;
	}
	}

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

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

	void Menu::logic(ImageManager&, SDL_Renderer&){
	animation++;
	if(animation>10)
	animation=-10;
	}

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

	//Draw the title.
	{
	int titleWidth, titleHeight = 0;
	SDL_QueryTexture(titleTexture.get(), NULL, NULL, &titleWidth, &titleHeight);
	const SDL_Rect rect = SDL_Rect{(SCREEN_WIDTH-titleWidth)/2, 40, titleWidth, titleHeight};
	SDL_RenderCopy(&renderer, titleTexture.get(), NULL, &rect);
	}

	// Position where we start drawing the menu entries from.
	const int menuStartY = std::max(SCREEN_HEIGHT - 200, 0) / 2;

	//Draw the menu entries.
	for(unsigned int i=0;i<5;i++){
	SDL_Rect dstRect = rectFromTexture(0, 0, *entries[i]);
	dstRect.x = std::max(SCREEN_WIDTH - dstRect.w, 0) / 2;
	dstRect.y = menuStartY + 64*i+(64-dstRect.h) / 2;
	SDL_RenderCopy(&renderer, entries[i].get(), NULL, &dstRect);
	}

	//Check if an option is selected/highlighted.
	if(highlight>0 && highlight<=5){
	// Width of highlighted entry.
	const int highlightWidth = rectFromTexture(0, 0, *entries[highlight - 1]).w;
	const int leftOfHighlight = (SCREEN_WIDTH-highlightWidth)/2;
	const SDL_Rect leftSize = rectFromTexture(0, 0, *entries[5]);
	const int rightHeight = rectFromTexture(0, 0, *entries[6]).h;
	// How much to offset the arrows to create the animation.
	const int animationX = (25-abs(animation)/2);
	// The common value of both arrow's y positions.
	const int yCommon = menuStartY-64+64*highlight;

	//Draw the '>' sign, which is entry 5.
	int x=leftOfHighlight-animationX-leftSize.w;
	int y=yCommon+(64-leftSize.h)/2;
	applyTexture(x, y, *entries[5], renderer);

	//Draw the '<' sign, which is entry 6.
	x=leftOfHighlight+highlightWidth+animationX;
	y=yCommon+(64-rightHeight)/2;
	applyTexture(x, y, *entries[6], renderer);
	}

	//Check if an icon is selected/highlighted and draw tooltip
	if(highlight==6 \|\| highlight==7){
	SDL_Texture* texture;
	if(highlight==6) {
	texture = creditsTooltip.get();
	} else {
	texture = statisticsTooltip.get();
	}
	const SDL_Rect textureSize = rectFromTexture(*texture);
	drawGUIBox(-2,SCREEN_HEIGHT-textureSize.h-2,textureSize.w+4,textureSize.h+4,renderer,0xFFFFFFFF);
	applyTexture(0, SCREEN_HEIGHT - textureSize.h, *texture, renderer);
	}

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

	//Draw icons.
	applyTexture(SCREEN_WIDTH-96,SCREEN_HEIGHT-48,*creditsIcon,renderer);
	applyTexture(SCREEN_WIDTH-48,SCREEN_HEIGHT-48,*statisticsIcon,renderer);
	}

	void Menu::resize(ImageManager &, SDL_Renderer&){}


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

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

	static bool useProxy;
	static string internetProxy;

	static bool restartFlag;

	static _res currentRes;
	static vector<_res> resolutionList;

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

	//Initialize variables.
	lastJumpSound=0;
	clearIconHower=false;

	//Load icon image and tooltip text.
	clearIcon=imageManager.loadTexture(getDataPath()+"gfx/menu/clear-progress.png",renderer);
	/// TRANSLATORS: Used for button which clear any level progress like unlocked levels and highscores.
	clearTooltip=textureFromText(renderer, *fontText, _("Clear Progress"), 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.w=atoi(getSettings()->getValue("width").c_str());
	currentRes.h=atoi(getSettings()->getValue("height").c_str());

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

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

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

	tabGeneral->addChild(resolutions);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	//Save the settings.
	saveSettings();

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

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

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

	if(langs->value!=lastLang){
	//We set the language.
	language=langs->getName();
	dictionaryManager->set_language(tinygettext::Language::from_name(language));
	getLevelPackManager()->updateLanguage();

	//And reload the font.
	if(!loadFonts()){
	//Loading failed so quit.
	setNextState(STATE_EXIT);
	return;
	}
	}

	//Now return to the main menu.
	setNextState(STATE_MENU);
	}else if(name=="chkFullscreen"){
	fullscreen=obj->value?true:false;

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

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

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

	void Options::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//Get the x and y location of the mouse.
	int x,y;
	SDL_GetMouseState(&x,&y);

	//Check icon.
	if(event.type==SDL_MOUSEMOTION \|\| event.type==SDL_MOUSEBUTTONDOWN){
	if(y>=SCREEN_HEIGHT-56&&y<SCREEN_HEIGHT-8&&x>=SCREEN_WIDTH-56)
	clearIconHower=true;
	else
	clearIconHower=false;
	}

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

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

	//Check if the escape button is pressed, if so go back to the main menu.
	if (inputMgr.isKeyUpEvent(INPUTMGR_ESCAPE) && (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 icon.
	applyTexture(SCREEN_WIDTH-48,SCREEN_HEIGHT-48,*clearIcon,renderer);

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

	void Options::resize(ImageManager& imageManager, SDL_Renderer& renderer){
	//Recreate the gui to fit the new resolution.
	createGUI(imageManager,renderer);
	}

	/////////////////////////CREDITS_MENU//////////////////////////////////

	Credits::Credits(ImageManager& imageManager,SDL_Renderer& renderer){
	//Render the title.
	title=textureFromText(renderer, *fontTitle,_("Credits"),objThemes.getTextColor(false));

	//Vector that will hold every line of the credits.
	vector<string> credits;

	//Open the AUTHORS file and read every line.
	{
	ifstream fin((getDataPath()+"/../AUTHORS").c_str());
	if(!fin.is_open()) {
	cerr<<"ERROR: Unable to open the AUTHORS file."<<endl;
	credits.push_back("ERROR: Unable to open the AUTHORS file.");
	credits.push_back("");
	}

	//Loop the lines of the file.
	string line;
	while(getline(fin,line)){
	credits.push_back(line);
	}
	}

	//Enter a new line between the two files.
	credits.push_back("");

	//Open the Credits.text file and read every line.
	{
	ifstream fin((getDataPath()+"/Credits.txt").c_str());
	if(!fin.is_open()) {
	cerr<<"ERROR: Unable to open the Credits.txt file."<<endl;
	credits.push_back("ERROR: Unable to open the Credits.txt file.");
	credits.push_back("");
	}

	//Loop the lines of the file.
	string line;
	while(getline(fin,line)){
	credits.push_back(line);

	//NOTE: Some sections point to other credits files.
	if(line=="music/") {
	vector<string> musicCredits=getMusicManager()->createCredits();
	credits.insert(credits.end(),musicCredits.begin(),musicCredits.end());
	}
	}
	}

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

	//Create back button.
	backButton=new GUIButton(imageManager,renderer,SCREEN_WIDTH*0.5,SCREEN_HEIGHT-60,-1,36,_("Back"),0,true,true,GUIGravityCenter);
	backButton->name="cmdBack";
	backButton->eventCallback=this;
	GUIObjectRoot->addChild(backButton);

	//Create a text area for credits.
	textArea=new GUITextArea(imageManager,renderer,SCREEN_WIDTH0.05,114,SCREEN_WIDTH0.9,SCREEN_HEIGHT-200);
	textArea->setFont(fontMono);
	textArea->setStringArray(renderer, std::move(credits));
	textArea->editable=false;
	textArea->extractHyperlinks();
	GUIObjectRoot->addChild(textArea);
	}

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

	void Credits::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Check what type of event it was.
	if(eventType==GUIEventClick){
	if(name=="cmdBack"){
	//Goto the main menu.
	setNextState(STATE_MENU);
	}
	}
	}

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

	+ //Check movement
	+ if (inputMgr.isKeyDownEvent(INPUTMGR_RIGHT)){
	+ isKeyboardOnly = true;
	+ textArea->scrollScrollbar(20, 0);
	+ } else if (inputMgr.isKeyDownEvent(INPUTMGR_LEFT)){
	+ isKeyboardOnly = true;
	+ textArea->scrollScrollbar(-20, 0);
	+ } else if (inputMgr.isKeyDownEvent(INPUTMGR_UP)){
	+ isKeyboardOnly = true;
	+ textArea->scrollScrollbar(0, -1);
	+ } else if (inputMgr.isKeyDownEvent(INPUTMGR_DOWN)){
	+ isKeyboardOnly = true;
	+ textArea->scrollScrollbar(0, 1);
	+ }
	+
	//Check if the escape button is pressed, if so go back to the main menu.
	if(inputMgr.isKeyUpEvent(INPUTMGR_ESCAPE)){
	setNextState(STATE_MENU);
	}
	}

	void Credits::logic(ImageManager&, SDL_Renderer&){}

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

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

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

	void Credits::resize(ImageManager&, SDL_Renderer&){
	//Resize and position widgets.
	GUIObjectRoot->width=SCREEN_WIDTH;
	GUIObjectRoot->height=SCREEN_HEIGHT;

	backButton->left=SCREEN_WIDTH/2;
	backButton->top=SCREEN_HEIGHT-60;

	textArea->left=SCREEN_WIDTH*0.05;
	textArea->width=SCREEN_WIDTH*0.9;
	textArea->height=SCREEN_HEIGHT-200;
	textArea->resize();
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, May 16, 8:13 AM (18 h, 9 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 64139
Default Alt Text: (105 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions