No OneTemporary
Actions

Authored By

Unknown

Size

47 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/GUIObject.cpp b/src/GUIObject.cpp
	index e1ffd3a..8636f39 100644
	--- a/src/GUIObject.cpp
	+++ b/src/GUIObject.cpp
	@@ -1,454 +1,454 @@
	/****************************************************************************
	** Copyright (C) 2011 Luka Horvat <redreaper132 at gmail.com>
	** Copyright (C) 2011 Edward Lii <edward_iii at myway.com>
	** Copyright (C) 2011 O. Bahri Gordebak <gordebak at gmail.com>
	**
	**
	** This file may be used under the terms of the GNU General Public
	** License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of
	** this file.
	**
	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see <http://www.gnu.org/licenses/>.
	**
	****************************************************************************/
	#include "GUIObject.h"
	#include <iostream>
	#include <list>
	using namespace std;

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


	void GUIObjectHandleEvents(bool kill){
	//Make sure that GUIObjectRoot isn't null.
	if(GUIObjectRoot)
	GUIObjectRoot->handleEvents();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	//We don't draw a background and/or border since that label is transparent.
	//Get the caption and make sure it isn't empty.
	const char* lp=caption.c_str();
	if(lp!=NULL && lp[0]){
	//Color the text will be: black.
	SDL_Color black={0,0,0,0};

	//Render the text using the small font.
	SDL_Surface* bm=TTF_RenderText_Blended(fontText,lp,black);

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

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

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

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

	//Draw the check (or not).
	SDL_Rect r1={0,0,16,16};
	if(value==1\|\|value==2)
	r1.x=value*16;
	r.x=x+width-20;
	r.y=y+(height-16)/2;
	SDL_BlitSurface(bmGUI,&r1,screen,&r);
	}
	break;
	case GUIObjectButton:
	{
	//Get the text.
	const char* lp=caption.c_str();
	//Make sure the text isn't empty.
	if(lp!=NULL && lp[0]){
	//Draw black text.
	SDL_Color black={0,0,0,0};
	//Draw in gray when disabled.
	if(!enabled)
	- black={96,96,96,0};
	+ black.r=black.g=black.b=96;

	SDL_Surface* bm;
	bm=TTF_RenderText_Blended(fontGUI,lp,black);

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

	SDL_Rect r2={64,0,16,16};
	if(state==1){
	applySurface(x+(width-bm->w)/2-25,y+(height-bm->h)/2+((bm->h-16)/2),bmGUI,screen,&r2);
	r2.x-=16;
	applySurface(x+(width-bm->w)/2+4+bm->w+5,y+(height-bm->h)/2+((bm->h-16)/2),bmGUI,screen,&r2);
	}else if(state==2){
	applySurface(x+(width-bm->w)/2-20,y+(height-bm->h)/2+((bm->h-16)/2),bmGUI,screen,&r2);
	r2.x-=16;
	applySurface(x+(width-bm->w)/2+4+bm->w,y+(height-bm->h)/2+((bm->h-16)/2),bmGUI,screen,&r2);
	}

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

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

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

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

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

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

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

	//Get the title text.
	const char* lp=caption.c_str();
	//Make sure it isn't empty.
	if(lp!=NULL && lp[0]){
	//The colors black and white used to render the title with white background.
	SDL_Color black={0,0,0,0};
	SDL_Surface* bm=TTF_RenderText_Blended(fontGUI,lp,black);

	//Calculate the location, center horizontally and vertically relative to the top.
	r.x=x+(width-bm->w)/2;
	r.y=y;

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

	//And free the surface.
	SDL_FreeSurface(bm);

	}
	}
	break;
	}

	//We now need to draw all the children of the GUIObject.
	for(unsigned int i=0;i<childControls.size();i++){
	childControls[i]->render(x,y);
	}
	}
	diff --git a/src/LevelEditSelect.cpp b/src/LevelEditSelect.cpp
	index 5ae0db7..5e570d1 100644
	--- a/src/LevelEditSelect.cpp
	+++ b/src/LevelEditSelect.cpp
	@@ -1,672 +1,671 @@
	/****************************************************************************
	** Copyright (C) 2011 Luka Horvat <redreaper132 at gmail.com>
	** Copyright (C) 2011 Edward Lii <edward_iii at myway.com>
	** Copyright (C) 2011 O. Bahri Gordebak <gordebak at gmail.com>
	**
	**
	** This file may be used under the terms of the GNU General Public
	** License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of
	** this file.
	**
	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see <http://www.gnu.org/licenses/>.
	**
	****************************************************************************/
	#include "LevelEditSelect.h"
	#include "GameState.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "Objects.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "GUIScrollBar.h"
	#include "InputManager.h"
	#include "Game.h"
	#include <SDL/SDL_ttf.h>
	#include <SDL/SDL.h>
	#include <stdio.h>
	#include <algorithm>
	#include <string>
	#include <iostream>
	using namespace std;

	LevelEditSelect::LevelEditSelect():LevelSelect("Map Editor"){
	//The levelpack name text field.
	levelpackName=new GUIObject(280,104,240,32,GUIObjectTextBox);
	levelpackName->eventCallback=this;
	levelpackName->visible=false;
	GUIObjectRoot->childControls.push_back(levelpackName);

	//Create the six buttons at the bottom of the screen.
	GUIObject* obj=new GUIObject(20,480,240,32,GUIObjectButton,"New Levelpack");
	obj->name="cmdNewLvlpack";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	propertiesPack=new GUIObject(280,480,240,32,GUIObjectButton,"Pack Properties");
	propertiesPack->name="cmdLvlpackProp";
	propertiesPack->eventCallback=this;
	GUIObjectRoot->childControls.push_back(propertiesPack);

	removePack=new GUIObject(540,480,240,32,GUIObjectButton,"Remove Pack");
	removePack->name="cmdRmLvlpack";
	removePack->eventCallback=this;
	GUIObjectRoot->childControls.push_back(removePack);

	move=new GUIObject(20,540,240,32,GUIObjectButton,"Move Map");
	move->name="cmdMoveMap";
	move->eventCallback=this;
	move->enabled=false;
	GUIObjectRoot->childControls.push_back(move);

	remove=new GUIObject(280,540,240,32,GUIObjectButton,"Remove Map");
	remove->name="cmdRmMap";
	remove->eventCallback=this;
	remove->enabled=false;
	GUIObjectRoot->childControls.push_back(remove);

	edit=new GUIObject(540,540,240,32,GUIObjectButton,"Edit Map");
	edit->name="cmdEdit";
	edit->eventCallback=this;
	edit->enabled=false;
	GUIObjectRoot->childControls.push_back(edit);

	//NOTE: We are changing the available list of levelpacks to prevent editing the main/addons levelpacks.
	listPacks();

	//show level list
	refresh();
	}

	LevelEditSelect::~LevelEditSelect(){
	selectedNumber=NULL;
	}

	void LevelEditSelect::listPacks(){
	levelpackLocations.clear();
	levelpacks->item.clear();
	levelpacks->value=0;

	vector<string> v=enumAllDirs(getUserPath()+"custom/levelpacks/");
	v.push_back("Levels");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelpackLocations[i]=getUserPath()+"custom/levelpacks/"+i;

	//Check if we can find the lastlevelpack.
	if(*i==getSettings()->getValue("lastlevelpack")){
	levelpacks->value=i-v.begin();
	packName=*i;
	}
	}
	levelpacks->item=v;

	//And call changePack since we changed the levelpack.
	changePack();
	}

	void LevelEditSelect::changePack(){
	packName=levelpacks->item[levelpacks->value];
	if(packName=="Levels"){
	//Clear the current levels.
	levels.clear();
	levels.setCurrentLevel(0);
	levels.levelpackPath="";

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

	//Disable some levelpack buttons.
	propertiesPack->enabled=false;
	removePack->enabled=false;
	}else{
	//Load the levelpack in the normal way.
	if(!levels.loadLevels(levelpackLocations[packName]+"/levels.lst")){
	msgBox("Can't load level pack:\n"+packName,MsgBoxOKOnly,"Error");
	}

	//Enable some levelpack buttons.
	propertiesPack->enabled=true;
	removePack->enabled=true;
	}
	}

	void LevelEditSelect::packProperties(){
	//Open a message popup.

	//Pointer to the current GUIObjectRoot.
	//We keep it so we can put it back after closing the fileDialog.
	GUIObject* tmp=GUIObjectRoot;

	GUIObjectRoot=new GUIObject(100,(SCREEN_HEIGHT-300)/2,600,300,GUIObjectFrame,"Properties");
	GUIObject* obj;

	obj=new GUIObject(40,80,240,36,GUIObjectLabel,"Name:");
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(300,80,240,36,GUIObjectTextBox,packName.c_str());
	obj->name="LvlpackName";
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(40,120,240,36,GUIObjectLabel,"Description:");
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(300,120,240,36,GUIObjectTextBox,levels.levelpackDescription.c_str());
	obj->name="LvlpackDescription";
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(40,160,240,36,GUIObjectLabel,"Congratulation text:");
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(300,160,240,36,GUIObjectTextBox,levels.congratulationText.c_str());
	obj->name="LvlpackCongratulation";
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(100,300-44,150,36,GUIObjectButton,"OK");
	obj->name="cfgOK";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	obj=new GUIObject(350,300-44,150,36,GUIObjectButton,"Cancel");
	obj->name="cfgCancel";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	//Dim the screen using the tempSurface.
	SDL_FillRect(tempSurface,NULL,0);
	SDL_SetAlpha(tempSurface,SDL_SRCALPHA,155);
	SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	while(GUIObjectRoot){
	while(SDL_PollEvent(&event)) GUIObjectHandleEvents(true);
	if(GUIObjectRoot) GUIObjectRoot->render();
	SDL_Flip(screen);
	SDL_Delay(30);
	}

	//We're done so set the original GUIObjectRoot back.
	GUIObjectRoot=tmp;
	}

	void LevelEditSelect::addLevel(){
	//Open a message popup.

	//Pointer to the current GUIObjectRoot.
	//We keep it so we can put it back after closing the fileDialog.
	GUIObject* tmp=GUIObjectRoot;

	GUIObjectRoot=new GUIObject(100,(SCREEN_HEIGHT-200)/2,600,200,GUIObjectFrame,"Add level");
	GUIObject* obj;

	obj=new GUIObject(40,80,240,36,GUIObjectLabel,"File name:");
	GUIObjectRoot->childControls.push_back(obj);

	char s[64];
	sprintf(s,"map%02d.map",levels.getLevelCount()+1);
	obj=new GUIObject(300,80,240,36,GUIObjectTextBox,s);
	obj->name="LvlFile";
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(100,200-44,150,36,GUIObjectButton,"OK");
	obj->name="cfgAddOK";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	obj=new GUIObject(350,200-44,150,36,GUIObjectButton,"Cancel");
	obj->name="cfgAddCancel";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	//Dim the screen using the tempSurface.
	SDL_FillRect(tempSurface,NULL,0);
	SDL_SetAlpha(tempSurface,SDL_SRCALPHA,155);
	SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	while(GUIObjectRoot){
	while(SDL_PollEvent(&event)) GUIObjectHandleEvents(true);
	if(GUIObjectRoot) GUIObjectRoot->render();
	SDL_Flip(screen);
	SDL_Delay(30);
	}

	//We're done so set the original GUIObjectRoot back.
	GUIObjectRoot=tmp;
	}

	void LevelEditSelect::moveLevel(){
	//Open a message popup.

	//Pointer to the current GUIObjectRoot.
	//We keep it so we can put it back after closing the fileDialog.
	GUIObject* tmp=GUIObjectRoot;

	GUIObjectRoot=new GUIObject(100,(SCREEN_HEIGHT-200)/2,600,200,GUIObjectFrame,"Move level");
	GUIObject* obj;

	obj=new GUIObject(40,80,240,36,GUIObjectLabel,"Level: ");
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(300,80,240,36,GUIObjectTextBox,"1");
	obj->name="MoveLevel";
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUISingleLineListBox(40,120,240,36);
	obj->name="lstPlacement";
	vector<string> v;
	v.push_back("Before");
	v.push_back("After");
	v.push_back("Swap");
	(dynamic_cast<GUISingleLineListBox*>(obj))->item=v;
	obj->value=0;
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(100,200-44,150,36,GUIObjectButton,"OK");
	obj->name="cfgMoveOK";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	obj=new GUIObject(350,200-44,150,36,GUIObjectButton,"Cancel");
	obj->name="cfgMoveCancel";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	//Dim the screen using the tempSurface.
	SDL_FillRect(tempSurface,NULL,0);
	SDL_SetAlpha(tempSurface,SDL_SRCALPHA,155);
	SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	while(GUIObjectRoot){
	while(SDL_PollEvent(&event)) GUIObjectHandleEvents(true);
	if(GUIObjectRoot) GUIObjectRoot->render();
	SDL_Flip(screen);
	SDL_Delay(30);
	}

	//We're done so set the original GUIObjectRoot back.
	GUIObjectRoot=tmp;
	}
	void LevelEditSelect::refresh(){
	int m=levels.getLevelCount();
	numbers.clear();

	//clear the selected level
	if(selectedNumber!=NULL){
	selectedNumber=NULL;
	}

	//Disable the level specific buttons.
	move->enabled=false;
	remove->enabled=false;
	edit->enabled=false;

	for(int n=0;n<=m;n++){
	numbers.push_back(Number());
	}

	for(int n=0;n<m;n++){
	SDL_Rect box={(n%10)64+80,(n/10)64+184,0,0};
	numbers[n].init(n,box);
	}
	SDL_Rect box={(m%10)64+80,(m/10)64+184,0,0};
	numbers[m].init("+",box);

	if(m>40){
	levelScrollBar->maxValue=(m-41)/10;
	levelScrollBar->visible=true;
	}else{
	levelScrollBar->maxValue=0;
	levelScrollBar->visible=false;
	}
	levelpackDescription->caption=levels.levelpackDescription;
	- int width;
	- TTF_SizeText(fontText,levels.levelpackDescription.c_str(),&width,NULL);
	- levelpackDescription->width=width;
	+ int width,height;
	+ TTF_SizeText(fontText,levels.levelpackDescription.c_str(),&width,&height);
	levelpackDescription->left=(800-width)/2;
	}

	void LevelEditSelect::selectNumber(unsigned int number,bool selected){
	if(selected){
	levels.setCurrentLevel(number);
	setNextState(STATE_LEVEL_EDITOR);

	//Pick music from the current music list.
	getMusicManager()->pickMusic();
	}else{
	if(number==numbers.size()-1){
	addLevel();
	}else if(number>=0 && number<numbers.size()){
	selectedNumber=&numbers[number];

	//Enable the level specific buttons.
	//NOTE: We check if 'remove levelpack' is enabled, if not then it's the Levels levelpack.
	if(removePack->enabled)
	move->enabled=true;
	remove->enabled=true;
	edit->enabled=true;
	}
	}
	}

	void LevelEditSelect::render(){
	//Let the levelselect render.
	LevelSelect::render();
	}

	void LevelEditSelect::renderTooltip(unsigned int number,int dy){
	SDL_Color fg={0,0,0};
	SDL_Surface* name;

	- if(number==levels.getLevelCount()){
	+ if(number==(unsigned)levels.getLevelCount()){
	//Render the name of the level.
	name=TTF_RenderText_Blended(fontText,"Add level",fg);
	}else{
	//Render the name of the level.
	name=TTF_RenderText_Blended(fontText,levels.getLevelName(number).c_str(),fg);
	}

	//Check if name isn't null.
	if(name==NULL)
	return;

	//Now draw a square the size of the three texts combined.
	SDL_Rect r=numbers[number].box;
	r.y-=dy*80;
	r.w=name->w;
	r.h=name->h;

	//Make sure the tooltip doesn't go outside the window.
	if(r.y>SCREEN_HEIGHT-200){
	r.y-=name->h+4;
	}else{
	r.y+=numbers[number].box.h+2;
	}
	if(r.x+r.w>SCREEN_WIDTH-50)
	r.x=SCREEN_WIDTH-50-r.w;

	//Draw a rectange
	Uint32 color=0xFFFFFF00\|240;
	drawGUIBox(r.x-5,r.y-5,r.w+10,r.h+10,screen,color);

	//Calc the position to draw.
	SDL_Rect r2=r;

	//Now we render the name if the surface isn't null.
	if(name!=NULL){
	//Draw the name.
	SDL_BlitSurface(name,NULL,screen,&r2);
	}

	//And free the surfaces.
	SDL_FreeSurface(name);
	}

	void LevelEditSelect::GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	//NOTE: We check for the levelpack change to enable/disable some levelpack buttons.
	if(name=="cmdLvlPack"){
	//Set the name of the levelpack.
	packName=((GUISingleLineListBox*)obj)->item[obj->value];

	//Check if it matches the Levels levelpack.
	if(((GUISingleLineListBox*)obj)->item[obj->value]=="Levels"){
	//Disable some levelpack buttons.
	propertiesPack->enabled=false;
	removePack->enabled=false;
	getSettings()->setValue("lastlevelpack","Levels");

	//We call changepack and return to prevent the LevelSelect to undo what we did.
	changePack();
	refresh();
	return;
	}else{
	//Enable some levelpack buttons.
	propertiesPack->enabled=true;
	removePack->enabled=true;
	}
	}

	//Let the level select handle his GUI events.
	LevelSelect::GUIEventCallback_OnEvent(name,obj,eventType);

	//Check for the edit button.
	if(name=="cmdNewLvlpack"){
	//Clear the current pack.
	packName.clear();
	levels.clear();

	//Create a new pack.
	packProperties();
	}else if(name=="cmdLvlpackProp"){
	//Show the pack properties.
	packProperties();
	}else if(name=="cmdRmLvlpack"){
	//Show an "are you sure" message.
	if(msgBox("Are you sure?",MsgBoxYesNo,"Remove prompt")==MsgBoxYes){
	//Remove the directory.
	if(!removeDirectory(levelpackLocations[packName].c_str())){
	cerr<<"ERROR: Unable to remove levelpack directory "<<levelpackLocations[packName]<<endl;
	}

	//Remove it from the vector (levelpack list).
	vector<string>::iterator it;
	it=find(levelpacks->item.begin(),levelpacks->item.end(),packName);
	if(it!=levelpacks->item.end()){
	levelpacks->item.erase(it);
	}

	//And call changePack.
	levelpacks->value=levelpacks->item.size()-1;
	changePack();
	refresh();
	}
	}else if(name=="cmdMoveMap"){
	if(selectedNumber!=NULL){
	moveLevel();
	}
	}else if(name=="cmdRmMap"){
	if(selectedNumber!=NULL){
	if(packName!="Levels"){
	if(!removeFile((levelpackLocations[packName]+"/"+levels.getLevel(selectedNumber->getNumber())->file).c_str())){
	cerr<<"ERROR: Unable to remove level "<<(levelpackLocations[packName]+"/"+levels.getLevel(selectedNumber->getNumber())->file).c_str()<<endl;
	}
	levels.removeLevel(selectedNumber->getNumber());
	levels.saveLevels(levelpackLocations[packName]+"/levels.lst");
	}else{
	//This is the levels levelpack so we just remove the file.
	if(!removeFile(levels.getLevel(selectedNumber->getNumber())->file.c_str())){
	cerr<<"ERROR: Unable to remove level "<<(levelpackLocations[packName]+"/"+levels.getLevel(selectedNumber->getNumber())->file).c_str()<<endl;
	}
	changePack();
	}

	//And refresh the selection screen.
	refresh();
	}
	}else if(name=="cmdEdit"){
	if(selectedNumber!=NULL){
	levels.setCurrentLevel(selectedNumber->getNumber());
	setNextState(STATE_LEVEL_EDITOR);

	//Pick music from the current music list.
	getMusicManager()->pickMusic();
	}
	}

	//Check for levelpack properties events.
	if(name=="cfgOK"){
	//Now loop throught the children of the GUIObjectRoot in search of the fields.
	for(unsigned int i=0;i<GUIObjectRoot->childControls.size();i++){
	if(GUIObjectRoot->childControls[i]->name=="LvlpackName"){
	//Check if the name changed.
	if(packName!=GUIObjectRoot->childControls[i]->caption){
	//Delete the old one.
	if(!packName.empty()){
	if(!renameDirectory((getUserPath()+"custom/levelpacks/"+packName).c_str(),(getUserPath()+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption).c_str())){
	cerr<<"ERROR: Unable to move levelpack directory "<<(getUserPath()+"custom/levelpacks/"+packName)<<" to "<<(getUserPath()+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption)<<endl;
	}

	//Also change the levelpack location.
	map<string,string>::iterator it;
	it=levelpackLocations.find(packName);

	if(it!=levelpackLocations.end()){
	levelpackLocations.erase(it);
	}

	//And the levelpack list.
	vector<string>::iterator it1;
	it1=find(levelpacks->item.begin(),levelpacks->item.end(),packName);
	if(it1!=levelpacks->item.end()){
	levelpacks->item.erase(it1);
	- if(levelpacks->value>levelpacks->item.size())
	+ if((unsigned)levelpacks->value>levelpacks->item.size())
	levelpacks->value=levelpacks->item.size()-1;
	}

	//Also add the levelpack location
	levelpackLocations[GUIObjectRoot->childControls[i]->caption]=(getUserPath()+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption);
	levelpacks->item.push_back(GUIObjectRoot->childControls[i]->caption);
	levelpacks->value=levelpacks->item.size()-1;
	}else{
	if(!createDirectory((getUserPath()+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption).c_str())){
	cerr<<"ERROR: Unable to create levelpack directory "<<(getUserPath()+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption)<<endl;
	}
	if(!createFile((getUserPath()+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption+"/levels.lst").c_str())){
	cerr<<"ERROR: Unable to create levelpack file "<<(getUserPath()+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption+"/levels.lst")<<endl;
	}

	//Also add the levelpack location.
	levelpackLocations[GUIObjectRoot->childControls[i]->caption]=(getUserPath()+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption);
	levelpacks->item.push_back(GUIObjectRoot->childControls[i]->caption);
	levelpacks->value=levelpacks->item.size()-1;
	}
	//And set the new name.
	packName=GUIObjectRoot->childControls[i]->caption;
	changePack();
	refresh();
	}
	}
	if(GUIObjectRoot->childControls[i]->name=="LvlpackDescription"){
	levels.levelpackDescription=GUIObjectRoot->childControls[i]->caption;
	}
	if(GUIObjectRoot->childControls[i]->name=="LvlpackCongratulation"){
	levels.congratulationText=GUIObjectRoot->childControls[i]->caption;
	}
	}

	//Save the configuration.
	levels.saveLevels(getUserPath()+"custom/levelpacks/"+packName+"/levels.lst");

	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}else if(name=="cfgCancel"){
	//Check if packName is empty, if so it was a new levelpack and we need to revert to an existing one.
	if(packName.empty()){
	packName=levelpacks->item[levelpacks->value];
	changePack();
	}

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

	//Check for add level events.
	if(name=="cfgAddOK"){
	//Check if the file name isn't null.
	//Now loop throught the children of the GUIObjectRoot in search of the fields.
	for(unsigned int i=0;i<GUIObjectRoot->childControls.size();i++){
	if(GUIObjectRoot->childControls[i]->name=="LvlFile"){
	if(GUIObjectRoot->childControls[i]->caption.empty()){
	msgBox("No file name given for the new level.",MsgBoxOKOnly,"Missing file name");
	return;
	}else{
	string path=(levelpackLocations[packName]+"/"+GUIObjectRoot->childControls[i]->caption);
	if(packName=="Levels"){
	path=(getUserPath()+"/custom/levels/"+GUIObjectRoot->childControls[i]->caption);
	}

	if(!createFile(path.c_str())){
	cerr<<"ERROR: Unable to create level file "<<path<<endl;
	}
	levels.addLevel(path);
	if(packName!="Levels")
	levels.saveLevels(getUserPath()+"custom/levelpacks/"+packName+"/levels.lst");
	refresh();

	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	return;
	}
	}
	}
	}
	}else if(name=="cfgAddCancel"){
	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}

	//Check for move level events.
	if(name=="cfgMoveOK"){
	//Check if the entered level number is valid.
	//Now loop throught the children of the GUIObjectRoot in search of the fields.
	int level=0;
	int placement=0;
	for(unsigned int i=0;i<GUIObjectRoot->childControls.size();i++){
	if(GUIObjectRoot->childControls[i]->name=="MoveLevel"){
	level=atoi(GUIObjectRoot->childControls[i]->caption.c_str());
	if(level<=0 \|\| level>levels.getLevelCount()){
	msgBox("The entered level number isn't valid!",MsgBoxOKOnly,"Illegal number");
	return;
	}
	}
	if(GUIObjectRoot->childControls[i]->name=="lstPlacement"){
	placement=GUIObjectRoot->childControls[i]->value;
	}
	}

	//Now we execute the swap/move.
	//Check for the place before.
	if(placement==0){
	//We place the selected level before the entered level.
	levels.moveLevel(selectedNumber->getNumber(),level-1);
	}else if(placement==1){
	//We place the selected level after the entered level.
	if(level<selectedNumber->getNumber())
	levels.moveLevel(selectedNumber->getNumber(),level);
	else
	levels.moveLevel(selectedNumber->getNumber(),level+1);
	}else if(placement==2){
	//We swap the selected level with the entered level.
	levels.swapLevel(selectedNumber->getNumber(),level-1);
	}

	//And save the change.
	if(packName!="Levels")
	levels.saveLevels(getUserPath()+"custom/levelpacks/"+packName+"/levels.lst");

	refresh();

	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}else if(name=="cfgMoveCancel"){
	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	}
	diff --git a/src/LevelSelect.cpp b/src/LevelSelect.cpp
	index aac5727..0f998ba 100644
	--- a/src/LevelSelect.cpp
	+++ b/src/LevelSelect.cpp
	@@ -1,377 +1,377 @@
	/****************************************************************************
	** Copyright (C) 2011 Luka Horvat <redreaper132 at gmail.com>
	** Copyright (C) 2011 Edward Lii <edward_iii at myway.com>
	** Copyright (C) 2011 O. Bahri Gordebak <gordebak at gmail.com>
	**
	**
	** This file may be used under the terms of the GNU General Public
	** License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of
	** this file.
	**
	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see <http://www.gnu.org/licenses/>.
	**
	****************************************************************************/
	#include "GameState.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "Objects.h"
	#include "LevelSelect.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "GUIScrollBar.h"
	#include "InputManager.h"
	#include "Game.h"
	#include <SDL/SDL_ttf.h>
	#include <SDL/SDL.h>
	#include <stdio.h>
	#include <string>
	#include <sstream>
	#include <iostream>
	using namespace std;

	////////////////////NUMBER////////////////////////
	Number::Number(){
	image=NULL;
	number=0;
	medal=0;
	selected=false;
	locked=false;

	//Set the default dimensions.
	box.x=0;
	box.y=0;
	box.h=50;
	box.w=50;

	//Load the medals image.
	background=loadImage(getDataPath()+"gfx/level.png");
	backgroundLocked=loadImage(getDataPath()+"gfx/levellocked.png");
	medals=loadImage(getDataPath()+"gfx/medals.png");
	}

	Number::~Number(){
	//We only need to free the SDLSurface.
	if(image) SDL_FreeSurface(image);
	}

	void Number::init(int number,SDL_Rect box){
	//First set the number and update our status.
	this->number=number;

	//Write our text, number+1 since the counting doens't start with 0, but with 1.
	std::stringstream text;
	number++;
	text<<number;

	//Create the text image.
	SDL_Color black={0,0,0};
	if(image) SDL_FreeSurface(image);
	//Create the text image.
	//Also check which font to use, if the number is higher than 100 use the small font.
	image=TTF_RenderText_Blended(fontGUI,text.str().c_str(),black);

	//Set the new location of the number.
	this->box.x=box.x;
	this->box.y=box.y;
	}

	void Number::init(std::string text,SDL_Rect box){
	//First set the number and update our status.
	this->number=-1;

	//Create the text image.
	SDL_Color black={0,0,0};
	if(image) SDL_FreeSurface(image);
	//Create the text image.
	//Also check which font to use, if the number is higher than 100 use the small font.
	image=TTF_RenderText_Blended(fontGUI,text.c_str(),black);

	//Set the new location of the number.
	this->box.x=box.x;
	this->box.y=box.y;
	}

	void Number::show(int dy){
	//First draw the background, also apply the yOffset(dy).
	if(!locked)
	applySurface(box.x,box.y-dy,background,screen,NULL);
	else
	applySurface(box.x,box.y-dy,backgroundLocked,screen,NULL);
	//Now draw the text image over the background.
	//We draw it centered inside the box.
	applySurface((box.x+25-(image->w/2)),box.y+((TTF_FontAscent(fontGUI)+TTF_FontDescent(fontGUI))/2)-dy,image,screen,NULL);

	//Draw the selection mark.
	if(selected){
	drawGUIBox(box.x,box.y-dy,50,50,screen,0xFFFFFF23);
	}

	//Draw the medal.
	if(medal>0){
	SDL_Rect r={(medal-1)*30,0,30,30};
	applySurface(box.x+30,(box.y+30)-dy,medals,screen,&r);
	}
	}

	void Number::setLocked(bool locked){
	this->locked=locked;
	}

	void Number::setMedal(int medal){
	this->medal=medal;
	}


	/////////////////////LEVEL SELECT/////////////////////
	LevelSelect::LevelSelect(string titleText){
	//clear the selected level
	selectedNumber=NULL;

	//Load the background image.
	background=loadImage(getDataPath()+"gfx/menu/background.png");

	//Render the title.
	SDL_Color black={0,0,0};
	title=TTF_RenderText_Blended(fontTitle,titleText.c_str(),black);

	//create GUI (test only)
	GUIObject* obj;
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	GUIObjectRoot=new GUIObject(0,0,800,600);

	//the level select scroll bar
	levelScrollBar=new GUIScrollBar(768,184,16,242,ScrollBarVertical,0,0,0,1,4,true,false);
	GUIObjectRoot->childControls.push_back(levelScrollBar);

	//level pack description
	levelpackDescription=new GUIObject(60,140,800,32,GUIObjectLabel);
	GUIObjectRoot->childControls.push_back(levelpackDescription);

	levelpacks=new GUISingleLineListBox(150,104,500,32);
	levelpacks->name="cmdLvlPack";
	levelpacks->eventCallback=this;
	vector<string> v=enumAllDirs(getDataPath()+"levelpacks/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelpackLocations[i]=getDataPath()+"levelpacks/"+i;
	}
	vector<string> v2=enumAllDirs(getUserPath()+"levelpacks/");
	for(vector<string>::iterator i=v2.begin(); i!=v2.end(); ++i){
	levelpackLocations[i]=getUserPath()+"levelpacks/"+i;
	}
	vector<string> v3=enumAllDirs(getUserPath()+"custom/levelpacks/");
	for(vector<string>::iterator i=v3.begin(); i!=v3.end(); ++i){
	levelpackLocations[i]=getUserPath()+"custom/levelpacks/"+i;
	}
	v.insert(v.end(),v2.begin(),v2.end());
	v.insert(v.end(),v3.begin(),v3.end());

	//Now we add a special levelpack that will contain the levels not in a levelpack.
	v.push_back("Levels");

	levelpacks->item=v;
	levelpacks->value=0;

	//Check if we can find the lastlevelpack.
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	if(*i==getSettings()->getValue("lastlevelpack")){
	levelpacks->value=i-v.begin();
	string s1=getUserPath()+"progress/"+*i+".progress";

	//Check if this is the special Levels levelpack.
	if(*i=="Levels"){
	//Clear the current levels.
	levels.clear();
	levels.setCurrentLevel(0);

	//List the custom levels and add them one for one.
	vector<string> v=enumAllFiles(getUserPath()+"custom/levels/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levels.addLevel(getUserPath()+"custom/levels/"+*i);
	levels.setLocked(levels.getLevelCount()-1);
	}
	//List the addon levels and add them one for one.
	v=enumAllFiles(getUserPath()+"levels/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levels.addLevel(getUserPath()+"levels/"+*i);
	levels.setLocked(levels.getLevelCount()-1);
	}
	}else{
	//This isn't so load the levelpack in the normal way.
	if(!levels.loadLevels(levelpackLocations[*i]+"/levels.lst")){
	msgBox("Can't load level pack:\n"+*i,MsgBoxOKOnly,"Error");
	}
	}
	//Load the progress.
	levels.loadProgress(s1);
	}
	}
	GUIObjectRoot->childControls.push_back(levelpacks);

	obj=new GUIObject(20,20,100,32,GUIObjectButton,"Back");
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	}

	LevelSelect::~LevelSelect(){
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	levelScrollBar=NULL;
	levelpackDescription=NULL;

	selectedNumber=NULL;

	//Free the rendered title surface.
	SDL_FreeSurface(title);
	}

	void LevelSelect::handleEvents(){
	//Check for an SDL_QUIT event.
	if(event.type==SDL_QUIT){
	setNextState(STATE_EXIT);
	}

	//Check for a mouse click.
	if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT){
	checkMouse();
	}

	//Check if escape is pressed.
	if(inputMgr.isKeyUpEvent(INPUTMGR_ESCAPE)){
	setNextState(STATE_MENU);
	}

	//Check for scrolling down and up.
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELDOWN && levelScrollBar){
	if(levelScrollBar->value<levelScrollBar->maxValue) levelScrollBar->value++;
	return;
	}else if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELUP && levelScrollBar){
	if(levelScrollBar->value>0) levelScrollBar->value--;
	return;
	}
	}

	void LevelSelect::checkMouse(){
	int x,y,dy=0,m=levels.getLevelCount();

	//Get the current mouse location.
	SDL_GetMouseState(&x,&y);

	//Check if there's a scrollbar, if so get the value.
	if(levelScrollBar)
	dy=levelScrollBar->value;
	if(m>dy*10+50)
	m=dy*10+50;
	y+=dy*64;

	SDL_Rect mouse={x,y,0,0};

	- for(int n=dy*10; n<numbers.size(); n++){
	+ for(int n=dy*10; n<int(numbers.size()); n++){
	if(!numbers[n].getLocked()){
	if(checkCollision(mouse,numbers[n].box)==true){
	if(numbers[n].selected){
	selectNumber(n,true);
	}else{
	//Select current level
	for(int i=0;i<levels.getLevelCount();i++){
	numbers[i].selected=(i==n);
	}
	selectNumber(n,false);
	}
	break;
	}
	}
	}
	}

	void LevelSelect::logic(){}

	void LevelSelect::render(){
	int x,y,dy=0,m=levels.getLevelCount();
	int idx=-1;

	//Get the current mouse location.
	SDL_GetMouseState(&x,&y);

	if(levelScrollBar)
	dy=levelScrollBar->value;
	if(m>dy*10+40)
	m=dy*10+40;
	y+=dy*64;

	SDL_Rect mouse={x,y,0,0};

	//Draw the background.
	applySurface(0,0,background,screen,NULL);
	//Draw the title.
	applySurface((800-title->w)/2,40,title,screen,NULL);

	//Loop through the level blocks and draw them.
	- for(int n=dy*10;n<numbers.size();n++){
	+ for(int n=dy*10;n<int(numbers.size());n++){
	numbers[n].show(dy*64);
	if(numbers[n].getLocked()==false && checkCollision(mouse,numbers[n].box)==true)
	idx=n;
	}

	//Show the tool tip text.
	if(idx>=0){
	renderTooltip(idx,dy);
	}
	}

	void LevelSelect::GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	string s;
	if(name=="cmdLvlPack"){
	s=levelpackLocations[((GUISingleLineListBox*)obj)->item[obj->value]];
	getSettings()->setValue("lastlevelpack",((GUISingleLineListBox*)obj)->item[obj->value]);
	}else if(name=="cmdBack"){
	setNextState(STATE_MENU);
	return;
	}else{
	return;
	}

	string s1=getUserPath()+"progress/"+((GUISingleLineListBox*)obj)->item[obj->value]+".progress";

	//Check if this is the special Levels levelpack.
	if(((GUISingleLineListBox*)obj)->item[obj->value]=="Levels"){
	//Clear the current levels.
	levels.clear();
	levels.setCurrentLevel(0);

	//List the custom levels and add them one for one.
	vector<string> v=enumAllFiles(getUserPath()+"custom/levels/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levels.addLevel(getUserPath()+"custom/levels/"+*i);
	levels.setLocked(levels.getLevelCount()-1);
	}
	//List the addon levels and add them one for one.
	v=enumAllFiles(getUserPath()+"levels/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levels.addLevel(getUserPath()+"levels/"+*i);
	levels.setLocked(levels.getLevelCount()-1);
	}
	}else{
	//This isn't so load the levelpack in the normal way.
	if(!levels.loadLevels(levelpackLocations[((GUISingleLineListBox*)obj)->item[obj->value]]+"/levels.lst")){
	msgBox("Can't load level pack:\n"+((GUISingleLineListBox*)obj)->item[obj->value],MsgBoxOKOnly,"Error");
	}
	}
	//Load the progress file.
	levels.loadProgress(s1);

	//And refresh the numbers.
	refresh();
	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jun 22, 8:13 PM (6 d, 12 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 72963
Default Alt Text: (47 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions