No OneTemporary
Actions

Authored By

Unknown

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/GUIListBox.cpp b/src/GUIListBox.cpp
	index 14e5edd..a2580eb 100644
	--- a/src/GUIListBox.cpp
	+++ b/src/GUIListBox.cpp
	@@ -1,353 +1,365 @@
	/****************************************************************************
	** 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 "GUIListBox.h"
	using namespace std;

	GUIListBox::GUIListBox(int left,int top,int width,int height,bool enabled,bool visible):
	GUIObject(left,top,width,height,0,NULL,-1,enabled,visible){
	//Set the state -1.
	state=-1;

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

	bool GUIListBox::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;

	//Calculate the scrollbar position.
	scrollBar->left=width-16;
	scrollBar->height=height;
	int m=item.size(),n=(height-4)/24;
	if(m>n){
	scrollBar->maxValue=m-n;
	scrollBar->smallChange=1;
	scrollBar->largeChange=n;
	scrollBar->visible=true;
	b=b\|\|scrollBar->handleEvents(x,y,enabled,visible,b);
	}else{
	scrollBar->value=0;
	scrollBar->maxValue=0;
	scrollBar->visible=false;
	}

	//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+2;
	j-=y+2;

	//Check if the mouse is inside the GUIListBox.
	if(i>=0&&i<width-4&&j>=0&&j<height-4){
	//Calculate the y location with the scrollbar position.
	int idx=j/24+scrollBar->value;

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

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

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

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

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

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

	void GUIListBox::render(int x,int y){
	//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;

	//Default background opacity
	int clr=128;
	//TODO: Add hover check?

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

	//We need to draw the items.
	//The number of items.
	int m=item.size();
	//The number of items that are visible.
	int n=(height-4)/24;
	//Integer containing the current entry that is being drawn.
	int i;
	//The y coordinate the current entries reaches.
	int j;

	//If the number of items is higer than fits on the screen set the begin value (m) to scrollBar->value+n.
	if(m>scrollBar->value+n)
	m=scrollBar->value+n;

	//Loop through the (visible) entries and draw them.
	for(i=scrollBar->value,j=y+1;i<m;i++,j+=24){
	//The background color for the entry.
	int clr=-1;
	//If i is the selected entry then give it a light gray background.
	if(value==i){
	clr=0xDDDDDDFF;
	}

	//Check if the current entry is selected. If so draw borders around it.
	if(state==i)
	drawGUIBox(x,j-1,width,25,screen,0x00000000);

	//Only draw when clr isn't -1.
	if(clr!=-1)
	drawGUIBox(x,j-1,width,25,screen,clr);

	//Now draw the text.
	const char* s=item[i].c_str();
	//Make sure the text isn't empty.
	if(s && s[0]){
	//Render black text.
	SDL_Color black={0,0,0,0};
	SDL_Surface *bm=TTF_RenderUTF8_Blended(fontText,s,black);

	//Calculate the text location, center it vertically.
	r.x=x+4;
	r.y=j+12-bm->h/2;

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

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

	GUISingleLineListBox::GUISingleLineListBox(int left,int top,int width,int height,bool enabled,bool visible):
	GUIObject(left,top,width,height,0,NULL,-1,enabled,visible),animation(0){}

	bool GUISingleLineListBox::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;

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

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

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

	+ //Check if the enabled state changed or the caption, if so we need to clear the (old) cache.
	+ if(enabled!=cachedEnabled \|\| caption.compare(cachedCaption)!=0){
	+ //Free the cache.
	+ SDL_FreeSurface(cache);
	+ cache=NULL;
	+
	+ //And cache the new values.
	+ cachedEnabled=enabled;
	+ cachedCaption=caption;
	+ }
	+
	//Draw the text.
	if(value>=0 && value<(int)item.size()){
	//Get the text.
	const char* lp=item[value].c_str();

	//Check if the text is empty or not.
	if(lp!=NULL && lp[0]){
	- //Render black text.
	- SDL_Color black={0,0,0,0};
	- SDL_Surface* bm=TTF_RenderUTF8_Blended(fontGUI,lp,black);
	+ if(!cache){
	+ //Render black text.
	+ SDL_Color black={0,0,0,0};
	+ cache=TTF_RenderUTF8_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;
	+ r.x=x+(width-cache->w)/2;
	+ r.y=y+(height-cache->h)/2;

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

	//Draw the arrows.
	SDL_Rect r2={48,0,16,16};
	r.x=x;
	if((state&0xF)==0x1)
	r.x+=abs(animation/2);
	r.y=y+(height-16)/2;
	SDL_BlitSurface(bmGUI,&r2,screen,&r);
	r2.x=64;
	r.x=x+width-16;
	if((state&0xF)==0x2)
	r.x-=abs(animation/2);
	SDL_BlitSurface(bmGUI,&r2,screen,&r);

	//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/GUIObject.cpp b/src/GUIObject.cpp
	index b39caba..189c166 100644
	--- a/src/GUIObject.cpp
	+++ b/src/GUIObject.cpp
	@@ -1,458 +1,469 @@
	/****************************************************************************
	** 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;

	+ //Check if the enabled state changed or the caption, if so we need to clear the (old) cache.
	+ if(enabled!=cachedEnabled \|\| caption.compare(cachedCaption)!=0){
	+ //Free the cache.
	+ SDL_FreeSurface(cache);
	+ cache=NULL;
	+
	+ //And cache the new values.
	+ cachedEnabled=enabled;
	+ cachedCaption=caption;
	+ }
	+
	+
	//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_RenderUTF8_Blended(fontText,lp,black);
	+ if(cache==NULL){
	+ //Color the text will be: black.
	+ SDL_Color black={0,0,0,0};
	+ cache=TTF_RenderUTF8_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);
	+ r.y=y+(height - cache->h)/2;
	+ SDL_BlitSurface(cache,NULL,screen,&r);
	}
	}
	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_RenderUTF8_Blended(fontText,lp,black);
	+ if(!cache){
	+ SDL_Color black={0,0,0,0};
	+ cache=TTF_RenderUTF8_Blended(fontText,lp,black);
	+ }

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

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

	//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.r=black.g=black.b=96;
	-
	- SDL_Surface* bm;
	- bm=TTF_RenderUTF8_Blended(fontGUI,lp,black);
	+ if(!cache){
	+ //Draw black text.
	+ SDL_Color black={0,0,0,0};
	+ //Draw in gray when disabled.
	+ if(!enabled)
	+ black.r=black.g=black.b=96;
	+
	+ cache=TTF_RenderUTF8_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;
	+ r.x=x+(width-cache->w)/2;
	+ r.y=y+(height-cache->h)/2;

	//Check if the arrows don't fall of.
	- if(bm->w+32<=width){
	+ if(cache->w+32<=width){
	//Create a rectangle that selects the right image from bmGUI,
	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);
	+ applySurface(x+(width-cache->w)/2-25,y+(height-cache->h)/2+((cache->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);
	+ applySurface(x+(width-cache->w)/2+4+cache->w+5,y+(height-cache->h)/2+((cache->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);
	+ applySurface(x+(width-cache->w)/2-20,y+(height-cache->h)/2+((cache->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);
	+ applySurface(x+(width-cache->w)/2+4+cache->w,y+(height-cache->h)/2+((cache->h-16)/2),bmGUI,screen,&r2);
	}
	}

	//Draw the text and free the surface.
	- SDL_BlitSurface(bm,NULL,screen,&r);
	- SDL_FreeSurface(bm);
	+ SDL_BlitSurface(cache,NULL,screen,&r);
	}
	}
	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_RenderUTF8_Blended(fontText,lp,black);
	+ if(!cache){
	+ //Draw the black text.
	+ SDL_Color black={0,0,0,0};
	+ cache=TTF_RenderUTF8_Blended(fontText,lp,black);
	+ }

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

	//Draw the text.
	SDL_Rect tmp={0,0,width-2,25};
	- SDL_BlitSurface(bm,&tmp,screen,&r);
	+ SDL_BlitSurface(cache,&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_RenderUTF8_Blended(fontGUI,lp,black);
	+ if(!cache){
	+ //The colors black and white used to render the title with white background.
	+ SDL_Color black={0,0,0,0};
	+ cache=TTF_RenderUTF8_Blended(fontGUI,lp,black);
	+ }

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

	//Draw the text and free the surface.
	- SDL_BlitSurface(bm,NULL,screen,&r);
	-
	- //And free the surface.
	- SDL_FreeSurface(bm);
	-
	+ SDL_BlitSurface(cache,NULL,screen,&r);
	}
	}
	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/GUIObject.h b/src/GUIObject.h
	index 319f6e4..d9bb9f1 100644
	--- a/src/GUIObject.h
	+++ b/src/GUIObject.h
	@@ -1,164 +1,176 @@
	/****************************************************************************
	** 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/>.
	**
	****************************************************************************/
	#ifndef GUIOBJECT_H
	#define GUIOBJECT_H

	#include "Globals.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include <string>
	#include <vector>
	#include <list>

	//Ids for the different GUIObject types.
	//None is a special type, it has no visual form.
	const int GUIObjectNone=0;
	//A label used to dispaly text.
	const int GUIObjectLabel=1;
	//Button which will invoke an event when pressed.
	const int GUIObjectButton=2;
	//Checkbox which represents a boolean value and can be toggled.
	const int GUIObjectCheckBox=3;
	//A text box used to enter text.
	const int GUIObjectTextBox=5;
	//Frame which is like a container.
	const int GUIObjectFrame=6;

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


	class GUIObject;

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

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

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

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

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

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

	//Event callback used to invoke events.
	GUIEventCallback* eventCallback;
	protected:
	//The state of the GUIObject.
	//It depends on the type of GUIObject where it's used for.
	int state;

	//Surface containing some gui images.
	SDL_Surface* bmGUI;
	+
	+ //Surface that can be used to cache rendered text.
	+ SDL_Surface* cache;
	+ //String containing the old caption to detect if it changed.
	+ std::string cachedCaption;
	+ //Boolean containing the previous enabled state.
	+ bool cachedEnabled;
	public:
	//Constructor.
	//left: The relative x location of the GUIObject.
	//top: The relative y location of the GUIObject.
	//witdh: The width of the GUIObject.
	//height: The height of the GUIObject.
	//type: The type of the GUIObject.
	//caption: The text on the GUIObject.
	//value: The value of the GUIObject.
	//enabled: Boolean if the GUIObject is enabled or not.
	//visible: Boolean if the GUIObject is visisble or not.
	GUIObject(int left=0,int top=0,int width=0,int height=0,int type=0,
	const char* caption=NULL,int value=0,
	bool enabled=true,bool visible=true):
	left(left),top(top),width(width),height(height),
	type(type),value(value),
	enabled(enabled),visible(visible),
	- eventCallback(NULL),state(0)
	+ eventCallback(NULL),state(0),
	+ cache(NULL),cachedEnabled(enabled)
	{
	//Make sure that caption isn't NULL before setting it.
	- if(caption) GUIObject::caption=caption;
	+ if(caption){
	+ GUIObject::caption=caption;
	+ //And set the cached caption.
	+ cachedCaption=caption;
	+ }

	//Load the gui images.
	bmGUI=loadImage(getDataPath()+"gfx/gui.png");
	}
	//Destructor.
	virtual ~GUIObject();

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

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

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

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

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jun 16, 12:15 AM (2 w, 2 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 71035
Default Alt Text: (32 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions