#include "stdafx.h"

#include "KUITabControl.h"
#include "KUIWndManager.h"
#include "KResourceManager.h"
#include "KViewport.h"

//#include <string>

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KUITabItemControlBase Implement
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace
{
	const int TAB_NAME_MAX_LEN = 10;
}

DWORD KUITabItemControlBase::OnMouseMessage(DWORD dwMessage, int x, int y)
{
	DWORD dwRet = KUIControl::OnMouseMessage( dwMessage, x, y);

	if(KMR_NO_GET & dwRet)
		return dwRet;

	if( IsDisable() )
		return dwRet;

	if(IsInRect(x,y) )
	{
		switch(dwMessage) 
		{
		case KMOUSE_MOVE:
			if(m_dwState != KTS_SELECTED)
				OnStateChange( KTS_ON_MOUSE);
			break;
		case KLBUTTON_DOWN:
			if( m_dwState != KTS_SELECTED)
			{
				OnStateChange( KTS_SELECTED);
				PumpUpMessage(GetID(), KUI_MESSAGE::KTAB_CHANGE, reinterpret_cast<DWORD>( static_cast< KUIControl* >( this ) ),0);
			}
			break;
		default:
			break;
		}
	}
	else
	{
		if( m_dwState != KTS_SELECTED)
		{
			OnStateChange( KTS_NORMAL);
			m_rcCaptionArea.top -= 2;		// 텍스트 위치
		}
	}

	return dwRet;
}

void KUITabItemControlBase::OnChangeCaptionNotify()
{
	if( !IsDisable() )
	{	
		size_t cpos = 0;
		while( ( cpos = m_sCaption.find( "<#" ) ) != m_sCaption.npos )
		{
			m_sCaption.erase( cpos, 9 );
		}

		std::string strNewCaption = m_strEnableColor.c_str();
		strNewCaption += m_sCaption;
		m_sCaption = strNewCaption;
	}

	KUIControl::OnChangeCaptionNotify();
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KUITabControlBase Implement
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace 
{
	const int TAB_ITEM_GAP = -9;
}
KUITabControlBase::KUITabControlBase()
: m_nGap(TAB_ITEM_GAP)
, m_dwSelectedItem(0)
, m_nTabItemCount( -1 )
, m_bDynamicTab( true )
{
}

KUITabControlBase::~KUITabControlBase()
{
	m_vtTabItemList.clear();
}

void KUITabControlBase::PumpUpMessage( LPCSTR lpszControlID, DWORD dwMessage, DWORD lparam, DWORD wparam )
{
	switch(dwMessage) 
	{
	case KUI_MESSAGE::KTAB_CHANGE:
		{
			KUITabItemControlBase* pItem = static_cast< KUITabItemControlBase* >( reinterpret_cast<KUIControl*>( lparam	) );

			int nIndex = -1;
			for(int i = 0; i < m_vtTabItemList.size(); ++i)
			{
				if( m_vtTabItemList.at(i) == pItem)
				{
					nIndex = i;
					break;
				}
			}

			if (nIndex != -1)
			{
				m_vtTabItemList.at(m_dwSelectedItem)->OnStateChange(KTS_NORMAL);
				m_pParent->PumpUpMessage(GetID(), KUI_MESSAGE::KTAB_CHANGE, m_dwSelectedItem,0);
				m_dwSelectedItem = nIndex;
				m_pParent->PumpUpMessage(GetID(), KUI_MESSAGE::KTAB_SELECT, m_dwSelectedItem,0);
			}
		}
		break;
	default:
		break;
	}
}


// 2010.06.14. bintitle. 탭컨트롤에 속한 버튼컨트롤의 AniName 변경.
void KUITabControlBase::SetTabItemAniName( int nIndex, const char * szName )
{
	if( nIndex >= 0 && nIndex < m_vtTabItemList.size() )
	{
		m_vtTabItemList[ nIndex ]->SetAniName( szName );
		//m_vtTabItemList[ nIndex ]->OnStateChange( TAB_STATE::KTS_TOTAL );
	}
}


void KUITabControlBase::SetTabProperty(int nGap, bool bDynamicTab, int nTabItemCount )
{
	// 사각형이 아닌 탭의 모양을 앞으로 당겨 줄때 값을 설정
	m_nGap = nGap;

	// MJ 2004/12/20 고정탭
	m_bDynamicTab = bDynamicTab;
	m_nTabItemCount = nTabItemCount;
	if( nTabItemCount < 0 )	m_bDynamicTab = true;
	InvalidateWnd();
}

void KUITabControlBase::AddTabItem(LPCSTR lpszCaption, LPCSTR lpszTip, LPCSTR lpszAniName, float fSizeCorr, const char * pStrColor )
{
	// uii에서 설정한 Animation Name으로 Button 설정 

	KUITabItemControlBase* pTabButton = _createItem(lpszCaption, lpszTip, (int)m_vtTabItemList.size(), lpszAniName, 
		fSizeCorr);

	pTabButton->SetEnableColor( "<#ffffff>" ); // 추가. bintitle. 2010.04.27
	if( pStrColor )
		pTabButton->SetDisableColor( pStrColor );
	pTabButton->Enable();
//	else
//		pTabButton->SetDisableColor( m_strDisableColor.c_str() );
	

	m_vtTabItemList.push_back(pTabButton);

	if(m_vtTabItemList.size() == 1)
	{
		m_dwSelectedItem = 0;
		m_vtTabItemList.at(0)->OnStateChange(KTS_SELECTED);
		SetSelectedItem(0, true);
	}
	else
	{
		m_vtTabItemList.at(m_vtTabItemList.size() - 1)->OnStateChange(KTS_NORMAL);
	}

	// Back도 줄 맞춘다.
	_onTabItemChange();
	InvalidateWnd();
}

void KUITabControlBase::ChangeTabItem(int nIndex, LPCSTR lpszCaption, LPCSTR lpszTip, float fSizeCorr)
{
	if(nIndex < 0 || nIndex >= m_vtTabItemList.size())
		return;

	DWORD  dwState = m_vtTabItemList[nIndex]->GetState();
	RemoveChild(m_vtTabItemList[nIndex]);
	m_vtTabItemList[nIndex] = _createItem(lpszCaption, lpszTip, nIndex, NULL, fSizeCorr);
	m_vtTabItemList[nIndex]->OnStateChange( dwState);

	// Tab Item 다시 줄 맞추기 -_-
	_reArrangItems();

	// Back도 줄 맞춘다.
	_onTabItemChange();
	InvalidateWnd();
}

void KUITabControlBase::RemoveTabItem(int nIndex)
{
	if(nIndex < 0 || nIndex >= m_vtTabItemList.size())
		return;

	RemoveChild(m_vtTabItemList[nIndex]);
	m_vtTabItemList.erase( m_vtTabItemList.begin() + nIndex);

	if(nIndex == static_cast<int>( m_dwSelectedItem ) )
	{
		SetSelectedItem(0);
	}

	// Tab Item 다시 줄 맞추기 -_-
	_reArrangItems();

	// Back도 줄 맞춘다.
	_onTabItemChange();
	InvalidateWnd();
}

void KUITabControlBase::RemoveTabAllItem()
{
	std::vector<KUITabItemControlBase *>::iterator it;
	it = m_vtTabItemList.begin();

	KUITabItemControlBase* pCtrBase(NULL);
	while( it != m_vtTabItemList.end() )
	{
		pCtrBase = *it;
		RemoveChild( pCtrBase );
		it = m_vtTabItemList.erase( it );
	}
	m_dwSelectedItem = 0;

	// Tab Item 다시 줄 맞추기 -_-
	_reArrangItems();

	// Back도 줄 맞춘다.
	_onTabItemChange();
	InvalidateWnd();
}



void KUITabControlBase::SetSelectedItem(DWORD dwSelected, bool bUpdate)
{
	if(dwSelected >= m_vtTabItemList.size() )
		return;

	if(dwSelected != m_dwSelectedItem)
	{
		m_vtTabItemList.at(m_dwSelectedItem)->OnStateChange(KTS_NORMAL);
		m_dwSelectedItem = dwSelected;
		m_vtTabItemList.at(m_dwSelectedItem)->OnStateChange(KTS_SELECTED);
	}
	InvalidateWnd();
}

void KUITabControlBase::_initControl()
{
	m_rcCaptionArea = m_rcRegion;

}
KRect KUITabControlBase::_getNextArea(int nIndex)
{
	int XPos = m_rcRegion.left;
	int YPos =  m_rcRegion.top;

	for(int i = 0; i < nIndex; ++i)
	{
		KUITabItemControlBase * pItem = m_vtTabItemList.at(i);

		if(NULL	 == pItem)
			continue;

		if(m_dwStyle & KSTYLE_TAB_VERTICAL)
			YPos += pItem->GetRect().bottom - pItem->GetRect().top + m_nGap;
		else
			XPos += pItem->GetRect().right - pItem->GetRect().left + m_nGap;

	}
	return KRect(XPos,YPos,-1,-1);
}

void KUITabControlBase::_reArrangItems()
{
	int XPos = m_rcRegion.left;
	int YPos =  m_rcRegion.top;

	for(int i = 0 ; i < m_vtTabItemList.size(); ++i)
	{
		KUITabItemControlBase* pItem = m_vtTabItemList[i];
		
		if(NULL	 == pItem)
			continue;

		pItem->MovePos(XPos, YPos);

		if(m_dwStyle & KSTYLE_TAB_VERTICAL)
			YPos += pItem->GetRect().bottom - pItem->GetRect().top + m_nGap;
		else
			XPos += pItem->GetRect().right - pItem->GetRect().left + m_nGap;

	}
}

void KUITabControlBase::SetDisableTab( int nIndex )
{
	if(nIndex < 0 || nIndex >= m_vtTabItemList.size())
		return;

	m_vtTabItemList[nIndex]->Disable();
	InvalidateWnd();
}


void KUITabControlBase::SetEnableTab( int nIndex )
{
	if(nIndex < 0 || nIndex >= m_vtTabItemList.size())
		return;

	m_vtTabItemList[nIndex]->Enable();
	InvalidateWnd();
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KUISimpleTabControl Implement
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace
{

	KUIWnd* Creator()
	{
		return new KUISimpleTabControl;
	}

	bool bTabRegister = KUIFactory::GetInstance()->RegisterCreator(Creator, "simple_tab" );

	const int TAB_ITEM_WIDTH_MARGIN = 38; // 탭이 사선으로 누워 있어서 사용 하는 듯.
}

KUISimpleTabControl::KUISimpleTabControl()
{
	for(int i = 0; i < 3; ++i)
		_registerSprite(&m_TabBackSprite[i]);
}

KUISimpleTabControl::~KUISimpleTabControl()
{
}

void KUISimpleTabControl::_initControl()
{

	KUITabControlBase::_initControl();

	for(int i = 0; i < 3; ++i)
	{
		m_TabBackSprite[i].SetRes( _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), i) );
	}

	_setBackSpriteRect( m_rcRegion);
}
KUITabItemControlBase* KUISimpleTabControl::_createItem(LPCSTR lpszCaption, LPCSTR lpszTip, int nIndex, LPCSTR lpszAniName,
														float fCorrSize)
{
	KUIWND_CREATE_ARG arg;
	arg.lpszClassName = "simple_tab_item";
	arg.rcRect = _getNextArea(nIndex);
	if( m_bDynamicTab )	arg.rcRect.right = arg.rcRect.left + (TAB_ITEM_WIDTH_MARGIN + KTextPhrase::GetOneLineStringSize( lpszCaption) ) * fCorrSize;
	else				arg.rcRect.right = arg.rcRect.left + ((GetRect().GetWidth())/m_nTabItemCount) * fCorrSize;
	arg.lpszCaption = lpszCaption;
	arg.lpszToolTip = lpszTip;
	arg.pParent = this;
	arg.lpszSprName = m_sSprName.c_str();
	arg.lpszID = lpszCaption;

	arg.lpszAniName = (lpszAniName != NULL) ? lpszAniName : m_sAniName.c_str();

	KUISimpleTabItemControl* pTabButton  = reinterpret_cast<KUISimpleTabItemControl*>( m_pManager->CreateControl(arg) );
	pTabButton->SetCorrectionRect( m_rcCorrectionRect );
	return pTabButton;
}
bool KUISimpleTabControl::ChangeTabName( int nIndex, const char* szName, const char* szTag /*= NULL*/ )
{
	for(int i = 0; i < static_cast<int>(m_vtTabItemList.size()); ++i)
	{
		KUISimpleTabItemControl* pItem = reinterpret_cast<KUISimpleTabItemControl*> ( m_vtTabItemList.at(i) );

		if( pItem && i == nIndex && !pItem->IsDisable() )
		{
			if( ::_stricmp( pItem->GetCaption(), szName ) == 0 )	return false;
			if( ::strlen( szName ) > TAB_NAME_MAX_LEN )	return false;

			if( szTag )
			{
				std::string strName = szTag;
				strName += szName;
				pItem->ChangeTabName( strName.c_str() );
			}
			else
				pItem->ChangeTabName( szName );

			return true;
		}
	}
	return false;
}


void KUISimpleTabControl::SetSelectedItem(DWORD dwSelected, bool bUpdate )
{
	if(dwSelected >= m_vtTabItemList.size() )
		return;

	if( dwSelected != m_dwSelectedItem || bUpdate )
	{
		reinterpret_cast<KUISimpleTabItemControl*>(m_vtTabItemList.at(m_dwSelectedItem))->OnStateChange(KTS_NORMAL);
		m_dwSelectedItem = dwSelected;
		reinterpret_cast<KUISimpleTabItemControl*>(m_vtTabItemList.at(m_dwSelectedItem))->OnStateChange(KTS_SELECTED);
	}
	InvalidateWnd();
}

void KUISimpleTabControl::_onTabItemChange()
{
    KRect rcRect = _getNextArea( (int)m_vtTabItemList.size() );
	rcRect.right = m_rcRegion.right;
	rcRect.bottom = m_rcRegion.bottom;
	_setBackSpriteRect(rcRect);
	InvalidateWnd();
}


void KUISimpleTabControl::_setBackSpriteRect(const KRect& rcRect)
{
	for(int i = 0; i < 3; ++i )
		m_TabBackSprite[i].SetRenderEnable(true);

	KResSprite* pFrameStart = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 0);
	KResSprite* pFrameCenter = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 1);
	KResSprite* pFrameEnd = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 2);

	if(m_dwStyle & KSTYLE_TAB_VERTICAL)
	{
		int nHeight = rcRect.GetHeight();
		int nMinimumsize = pFrameStart->GetSizeY() + pFrameCenter->GetSizeY() + pFrameEnd->GetSizeY();

		// 남아 있는 값이 더 작으면 아예 찍지를 말자 -_-
		if(nHeight < nMinimumsize)
		{
			for(int i = 0; i < 3; ++i )
				m_TabBackSprite[i].SetRenderEnable(false);
			return;
		}

		int nMidSize = nHeight  - pFrameStart->GetSizeY() - pFrameEnd->GetSizeY();

		m_TabBackSprite[0].SetPosition( rcRect.left, rcRect.top, m_fZPos);
		m_TabBackSprite[1].SetPosition( rcRect.left, rcRect.top + pFrameStart->GetSizeY(), m_fZPos );
		m_TabBackSprite[1].SetTargetSize( pFrameCenter->GetSizeX(), nMidSize);
		m_TabBackSprite[2].SetPosition( rcRect.left, m_rcRegion.bottom - pFrameEnd->GetSizeY() , m_fZPos);
	}
	else
	{
		int nWidth = rcRect.GetWidth();
		int nMinimumsize = pFrameStart->GetSizeX() + pFrameCenter->GetSizeX() + pFrameEnd->GetSizeX();

		// 남아 있는 값이 더 작으면 아예 찍지를 말자 -_-
		if(nWidth < nMinimumsize)
		{
			for(int i = 0; i < 3; ++i )
				m_TabBackSprite[i].SetRenderEnable(false);
			return;
		}

		int nMidSize = nWidth  - pFrameStart->GetSizeX() - pFrameEnd->GetSizeX();

		m_TabBackSprite[0].SetPosition( rcRect.left, rcRect.top, m_fZPos);
		m_TabBackSprite[1].SetPosition( rcRect.left + pFrameStart->GetSizeX() , rcRect.top , m_fZPos);
		m_TabBackSprite[1].SetTargetSize( nMidSize, pFrameCenter->GetSizeY() );
		m_TabBackSprite[2].SetPosition( rcRect.right - pFrameEnd->GetSizeX(), rcRect.top , m_fZPos);
	}
	InvalidateWnd();
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KUISimpleTabItemControl Implement
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace
{

	KUIWnd* TabItemCreator()
	{
		return new KUISimpleTabControl::KUISimpleTabItemControl;
	}

	bool bTabItemRegister = KUIFactory::GetInstance()->RegisterCreator(TabItemCreator, "simple_tab_item" );
}


KUISimpleTabControl::KUISimpleTabItemControl::KUISimpleTabItemControl()
{
	m_nTop = 0;
}

DWORD KUISimpleTabControl::KUISimpleTabItemControl::OnMouseMessage( DWORD dwMessage, int x, int y )
{
	DWORD dwRet = KUIControl::OnMouseMessage( dwMessage, x, y);

	if(KMR_NO_GET & dwRet)
		return dwRet;

	if( IsDisable() )
		return dwRet;

	if(IsInRect(x,y) )
	{
		switch(dwMessage) 
		{
		case KMOUSE_MOVE:
			if(m_dwState != KTS_SELECTED)
				OnStateChange( KTS_ON_MOUSE);
			break;
		case KLBUTTON_DOWN:
			if( m_dwState != KTS_SELECTED)
			{
				OnStateChange( KTS_SELECTED);
				PumpUpMessage(GetID(), KUI_MESSAGE::KTAB_CHANGE, reinterpret_cast<DWORD>( static_cast< KUIControl* >( this ) ),0);
			}
			break;
		default:
			break;
		}
	}
	else
	{
		if( m_dwState != KTS_SELECTED)
		{
			OnStateChange( KTS_NORMAL );
			m_rcCaptionArea.top -= 2;		// 텍스트 위치
		}
	}

	return dwRet;
}

//void KUITabControlBase::OnPosChangeNofity(int XOffset, int YOffset)
//{
//	KUITabItemControlBase * p = NULL;
//	int size = m_vtTabItemList.size();
//	for( int i=0; i<size; ++i )
//	{
//		p = m_vtTabItemList[ i ];
//		if( p )
//		{
//			p->MovePosOffset( XOffset, YOffset );
//		}
//	}
//	
//	KUIControl::OnPosChangeNofity(XOffset, YOffset);
//
//}

void KUITabControlBase::OnChangeCaptionNotify()
{
	size_t cpos = 0;
	while( ( cpos = m_sCaption.find( "<#" ) ) != m_sCaption.npos )
	{
		m_sCaption.erase( cpos, 9 );
	}

	std::string strNewCaption = IsDisable() ? m_strDisableColor.c_str() : m_strEnableColor.c_str();
	strNewCaption += m_sCaption;
	m_sCaption = strNewCaption;
	
	UpdateCaption();

	KUIWnd::OnChangeCaptionNotify();
}
void KUISimpleTabControl::KUISimpleTabItemControl::OnStateChange(DWORD dwState, bool bUpdate )
{
	/*if( dwState == m_dwState && !bUpdate )
		return;*/

	KUITabItemControlBase::OnStateChange(dwState);
	
	if(m_dwState >= KTS_TOTAL)
	{
		assert(false && "invalid Tab State");
		return;
	}
	// MJ 2004/12/20 텍스트 위치
	switch(dwState)
	{
	case KTS_ON_MOUSE:
	case KTS_SELECTED:
		{
			m_rcCaptionArea.left = m_rcRegion.left;
			m_rcCaptionArea.top = m_rcRegion.top;
			SetCaption( m_sCaption.c_str() );
		}
		break;
	default:
		{
			m_rcCaptionArea.left = m_rcRegion.left - 4;
			m_rcCaptionArea.top = m_rcRegion.top + 4;
			SetCaption( m_sCaption.c_str() );
		}
		break;
	}

	_disableAllSprite();
	for(int i = 0 ; i < 3; ++i)
		m_SelectSprite[m_dwState][i].SetRenderEnable(true);

	InvalidateWnd();
}
void KUISimpleTabControl::KUISimpleTabItemControl::_initControl()
{
	if( m_sAniName.empty() )
	{
		m_rcCaptionArea = m_rcRegion;
		return;
	}
	KResSprite* pFrameLeft =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 0 );
	KResSprite* pFrameCenter =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 1 );
	KResSprite* pFrameRight =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 2 );

	if( !pFrameLeft || !pFrameCenter || !pFrameRight )
	{
		assert( false && "Cannot find Sprite Res Frame" ); 
		return;
	}

	int nMinimunSize = pFrameLeft->GetSizeX() + pFrameRight->GetSizeX() + pFrameCenter->GetSizeX();
	
	if ( m_rcRegion.GetWidth() < nMinimunSize)
		m_rcRegion.right = m_rcRegion.left + nMinimunSize;

	m_rcRegion.bottom = m_rcRegion.top + pFrameLeft->GetSizeY();

	for( int i = 0; i < KTS_TOTAL; ++i ) 
	{
		for ( int j = 0 ; j<3 ; ++j )
		{
			KResSprite* pFrame = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), i*3 + j );

			if(!pFrame)	
				continue;

			m_SelectSprite[i][j].SetRes( pFrame );

			switch( j )
			{
			case 0:	
				m_SelectSprite[i][j].SetPosition( m_rcRegion.left, m_rcRegion.top, m_fZPos ); 
				break;
			case 1:
				m_SelectSprite[i][j].SetPosition( pFrameLeft->GetSizeX() + m_rcRegion.left, m_rcRegion.top, m_fZPos );
				m_SelectSprite[i][j].SetTargetSize( m_rcRegion.GetWidth() - pFrameLeft->GetSizeX() - pFrameRight->GetSizeX(),
					pFrameCenter->GetSizeY() );
				break;
			case 2:
				m_SelectSprite[i][j].SetPosition( m_rcRegion.left + m_rcRegion.GetWidth() - pFrameRight->GetSizeX(),
					m_rcRegion.top, m_fZPos );
				break;
			}
			_registerSprite(&m_SelectSprite[i][j]);
		}
	}

	m_rcCaptionArea = m_rcRegion;
	m_rcCaptionArea.top += 2;
	m_rcCaptionArea.left -= 4;

	SetCaptionAlign( KTextRender::KTALIGN_HCENTER | KTextRender::KTALIGN_VCENTER );
	UpdateCaption();
	OnStateChange(KTS_NORMAL);
}

void KUISimpleTabControl::KUISimpleTabItemControl::_disableAllSprite()
{
	for(int i = 0 ; i <	KTS_TOTAL; ++i)
	{
		for(int  k = 0; k < 3; ++k)
			m_SelectSprite[i][k].SetRenderEnable(false);
	}
	InvalidateWnd();
}

void KUISimpleTabControl::KUISimpleTabItemControl::ChangeTabName( const char* szName )
{
	SetCaption( szName );
	SetTooltip( szName );

	SetCaptionAlign( KTextRender::KTALIGN_HCENTER | KTextRender::KTALIGN_VCENTER );
	UpdateCaption();
	OnStateChange( GetState(), true );
	InvalidateWnd();
}

// 2010.06.15. bintitle. 탭컨트롤 Sprite 변경.	
void KUISimpleTabControl::KUISimpleTabItemControl::UpdateBack()
{
	if( m_sAniName.empty() )
	{		
		return;
	}
	KResSprite* pFrameLeft =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 0 );
	KResSprite* pFrameCenter =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 1 );
	KResSprite* pFrameRight =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 2 );

	if( !pFrameLeft || !pFrameCenter || !pFrameRight )
	{		
		return;
	}

	int nMinimunSize = pFrameLeft->GetSizeX() + pFrameRight->GetSizeX() + pFrameCenter->GetSizeX();
	
	if ( m_rcRegion.GetWidth() < nMinimunSize)
		m_rcRegion.right = m_rcRegion.left + nMinimunSize;

	m_rcRegion.bottom = m_rcRegion.top + pFrameLeft->GetSizeY();

	for( int i = 0; i < KTS_TOTAL; ++i ) 
	{
		for ( int j = 0 ; j<3 ; ++j )
		{
			KResSprite* pFrame = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), i*3 + j );

			if(!pFrame)	
				continue;

			m_SelectSprite[i][j].SetRes( pFrame );			
		}
	}

//	KUIControl::UpdateBack();
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KUIDetailTabControl Implement
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace
{

	KUIWnd* DetailTabCreator()
	{
		return new KUIDetailTabControl;
	}

	bool bDetailTabRegister = KUIFactory::GetInstance()->RegisterCreator(DetailTabCreator, "detail_tab" );
}


KUIDetailTabControl::KUIDetailTabControl()
{
}
KUIDetailTabControl::~KUIDetailTabControl()
{
}

KUITabItemControlBase* KUIDetailTabControl::_createItem(LPCSTR lpszCaption,  LPCSTR lpszTip, int nIndex, LPCSTR lpszAniName,
														float fCorrSize)
{
	KUIWND_CREATE_ARG arg;
	arg.lpszClassName = "detail_tab_item";
	arg.rcRect = _getNextArea(nIndex);
	arg.lpszToolTip = lpszTip;
	arg.pParent = this;
	arg.lpszSprName = m_sSprName.c_str();
	arg.lpszID = lpszCaption;

	arg.lpszAniName = (lpszAniName != NULL) ? lpszAniName : m_sAniName.c_str();

	KUIDetailTabItemControl* pTabButton  = reinterpret_cast<KUIDetailTabItemControl*>( m_pManager->CreateControl(arg) );
	pTabButton->SetCorrectionRect( m_rcCorrectionRect );
	return pTabButton;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KUIDetailTabItemControl Implement
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace
{

	KUIWnd* DetailItemCreator()
	{
		return new KUIDetailTabControl::KUIDetailTabItemControl;
	}

	bool bDetailTabItemRegister = KUIFactory::GetInstance()->RegisterCreator(DetailItemCreator, "detail_tab_item" );
}

KUIDetailTabControl::KUIDetailTabItemControl::KUIDetailTabItemControl()
{
}

void KUIDetailTabControl::KUIDetailTabItemControl::OnStateChange(DWORD dwState)
{
	if( dwState == m_dwState)
		return;

	KUITabItemControlBase::OnStateChange(dwState);

	if(m_dwState >= KTS_TOTAL)
	{
		assert(false && "invalid Tab State");
		return;
	}

	_disableAllSprite();
    m_SelectSprite[m_dwState].SetRenderEnable(true);
	InvalidateWnd();
}
void KUIDetailTabControl::KUIDetailTabItemControl::_initControl()
{
	if( m_sAniName.empty() )
	{
		m_rcCaptionArea = m_rcRegion;
		return;
	}
	KResSprite* pFrame = _getSpriteSet()->GetSpriteRes(m_sAniName.c_str(),0);

	if( !pFrame )
	{
		assert( false && "Cannot find Sprite Res Frame" ); 
		return;
	}

	m_rcRegion.right = m_rcRegion.left + pFrame->GetSizeX();
	m_rcRegion.bottom = m_rcRegion.top + pFrame->GetSizeY();
	for( int i = 0; i < KTS_TOTAL; ++i ) 
	{
		KResSprite* pFrame = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), i );

		if(!pFrame)
		{
			continue;
		}

		m_SelectSprite[i].SetRes( pFrame );
		m_SelectSprite[i].SetPosition( m_rcRegion.left, m_rcRegion.top, m_fZPos );
		_registerSprite(&m_SelectSprite[i]);
	}

	m_rcCaptionArea = m_rcRegion;

	UpdateCaption();

	OnStateChange(KTS_NORMAL);
}
void KUIDetailTabControl::KUIDetailTabItemControl::_disableAllSprite()
{
	for(int i = 0 ; i <	KTS_TOTAL; ++i)
	{
		m_SelectSprite[i].SetRenderEnable(false);
	}
	InvalidateWnd();
}


/////////////// New Tab /////////////

namespace
{
	KUIWnd* TabSheetCreator()
	{
		return new KUITabControlSheet;
	}

	bool bTabSheetRegister = KUIFactory::GetInstance()->RegisterCreator(TabSheetCreator, "tab_sheet" );

	//const int TAB_ITEM_WIDTH_MARGIN = 38; // 탭이 사선으로 누워 있어서 사용 하는 듯.
}

KUITabControlSheet::KUITabControlSheet()
{
	for( int i=0 ; i<3 ; ++i )
	{	_registerSprite(&m_TabBackSprite[i] ); }
}

KUITabControlSheet::~KUITabControlSheet()
{
}

void KUITabControlSheet::_initControl()
{
	SetTabProperty(0, true, 2);
	KUITabControlBase::_initControl();

	for(int i = 0; i < 3; ++i)
	{
		m_TabBackSprite[i].SetRes( _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), i) );
	}

	_setBackSpriteRect( m_rcRegion);
	//this->AddTabHead( "<size:10>전체","","button_common");
	//this->AddTabHead( "teachme","","button_common");
}

KUITabItemControlBase* KUITabControlSheet::_createItem(LPCSTR lpszCaption,  LPCSTR lpszTip, int nIndex, LPCSTR lpszAniName,
														float fCorrSize)
{
	KUIWND_CREATE_ARG arg;
	arg.lpszClassName = "button";
	arg.rcRect = _getNextArea(nIndex);
	arg.lpszToolTip = lpszTip;
	arg.pParent = this;
	arg.lpszSprName = m_sSprName.c_str();
	arg.lpszID = lpszCaption;

	arg.lpszAniName = (lpszAniName != NULL) ? lpszAniName : m_sAniName.c_str();

	KUITabItemControlBase* pTabHead  = reinterpret_cast<KUITabItemControlBase*>( m_pManager->CreateControl(arg) );
	pTabHead->SetCorrectionRect( m_rcCorrectionRect );
	return pTabHead;
}

KUITabControlHead* KUITabControlSheet::CreateHead(LPCSTR lpszCaption,  LPCSTR lpszTip, int nIndex, LPCSTR lpszAniName,
													float fCorrSize)
{
	KUIWND_CREATE_ARG arg;
	arg.lpszClassName = "tab_head";
	arg.rcRect = _getNextArea(nIndex);
	arg.lpszToolTip = lpszTip;
	arg.pParent = this;
	arg.lpszSprName = m_sSprName.c_str();
	arg.lpszID = lpszCaption;

	arg.lpszAniName = (lpszAniName != NULL) ? lpszAniName : m_sAniName.c_str();

	KUITabControlHead* pTabHead  = reinterpret_cast<KUITabControlHead*>( m_pManager->CreateControl(arg) );
	pTabHead->SetCorrectionRect( m_rcCorrectionRect );
	return pTabHead;
}

void KUITabControlSheet::_onTabItemChange()
{
	KRect rcRect = _getNextArea( (int)m_vtTabItemList.size() );
	rcRect.right = m_rcRegion.right;
	rcRect.bottom = m_rcRegion.bottom;
	_setBackSpriteRect(rcRect);
	InvalidateWnd();
}

void KUITabControlSheet::_setBackSpriteRect( const KRect& rcRect )
{
	for(int i = 0; i < 3; ++i )
		m_TabBackSprite[i].SetRenderEnable(true);

	KResSprite* pFrameStart = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 0);
	KResSprite* pFrameCenter = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 1);
	KResSprite* pFrameEnd = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 2);

	if(m_dwStyle & KSTYLE_TAB_VERTICAL)
	{
		int nHeight = rcRect.GetHeight();
		int nMinimumsize = pFrameStart->GetSizeY() + pFrameCenter->GetSizeY() + pFrameEnd->GetSizeY();

		// 남아 있는 값이 더 작으면 아예 찍지를 말자 -_-
		if(nHeight < nMinimumsize)
		{
			for(int i = 0; i < 3; ++i )
				m_TabBackSprite[i].SetRenderEnable(false);
			return;
		}

		int nMidSize = nHeight  - pFrameStart->GetSizeY() - pFrameEnd->GetSizeY();

		m_TabBackSprite[0].SetPosition( rcRect.left, rcRect.top, m_fZPos);
		m_TabBackSprite[1].SetPosition( rcRect.left, rcRect.top + pFrameStart->GetSizeY(), m_fZPos );
		m_TabBackSprite[1].SetTargetSize( pFrameCenter->GetSizeX(), nMidSize);
		m_TabBackSprite[2].SetPosition( rcRect.left, m_rcRegion.bottom - pFrameEnd->GetSizeY() , m_fZPos);
	}
	else
	{
		int nWidth = rcRect.GetWidth();
		int nMinimumsize = pFrameStart->GetSizeX() + pFrameCenter->GetSizeX() + pFrameEnd->GetSizeX();

		// 남아 있는 값이 더 작으면 아예 찍지를 말자 -_-
		if(nWidth < nMinimumsize)
		{
			for(int i = 0; i < 3; ++i )
				m_TabBackSprite[i].SetRenderEnable(false);
			return;
		}

		int nMidSize = nWidth  - pFrameStart->GetSizeX() - pFrameEnd->GetSizeX();

		m_TabBackSprite[0].SetPosition( rcRect.left, rcRect.top, m_fZPos);
		m_TabBackSprite[1].SetPosition( rcRect.left + pFrameStart->GetSizeX() , rcRect.top , m_fZPos);
		m_TabBackSprite[1].SetTargetSize( nMidSize, pFrameCenter->GetSizeY() );
		m_TabBackSprite[2].SetPosition( rcRect.right - pFrameEnd->GetSizeX(), rcRect.top , m_fZPos);
	}
	InvalidateWnd();	
}

//void KUITabControlSheet::AddTabHead(LPCSTR lpszCaption, LPCSTR lpszTip, LPCSTR lpszAniName, float fSizeCorr, const char * pStrColor )
//{
//	// uii에서 설정한 Animation Name으로 Button 설정 
//
//	KUITabControlHead* pTabButton = CreateHead(lpszCaption, lpszTip, (int)m_vtTabHeadList.size(), lpszAniName, 
//		fSizeCorr);
//
//	pTabButton->SetEnableColor( "<#ffffff>" ); // 추가. bintitle. 2010.04.27
//	if( pStrColor )
//		pTabButton->SetDisableColor( pStrColor );
//	pTabButton->Enable();
//	//	else
//	//		pTabButton->SetDisableColor( m_strDisableColor.c_str() );
//
//
//	m_vtTabHeadList.push_back(pTabButton);
//
//	if(m_vtTabHeadList.size() == 1)
//	{
//		m_dwSelectedItem = 0;
//		m_vtTabHeadList.at(0)->OnStateChange(KTS_SELECTED);
//		SetSelectedItem(0, true);
//	}
//	else
//	{
//		m_vtTabHeadList.at(m_vtTabHeadList.size() - 1)->OnStateChange(KTS_NORMAL);
//	}
//
//	// Back도 줄 맞춘다.
//	_onTabItemChange();
//	InvalidateWnd();
//}

void KUITabControlSheet::PumpUpMessage( LPCSTR lpszControlID, DWORD dwMessage, DWORD lparam, DWORD wparam )
{
	switch(dwMessage) 
	{
	case KUI_MESSAGE::KTAB_CHANGE:
		{
			KUITabControlHead* pItem = static_cast< KUITabControlHead* >( reinterpret_cast<KUIControl*>( lparam	) );

			if(!pItem)
				return;

			int nIndex = -1;
			for(int i = 0; i < m_vtTabHeadList.size(); ++i)
			{
				if( m_vtTabHeadList.at(i) == pItem)
				{
					nIndex = i;
					break;
				}
			}
			SetSelectHead(nIndex);
		}
		break;
	default:
		break;
	}
}

// 2010. 12. 20 - marine
// 탭헤드 선택 함수
void KUITabControlSheet::SetSelectHead(int nIndex)
{
	if ( ( nIndex<m_vtTabHeadList.size() ) && (nIndex >= 0))
	{
		m_vtTabHeadList.at(m_dwSelectedItem)->OnStateChange(KTS_NORMAL);
		m_pParent->PumpUpMessage(GetID(), KUI_MESSAGE::KTAB_CHANGE, m_dwSelectedItem,0);
		m_dwSelectedItem = nIndex;
		m_pParent->PumpUpMessage(GetID(), KUI_MESSAGE::KTAB_SELECT, m_dwSelectedItem,0);

		for(int i=0 ; i< m_vtTabHeadList.size() ; ++i)
		{
			if( i == nIndex )
			{
				m_vtTabHeadList.at(i)->OnStateChange(KTS_SELECTED);
				m_vtTabHeadList.at(i)->SetHeadState(KUITabControlHeadBase::KTAB_DOWN_O);

				SetFontColor( true, i);
			}
			else
			{
				m_vtTabHeadList.at(i)->OnStateChange(KTS_NORMAL);
				m_vtTabHeadList.at(i)->SetHeadState(KUITabControlHeadBase::KTAB_NORMAL_O);
				SetFontColor( false, i);
			}				
		}
	}
}

void KUITabControlSheet::SetFontColor( bool bSelected, int iHeadindex )
{
	std::string strCaption = m_vtTabHeadList.at(iHeadindex)->GetCaption();
	if(strCaption.empty()) return;

	std::string strNewCaption = (bSelected)? m_vtTabHeadList.at(iHeadindex)->GetFontColorSel() : m_vtTabHeadList.at(iHeadindex)->GetFontColorNoSel();
	
	m_vtTabHeadList.at(iHeadindex)->SetEnableColor(strNewCaption.c_str());
	
	size_t cpos = 0;
	while( ( cpos = strCaption.find( "<#" ) ) != strCaption.npos )
	{
		strCaption.erase( cpos, 9 );
	}

	strNewCaption += strCaption;
	m_vtTabHeadList.at(iHeadindex)->SetCaption(strNewCaption.c_str());	
}

namespace
{
	KUIWnd* TabHeadCreator()
	{
		KUITabControlHeadBase *Temp = new KUITabControlHead;
		return Temp;
	}

	bool bTabHeadRegister = KUIFactory::GetInstance()->RegisterCreator(TabHeadCreator, "tab_head" );
}

// 2010. 12. 1 - marine
// sheet 이름과 color 지정
void KUITabControlHeadBase::DivideSheetName()
{
	std::string buf =  m_sAniName;

	size_t iEnd,iStart = 0;

	// aniname 설정
	iEnd = buf.find("/");
	if(iEnd != -1)
	{
		m_sAniName = buf.substr(iStart,iEnd);
	}
	else
	{
		list<KUIWnd*> ChildList = GetParent()->GetChildList();

		list<KUIWnd*>::iterator It;
		list<KUIWnd*>::iterator startIt = ChildList.begin();
		list<KUIWnd*>::iterator endIt = ChildList.end();
		for( It = startIt ; It != endIt ; ++It )
		{
			std::string strClassName = (*It)->GetClassName();
			if(strClassName.compare("tab_sheet") == 0)
			{
				m_strSheet = (*It)->GetID();				
			}
		}
	}

	// sheet 이름 분리
	iEnd = iStart = 0;
	iStart = buf.find("/");
	iEnd = buf.find("<")-1;
	if(iEnd != -1 && iStart != -1)
		m_strSheet = buf.substr(iStart+1, iEnd-iStart);

	// color 분리
	iStart = 0;
	iStart = buf.find("<");
	iEnd = buf.find(">")+1;
	if(iEnd != -1 && iStart != -1)
		m_strFontColorNoSel = buf.substr(iStart, iEnd-iStart);	
}

KUITabControlHead::KUITabControlHead()
{
	m_dwState = KTS_NORMAL;
	SetHeadState( KTAB_NORMAL_S );

	m_bLeftButton = false;
	m_bIsInit = false;

	for(int i = 0; i < KTAB_HEAD_MAX; ++i)
	{
		for(int k = 0; k < 3; ++k)
		{
			_registerSprite( &m_HeadSprite[i][k]);
		}
	}
}

void KUITabControlHead::_initControl()
{
	if( m_sAniName.empty() )
	{
		m_rcCaptionArea = m_rcRegion;
		return;
	}

	DivideSheetName();

	if( m_dwStyle  & KSTYLE_BUTTON_VERTICAL)
	{
		_initVertical();
	}
	else
	{
		_initHorizontal();
	}

	m_rcCaptionArea = m_rcRegion;
	SetCaptionAlign( KTextRender::KTALIGN_HCENTER | KTextRender::KTALIGN_VCENTER );
	UpdateCaption();

	// 2010. 11. 1 - marine
	// 이 컨트롤의 부모 컨트롤이 갖고 있는 ChildList 중에서
	// tab_sheet 이면서 이 컨트롤이 갖고 있는 sheet ID와 일치 하는
	// 컨트롤 을 찾아 낸다.
	// 찾아낸 sheet 의 벡터에 이 컨트롤을 등록하고
	// 이 컨트롤이 등록된 sheet 의 포인터를 갖는다.
	if(m_bIsInit == false)
	{
		list<KUIWnd*> ChildList = GetParent()->GetChildList();

		list<KUIWnd*>::iterator It;
		list<KUIWnd*>::iterator startIt = ChildList.begin();
		list<KUIWnd*>::iterator endIt = ChildList.end();
		for( It = startIt ; It != endIt ; ++It )
		{
			std::string strClassName = (*It)->GetClassName();
			if(strClassName.compare("tab_sheet") == 0)
			{
				std::string strID = (*It)->GetID();
				if( strID.compare(m_strSheet) == 0)
				{
					KUITabControlSheet* pSheet = (KUITabControlSheet *)(*It);
					SetMyNum(pSheet->GetHeadNum());
					pSheet->RegistHead( this );
					RegisterSheet( pSheet );

					std::string strCaption = this->GetCaption();
					if(!strCaption.empty())
					{
						size_t cpos = strCaption.find( "<#" );
						if(cpos != -1)
							m_strFontColorSel = strCaption.substr( cpos, 9 );
					}

					// 2010. 11. 8 - marine
					// 일단은 첫 번째로 읽어오는 탭버튼이 선택되게 만든다.
					// 하지만 툴에서 만들 때 처음 만든 탭버튼이 처음 만든 놈이 아닐 수 있으므로
					// 별도로 지정을 해줘야 할듯.
					if(pSheet->GetHeadNum() == 1)
					{
						this->OnStateChange(KTS_SELECTED);
						SetHeadState(KTAB_NORMAL_S);
					}
					else
					{
						this->OnStateChange(KTS_NORMAL);
						SetHeadState(KTAB_NORMAL_O);
					}
					m_bIsInit = true;
				}
			}
		}
	}
	// 2010. 12. 1 - marine 
	// 폰트의 색이 선택된 헤드인지 아닌지에 따라 다른데
	// 초기화 할때 해줘야 한다. 위치는 여기가 적당한듯
	SetInitFont();
}

void KUITabControlHead::_destroyControl()
{
	KUIControl::_destroyControl();

	for( int i = 0; i < KTAB_HEAD_MAX; ++i ) 
	{
		for( int j=0 ; j< 3 ; ++i )
			m_HeadSprite[i][j].SetRes( NULL );
	}
}

DWORD KUITabControlHead::OnMouseMessage(DWORD dwMessage, int x, int y)
{
	DWORD dwRet = KUIControl::OnMouseMessage(dwMessage,x,y);

	if(KMR_NO_GET & dwRet)
		return dwRet;

	if( IsDisable() ) return dwRet;

	if( m_pCaptionPhrase && m_dwHeadState != KTAB_DOWN_S && m_dwHeadState != KTAB_DOWN_O)
		m_pCaptionPhrase->SetPosition(m_rcCaptionArea.left, m_rcCaptionArea.top, m_fZPos);


	DWORD dwIsSelected = 0;
	if(GetState() != KTS_SELECTED)
		dwIsSelected = 1;

	if(IsInRect(x, y))
	{
		switch(dwMessage) 
		{
		case KMOUSE_MOVE:
			{
				if(m_dwHeadState != KTAB_DOWN_S && m_dwHeadState != KTAB_DOWN_O)
				{
					if ( m_bLeftButton )
					{
						//SetHeadState( KBUTTON_DOWN + 3*dwIsSelected);
						if(dwIsSelected)
							SetHeadState( KTAB_DOWN_S );
						else
							SetHeadState( KTAB_DOWN_O );
					}
						
					else SetHeadState( KTAB_ACTIVATE_S + KTAB_SET_NUM*dwIsSelected );
				} 
			}
			break;
		case KLBUTTON_DOWN:
			{
				//if( m_pCaptionPhrase )	m_pCaptionPhrase->SetPosition(m_rcCaptionArea.left, m_rcCaptionArea.top+2, m_fZPos);

				m_bLeftButton = true;
				SetHeadState( KTAB_DOWN_S + KTAB_SET_NUM*dwIsSelected);
				PumpUpMessage(GetID(), KUI_MESSAGE::KTAB_CHANGE, GetMyNum(),0);
			}
			break;
		case KLBUTTON_UP:
			{
				m_bLeftButton = false;

				if(m_dwHeadState == KTAB_DOWN_S || m_dwHeadState == KTAB_DOWN_O)
					PumpUpMessage(GetID(), KUI_MESSAGE::KBUTTON_CLICK, GetMyNum(),0);

				SetHeadState( KTAB_ACTIVATE_S + KTAB_SET_NUM*dwIsSelected);
			}
			break;
		default:
			break;
		}

	}
	else
	{
		if ( dwMessage == KLBUTTON_UP )
		{
			m_bLeftButton = false;
			m_pManager->ReleaseCapture( this );
		}
		// 마우스 범위를 벗어나면 Normal로 돌린다. 
		if(m_dwHeadState == KTAB_ACTIVATE_S || m_dwHeadState == KTAB_DOWN_S ||
			m_dwHeadState == KTAB_ACTIVATE_O || m_dwHeadState == KTAB_DOWN_O)
			SetHeadState( KTAB_NORMAL_S + KTAB_SET_NUM*dwIsSelected);
	}
	
	dwRet = OnMouseMessageEx(dwMessage, x, y, dwRet);

	return dwRet;
}

DWORD KUITabControlHeadBase::OnMouseMessageEx(DWORD dwMessage, int x, int y, DWORD dwRet)
{
	if(KMR_NO_GET & dwRet)
		return dwRet;

	if( IsDisable() )
		return dwRet;

	if(IsInRect(x,y) )
	{
		switch(dwMessage) 
		{
		case KMOUSE_MOVE:
			if(m_dwState != KTS_SELECTED)
				OnStateChange( KTS_ON_MOUSE);
			break;
		case KLBUTTON_DOWN:
			if( m_dwState != KTS_SELECTED)
			{
				// 버튼이 선택됐을때 다른 버튼들을 뒤로 빼줘야 한다. 여기서 처리
				OnStateChange( KTS_SELECTED);
				if(m_pSheet)
					m_pSheet->PumpUpMessage(GetID(), KUI_MESSAGE::KTAB_CHANGE, reinterpret_cast<DWORD>( static_cast< KUIControl* >( this ) ),0);
			}
			break;
		default:
			break;
		}
	}
	else
	{
		if( m_dwState != KTS_SELECTED)
		{
			OnStateChange( KTS_NORMAL);
			//m_rcCaptionArea.top -= 2;		// 텍스트 위치
		}
	}

	return dwRet;
}

void KUITabControlHead::OnChangeCaptionNotify()
{
	if( !IsDisable() )
	{	
		size_t cpos = 0;
		while( ( cpos = m_sCaption.find( "<#" ) ) != m_sCaption.npos )
		{
			m_sCaption.erase( cpos, 9 );
		}

		std::string strNewCaption = m_strEnableColor.c_str();
		strNewCaption += m_sCaption;
		m_sCaption = strNewCaption;
	}

	KUIControl::OnChangeCaptionNotify();
}

DWORD KUITabControlHead::OnKeyMessage(DWORD dwMessage, DWORD dwKeyCode)
{
	return KUIControl::OnKeyMessage(dwMessage, dwKeyCode);
}

void KUITabControlHead::Render(KViewportObject * pViewport, bool isFront )
{
	if ( m_bShowFlag )
	{
		// { 땜빵
		int nSprite = m_dwHeadState;
		if( IsDisable() )
		{
			if(GetState() < KTAB_NORMAL_O)
				nSprite = KTAB_DISABLE_S;
			else
				nSprite = KTAB_DISABLE_O;
		}
		// } 

		if ( !(m_dwStyle & KSTYLE_BUTTON_LEFTSIDE) )
			pViewport->Register( &m_HeadSprite[nSprite][0], isFront );
		
		pViewport->Register( &m_HeadSprite[nSprite][1], isFront );

		if ( !(m_dwStyle & KSTYLE_BUTTON_RIGHTSIDE) )
			pViewport->Register( &m_HeadSprite[nSprite][2], isFront );

		// Caption Render
		_renderCaption(pViewport, isFront);

		// ToolTip Render
#ifndef _KUI_INVALIDATION
		_renderToolTip(pViewport, isFront);
#endif
	}
}


int KUITabControlHeadBase::GetButtonWidth()
{
	KResSprite* pResSprite = _getSpriteSet()->GetSpriteRes(m_sAniName.c_str(),0);

	if(!pResSprite)	
		return 0;

	return pResSprite->GetSizeX();
}

void KUITabControlHead::_initHorizontal()
{
	KResSprite* pFrameLeft =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 0 );
	KResSprite* pFrameCenter =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 1 );
	KResSprite* pFrameRight =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 2 );

	if( !pFrameLeft || !pFrameRight )
	{
		assert( false && "Cannot find Sprite Res Frame" ); 
		return;
	}


	int nMinWidth = pFrameLeft->GetSizeX() + pFrameRight->GetSizeX() + pFrameCenter->GetSizeX();
	if ( m_rcRegion.GetWidth() < nMinWidth )
		m_rcRegion.right = m_rcRegion.left + nMinWidth;

	m_rcRegion.bottom = m_rcRegion.top + pFrameLeft->GetSizeY();

	for( int i = 0; i < KTAB_HEAD_MAX; ++i ) 
	{
		for ( int j = 0 ; j<3 ; ++j )
		{
			KResSprite* pFrame = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), i*3 + j );

			if(!pFrame)	continue;

			m_HeadSprite[i][j].SetRes( pFrame );
			if ( m_dwStyle & KSTYLE_BUTTON_LEFTSIDE )
			{
				switch( j )
				{
				case 0:	break;
				case 1:
					m_HeadSprite[i][j].SetPosition( m_rcRegion.left, m_rcRegion.top, m_fZPos );
					m_HeadSprite[i][j].SetTargetSize( m_rcRegion.GetWidth() - pFrameRight->GetSizeX(),
						pFrameCenter->GetSizeY() );
					break;
				case 2:
					m_HeadSprite[i][j].SetPosition( m_rcRegion.left + m_rcRegion.GetWidth() - pFrameRight->GetSizeX(),
						m_rcRegion.top, m_fZPos );
					break;
				}
			}
			else if ( m_dwStyle & KSTYLE_BUTTON_RIGHTSIDE )
			{
				switch( j )
				{
				case 0:	m_HeadSprite[i][j].SetPosition( m_rcRegion.left, m_rcRegion.top, m_fZPos ); break;
				case 1:
					m_HeadSprite[i][j].SetPosition( pFrameLeft->GetSizeX() + m_rcRegion.left, m_rcRegion.top, m_fZPos );
					m_HeadSprite[i][j].SetTargetSize( m_rcRegion.GetWidth() - pFrameLeft->GetSizeX(),
						pFrameCenter->GetSizeY() );
					break;
				case 2:
					break;
				}
			}
			else
			{
				switch( j )
				{
				case 0:	m_HeadSprite[i][j].SetPosition( m_rcRegion.left, m_rcRegion.top, m_fZPos ); break;
				case 1:
					m_HeadSprite[i][j].SetPosition( pFrameLeft->GetSizeX() + m_rcRegion.left, m_rcRegion.top, m_fZPos );
					m_HeadSprite[i][j].SetTargetSize( m_rcRegion.GetWidth() - pFrameLeft->GetSizeX() - pFrameRight->GetSizeX(),
						pFrameCenter->GetSizeY() );
					break;
				case 2:
					m_HeadSprite[i][j].SetPosition( m_rcRegion.left + m_rcRegion.GetWidth() - pFrameRight->GetSizeX(),
						m_rcRegion.top, m_fZPos );
					break;
				}
			}
		}
	}
}
void KUITabControlHead::_initVertical()
{
	KResSprite* pFrameTop =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 0 );
	KResSprite* pFrameCenter =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 1 );
	KResSprite* pFrameBottom =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 2 );

	if( !pFrameTop || !pFrameBottom )
	{
		assert( false && "Cannot find Sprite Res Frame" ); 
		return;
	}


	int nMinHeight = pFrameTop->GetSizeY() + pFrameBottom->GetSizeY() + pFrameCenter->GetSizeY();

	if ( m_rcRegion.GetHeight() < nMinHeight )
		m_rcRegion.bottom = m_rcRegion.top + nMinHeight;

	m_rcRegion.right = m_rcRegion.left + pFrameTop->GetSizeX();

	for( int i = 0; i < KTAB_HEAD_MAX; ++i ) 
	{
		for ( int j = 0 ; j<3 ; ++j )
		{
			KResSprite* pFrame = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), i*3 + j );

			if(!pFrame)	continue;

			m_HeadSprite[i][j].SetRes( pFrame );
			switch( j )
			{
			case 0:	
				m_HeadSprite[i][j].SetPosition( m_rcRegion.left, m_rcRegion.top, m_fZPos );
				break;
			case 1:
				m_HeadSprite[i][j].SetPosition( m_rcRegion.left, pFrameTop->GetSizeY() + m_rcRegion.top, m_fZPos );
				m_HeadSprite[i][j].SetTargetSize( pFrameCenter->GetSizeX(), 
					m_rcRegion.GetHeight() - pFrameTop->GetSizeY() - pFrameBottom->GetSizeY());
				break;
			case 2:
				m_HeadSprite[i][j].SetPosition( m_rcRegion.left, 
					m_rcRegion.top + m_rcRegion.GetHeight() - pFrameBottom->GetSizeY(),	m_fZPos );
				break;
			}
		}
	}
}

void KUITabControlHead::UpdateBack()
{
	if( m_sAniName.empty() )
	{		
		return;
	}
	KResSprite* pFrameLeft =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 0 );
	KResSprite* pFrameCenter =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 1 );
	KResSprite* pFrameRight =	_getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 2 );

	if( !pFrameLeft || !pFrameCenter || !pFrameRight )
	{		
		return;
	}

	int nMinimunSize = pFrameLeft->GetSizeX() + pFrameRight->GetSizeX() + pFrameCenter->GetSizeX();

	if ( m_rcRegion.GetWidth() < nMinimunSize)
		m_rcRegion.right = m_rcRegion.left + nMinimunSize;

	m_rcRegion.bottom = m_rcRegion.top + pFrameLeft->GetSizeY();

	for( int i = 0; i < KTAB_HEAD_MAX; ++i ) 
	{
		for ( int j = 0 ; j<3 ; ++j )
		{
			KResSprite* pFrame = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), i*3 + j );

			if(!pFrame)	
				continue;

			m_HeadSprite[i][j].SetRes( pFrame );			
		}
	}

}

namespace
{
	KUIWnd* TabSimpleHeadCreator()
	{
		KUITabControlHeadBase *Temp = new KUITabControlSimpleHead;
		return Temp;
	}

	bool bTabSimpleHeadRegister = KUIFactory::GetInstance()->RegisterCreator(TabSimpleHeadCreator, "tab_simple_head" );
}

KUITabControlSimpleHead::KUITabControlSimpleHead()
{
	m_dwState = KTS_NORMAL;

	SetHeadState( KTAB_NORMAL_S );

	m_bLeftButton = false;
	m_bIsInit = false;

	for(int i = 0; i < KTAB_HEAD_MAX; ++i)
	{
		_registerSprite( &m_HeadSprite[i] );
	}
}

DWORD KUITabControlSimpleHead::OnMouseMessage(DWORD dwMessage, int x, int y)
{
	DWORD dwRet = KUIControl::OnMouseMessage(dwMessage,x,y);

	if(KMR_NO_GET & dwRet)
		return dwRet;

	if( IsDisable() ) return dwRet;

	DWORD dwIsSelected = 0;
	if(GetState() != KTS_SELECTED)
		dwIsSelected = 1;

	if(IsInRect(x,y) )
	{
		switch(dwMessage) 
		{
		case KMOUSE_MOVE:
			if(m_dwHeadState != KTAB_DOWN_S && m_dwHeadState != KTAB_DOWN_O)
			{
				if ( m_bLeftButton )
					SetHeadState( KTAB_DOWN_S + KTAB_SET_NUM*dwIsSelected );
				else 
					SetHeadState( KTAB_ACTIVATE_S + KTAB_SET_NUM*dwIsSelected);
			}break;
		
		case KLBUTTON_DOWN:
			{
				m_bLeftButton = true;
				PumpUpMessage(GetID(), KUI_MESSAGE::KTAB_CHANGE, GetMyNum() ,0);
				SetHeadState( KTAB_DOWN_S + KTAB_SET_NUM*dwIsSelected);
			}break;
		
		case KLBUTTON_UP:
			{
				m_bLeftButton = false;
				if(m_dwHeadState == KTAB_DOWN_S || m_dwHeadState == KTAB_DOWN_O )
					PumpUpMessage(GetID(), KUI_MESSAGE::KBUTTON_CLICK, GetMyNum() ,0);

				SetHeadState( KTAB_ACTIVATE_S + KTAB_SET_NUM*dwIsSelected);
			}break;
		
		default:
			break;
		}

	}
	else
	{
		if ( dwMessage == KLBUTTON_UP )
		{
			m_bLeftButton = false;
			m_pManager->ReleaseCapture( this );
		}
		// 마우스 범위를 벗어나면 Normal로 돌린다. 
		if(m_dwHeadState == KTAB_ACTIVATE_S || m_dwHeadState == KTAB_DOWN_S||
			m_dwHeadState == KTAB_ACTIVATE_O || m_dwHeadState == KTAB_DOWN_O)
			SetHeadState( KTAB_NORMAL_S + KTAB_SET_NUM*dwIsSelected);
	}

	dwRet = OnMouseMessageEx(dwMessage, x, y, dwRet);

	return dwRet;
}

DWORD KUITabControlSimpleHead::OnKeyMessage(DWORD dwMessage, DWORD dwKeyCode)
{
	return KUIControl::OnKeyMessage(dwMessage, dwKeyCode);
}

void KUITabControlSimpleHead::Render(KViewportObject * pViewport, bool isFront)
{
	if ( m_bShowFlag )
	{
		int nSprite = m_dwHeadState;
		if( IsDisable() )
		{
			if(GetState() < KTAB_NORMAL_O)
				nSprite = KTAB_DISABLE_S;
			else
				nSprite = KTAB_DISABLE_O;
		}

		pViewport->Register(&m_HeadSprite[nSprite], isFront );
		// Caption Render
		_renderCaption(pViewport, isFront);

		// ToolTip Render
#ifndef _KUI_INVALIDATION
		_renderToolTip(pViewport, isFront);
#endif
	}
}

void KUITabControlSimpleHead::UpdateBack()
{
	if( m_sAniName.empty() )
		return;

	KResSprite* pFrame = _getSpriteSet()->GetSpriteRes(m_sAniName.c_str(),0);

	if( !pFrame )
	{
		assert( false && "Cannot find Sprite Res Frame" ); 
		return;
	}

	m_rcRegion.right = m_rcRegion.left + pFrame->GetSizeX();
	m_rcRegion.bottom = m_rcRegion.top + pFrame->GetSizeY();
	for( int i = 0; i < KTAB_HEAD_MAX; ++i ) 
	{
		KResSprite* pFrame = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), i );

		if(!pFrame)
		{
			continue;
		}

		m_HeadSprite[i].SetRes( pFrame );
		m_HeadSprite[i].SetPosition( m_rcRegion.left , m_rcRegion.top , m_fZPos );
	}
	m_rcCaptionArea = m_rcRegion;
}

void KUITabControlSimpleHead::_destroyControl()
{
	KUIControl::_destroyControl();

	for( int i = 0; i < KTAB_HEAD_MAX; ++i ) 
	{
		m_HeadSprite[i].SetRes( NULL );
	}
}

void KUITabControlSimpleHead::_initControl()
{  
	if( m_sAniName.empty() )
		return;

	DivideSheetName();

	KResSprite* pFrame = _getSpriteSet()->GetSpriteRes(m_sAniName.c_str(),0);

	if( !pFrame )
	{
		assert( false && "Cannot find Sprite Res Frame" ); 
		return;
	}

	m_rcRegion.right = m_rcRegion.left + pFrame->GetSizeX();
	m_rcRegion.bottom = m_rcRegion.top + pFrame->GetSizeY();
	for( int i = 0; i < KTAB_HEAD_MAX; ++i ) 
	{
		KResSprite* pFrame = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), i );

		if(!pFrame)
		{
			continue;
		}

		m_HeadSprite[i].SetRes( pFrame );
		m_HeadSprite[i].SetPosition( m_rcRegion.left , m_rcRegion.top , m_fZPos );
	}

	m_rcCaptionArea = m_rcRegion;

	UpdateCaption();
	if(m_bIsInit == false)
	{
		list<KUIWnd*> ChildList = GetParent()->GetChildList();

		list<KUIWnd*>::iterator It;
		list<KUIWnd*>::iterator startIt = ChildList.begin();
		list<KUIWnd*>::iterator endIt = ChildList.end();
		for( It = startIt ; It != endIt ; ++It )
		{
			std::string strClassName = (*It)->GetClassName();
			if(strClassName.compare("tab_sheet") == 0)
			{
				std::string strID = (*It)->GetID();
				if( strID.compare(m_strSheet) == 0)
				{
					KUITabControlSheet* pSheet = (KUITabControlSheet *)(*It);
					SetMyNum(pSheet->GetHeadNum());
					pSheet->RegistHead( this );
					RegisterSheet( pSheet );

					std::string strCaption = this->GetCaption();
					if(!strCaption.empty())
					{
						size_t cpos = strCaption.find( "<#" );
						if(cpos != -1)
							m_strFontColorSel = strCaption.substr( cpos, 9 );
					}

					// 2010. 11. 8 - marine
					// 일단은 첫 번째로 읽어오는 탭버튼이 선택되게 만든다.
					// 하지만 툴에서 만들 때 처음 만든 탭버튼이 처음 만든 놈이 아닐 수 있으므로
					// 별도로 지정을 해줘야 할듯.
					if(pSheet->GetHeadNum() == 1)
					{
						this->OnStateChange(KTS_SELECTED);
						SetHeadState(KTAB_NORMAL_S);
					}
					else
					{
						this->OnStateChange(KTS_NORMAL);
						SetHeadState(KTAB_NORMAL_O);
					}
				}
				m_bIsInit = true;
			}
		}
	}
	// 2010. 12. 1 - marine 
	// 폰트의 색이 선택된 헤드인지 아닌지에 따라 다른데
	// 초기화 할때 해줘야 한다. 위치는 여기가 적당한듯
	SetInitFont();
}

void KUITabControlHeadBase::SetInitFont()
{
	std::string strCaption = GetCaption();
	if(strCaption.empty()) return;

	std::string strNewCaption = (GetState() ==KTS_SELECTED)? GetFontColorSel() :GetFontColorNoSel();

	SetEnableColor(strNewCaption.c_str());

	size_t cpos = 0;
	while( ( cpos = strCaption.find( "<#" ) ) != strCaption.npos )
	{
		strCaption.erase( cpos, 9 );
	}

	strNewCaption += strCaption;
	SetCaption(strNewCaption.c_str());
}