#include "include/Engine.h"

namespace SE
{

const cardinal CONST_BUTTON_HIGHLIGHT_TIME = 100;

TInstancingWidgetAncestor::~TInstancingWidgetAncestor() 
{
}


void TInstancingWidgetAncestor::Update(cardinal dt) 
{
}

bool TInstancingWidgetAncestor::CheckClick(vec2 mousePos) 
{
	return false;
}


bool TSquareStatic::CheckClick(vec2 mousePos)
{
	if (mousePos.v[0] >= LeftBottomPos.v[0] &&
		mousePos.v[0] <= LeftBottomPos.v[0] + Width &&
		mousePos.v[1] >= LeftBottomPos.v[1] &&
		mousePos.v[1] <= LeftBottomPos.v[1] + Height)
	{
		return true;
	}
	else
	{
		return false;
	}
}

TSquareStatic* TSquareStatic::CreateStatic(vec2 posFrom, vec2 posTo)
{
	TSquareStatic* staticWidget = new TSquareStatic();

	staticWidget->LeftBottomPos = posFrom;
	staticWidget->Width = posTo.v[0] - posFrom.v[0];
	staticWidget->Height = posTo.v[1] - posFrom.v[1];

	return staticWidget;

}


TSquareStatic* TSquareStatic::CreateStaticWithFiller(vec2 posFrom, vec2 posTo, boost::function<void(TSquareStatic*)> staticFillerFunc)
{
	TSquareStatic* staticWidget = TSquareStatic::CreateStatic(posFrom, posTo);

	staticFillerFunc(staticWidget);

	return staticWidget;
}


TSquareStatic* TSquareStatic::CreateStaticWithFillers(vec2 posFrom, vec2 posTo, std::vector<boost::function<void(TSquareStatic*)>> staticFillerFuncArr)
{
	TSquareStatic* staticWidget = TSquareStatic::CreateStatic(posFrom, posTo);

	BOOST_FOREACH(auto& func, staticFillerFuncArr)
	{
		func(staticWidget);
	}

	return staticWidget;
}


void TSquareStatic::StaticTextureFiller(vec2 posFrom, vec2 posTo, const std::string& texName, TSquareStatic* staticToFill)
{
	
	TRenderParams renderParams;

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = texName;
	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 1.f;

	TTriangleList triangleList = MakeTriangleList(posFrom, posTo);

	triangleList.RefreshBuffer();

	staticToFill->TriangleListVector.insert(staticToFill->TriangleListVector.end(), TRenderPair(renderParams, triangleList));
}

void TSquareStatic::StaticTextFiller(vec2 posFrom, vec2 posTo, TTextParams buttonTextParams, TSquareStatic* staticToFill)
{
	
	TRenderParams renderParams = buttonTextParams.RenderParams;

	TTriangleList triangleList;
	
	if (buttonTextParams.FontName == "")
	{
		buttonTextParams.FontName = ResourceManager->FontManager.GetCurrentFontName();
	}

	ResourceManager->FontManager.PushFont(buttonTextParams.FontName);

	triangleList = CreateTriangleListForText(posFrom, posTo, buttonTextParams);

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = ResourceManager->FontManager.GetCurrentFontTextureName();
	
	staticToFill->TriangleListVector.insert(staticToFill->TriangleListVector.end(),TRenderPair(renderParams, triangleList));
	triangleList.RefreshBuffer();

	ResourceManager->FontManager.PopFont();
	
}

TSquareStatic* TSquareStatic::CreateStaticTexture(vec2 posFrom, vec2 posTo, const std::string& texName)
{
	return CreateStaticWithFiller(posFrom, posTo, boost::bind(TSquareStatic::StaticTextureFiller, posFrom, posTo, texName, _1));

}

TSquareStatic* TSquareStatic::CreateStaticText(vec2 posFrom, vec2 posTo, TTextParams buttonTextParams)
{
	return CreateStaticWithFiller(posFrom, posTo, boost::bind(TSquareStatic::StaticTextFiller, posFrom, posTo, buttonTextParams, _1));
}




TTriangleList CreateTriangleListForText(vec2 posFrom, vec2 posTo, TTextParams buttonTextParams)
{
	TTriangleList triangleList;

	triangleList = ResourceManager->FontManager.DrawTextInBoxToVBO(posFrom, posTo, buttonTextParams.BasicTextAreaParams, buttonTextParams.Text);

	return triangleList;
}

//====================================================


TDynamicText::TDynamicText()
	: Width(0)
	, Height(0)
{
}

TDynamicText::~TDynamicText()
{
	if (SmartValueConnection.connected())
	{
		SmartValueConnection.disconnect();
	}
}

bool TDynamicText::CheckClick(vec2 mousePos)
{
	if (mousePos.v[0] >= LeftBottomPos.v[0] &&
		mousePos.v[0] <= LeftBottomPos.v[0] + Width &&
		mousePos.v[1] >= LeftBottomPos.v[1] &&
		mousePos.v[1] <= LeftBottomPos.v[1] + Height)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void TDynamicText::UpdateText(std::string text)
{
	if (LastTextParams.Text != text)
	{
		LastTextParams.Text = text;

		vec2 posFrom = LeftBottomPos;
		vec2 posTo = LeftBottomPos + vec2(Width, Height);

		
		PerformInMainThreadAsync(
		[this, posFrom, posTo]()
		{
			this->TextRenderPairItr->second = CreateTriangleListForText(posFrom, posTo, this->LastTextParams);
		}
		);
	}
}

TDynamicText* TDynamicText::CreateDynamicText(vec2 posFrom, vec2 posTo)
{
	TDynamicText* dynamicText = new TDynamicText();

	dynamicText->LeftBottomPos = posFrom;
	dynamicText->Width = posTo.v[0] - posFrom.v[0];
	dynamicText->Height = posTo.v[1] - posFrom.v[1];

	return dynamicText;
}

TDynamicText* TDynamicText::CreateDynamicTextWithFiller(vec2 posFrom, vec2 posTo, boost::function<void(TDynamicText*)> dynamicTextFillerFunc)
{
	TDynamicText* dynamicText = TDynamicText::CreateDynamicText(posFrom, posTo);

	dynamicTextFillerFunc(dynamicText);

	return dynamicText;
}

TDynamicText* TDynamicText::CreateDynamicTextWithFillers(vec2 posFrom, vec2 posTo, std::vector<boost::function<void(TDynamicText*)>> dynamicTextFillerFuncArr)
{
	TDynamicText* dynamicText = TDynamicText::CreateDynamicText(posFrom, posTo);

	BOOST_FOREACH(auto& func, dynamicTextFillerFuncArr)
	{
		func(dynamicText);
	}

	return dynamicText;
}

void TDynamicText::TextParamsFiller(vec2 posFrom, vec2 posTo, TTextParams textParams, TDynamicText* dynamicTextToFill)
{
	TRenderParams renderParams = textParams.RenderParams;

	TTriangleList triangleList;
	
	if (textParams.FontName == "")
	{
		textParams.FontName = ResourceManager->FontManager.GetCurrentFontName();
	}

	ResourceManager->FontManager.PushFont(textParams.FontName);

	triangleList = CreateTriangleListForText(posFrom, posTo, textParams);

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = ResourceManager->FontManager.GetCurrentFontTextureName();

	dynamicTextToFill->TextRenderPairItr = dynamicTextToFill->TriangleListVector.insert(dynamicTextToFill->TriangleListVector.end(),TRenderPair(renderParams, triangleList));
	triangleList.RefreshBuffer();

	ResourceManager->FontManager.PopFont();


	dynamicTextToFill->LastTextParams = textParams;
}

void TDynamicText::SmartValueTextFiller(const std::string& dictionaryName, const std::string& smartValueName, TDynamicText* dynamicTextToFill)
{

	dynamicTextToFill->UpdateText(ResourceManager->SmartValueManager.GetImmediateValue<std::string>(dictionaryName, smartValueName));
	
	dynamicTextToFill->SmartValueConnection = ResourceManager->SmartValueManager.GetSignal<std::string>(dictionaryName, smartValueName).connect(boost::bind(&TDynamicText::UpdateText, dynamicTextToFill, _1));

}


	



//=======================================================


TUniversalButton::TUniversalButton()
	: ButtonState(BS_NORMAL)
	, ButtonStateTimer(0.f)
{
}



void TUniversalButton::Update(cardinal dt)
{
	if (ButtonState == BS_GO_PRESSED)
	{
		ButtonStateTimer += dt;
		if (ButtonStateTimer >= CONST_BUTTON_HIGHLIGHT_TIME)
		{
			ButtonStateTimer = CONST_BUTTON_HIGHLIGHT_TIME;
			ButtonState = BS_PRESSED;
		}
	}
	else if (ButtonState == BS_GO_NORMAL)
	{
		ButtonStateTimer -= dt;
		if (ButtonStateTimer <= 0)
		{
			ButtonStateTimer = 0;
			ButtonState = BS_NORMAL;
		}
	}

	for (std::vector<TRenderPairList::iterator>::iterator i = PressedTextureIteratorArr.begin(); i != PressedTextureIteratorArr.end(); ++i)
	{
		(*i)->first.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = (ButtonStateTimer+0.f) / CONST_BUTTON_HIGHLIGHT_TIME;
	}


}


bool TUniversalButton::CheckClick(vec2 mousePos)
{
	if (mousePos.v[0] >= LeftBottomPos.v[0] &&
		mousePos.v[0] <= LeftBottomPos.v[0] + Width &&
		mousePos.v[1] >= LeftBottomPos.v[1] &&
		mousePos.v[1] <= LeftBottomPos.v[1] + Height)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void TUniversalButton::OnTapDown(vec2 pos)
{
	if (ButtonState == BS_NORMAL || ButtonState == BS_GO_NORMAL)
	{
		ButtonState = BS_GO_PRESSED;
	}

}

void TUniversalButton::OnTapUp(vec2 pos)
{
	if (ButtonState == BS_PRESSED || ButtonState == BS_GO_PRESSED)
	{
		ButtonState = BS_GO_NORMAL;
	}

}
    
void TUniversalButton::OnTapUpAfterMove(vec2 pos)
{
    OnTapUp(pos);
}

void TUniversalButton::OnMoveOut()
{
	if (ButtonState == BS_PRESSED || ButtonState == BS_GO_PRESSED)
	{
		
		ButtonState = BS_GO_NORMAL;
	}
}

TUniversalButton* TUniversalButton::CreateButton(vec2 posFrom, vec2 posTo)
{
	TUniversalButton* button = new TUniversalButton();

	button->LeftBottomPos = posFrom;

	button->Width = posTo.v[0] - posFrom.v[0];

	button->Height = posTo.v[1] - posFrom.v[1];

	return button;
}

TUniversalButton* TUniversalButton::CreateButtonWithFiller(vec2 posFrom, vec2 posTo, boost::function<void(TUniversalButton*)> buttonFillerFunc)
{
	
	TUniversalButton* button = TUniversalButton::CreateButton(posFrom, posTo);

	buttonFillerFunc(button);

	return button;
}

TUniversalButton* TUniversalButton::CreateButtonWithFillers(vec2 posFrom, vec2 posTo, std::vector<boost::function<void(TUniversalButton*)> > buttonFillerFuncArr)
{
	TUniversalButton* button = TUniversalButton::CreateButton(posFrom, posTo);

	for (std::vector<boost::function<void(TUniversalButton*)> >::iterator funcItr = buttonFillerFuncArr.begin(); funcItr != buttonFillerFuncArr.end(); ++funcItr)
	{
		(*funcItr)(button);
	}

	return button;
}

void TUniversalButton::SquareButtonFiller(vec2 posFrom, vec2 posTo, const std::string& texName, const std::string& texNamePressed, TUniversalButton* buttonToFill)
{
	
	TRenderParams renderParams;

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = texName;
	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 1.f;

	TTriangleList triangleList = MakeTriangleList(posFrom, posTo);

	triangleList.RefreshBuffer();

	buttonToFill->NormalTextureIteratorArr.push_back(buttonToFill->TriangleListVector.insert(buttonToFill->TriangleListVector.end(), TRenderPair(renderParams, triangleList)));

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = texNamePressed;
	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 0.f;

	buttonToFill->PressedTextureIteratorArr.push_back(buttonToFill->TriangleListVector.insert(buttonToFill->TriangleListVector.end(),TRenderPair(renderParams, triangleList)));

}


void TUniversalButton::TextButtonFiller(vec2 posFrom, vec2 posTo, TTextParams buttonTextParamsNormal, TTextParams buttonTextParamsPressed, TUniversalButton* buttonToFill)
{


	
	TTriangleList triangleList;
	
	if (buttonTextParamsNormal.FontName == "")
	{
		buttonTextParamsNormal.FontName = ResourceManager->FontManager.GetCurrentFontName();
	}

	if (buttonTextParamsPressed.FontName == "")
	{
		buttonTextParamsPressed.FontName = ResourceManager->FontManager.GetCurrentFontName();
	}



	TRenderParams renderParams = buttonTextParamsNormal.RenderParams;

	ResourceManager->FontManager.PushFont(buttonTextParamsNormal.FontName);

	triangleList = CreateTriangleListForText(posFrom, posTo, buttonTextParamsNormal);

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = ResourceManager->FontManager.GetCurrentFontTextureName();
	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 1.f;


	buttonToFill->NormalTextureIteratorArr.push_back(buttonToFill->TriangleListVector.insert(buttonToFill->TriangleListVector.end(),TRenderPair(renderParams, triangleList)));
	triangleList.RefreshBuffer();
	ResourceManager->FontManager.PopFont();
	

	renderParams = buttonTextParamsPressed.RenderParams;

	ResourceManager->FontManager.PushFont(buttonTextParamsPressed.FontName);

	triangleList = CreateTriangleListForText(posFrom, posTo, buttonTextParamsPressed);

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = ResourceManager->FontManager.GetCurrentFontTextureName();
	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 0.f;


	buttonToFill->PressedTextureIteratorArr.push_back(buttonToFill->TriangleListVector.insert(buttonToFill->TriangleListVector.end(),TRenderPair(renderParams, triangleList)));
	triangleList.RefreshBuffer();
	ResourceManager->FontManager.PopFont();

}

TUniversalButton* TUniversalButton::CreateSquareButton(vec2 posFrom, vec2 posTo, const std::string& texName, const std::string& texNamePressed)
{
	return CreateButtonWithFiller(posFrom, posTo, boost::bind(TUniversalButton::SquareButtonFiller, posFrom, posTo, texName, texNamePressed, _1));
}

TUniversalButton* TUniversalButton::CreateTextOnlyButton(vec2 posFrom, vec2 posTo, TTextParams buttonTextParamsNormal, TTextParams buttonTextParamsPressed)
{
	return CreateButtonWithFiller(posFrom, posTo, boost::bind(TUniversalButton::TextButtonFiller, posFrom, posTo, buttonTextParamsNormal, buttonTextParamsPressed, _1));
}

TUniversalButton* TUniversalButton::CreateSquareAndTextButton(vec2 posFrom, vec2 posTo, const std::string& texName, const std::string& texNamePressed, TTextParams buttonTextParamsNormal, TTextParams buttonTextParamsPressed)
{

	std::vector<boost::function<void(TUniversalButton*)> > funcIter;
	
	funcIter.push_back(boost::bind(TUniversalButton::SquareButtonFiller, posFrom, posTo, texName, texNamePressed, _1));
	funcIter.push_back(boost::bind(TUniversalButton::TextButtonFiller, posFrom, posTo, buttonTextParamsNormal, buttonTextParamsPressed, _1));
	
	TUniversalButton* universalButton = CreateButtonWithFillers(posFrom, posTo, funcIter);
	
	return universalButton;
}


TEdit* TEdit::CreateEdit(vec2 posFrom, vec2 posTo)
{
	TEdit* edit = new TEdit();

	edit->LeftBottomPos = posFrom;

	edit->Width = posTo.v[0] - posFrom.v[0];

	edit->Height = posTo.v[1] - posFrom.v[1];

	return edit;
}

TEdit* TEdit::CreateEditWithFiller(vec2 posFrom, vec2 posTo, boost::function<void(TEdit*)> fillerFunc)
{
	TEdit* edit = CreateEdit(posFrom, posTo);

	fillerFunc(edit);

	return edit;
}

TEdit* TEdit::CreateEditWithFillers(vec2 posFrom, vec2 posTo, std::vector<boost::function<void(TEdit*)> > fillerFuncArr)
{
	TEdit* edit = CreateEdit(posFrom, posTo);

	BOOST_FOREACH(auto& f, fillerFuncArr)
	{
		f(edit);
	}

	return edit;
}

void TEdit::EditFiller(vec2 posFrom, vec2 posTo, const std::string& texName, TTextParams textParams, TEdit* edit)
{

	TRenderParams renderParams;

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = texName;
	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 1.f;
	
	TTriangleList triangleList = MakeTriangleList(posFrom, posTo);

	triangleList.RefreshBuffer();

	edit->TriangleListVector.insert(edit->TriangleListVector.end(), TRenderPair(renderParams, triangleList));


	renderParams = textParams.RenderParams;

	if (textParams.FontName == "")
	{
		textParams.FontName = ResourceManager->FontManager.GetCurrentFontName();
	}

	ResourceManager->FontManager.PushFont(textParams.FontName);

	TTriangleList textTriangleList = CreateTriangleListForText(posFrom, posTo, textParams);

	textTriangleList.RefreshBuffer();

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = ResourceManager->FontManager.GetCurrentFontTextureName();

	edit->TextIterator = (edit->TriangleListVector.insert(edit->TriangleListVector.end(),TRenderPair(renderParams, textTriangleList)));
	
	ResourceManager->FontManager.PopFont();

	edit->TextParams = textParams;


}

void TEdit::SmartValueTextFiller(const std::string& dictionaryName, const std::string& smartValueName, TEdit* edit)
{
	edit->SetText(ResourceManager->SmartValueManager.GetImmediateValue<std::string>(dictionaryName, smartValueName));
	
	edit->SetTextSlotConnection = ResourceManager->SmartValueManager.GetSignal<std::string>(dictionaryName, smartValueName).connect(boost::bind(&TEdit::SetText, edit, _1));

	edit->OnTextChanged.connect
	(
		[dictionaryName, smartValueName](std::string text)
		{
			if (ResourceManager->SmartValueManager.GetImmediateValue<std::string>(dictionaryName, smartValueName) != text)
			{
				ResourceManager->SmartValueManager.SetImmediateValue<std::string>(dictionaryName, smartValueName, text);
			}
		}
	);
}

/*
TEdit* TEdit::CreateEdit(vec2 posFrom, vec2 posTo, const std::string& texName, TTextParams textParams)
{
	

	//Filler:

	TRenderParams renderParams = textParams.RenderParams;

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = texName;
	
	TTriangleList triangleList = MakeTriangleList(posFrom, posTo);

	triangleList.RefreshBuffer();

	edit->TriangleListVector.insert(edit->TriangleListVector.end(), TRenderPair(renderParams, triangleList));


	if (textParams.FontName == "")
	{
		textParams.FontName = ResourceManager->FontManager.GetCurrentFontName();
	}

	ResourceManager->FontManager.PushFont(textParams.FontName);

	triangleList = CreateTriangleListForText(posFrom, posTo, textParams);

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = ResourceManager->FontManager.GetCurrentFontTextureName();

	edit->TextIterator = (edit->TriangleListVector.insert(edit->TriangleListVector.end(),TRenderPair(renderParams, triangleList)));
	triangleList.RefreshBuffer();
	ResourceManager->FontManager.PopFont();

	return edit;
}*/

TEdit::~TEdit()
{
	if (InputConnection.connected())
	{
		InputConnection.disconnect();
	}

	if (SetTextSlotConnection.connected())
	{
		SetTextSlotConnection.disconnect();
	}
}

void TEdit::RefreshTextTriangleList()
{
	TTriangleList triangleList = CreateTriangleListForText(LeftBottomPos, LeftBottomPos + vec2(Width, Height), TextParams);

	TextIterator->second = triangleList;

}

bool TEdit::CheckClick(vec2 mousePos)
{
	if (mousePos.v[0] >= LeftBottomPos.v[0] &&
		mousePos.v[0] <= LeftBottomPos.v[0] + Width &&
		mousePos.v[1] >= LeftBottomPos.v[1] &&
		mousePos.v[1] <= LeftBottomPos.v[1] + Height)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void TEdit::OnTapDown(vec2 pos)
{
	if (!InputConnection.connected())
	{
		ResourceManager->GUIManager.KeyPressedSignal.disconnect_all_slots();
		InputConnection = ResourceManager->GUIManager.KeyPressedSignal.connect(boost::bind(&TEdit::OnKeyPress, this, _1));

	}

	ResourceManager->GUIManager.ShowKeyboard(GetText());
    ResourceManager->GUIManager.SetTextSignal.connect(boost::bind(&TEdit::OnSetAllText, this, _1));
}

void TEdit::OnKeyPress(int key)
{
	if (key == 8) //Backspace
	{
		if (TextParams.Text.size() > 0)
		{
			TextParams.Text.erase(TextParams.Text.end()-1);
		}
	}
	else if (key >= 32 && key <= 255) //ASCII
	{
		TextParams.Text += static_cast<char>(key);
	}

	OnTextChanged(TextParams.Text);

	RefreshTextTriangleList();
}

void TEdit::SetText(const std::string& newText)
{
	if (newText != TextParams.Text)
	{
		TextParams.Text = newText;

		OnTextChanged(TextParams.Text);

		RefreshTextTriangleList();
	}
}
    
void TEdit::OnSetAllText(std::string newText)
{
    SetText(newText);
}
    
    
std::string TEdit::GetText()
{
    return TextParams.Text;
}


//============================ Check Box ============================


TCheckBox::TCheckBox()
	: IsChecked(false)
	, Width(0.f)
	, Height(0.f)
{
}

TCheckBox::~TCheckBox()
{

	if (SetCheckedSlotConnection.connected())
	{
		SetCheckedSlotConnection.disconnect();
	}
}

void TCheckBox::SetChecked(bool isChecked)
{

	if (isChecked == IsChecked)
	{
		return; //This prevent recursion
	}


		if (!IsChecked)
		{
			IsChecked = true;

			OnSetChecked(IsChecked);

			RefreshVisibility();
		}
		else
		{
			IsChecked = false;

			OnSetChecked(IsChecked);

			RefreshVisibility();
		}
}

void TCheckBox::RefreshVisibility()
{

	//IsChecked
	if (IsChecked)
	{
		for (std::vector<TRenderPairList::iterator>::iterator i = CheckedTextureIteratorArr.begin(); i != CheckedTextureIteratorArr.end(); ++i)
		{
			(*i)->first.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 1.f;
		}
	}
	else
	{
		for (std::vector<TRenderPairList::iterator>::iterator i = CheckedTextureIteratorArr.begin(); i != CheckedTextureIteratorArr.end(); ++i)
		{
			(*i)->first.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 0.f;
		}
	}
}

bool TCheckBox::CheckClick(vec2 mousePos)
{
	if (mousePos.v[0] >= LeftBottomPos.v[0] &&
		mousePos.v[0] <= LeftBottomPos.v[0] + Width &&
		mousePos.v[1] >= LeftBottomPos.v[1] &&
		mousePos.v[1] <= LeftBottomPos.v[1] + Height)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void TCheckBox::Update(cardinal dt)
{
}

void TCheckBox::OnTapDown(vec2 pos)
{
}

void TCheckBox::OnTapUp(vec2 pos)
{
	SetChecked(!IsChecked);
}

void TCheckBox::OnMoveOut()
{
}


TCheckBox* TCheckBox::CreateCheckBox(vec2 posFrom, vec2 posTo)
{
	TCheckBox* checkBox = new TCheckBox();

	checkBox->LeftBottomPos = posFrom;

	checkBox->Width = posTo.v[0] - posFrom.v[0];

	checkBox->Height = posTo.v[1] - posFrom.v[1];

	return checkBox;
}

TCheckBox* TCheckBox::CreateCheckBoxWithFiller(vec2 posFrom, vec2 posTo, boost::function<void(TCheckBox*)> checkBoxFillerFunc)
{
	TCheckBox* checkBox = TCheckBox::CreateCheckBox(posFrom, posTo);

	checkBoxFillerFunc(checkBox);

	return checkBox;
}

TCheckBox* TCheckBox::CreateCheckBoxWithFillers(vec2 posFrom, vec2 posTo, std::vector<boost::function<void(TCheckBox*)> > checkBoxFillerFuncArr)
{
	TCheckBox* checkBox = TCheckBox::CreateCheckBox(posFrom, posTo);

	BOOST_FOREACH(boost::function<void(TCheckBox*)>& fillerFunc, checkBoxFillerFuncArr)
	{
		fillerFunc(checkBox);
	}

	return checkBox;
}

void TCheckBox::TextureFiller(vec2 posFrom, vec2 posTo, const std::string& texName, const std::string& texNameChecked, TCheckBox* checkBoxToFill)
{

	TRenderParams renderParams;

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = texName;
	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 1.f;

	TTriangleList triangleList = MakeTriangleList(posFrom, posTo);

	triangleList.RefreshBuffer();


	checkBoxToFill->StaticTextureIteratorArr.push_back(checkBoxToFill->TriangleListVector.insert(checkBoxToFill->TriangleListVector.end(), TRenderPair(renderParams, triangleList)));

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = texNameChecked;
	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 0.f;

	checkBoxToFill->CheckedTextureIteratorArr.push_back(checkBoxToFill->TriangleListVector.insert(checkBoxToFill->TriangleListVector.end(),TRenderPair(renderParams, triangleList)));

}

void TCheckBox::TextFiller(vec2 posFrom, vec2 posTo, TTextParams textParams, TCheckBox* checkBoxToFill)
{
	
	TRenderParams renderParams = textParams.RenderParams;

	TTriangleList triangleList;

	if (textParams.FontName == "")
	{
		textParams.FontName = ResourceManager->FontManager.GetCurrentFontName();
	}

	ResourceManager->FontManager.PushFont(textParams.FontName);

	triangleList = CreateTriangleListForText(posFrom, posTo, textParams);

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = ResourceManager->FontManager.GetCurrentFontTextureName();

	checkBoxToFill->StaticTextureIteratorArr.push_back(checkBoxToFill->TriangleListVector.insert(checkBoxToFill->TriangleListVector.end(),TRenderPair(renderParams, triangleList)));
	triangleList.RefreshBuffer();
	ResourceManager->FontManager.PopFont();

}

void TCheckBox::CheckedFiller(bool isChecked, TCheckBox* checkBoxToFill)
{
	checkBoxToFill->SetChecked(isChecked);
}

void TCheckBox::SmartValueFiller(const std::string& dictionaryName, const std::string& smartValueName, TCheckBox* checkBoxToFill)
{

	checkBoxToFill->SetChecked(ResourceManager->SmartValueManager.GetImmediateValue<bool>(dictionaryName, smartValueName));
	
	checkBoxToFill->SetCheckedSlotConnection = ResourceManager->SmartValueManager.GetSignal<bool>(dictionaryName, smartValueName).connect(boost::bind(&TCheckBox::SetChecked, checkBoxToFill, _1));
    
	checkBoxToFill->OnSetChecked.connect
	(
		[dictionaryName, smartValueName](bool checked)
		{
			if (ResourceManager->SmartValueManager.GetImmediateValue<bool>(dictionaryName, smartValueName) != checked)
			{
				ResourceManager->SmartValueManager.SetImmediateValue<bool>(dictionaryName, smartValueName, checked);
			}
		}
	);
}


TCheckBox* TCheckBox::CreateSimpleCheckBox(vec2 posFrom, vec2 posTo, const std::string& texName, const std::string& texNameChecked)
{
	return CreateCheckBoxWithFiller(posFrom, posTo, boost::bind(&TCheckBox::TextureFiller, posFrom, posTo, texName, texNameChecked, _1));
}

TCheckBox* TCheckBox::CreateCheckBoxWithText(vec2 posFrom, vec2 posTo, const std::string& texName, const std::string& texNameChecked, vec2 textPosFrom, vec2 textPosTo, TTextParams textParams)
{
	TCheckBox* checkBox = CreateCheckBox(posFrom, posTo);

	TCheckBox::TextureFiller(posFrom, posTo, texName, texNameChecked, checkBox);
	TCheckBox::TextFiller(textPosFrom, textPosTo, textParams, checkBox);

	return checkBox;
}


//============================ Radio Button ============================


TRadioButton::TRadioButton()
	: IsChecked(false)
	, Width(0.f)
	, Height(0.f)
{
}

TRadioButton::~TRadioButton()
{

	if (SetCheckedSlotConnection.connected())
	{
		SetCheckedSlotConnection.disconnect();
	}
}

void TRadioButton::SetChecked(bool isChecked)
{

	if (isChecked == IsChecked)
	{
		return; //This prevent recursion
	}

	IsChecked = isChecked;

	OnSetChecked(IsChecked);

	RefreshVisibility();
}

void TRadioButton::RefreshVisibility()
{

	//IsChecked
	if (IsChecked)
	{
		for (std::vector<TRenderPairList::iterator>::iterator i = CheckedTextureIteratorArr.begin(); i != CheckedTextureIteratorArr.end(); ++i)
		{
			(*i)->first.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 1.f;
		}
	}
	else
	{
		for (std::vector<TRenderPairList::iterator>::iterator i = CheckedTextureIteratorArr.begin(); i != CheckedTextureIteratorArr.end(); ++i)
		{
			(*i)->first.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 0.f;
		}
	}
}

bool TRadioButton::CheckClick(vec2 mousePos)
{
	if (mousePos.v[0] >= LeftBottomPos.v[0] &&
		mousePos.v[0] <= LeftBottomPos.v[0] + Width &&
		mousePos.v[1] >= LeftBottomPos.v[1] &&
		mousePos.v[1] <= LeftBottomPos.v[1] + Height)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void TRadioButton::Update(cardinal dt)
{
}

void TRadioButton::OnTapDown(vec2 pos)
{
}

void TRadioButton::OnTapUp(vec2 pos)
{
	SetChecked(true);
}

void TRadioButton::OnMoveOut()
{
}


TRadioButton* TRadioButton::CreateRadioButton(vec2 posFrom, vec2 posTo)
{
	TRadioButton* radioButton = new TRadioButton();

	radioButton->LeftBottomPos = posFrom;

	radioButton->Width = posTo.v[0] - posFrom.v[0];

	radioButton->Height = posTo.v[1] - posFrom.v[1];

	return radioButton;
}

TRadioButton* TRadioButton::CreateRadioButtonWithFiller(vec2 posFrom, vec2 posTo, boost::function<void(TRadioButton*)> radioButtonFillerFunc)
{
	TRadioButton* radioButton = TRadioButton::CreateRadioButton(posFrom, posTo);

	radioButtonFillerFunc(radioButton);

	return radioButton;
}

TRadioButton* TRadioButton::CreateRadioButtonWithFillers(vec2 posFrom, vec2 posTo, std::vector<boost::function<void(TRadioButton*)> > radioButtonFillerFuncArr)
{
	TRadioButton* radioButton = TRadioButton::CreateRadioButton(posFrom, posTo);

	BOOST_FOREACH(boost::function<void(TRadioButton*)>& fillerFunc, radioButtonFillerFuncArr)
	{
		fillerFunc(radioButton);
	}

	return radioButton;
}

void TRadioButton::TextureFiller(vec2 posFrom, vec2 posTo, const std::string& texName, const std::string& texNameChecked, TRadioButton* radioButtonToFill)
{

	TRenderParams renderParams;

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = texName;
	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 1.f;

	TTriangleList triangleList = MakeTriangleList(posFrom, posTo);

	triangleList.RefreshBuffer();


	radioButtonToFill->StaticTextureIteratorArr.push_back(radioButtonToFill->TriangleListVector.insert(radioButtonToFill->TriangleListVector.end(), TRenderPair(renderParams, triangleList)));

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = texNameChecked;
	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 0.f;

	radioButtonToFill->CheckedTextureIteratorArr.push_back(radioButtonToFill->TriangleListVector.insert(radioButtonToFill->TriangleListVector.end(),TRenderPair(renderParams, triangleList)));

}

void TRadioButton::TextFiller(vec2 posFrom, vec2 posTo, TTextParams textParams, TRadioButton* radioButtonToFill)
{
	
	TRenderParams renderParams = textParams.RenderParams;

	TTriangleList triangleList;

	if (textParams.FontName == "")
	{
		textParams.FontName = ResourceManager->FontManager.GetCurrentFontName();
	}

	ResourceManager->FontManager.PushFont(textParams.FontName);

	triangleList = CreateTriangleListForText(posFrom, posTo, textParams);

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = ResourceManager->FontManager.GetCurrentFontTextureName();
	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 1.f;


	radioButtonToFill->StaticTextureIteratorArr.push_back(radioButtonToFill->TriangleListVector.insert(radioButtonToFill->TriangleListVector.end(),TRenderPair(renderParams, triangleList)));
	triangleList.RefreshBuffer();
	ResourceManager->FontManager.PopFont();

}

void TRadioButton::CheckedFiller(bool isChecked, TRadioButton* radioButtonToFill)
{
	radioButtonToFill->SetChecked(isChecked);
}

TRadioButton* TRadioButton::CreateSimpleRadioButton(vec2 posFrom, vec2 posTo, const std::string& texName, const std::string& texNameChecked)
{
	return CreateRadioButtonWithFiller(posFrom, posTo, boost::bind(&TRadioButton::TextureFiller, posFrom, posTo, texName, texNameChecked, _1));
}

TRadioButton* TRadioButton::CreateRadioButtonWithText(vec2 posFrom, vec2 posTo, const std::string& texName, const std::string& texNameChecked, vec2 textPosFrom, vec2 textPosTo, TTextParams textParams)
{
	TRadioButton* radioButton = CreateRadioButton(posFrom, posTo);

	TRadioButton::TextureFiller(posFrom, posTo, texName, texNameChecked, radioButton);
	TRadioButton::TextFiller(textPosFrom, textPosTo, textParams, radioButton);

	return radioButton;
}




//====================== Mover =====================





TMover::TMover()
	: Width(0)
	, Height(0)
	, PosCursor(0)
{
}


TMover::~TMover()
{
}

void TMover::Update(cardinal dt)
{
}

bool TMover::CheckClick(vec2 mousePos)
{
	if (mousePos.v[0] >= LeftBottomPos.v[0] &&
		mousePos.v[0] <= LeftBottomPos.v[0] + Width &&
		mousePos.v[1] >= LeftBottomPos.v[1] &&
		mousePos.v[1] <= LeftBottomPos.v[1] + Height)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void TMover::OnTapDown(vec2 pos)
{
}

void TMover::OnTapUp(vec2 pos)
{
}

void TMover::OnMove(vec2 shift)
{
	float oldPosCursor = PosCursor;
	PosCursor -= shift.v[1];

	if (PosCursor < 0)
	{
		PosCursor = 0;
	}

	if (PosCursor > MaxHeight - Height)
	{
		PosCursor = MaxHeight - Height;
	}

	float shift_y = PosCursor - oldPosCursor;

	if (shift_y != 0)
	{
	ResourceManager->GUIManager.MoveWidgetGroup(GroupName, SelfName, vec2(0, shift_y));
	}
}

void TMover::OnMoveOut()
{
}


TMover* TMover::CreateMover(vec2 posFrom, vec2 posTo, std::string groupName, std::string selfName, float maxHeight)
{
	TMover* mover = new TMover();

	mover->LeftBottomPos = posFrom;

	mover->Width = posTo.v[0] - posFrom.v[0];

	mover->Height = posTo.v[1] - posFrom.v[1];

	mover->GroupName = groupName;

	mover->SelfName = selfName;

	mover->MaxHeight = maxHeight;

	return mover;
}


THorizontalJoystick::THorizontalJoystick()
	: ButtonState(BS_NORMAL)
	, ButtonStateTimer(0.f)
	, SelectorWidth(0)
	, SelectorPos(0)
	, SelectorTouched(false)
{
}


void THorizontalJoystick::ReturnSelectorBack()
{
	SelectorPos = 0;

	float selectorCenterPos = LeftBottomPos.v[0] + 0.5f * Width;

	vec2 selectorPosFrom = vec2(selectorCenterPos - SelectorWidth * 0.5f, LeftBottomPos.v[1]);
	vec2 selectorPosTo = vec2(selectorCenterPos + SelectorWidth * 0.5f, LeftBottomPos.v[1] + Height);


	for (std::vector<TRenderPairList::iterator>::iterator i = PressedTextureIteratorArr.begin(); i != PressedTextureIteratorArr.end(); ++i)
	{
		Replace6PointsInTriangleList((*i)->second.Data, 0, selectorPosFrom, selectorPosTo);
		(*i)->second.RefreshBuffer();
	}

	for (std::vector<TRenderPairList::iterator>::iterator i = NormalTextureIteratorArr.begin(); i != NormalTextureIteratorArr.end(); ++i)
	{
		Replace6PointsInTriangleList((*i)->second.Data, 0, selectorPosFrom, selectorPosTo);
		(*i)->second.RefreshBuffer();
	}
}

void THorizontalJoystick::Update(cardinal dt)
{
	if (ButtonState == BS_GO_PRESSED)
	{
		ButtonStateTimer += dt;
		if (ButtonStateTimer >= CONST_BUTTON_HIGHLIGHT_TIME)
		{
			ButtonStateTimer = CONST_BUTTON_HIGHLIGHT_TIME;
			ButtonState = BS_PRESSED;
		}
	}
	else if (ButtonState == BS_GO_NORMAL)
	{
		ButtonStateTimer -= dt;
		if (ButtonStateTimer <= 0)
		{
			ButtonStateTimer = 0;
			ButtonState = BS_NORMAL;
		}
	}

	for (std::vector<TRenderPairList::iterator>::iterator i = PressedTextureIteratorArr.begin(); i != PressedTextureIteratorArr.end(); ++i)
	{
		(*i)->first.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = (ButtonStateTimer+0.f) / CONST_BUTTON_HIGHLIGHT_TIME;
	}


}


bool THorizontalJoystick::CheckClick(vec2 mousePos)
{
	if (mousePos.v[0] >= LeftBottomPos.v[0] &&
		mousePos.v[0] <= LeftBottomPos.v[0] + Width &&
		mousePos.v[1] >= LeftBottomPos.v[1] &&
		mousePos.v[1] <= LeftBottomPos.v[1] + Height)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool THorizontalJoystick::CheckSelectorClicked(vec2 mousePos)
{
	float selectorCenterPos = LeftBottomPos.v[0] + (SelectorPos + 1) * 0.5f * Width;
	float selectorLeftPos = selectorCenterPos - SelectorWidth * 0.5f;
	float selectorRightPos = selectorCenterPos + SelectorWidth * 0.5f;

	if (mousePos.v[0] >= selectorLeftPos &&
		mousePos.v[0] <= selectorRightPos &&
		mousePos.v[1] >= LeftBottomPos.v[1] &&
		mousePos.v[1] <= LeftBottomPos.v[1] + Height)
	{
		return true;
	}
	else
	{
		return false;
	}
}


void THorizontalJoystick::OnTapDown(vec2 pos)
{
	if (ButtonState == BS_NORMAL || ButtonState == BS_GO_NORMAL)
	{
		ButtonState = BS_GO_PRESSED;
	}

	if (CheckSelectorClicked(pos))
	{
		SelectorTouched = true;
	}
}

void THorizontalJoystick::OnTapUp(vec2 pos)
{
	if (ButtonState == BS_PRESSED || ButtonState == BS_GO_PRESSED)
	{
		ButtonState = BS_GO_NORMAL;
	}

	SelectorTouched = false;
	ReturnSelectorBack();
}
    
void THorizontalJoystick::OnTapUpAfterMove(vec2 pos)
{
    OnTapUp(pos);
	SelectorPos = 0.f;
}

void THorizontalJoystick::OnTapUpAfterMoveOut(vec2 pos)
{
    OnTapUp(pos);
	SelectorPos = 0.f;
}

void THorizontalJoystick::OnMove(vec2 shift)
{
	if (SelectorTouched)
	{
		SelectorPos = SE::clamp(SelectorPos - 2.f * shift.v[0] / (Width - SelectorWidth), -1.f, 1.f);
		
		float selectorCenterPos = LeftBottomPos.v[0] + SelectorWidth * 0.5f + (SelectorPos + 1) * 0.5f * (Width - SelectorWidth);

		vec2 selectorPosFrom = vec2(selectorCenterPos - SelectorWidth * 0.5f, LeftBottomPos.v[1]);
		vec2 selectorPosTo = vec2(selectorCenterPos + SelectorWidth * 0.5f, LeftBottomPos.v[1] + Height);


		for (std::vector<TRenderPairList::iterator>::iterator i = PressedTextureIteratorArr.begin(); i != PressedTextureIteratorArr.end(); ++i)
		{
			Replace6PointsInTriangleList((*i)->second.Data, 0, selectorPosFrom, selectorPosTo);
			(*i)->second.RefreshBuffer();
		}

		for (std::vector<TRenderPairList::iterator>::iterator i = NormalTextureIteratorArr.begin(); i != NormalTextureIteratorArr.end(); ++i)
		{
			Replace6PointsInTriangleList((*i)->second.Data, 0, selectorPosFrom, selectorPosTo);
			(*i)->second.RefreshBuffer();
		}
	}
}

void THorizontalJoystick::OnMoveOut()
{
	if (ButtonState == BS_PRESSED || ButtonState == BS_GO_PRESSED)
	{
		
		ButtonState = BS_GO_NORMAL;
	}
}

float THorizontalJoystick::GetSelectorPos()
{
	return SelectorPos;
}

THorizontalJoystick* THorizontalJoystick::CreateJoystick(vec2 posFrom, vec2 posTo, float selectorWidth)
{
	
	THorizontalJoystick* widget = new THorizontalJoystick();

	widget->LeftBottomPos = posFrom;

	widget->Width = posTo.v[0] - posFrom.v[0];

	widget->Height = posTo.v[1] - posFrom.v[1];

	widget->SelectorWidth = selectorWidth;

	return widget;
}

THorizontalJoystick* THorizontalJoystick::CreateJoystickWithFiller(vec2 posFrom, vec2 posTo, float selectorWidth, boost::function<void(THorizontalJoystick*)> fillerFunc)
{
	
	THorizontalJoystick* joystick = THorizontalJoystick::CreateJoystick(posFrom, posTo, selectorWidth);

	fillerFunc(joystick);

	return joystick;
}

THorizontalJoystick* THorizontalJoystick::CreateJoystickWithFillers(vec2 posFrom, vec2 posTo, float selectorWidth, std::vector<boost::function<void(THorizontalJoystick*)> > fillerFuncArr)
{
	THorizontalJoystick* joystick = THorizontalJoystick::CreateJoystick(posFrom, posTo, selectorWidth);

	for (std::vector<boost::function<void(THorizontalJoystick*)> >::iterator funcItr = fillerFuncArr.begin(); funcItr != fillerFuncArr.end(); ++funcItr)
	{
		(*funcItr)(joystick);
	}

	return joystick;
}


void THorizontalJoystick::SquareJoystickFiller(vec2 posFrom, vec2 posTo, float selectorWidth, const std::string& texNameField, const std::string& texName, const std::string& texNamePressed, THorizontalJoystick* joystickToFill)
{
	
	float selectorCenterPos = 0.5f * (posFrom.v[0] + posTo.v[0]);

	vec2 selectorPosFrom = vec2(selectorCenterPos - selectorWidth * 0.5f, posFrom.v[1]);
	vec2 selectorPosTo = vec2(selectorCenterPos + selectorWidth * 0.5f, posTo.v[1]);

	TRenderParams renderParams;

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = texName;
	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 1.f;

	TTriangleList triangleList = MakeTriangleList(selectorPosFrom, selectorPosTo);
		
	triangleList.RefreshBuffer();

	joystickToFill->NormalTextureIteratorArr.push_back(joystickToFill->TriangleListVector.insert(joystickToFill->TriangleListVector.end(), TRenderPair(renderParams, triangleList)));

	TTriangleList triangleList2 = MakeTriangleList(selectorPosFrom, selectorPosTo);
	triangleList2.RefreshBuffer();

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = texNamePressed;
	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 0.f;

	joystickToFill->PressedTextureIteratorArr.push_back(joystickToFill->TriangleListVector.insert(joystickToFill->TriangleListVector.end(),TRenderPair(renderParams, triangleList2)));
	

	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = texNameField;
	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 1.f;

	TTriangleList fieldTriangleList = MakeTriangleList(posFrom, posTo);
		
	fieldTriangleList.RefreshBuffer();

	joystickToFill->FieldTextureIteratorArr.push_back(joystickToFill->TriangleListVector.insert(joystickToFill->TriangleListVector.end(), TRenderPair(renderParams, fieldTriangleList)));

}

THorizontalJoystick* THorizontalJoystick::CreateSquareJoystick(vec2 posFrom, vec2 posTo, float selectorWidth, const std::string& texNameField, const std::string& texName, const std::string& texNamePressed)
{
	return CreateJoystickWithFiller(posFrom, posTo, selectorWidth, boost::bind(THorizontalJoystick::SquareJoystickFiller, posFrom, posTo, selectorWidth, texNameField, texName, texNamePressed, _1));
}

} //namespace SE