/// 2010.12.17 - prodongi

#include "stdafx.h"

#include "SUISkillWnd.h"
#include "KUITabControl.h"
//#include "KUIControlButton.h"
#include "KUIControlStatic.h"
//#include "KUIControlScroll.h"
#include "KUIDragAndDrop.h"

#include "SGameManager.h"
//#include "SGameMessageUI.h"
#include "SUIDisplayInfo.h"

#include "SSkillDB.h"
#include "SStringDB.h"
//#include "SJobDB.h"

#include "SSkillSlot.h"
#include "SPlayerInfoMgr.h"
#include "ErrorCode/ErrorCode.h"
#include "SUILazyTooltip.h" // sonador #2.1.2.4.3	팻 조작 UI 연동
#include "SUISkillTreeFundWnd.h"	/// 2010.12.03 - prodongi
//#include "SUIUtil.h"	/// 2010.12.17 - prodongi


//
//struct SkillTreeDisplay
//{
//	int job_id;		//잡 ID
//	int slot_v;		//슬롯 위치1~9
//	int skill1_id;	//스킬 ID
//	int skill2_id;	//스킬 ID
//	int skill3_id;	//스킬 ID
//	int skill4_id;	//스킬 ID
//	int skill5_id;  //스킬 ID
//};

const int	c_nSkillWidthCnt	= 5;
const int	c_nSkillHeightCnt	= 9;
//const int	c_nDelta			= 63;
const int	c_nDelta			= 64;	/// 2011.04.20 - prodongi
//const float	c_ftabSize			= (342-8)/4;


const char*	c_lpSkillEmptyAni		= "static_common_itemslot";
const char*	c_lpPassiveAni			= "static_treeslot_passive";

const char*	c_lpSkillSlotCtrName	= "skillslot";
const char*	c_lpPassiveSlotCtrName	= "passiveslot";
const char*	c_lpSlotDisableCtrName	= "icondisable";
const char*	c_lpSkillLvBackCtrName	= "skill_lv_back";
const char*	c_lpSkillLvTextCtrName	= "skill_lv";
const char*	c_lpSkillUpCtrName		= "buttonskillup";
const char*	c_lpSkillAbleUpCtrName	= "skillslotableup";

/// 2011.02.24 - prodongi
/*
const char*	c_lpAsura_0			= "static_player_skilltree_asura_00_bb";	//스테퍼
const char*	c_lpAsura_1_mgc		= "static_player_skilltree_asura_01_pp";	//매지션
const char*	c_lpAsura_1_smr		= "static_player_skilltree_asura_01_ss";	//서모너
const char*	c_lpAsura_1_std		= "static_player_skilltree_asura_01_ww";	//스트라이더
const char*	c_lpAsura_2_rgr		= "static_player_skilltree_asura_02_hh";	//레인저
const char*	c_lpAsura_2_dmg		= "static_player_skilltree_asura_02_pd";	//다크매지션
const char*	c_lpAsura_2_ssr		= "static_player_skilltree_asura_02_pp";	//소서러
const char*	c_lpAsura_2_bsm		= "static_player_skilltree_asura_02_ss";	//배틀서모너
const char*	c_lpAsura_2_asn		= "static_player_skilltree_asura_02_ww";	//어쌔신


const char*	c_lpDeva_0			= "static_player_skilltree_deva_00_bb";		//가이드
const char*	c_lpDeva_1_clr		= "static_player_skilltree_deva_01_pp";		//클레릭
const char*	c_lpDeva_1_tmr		= "static_player_skilltree_deva_01_ss";		//테이머
const char*	c_lpDeva_1_ptr		= "static_player_skilltree_deva_01_ww";		//파이터
const char*	c_lpDeva_2_mge		= "static_player_skilltree_deva_02_pm";		//메이지
const char*	c_lpDeva_2_prt		= "static_player_skilltree_deva_02_pp";		//프리스트
const char*	c_lpDeva_2_brd		= "static_player_skilltree_deva_02_ss";		//브리더
const char*	c_lpDeva_2_nit		= "static_player_skilltree_deva_02_wn";		//나이트
const char*	c_lpDeva_2_wr		= "static_player_skilltree_deva_02_ww";		//워리어

const char*	c_lpGaia_0			= "static_player_skilltree_gaia_00_bb";		//방랑자
const char*	c_lpGaia_1_jss		= "static_player_skilltree_gaia_01_pp";		//주술사
const char*	c_lpGaia_1_yss		= "static_player_skilltree_gaia_01_ss";		//야수사
const char*	c_lpGaia_1_tsa		= "static_player_skilltree_gaia_01_ww";		//투사
const char*	c_lpGaia_2_gsa		= "static_player_skilltree_gaia_02_hh";		//궁사
const char*	c_lpGaia_2_mds		= "static_player_skilltree_gaia_02_pp";		//마도사
const char*	c_lpGaia_2_mts		= "static_player_skilltree_gaia_02_pw";		//마투사
const char*	c_lpGaia_2_mss		= "static_player_skilltree_gaia_02_ss";		//마수사
const char*	c_lpGaia_2_js		= "static_player_skilltree_gaia_02_ww";		//전사
*/
using namespace rp;

SUISkillTreeFundWnd::SUISkillTreeFundWnd( SGameManager* pGameManager, SUIDisplayInfo* pDisplayInfo )
: SUIWnd( pGameManager ), m_pDisplayInfo(pDisplayInfo), m_nTabType(0), m_nJopPoint(0), m_bCreateInfo(false)
{
	::memset( m_nJopID, 0x00, sizeof(m_nJopID) );
	::memset( m_nJopLv, 0x00, sizeof(m_nJopLv) );
}

SUISkillTreeFundWnd::~SUISkillTreeFundWnd()
{
	ClearSkillTreeList();
	m_treeImageList.clear();
}

void SUISkillTreeFundWnd::ClearSkillTreeList()
{
	int nSize(m_SkillTreeList.size());
	for( int i(0); i<nSize; ++i )
		SAFE_DELETE(m_SkillTreeList[i]);
	m_SkillTreeList.clear();
}

void SUISkillTreeFundWnd::CreateSkillTreeLists()
{
	ClearSkillTreeList();
	for( int i(0); i<c_nJopCnt; ++i )
		CreateSkillTreeList( i );
}

/// 2011.02.24 - prodongi
void SUISkillTreeFundWnd::initTreeImageList()
{
	m_treeImageList[100] = "game_panel_skill_skilltree_gaia_basic_bangrangza";		//방랑자
	m_treeImageList[101] = "game_panel_skill_skilltree_gaia_01_toosa";				//투사
	m_treeImageList[102] = "game_panel_skill_skilltree_gaia_01_joosulsa";			//주술사
	m_treeImageList[103] = "game_panel_skill_skilltree_gaia_01_yasoosa";			//야수사
	m_treeImageList[110] = "game_panel_skill_skilltree_gaia_02_zeonsa";				//전사
	m_treeImageList[111] = "game_panel_skill_skilltree_gaia_02_gungsa";				//궁사
	m_treeImageList[112] = "game_panel_skill_skilltree_gaia_02_madosa";				//마도사
	m_treeImageList[113] = "game_panel_skill_skilltree_gaia_02_matoosa";			//마투사
	m_treeImageList[114] = "game_panel_skill_skilltree_gaia_02_masoosa";			//마수사
	m_treeImageList[120] = "game_panel_skill_skilltree_gaia_master_tooshin";		//투신
	m_treeImageList[121] = "game_panel_skill_skilltree_gaia_master_shingung";		//신궁
	m_treeImageList[122] = "game_panel_skill_skilltree_gaia_master_hyunza";			//현자
	m_treeImageList[123] = "game_panel_skill_skilltree_gaia_master_gumgang";		//금강
	m_treeImageList[124] = "game_panel_skill_skilltree_gaia_master_nachal";			//나찰

	m_treeImageList[200] = "game_panel_skill_skilltree_deva_basic_guide";			//가이드
	m_treeImageList[201] = "game_panel_skill_skilltree_deva_01_fighter";			//파이터
	m_treeImageList[202] = "game_panel_skill_skilltree_deva_01_cleric";				//클레릭
	m_treeImageList[203] = "game_panel_skill_skilltree_deva_01_tamer";				//테이머
	m_treeImageList[210] = "game_panel_skill_skilltree_deva_02_knight";				//나이트
	m_treeImageList[211] = "game_panel_skill_skilltree_deva_02_warrior";			//워리어
	m_treeImageList[212] = "game_panel_skill_skilltree_deva_02_mage";				//메이지
	m_treeImageList[213] = "game_panel_skill_skilltree_deva_02_priest";				//프리스트
	m_treeImageList[214] = "game_panel_skill_skilltree_deva_02_breeder";			//브리더
	m_treeImageList[220] = "game_panel_skill_skilltree_deva_master_godsknight";		//가나이트
	m_treeImageList[221] = "game_panel_skill_skilltree_deva_master_hero";			//히어로
	m_treeImageList[222] = "game_panel_skill_skilltree_deva_master_arcmage";		//아크메이지
	m_treeImageList[223] = "game_panel_skill_skilltree_deva_master_saint";			//세인트
	m_treeImageList[224] = "game_panel_skill_skilltree_deva_master_maestro";		//마에스트로
	
	m_treeImageList[300] = "game_panel_skill_skilltree_asura_basic_staffer";		//스테퍼
	m_treeImageList[301] = "game_panel_skill_skilltree_asura_01_strider";			//스트라이더
	m_treeImageList[302] = "game_panel_skill_skilltree_asura_01_magician";			//매지션
	m_treeImageList[303] = "game_panel_skill_skilltree_asura_01_summoner";			//서모너
	m_treeImageList[310] = "game_panel_skill_skilltree_asura_02_assassin";			//어쌔신	
	m_treeImageList[311] = "game_panel_skill_skilltree_asura_02_ranger";			//레인저
	m_treeImageList[312] = "game_panel_skill_skilltree_asura_02_sorcerer";			//소서러
	m_treeImageList[313] = "game_panel_skill_skilltree_asura_02_darkmagician";		//다크매지션
	m_treeImageList[314] = "game_panel_skill_skilltree_asura_02_battlesummoner";	//배틀서모너
	m_treeImageList[320] = "game_panel_skill_skilltree_asura_master_spectre";		//스펙터	
	m_treeImageList[321] = "game_panel_skill_skilltree_asura_master_shadowstalker";	//섀도우스토커
	m_treeImageList[322] = "game_panel_skill_skilltree_asura_master_doomsayer";		//둠세이어
	m_treeImageList[323] = "game_panel_skill_skilltree_asura_master_soulriver";		//소울리버
	m_treeImageList[324] = "game_panel_skill_skilltree_asura_master_gilgamesh";		//길가메쉬
}

bool SUISkillTreeFundWnd::InitControls( KPoint kPos )
{
	CreateControls();
	SetChildAsTop( "skillfund_select" );

//	KUIControlMultiIcon* pSlot = (KUIControlMultiIcon*)GetChild( CStringUtil::StringFormat( "%s_00_00", c_lpSkillSlotCtrName ).c_str() );
//	if( pSlot )	pSlot->SetIconLayer( 2 );

	return SUIWnd::InitControls(kPos);
}

void SUISkillTreeFundWnd::UpdateTab( int nCnt )
{
	/// 2010.12.17 탭 버튼 개수는 변하지 않으므로, enable/disable로 설정해 준다 - prodngi
	/*
	KUISimpleTabControl* pTabControl = (KUISimpleTabControl*)GetChild("skillfund_tab00");
	if( pTabControl )
	{
		pTabControl->RemoveTabAllItem();

		KRect rt = pTabControl->GetRect();
		rt.right = rt.left + ( c_ftabSize * (float)nCnt );
		pTabControl->SetRect(rt);

		pTabControl->SetTabProperty( 0, false, nCnt );

		if( nCnt > 0 )	pTabControl->AddTabItem( S(6471), S(6471) );
		if( nCnt > 1 )	pTabControl->AddTabItem( S(6472), S(6472) );
		if( nCnt > 2 )	pTabControl->AddTabItem( S(6473), S(6473) );
		if( nCnt > 3 )	pTabControl->AddTabItem( S(6474), S(6474) );

		pTabControl->SetSelectedItem( m_nTabType );
	}
	*/

	/// 2011.05.30 - prodongi
	KUITabControlSheet* tabSheet = dynamicCast<KUITabControlSheet*>(GetChild("skill_tree_tab01"));
	if (tabSheet) tabSheet->SetSelectHead((DWORD)m_nTabType);

	int i = 0;
	char const* childId[] = { "skill_tree_tab_basic_01", "skill_tree_tab_first_01", "skill_tree_tab_second_01", "skill_tree_tab_master_01"};
	for (;i < nCnt; ++i)
	{
		setChildControlEnable(this, childId[i], true);
	}
	for (; i < 4; ++i)
	{
		setChildControlEnable(this, childId[i], false);
	}
}

/////////////////////////////////////////////
// 스킬투자윈도우
/////////////////////////////////////////////
void SUISkillTreeFundWnd::CreateControls()
{
	RECT rcHeight;
	rcHeight.left = 0;	rcHeight.top = c_nDelta;	rcHeight.right = 0;	rcHeight.bottom = c_nDelta;
	RECT rcWidth;
	rcWidth.left = c_nDelta;	rcWidth.top = 0;	rcWidth.right = c_nDelta;	rcWidth.bottom = 0;

	KUIControlMultiIcon* pSlot(NULL);
	for( int i(0); i<c_nSkillWidthCnt-1; ++i )
	{
		CopyControl( CStringUtil::StringFormat( "%s_00_%02d", c_lpSkillSlotCtrName, i ).c_str(), CStringUtil::StringFormat( "%s_00_%02d", c_lpSkillSlotCtrName, i+1 ).c_str(), rcWidth );
		CopyControl( CStringUtil::StringFormat( "%s_00_%02d", c_lpSkillAbleUpCtrName, i ).c_str(), CStringUtil::StringFormat( "%s_00_%02d", c_lpSkillAbleUpCtrName, i+1 ).c_str(), rcWidth );
		CopyControl( CStringUtil::StringFormat( "%s_00_%02d", c_lpSlotDisableCtrName, i ).c_str(), CStringUtil::StringFormat( "%s_00_%02d", c_lpSlotDisableCtrName, i+1 ).c_str(), rcWidth );
		CopyControl( CStringUtil::StringFormat( "%s_00_%02d", c_lpSkillLvBackCtrName, i ).c_str(), CStringUtil::StringFormat( "%s_00_%02d", c_lpSkillLvBackCtrName, i+1 ).c_str(), rcWidth );
		CopyControl( CStringUtil::StringFormat( "%s_00_%02d", c_lpSkillLvTextCtrName, i ).c_str(), CStringUtil::StringFormat( "%s_00_%02d", c_lpSkillLvTextCtrName, i+1 ).c_str(), rcWidth );
		CopyControl( CStringUtil::StringFormat( "%s_00_%02d", c_lpSkillUpCtrName, i ).c_str(), CStringUtil::StringFormat( "%s_00_%02d", c_lpSkillUpCtrName, i+1 ).c_str(), rcWidth );
		CopyControl( CStringUtil::StringFormat( "%s_00_%02d", c_lpPassiveSlotCtrName, i ).c_str(), CStringUtil::StringFormat( "%s_00_%02d", c_lpPassiveSlotCtrName, i+1 ).c_str(), rcWidth );
	}

	for( int i(0); i<c_nSkillWidthCnt; ++i )
	{
		for( int j(0); j<c_nSkillHeightCnt-1; ++j )
		{
			CopyControl( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillSlotCtrName, j, i ).c_str(), CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillSlotCtrName, j+1, i ).c_str(), rcHeight );
			CopyControl( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillAbleUpCtrName, j, i ).c_str(), CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillAbleUpCtrName, j+1, i ).c_str(), rcHeight );
			CopyControl( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSlotDisableCtrName, j, i ).c_str(), CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSlotDisableCtrName, j+1, i ).c_str(), rcHeight );
			CopyControl( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillLvBackCtrName, j, i ).c_str(), CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillLvBackCtrName, j+1, i ).c_str(), rcHeight );
			CopyControl( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillLvTextCtrName, j, i ).c_str(), CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillLvTextCtrName, j+1, i ).c_str(), rcHeight );
			CopyControl( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillUpCtrName, j, i ).c_str(), CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillUpCtrName, j+1, i ).c_str(), rcHeight );
			CopyControl( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpPassiveSlotCtrName, j, i ).c_str(), CStringUtil::StringFormat( "%s_%02d_%02d", c_lpPassiveSlotCtrName, j+1, i ).c_str(), rcHeight );
		}
	}
}

void SUISkillTreeFundWnd::OnNotifyUIWindowOpen( bool bOpen, bool bLimitWnd )
{
	if( bOpen )
	{
//		if( !m_bCreateInfo )
		{
			Create_N_Init_AllData();
			m_bCreateInfo = true;
		}
	}
}

void SUISkillTreeFundWnd::Create_N_Init_AllData()
{
	InitPlayerJopInfo();
	CreateSkillTreeLists();
	RefreshMasterBoxImage( m_nTabType );   // AziaMafia MasterskillBox
	RefreshSkillData( m_nTabType );
	RefreshJopTreeImage( m_nTabType );
	refreshTP();	/// 2011.03.28 - prodongi
	InitClickIconData();
}

bool SUISkillTreeFundWnd::InitData( bool bReload )
{
	/// 2011.02.24 - prodongi
	initTreeImageList();

	return SUIWnd::InitData(bReload);
}

void SUISkillTreeFundWnd::PumpUpMessage( LPCSTR lpszControlID, DWORD nMessage, DWORD lparam, DWORD wparam )
{
	switch(nMessage)
	{
	case KUI_MESSAGE::KBUTTON_CLICK:
		{
			std::string strCtrName = lpszControlID;
			if( ::strcmp( lpszControlID, "button_close" ) == 0 )
			{
				m_pGameManager->PostMsgAtDynamic( new SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_SKILLFUND, false ) );
			}
			else if( strCtrName.find(c_lpSkillUpCtrName) != -1 )
			{
				SkillUP( m_nTabType, lpszControlID );
				m_pGameManager->StartSound( "skillup.wav" );
			}
			else if (strcmp(lpszControlID, "skill_tree_tab_basic_01") == 0)
			{
				m_pGameManager->StartSound( "ui_button_click.wav" );
				SelectTab(0);
			}
			else if (strcmp(lpszControlID, "skill_tree_tab_first_01") == 0)
			{
				m_pGameManager->StartSound( "ui_button_click.wav" );
				SelectTab(1);
			}
			else if (strcmp(lpszControlID, "skill_tree_tab_second_01") == 0)
			{
				m_pGameManager->StartSound( "ui_button_click.wav" );
				SelectTab(2);
			}
			else if (strcmp(lpszControlID, "skill_tree_tab_master_01") == 0)
			{
				m_pGameManager->StartSound( "ui_button_click.wav" );
				SelectTab(3);
			}
			// 2011.05.24 도움말 윈도우.(가방창에서 갖고 옴) - prodongi
			else if( !::_stricmp( lpszControlID, "button_help" ) )
			{	
				const KRect & rt = GetChild( "button_help" )->GetRect();
				m_pGameManager->PostMsgAtDynamic( new SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HELP_WND, false ) );				  // 닫기.
				m_pGameManager->PostMsgAtDynamic( new SIMSG_UI_MOVE( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HELP_WND, rt.left, rt.top ) );			  // 위치전달.
				m_pGameManager->PostMsgAtDynamic( new SIMSG_HELP_TEXT( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HELP_WND, std::string( S( 9795 ) ) ) ); // 텍스트전달.
				m_pGameManager->PostMsgAtDynamic( new SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HELP_WND, true ) );				  // 열기.
			}
		}
		break;
	case KUI_MESSAGE::KICON_CLICK:
		{
			SetClickIcon( lpszControlID );
		}
		break;
		/// 2010.12.17 - prodongi
		/*
	case KUI_MESSAGE::KTAB_SELECT:	// 탭 변경
		{
			m_pGameManager->StartSound( "ui_button_click.wav" );

			SelectTab( (int)lparam );
//			m_pGameManager->PostMsgAtDynamic( new SIMSG_UI_TAB_UPDATE( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_SKILL, m_nTabType ) );
		}
		break;
		*/
	}

	SUIWnd::PumpUpMessage( lpszControlID, nMessage, lparam, wparam );
}

void SUISkillTreeFundWnd::ProcMsgAtStatic( SGameMessage* pMsg )
{
	switch(pMsg->nType)
	{
	case IMSG_UI_MOVE:
		{
			SIMSG_UI_MOVE* pMoveMsg = ( SIMSG_UI_MOVE* )pMsg;
			MovePos( pMoveMsg->m_nX, pMoveMsg->m_nY-GetBoundingRect().GetHeight() );
			pMsg->bUse = true;
		}
		break;
	case MSG_ADDED_SKILL_LIST:
		//break;
	case MSG_SKILL_LIST:
		{
			pMsg->bUse = true;
		}
		break;
	case IMSG_UI_SEND_DATA:
		{
			/// 2012.01.26 skill_reset은 안 쓰이는 것 같다, 문법도 틀렸다,, prodongi
			SIMSG_UI_SEND_DATA* msg = ( SIMSG_UI_SEND_DATA* )pMsg;
			if (msg->m_strString == "refresh")
			{
				if (IsShow())
				{
					Create_N_Init_AllData();
					m_bCreateInfo	= true;
				}
			}
			pMsg->bUse = true;
			}
		break;
	case MSG_EXP_UPDATE:
		{
			//if( m_bCreateInfo )
			//{
			//	if( m_pMgr && m_pPlayerInfoMgr )
			//	{
			//		SPlayerInfo & info = m_PlayerInfoMgr.GetPlayerInfo();
			//		m_nJopPoint = info.GetJP();
			//	}
			//	CreateSkillTreeLists();
			//	RefreshSkillData( m_nTabType );	//InitPlayerJopInfo(); RefreshJopTreeImage( 0 ); InitClickIconData();	-> 잡포와 무관
			//}
			//else
			{
				Create_N_Init_AllData();
				m_bCreateInfo	= true;
			}
			pMsg->bUse = true;
		}
		break;
	case IMSG_UI_TAB_UPDATE:
		{
			/*SIMSG_UI_TAB_UPDATE* pTabMsg = ( SIMSG_UI_TAB_UPDATE* )pMsg;

			KUISimpleTabControl* pTab = ( KUISimpleTabControl* )GetChild("skillfund_tab00");
			if( pTab )	pTab->SetSelectedItem( pTabMsg->m_nTabType );

			SelectTab( pTabMsg->m_nTabType );*/

			pMsg->bUse = true;
		}
		break;
	case MSG_RESULT:
		{
			SMSG_RESULT* pMsgResult = (SMSG_RESULT*)pMsg;
			switch(pMsgResult->request_msg_id)
			{
			case TM_CS_LEARN_SKILL:
				{
					if( pMsgResult->result == RESULT_SUCCESS )
					{
						if( !IsShow() )	break;

						if( m_bCreateInfo )
						{
							CreateSkillTreeLists();
							RefreshSkillData( m_nTabType );	//InitPlayerJopInfo(); RefreshJopTreeImage( 0 ); InitClickIconData();	-> 스킬배움과 무관
						}
						else
						{
							Create_N_Init_AllData();
							m_bCreateInfo	= true;
						}
					}
				}
				break;
			}
			pMsg->bUse = true;
		}
		break;
	case MSG_PROPERTY:
		{
			if( !IsShow() )	break;

			SMSG_PROPERTY* pPropertyMsg = (SMSG_PROPERTY*)pMsg;
			switch( pPropertyMsg->nPropertyType )
			{
			case SMSG_PROPERTY::PROPERTY_JOB:
				{
					Create_N_Init_AllData();
					m_bCreateInfo	= true;
				}
				break;
			case SMSG_PROPERTY::PROPERTY_JOB_LEVEL:
				{
					if( m_bCreateInfo )
					{
						InitPlayerJopInfo();
						CreateSkillTreeLists();
						RefreshSkillData( m_nTabType );	//RefreshJopTreeImage( m_nTabType ); InitClickIconData();	-> 잡렙업과 무관
					}
					else
					{
						Create_N_Init_AllData();
						m_bCreateInfo	= true;
					}
				}
				break;
			case SMSG_PROPERTY::PROPERTY_JP:
				{
					if( m_bCreateInfo )
					{
						SPlayerInfo & info = m_PlayerInfoMgr.GetPlayerInfo();
						m_nJopPoint = info.GetJP();

						CreateSkillTreeLists();
						RefreshSkillData( m_nTabType );	//InitPlayerJopInfo(); RefreshJopTreeImage( 0 ); InitClickIconData();	-> 잡포와 무관
					}
					else
					{
						Create_N_Init_AllData();
						m_bCreateInfo	= true;
					}
				}
				break;
			/// 2011.03.28 - prodongi
			case SMSG_PROPERTY::PROPERTY_TP:
				{
					refreshTP();
				}
				break;
			}
			pMsg->bUse = true;
		}
		break;
	}
}

void* SUISkillTreeFundWnd::Perform( KID id, KArg& msg )
{
	_CID( UI_BEGIN_DRAG );
	_CID( UI_SEND_DROP );

	if ( id == id_UI_BEGIN_DRAG )
	{
		KUIBeginDragMessage* pBeginMsg = static_cast<KUIBeginDragMessage*>( &msg );
		const char* szControlID = pBeginMsg->sDragControlID.c_str();

		KUIWnd* pWnd = GetChild( szControlID );
		if( pWnd == NULL )	return NULL;

		SetClickIcon( szControlID );
		if( 0 < m_sClickData.nSkillID )
		{
			SkillBaseEx* s_data = GetSkillDB().GetSkillData( m_sClickData.nSkillID );
			if( s_data->IsPassive() )	return NULL;

			int nUseLevel(1);
			SSkillSlot* pCrrSkill = m_SkillSlotMgr.GetSkillSlot( m_sClickData.nSkillID );
			if( pCrrSkill )
				nUseLevel = pCrrSkill->GetUseLevel();

			if( 0 < nUseLevel )
			{
				m_pDisplayInfo->SetUIDragInfo( new SUISkillDragInfo( m_sClickData.nSkillID, nUseLevel, NULL, m_PlayerInfoMgr.GetPlayerHandle() ) );
				m_pDragAndDropIcon->SetStateIcon( pWnd->GetSprName(), pWnd->GetAniName(), pWnd->GetFrameIndex(), STATE_NORMAL );

				pBeginMsg->pDragAndDropRenderer = m_pDragAndDropIcon;
			}
		}
		return NULL;
	}
	else if ( id == id_UI_SEND_DROP )
	{
		KUISendRecvDropMessage* pSendMsg = static_cast<KUISendRecvDropMessage*>( &msg );

		SUIDragInfo* pUIDragInfo = m_pDisplayInfo->GetUIDragInfo();
		if( NULL != pUIDragInfo ) m_pDisplayInfo->SetUIDragInfo();
		return NULL;
	}

	return SUIWnd::Perform( id, msg );
}

void SUISkillTreeFundWnd::SelectTab( int TabIndex )
{
	if( TabIndex < 0 || TabIndex >= c_nJopCnt )	return;

	m_nTabType = TabIndex;

//	InitPlayerJopInfo();
	RefreshMasterBoxImage( m_nTabType );   // AziaMafia MasterskillBox
	RefreshSkillData( TabIndex );
	InitClickIconData();
	RefreshJopTreeImage( TabIndex );
}

void SUISkillTreeFundWnd::InitPlayerJopInfo()
{
	if( !IsShow() ) return;

	int i(0), nJopID(0), nJopLv(0);
	for( ; i<c_nOldJopCnt; ++i )
	{
		nJopID = m_PlayerInfoMgr.GetOldJobID(i);
		nJopLv = m_PlayerInfoMgr.GetOldJobLv(i);

		if( nJopID )
		{
			m_nJopID[i] = nJopID;
			m_nJopLv[i] = nJopLv;
		}
		else	break;
	}
	/// 2011.02.24 test - prodongi
	//m_nJopID[3] = 221;
	//m_nJopLv[3] = 300;

	m_nJopID[i] = m_PlayerInfoMgr.GetJobID();
	m_nJopLv[i] = m_PlayerInfoMgr.GetJLv();
	m_nJopPoint = m_PlayerInfoMgr.GetJP();

	if( m_nTabType>i )
		m_nTabType = i;

	UpdateTab(i+1);
}

void SUISkillTreeFundWnd::CreateSkillTreeList( int nJopIndex )
{
	if( nJopIndex >= 0 && nJopIndex < c_nJopCnt && m_nJopID[nJopIndex] )
	{
		const JobInfoEx* pJobDB = GetJobDB().GetJobData( m_nJopID[nJopIndex] );
		if( pJobDB == NULL )
		{
			return;
		}

		m_SkillTreeDisplay[nJopIndex].clear();
		//ClearSkillTreeList( nJopIndex );

		GetSkillTreeDisplayDB().GetSkillTree( m_nJopID[nJopIndex], m_SkillTreeDisplay[nJopIndex] );

		const std::vector< SkillTreeEx >* pSkillTreeList;
		pSkillTreeList = GetSkillTreeDB().GetSkillTreeData( pJobDB->skill_tree_id );
		if( pSkillTreeList == NULL ) return;

		SSkillSlot* pSkillSlot(NULL);
		SSkillSlot* pNeedSkill(NULL);
		SSkillSlot* pLearnSkill(NULL);
		int nLearnSkillLV(0);
		std::vector<SkillTreeEx>::const_iterator it	= pSkillTreeList->begin();
		while( it != pSkillTreeList->end() )
		{
			const SkillTreeEx* pTree = &(*it);
			SkillBaseEx* s_data = GetSkillDB().GetSkillData(pTree->skill_id);
			if( s_data == NULL )	{ it++; continue; }
			if( s_data->IsSystemSkill() )	{ it++; continue; }

			if( CheckSkillTreeListData( nJopIndex, pTree ) )
			{
				_SkillSlotInfo* pInfo = new _SkillSlotInfo;

				pInfo->nID = pTree->skill_id;
				pInfo->nMaxLv[nJopIndex] = pTree->max_skill_lv;

				pInfo->lv = pTree->lv;	/// 2011.04.04 - prodongi

				pLearnSkill = m_SkillSlotMgr.GetSkillSlot( pInfo->nID );
				pInfo->nLearnNextMaxLv = pTree->max_skill_lv;
				if( pLearnSkill )
				{
					nLearnSkillLV = pLearnSkill->GetSkill().base_skill_level;
					if( nLearnSkillLV >= pTree->max_skill_lv )
						pInfo->nLearnNextMaxLv = nLearnSkillLV;
				}
//				pInfo->nLearnNextMaxLv = pTree->max_skill_lv;

				if( m_nJopLv[nJopIndex] < pTree->jop_lv )
					pInfo->nEnoughJLv = pTree->jop_lv;
				else	pInfo->nEnoughJLv = 0;

				pNeedSkill = m_SkillSlotMgr.GetSkillSlot( pTree->need_skill_id[0] );
				if( pNeedSkill && pNeedSkill->GetSkill().base_skill_level >= pTree->need_skill_lv[0] )
				{
					pInfo->nNeedSkillID	= 0;
					pInfo->nNeedSkillLv	= 0;
				}
				else
				{
					pInfo->nNeedSkillID	= pTree->need_skill_id[0];
					pInfo->nNeedSkillLv	= pTree->need_skill_lv[0];
				}

				pSkillSlot = m_SkillSlotMgr.GetSkillSlot( s_data->GetID() );
				if( pSkillSlot )	pInfo->nCrrLv = pSkillSlot->GetSkill().base_skill_level;
				else				pInfo->nCrrLv = 0;

				GetSkillDisplayPos( m_SkillTreeDisplay[nJopIndex], pInfo->nID, pInfo->nX, pInfo->nY );
				m_SkillTreeList.push_back(pInfo);
			}
			it++;
		}
	}
}

void SUISkillTreeFundWnd::GetSkillDisplayPos( const std::vector<SkillTreeDisplay*>& rSkillTree, int nSkillID, int& rX, int& rY )
{
	int nSize( rSkillTree.size() );
	for( int i(0); i<nSize; ++i )
	{
		if( nSkillID == rSkillTree[i]->skill1_id )		{	rX = 0;	rY = i;	return;	}
		else if( nSkillID == rSkillTree[i]->skill2_id )	{	rX = 1;	rY = i;	return;	}
		else if( nSkillID == rSkillTree[i]->skill3_id )	{	rX = 2;	rY = i;	return;	}
		else if( nSkillID == rSkillTree[i]->skill4_id )	{	rX = 3;	rY = i;	return;	}
		else if( nSkillID == rSkillTree[i]->skill5_id )	{	rX = 4;	rY = i;	return;	}
	}
}

bool SUISkillTreeFundWnd::CheckSkillTreeListData( int nJopIndex, const SkillTreeEx* pTree )
{
	if( nJopIndex < 0 || nJopIndex >= c_nJopCnt || !m_nJopID[nJopIndex] )	return false;

	bool bChangeData(false);
	int nLearnSkillLV(0);
	_SkillSlotInfo* pInfo(NULL);
	SSkillSlot* pLearnSkill(NULL);
	SSkillSlot* pNeedSkill(NULL);
	int nSize( m_SkillTreeList.size() );
	for( int i(0); i<nSize; ++i )
	{
		pInfo = m_SkillTreeList[i];
		if( pInfo->nID == pTree->skill_id )
		{
			if( pInfo->nMaxLv[nJopIndex] < pTree->max_skill_lv )
				pInfo->nMaxLv[nJopIndex] = pTree->max_skill_lv;

			//이미 배운스킬이 있다면 배운 스킬보다 높아야 요구조건에 충족된다.
			pLearnSkill = m_SkillSlotMgr.GetSkillSlot( pInfo->nID );
			if( pLearnSkill )	nLearnSkillLV = pLearnSkill->GetSkill().base_skill_level;
			else				nLearnSkillLV = 0;
			
			for( int k(nJopIndex-1); k>=0; --k )
			{
				if( nLearnSkillLV < pInfo->nMaxLv[k] )
					return false;
			}

			if( nLearnSkillLV < pTree->max_skill_lv )	//배운스킬보다 max가높으니 조건체크 시작
			{
				//현재 등록된 스킬의 max레벨이 배운 스킬보다큰데 새로 넣을 max레벨이 등록되있는거보다 높으면 pass
				//스킬상의 배우는 조건은 당연히 렙이 낮은게 우선순위가 높다...
//				if( pInfo->nLearnNextMaxLv == 0 )
//					bChangeData = true;
//				else
				{
					if( nLearnSkillLV < pTree->max_skill_lv && pInfo->nLearnNextMaxLv > pTree->max_skill_lv )
					{
						bChangeData = true;
					}
					else
					{
						if( nLearnSkillLV >= pInfo->nLearnNextMaxLv )
							bChangeData = true;
						else	bChangeData = false;
					}
				}
				
				if( bChangeData )
				{
					pInfo->nLearnNextMaxLv = pTree->max_skill_lv;

					if( m_nJopLv[nJopIndex] < pTree->jop_lv )
					{
						pInfo->nEnoughJLv = pTree->jop_lv;
					}
					else
					{
						pInfo->nEnoughJLv = 0;
					}

					/// 2011.04.07 - prodongi
					pInfo->lv = pTree->lv;

					pNeedSkill = m_SkillSlotMgr.GetSkillSlot( pTree->need_skill_id[0] );
					if( pNeedSkill && pNeedSkill->GetSkill().base_skill_level >= pTree->need_skill_lv[0] )
					{
						pInfo->nNeedSkillID	= 0;
						pInfo->nNeedSkillLv	= 0;
					}
					else
					{
						pInfo->nNeedSkillID	= pTree->need_skill_id[0];
						pInfo->nNeedSkillLv	= pTree->need_skill_lv[0];
					}
				}
			}

			return false;
		}
	}
	return true;
}

void SUISkillTreeFundWnd::RefreshSkillData( int nJopIndex )
{
	if( nJopIndex < 0 || nJopIndex >= c_nJopCnt )	return;

	if( m_nJopID[nJopIndex] == 0 || m_SkillTreeDisplay[nJopIndex].empty() )
	{
		for( int nX(0); nX<c_nSkillWidthCnt; ++nX )
		{
			for( int nY(0); nY<c_nSkillHeightCnt; ++nY )
			{
				SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillSlotCtrName, nY, nX ).c_str() , false );
				SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillAbleUpCtrName, nY, nX ).c_str() , false );
				SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSlotDisableCtrName, nY, nX ).c_str() , false );
				SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillLvBackCtrName, nY, nX ).c_str() , false );
				SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillLvTextCtrName, nY, nX ).c_str() , false );
				SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillUpCtrName, nY, nX ).c_str() , false );
			}
		}
	}
	else
	{
		for( int i(0); i<m_SkillTreeDisplay[nJopIndex].size(); ++i )
		{
			SetSkillData( 0, i, nJopIndex, m_SkillTreeDisplay[nJopIndex][i]->skill1_id, GetSkillTreeInfo( m_SkillTreeDisplay[nJopIndex][i]->skill1_id ) );
			SetSkillData( 1, i, nJopIndex, m_SkillTreeDisplay[nJopIndex][i]->skill2_id, GetSkillTreeInfo( m_SkillTreeDisplay[nJopIndex][i]->skill2_id ) );
			SetSkillData( 2, i, nJopIndex, m_SkillTreeDisplay[nJopIndex][i]->skill3_id, GetSkillTreeInfo( m_SkillTreeDisplay[nJopIndex][i]->skill3_id ) );
			SetSkillData( 3, i, nJopIndex, m_SkillTreeDisplay[nJopIndex][i]->skill4_id, GetSkillTreeInfo( m_SkillTreeDisplay[nJopIndex][i]->skill4_id ) );
			SetSkillData( 4, i, nJopIndex, m_SkillTreeDisplay[nJopIndex][i]->skill5_id, GetSkillTreeInfo( m_SkillTreeDisplay[nJopIndex][i]->skill5_id ) );
		}
	}
}

void SUISkillTreeFundWnd::RefreshMasterBoxImage( int nJobIndex )
{
	KUIControlStatic* pTreeImageCtr = dynamicCast<KUIControlStatic*>( GetChild( "job_tree_master" ) );

	if( nJobIndex == 3 )
		pTreeImageCtr->SetShow( true );  //false
	else
		pTreeImageCtr->SetShow( false );
}

_SkillSlotInfo* SUISkillTreeFundWnd::GetSkillTreeInfo( int nSkillID ) // sonador #2.1.2.4.3	팻 조작 UI 연동
{
	int nSize( m_SkillTreeList.size() );
	for( int i(0); i<nSize; ++i )
	{
		if( m_SkillTreeList[i]->nID == nSkillID )
			return m_SkillTreeList[i];
	}
	return NULL;
}

void SUISkillTreeFundWnd::RefreshJopTreeImage( int nJopIndex )
{
	if( nJopIndex < 0 || nJopIndex >= c_nJopCnt )	return;


	const char* lpJopTreeImage = GetJopTreeImage( m_nJopID[nJopIndex] );
	lpJopTreeImage = NULL;

	// AziaMafia SkilltreeDisplay
	//if (lpJopTreeImage == NULL)
	//	lpJopTreeImage = "game_panel_skill_skilltree_" + m_nJopID[nJopIndex];

	KUIControlStatic* pTreeImageCtr = dynamicCast<KUIControlStatic*>(GetChild( "jop_tree_image" ));
	if( pTreeImageCtr )
	{
		if( lpJopTreeImage )
		{
			pTreeImageCtr->SetAniName( lpJopTreeImage );
			pTreeImageCtr->SetCaption( "" );
		}
		else
		{
			pTreeImageCtr->SetAniName( "" );
			pTreeImageCtr->SetCaption("");
		//	pTreeImageCtr->SetCaption( "[!!! ERR !!!] can't search [JopTree]..." );
		}
	}
}

void SUISkillTreeFundWnd::SetSkillData( int nX, int nY, int nJopIndex, int nSkillID, _SkillSlotInfo* pInfo )
{
	SkillBaseEx* s_data = GetSkillDB().GetSkillData( nSkillID );
	if( s_data )
	{
		if( pInfo == NULL )
		{
			assert(false && "Database data does not match");
			return;
		}

		SetSkillSlotTooltip( dynamicCast<KUIControlIconStatic*>(GetChild( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillSlotCtrName, nY, nX ).c_str() )), s_data, pInfo, nJopIndex );

		int nLv( ::min(pInfo->nCrrLv, pInfo->nMaxLv[nJopIndex]) );
		std::string strCaption = CStringUtil::StringFormat( "<font:font_02><hcenter><size:8>%d/%d", nLv, pInfo->nMaxLv[nJopIndex] );
		SetChildCaption( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillLvTextCtrName, nY, nX ).c_str() , strCaption.c_str() );

		SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillSlotCtrName, nY, nX ).c_str() , true );
		SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillLvBackCtrName, nY, nX ).c_str() , true );
		SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillLvTextCtrName, nY, nX ).c_str() , true );

		int nNeedJp(0);
		SkillBaseEx* s_data = GetSkillDB().GetSkillData( pInfo->nID );
		if( s_data )	nNeedJp = s_data->GetNeedJopPoint(pInfo->nCrrLv+1);

		/// 2011.03.30 - prodongi
		bool bShowDis;
		if (0 > nNeedJp)	/// tp
		{
			int playerTp = m_PlayerInfoMgr.GetTP();
			int needTp = abs(nNeedJp);
			bShowDis = ( pInfo->nEnoughJLv || playerTp < needTp || pInfo->nNeedSkillID );
		}
		else
		{
			bShowDis = ( pInfo->nEnoughJLv || m_nJopPoint < nNeedJp || pInfo->nNeedSkillID );
		}		

		if( pInfo->nCrrLv >= pInfo->nMaxLv[nJopIndex] )
			bShowDis = false;
		SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSlotDisableCtrName, nY, nX ).c_str() , bShowDis );

		//gmpbigsun( 20130405 ) : 레벨검사 추가
		bool bShowUp( !bShowDis && pInfo->nCrrLv < pInfo->nMaxLv[nJopIndex] && m_PlayerInfoMgr.GetLevel() >= pInfo->lv );
		SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillUpCtrName, nY, nX ).c_str() , bShowUp );
		SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillAbleUpCtrName, nY, nX ).c_str() , bShowUp );

		/// 2010.12.21 - prodongi
		//SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpPassiveSlotCtrName, nY, nX ).c_str() , !bShowUp && s_data->IsPassive() );
		KUIWnd* passiveWnd = GetChild(CStringUtil::StringFormat( "%s_%02d_%02d", c_lpPassiveSlotCtrName, nY, nX ).c_str());
		if (passiveWnd)
		{
			passiveWnd->SetShow(true);
			if (s_data->IsPassive())	passiveWnd->SetBack(m_sSprName.c_str(), "game_panel_titanium_slot_skill_passive");
			else						passiveWnd->SetBack(m_sSprName.c_str(), "game_panel_titanium_slot_skill_active");
		}
	}
	else
	{
		SetSkillSlotTooltip( dynamicCast<KUIControlIconStatic*>(GetChild( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillSlotCtrName, nY, nX ).c_str() )), s_data, NULL, nJopIndex );

		SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillSlotCtrName, nY, nX ).c_str() , false );
		SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillAbleUpCtrName, nY, nX ).c_str() , false );
		SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSlotDisableCtrName, nY, nX ).c_str() , false );
		SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillLvBackCtrName, nY, nX ).c_str() , false );
		SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillLvTextCtrName, nY, nX ).c_str() , false );
		SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpSkillUpCtrName, nY, nX ).c_str() , false );
		SetChildShow( CStringUtil::StringFormat( "%s_%02d_%02d", c_lpPassiveSlotCtrName, nY, nX ).c_str() , false );
	}
}

void SUISkillTreeFundWnd::SetSkillSlotTooltip( KUIControlIconStatic* pIcon, SkillBaseEx* s_data, _SkillSlotInfo* pInfo, int nJopIndex )
{
	if( pIcon == NULL )	return;

	if( s_data )
	{
		if( pInfo->nCrrLv == 0 )
			pIcon->SetIcon( c_szDEF_SPR_NAME, "common_mark_icon_unknown_middle" );	/// 2011.01.10 - prodongi
		else	pIcon->SetIcon( c_szDEF_SPR_NAME, s_data->GetIconName() );

		if( !pInfo )	pIcon->SetTooltip( "아니 어떻게 스킬트리에 데이터가 없냐??" );
		else
		{
			// sonador 1.2.5	Lazy Tooltip 구현
			pIcon->SetLazyTooltip( new KLazySkillTreeFundTooltip( *m_pDisplayInfo, *s_data, *pInfo, nJopIndex, m_nJopPoint, m_PlayerInfoMgr.GetTP(), m_PlayerInfoMgr.GetLevel() ) );	// sonador #2.1.2.4.3	팻 조작 UI 연동
		}
	}
	else
	{
		pIcon->SetIcon( c_szDEF_SPR_NAME, c_lpSkillEmptyAni );
	}
}

int SUISkillTreeFundWnd::GetSkillData( int nJopIndex, int nX, int nY )
{
	if( nJopIndex < 0 || nJopIndex >= c_nJopCnt || !m_nJopID[nJopIndex] )	return 0;

	for( int i(0); i<m_SkillTreeDisplay[nJopIndex].size(); ++i )
	{
		if( m_nJopID[nJopIndex] == m_SkillTreeDisplay[nJopIndex][i]->job_id )
		{
			if( nY = m_SkillTreeDisplay[nJopIndex][i]->slot_v )
			{
				switch( nX )
				{
				case 0:		return m_SkillTreeDisplay[nJopIndex][i]->skill1_id;		break;
				case 1:		return m_SkillTreeDisplay[nJopIndex][i]->skill2_id;		break;
				case 2:		return m_SkillTreeDisplay[nJopIndex][i]->skill3_id;		break;
				case 3:		return m_SkillTreeDisplay[nJopIndex][i]->skill4_id;		break;
				case 4:		return m_SkillTreeDisplay[nJopIndex][i]->skill5_id;		break;
				}
			}
		}
	}

	return 0;
}

void SUISkillTreeFundWnd::SetClickIcon( const char* lpCtrName )
{
	SetClickIconData( m_nTabType, lpCtrName );

	KUIWnd* pWnd = GetChild( lpCtrName );
	if( pWnd )
	{
		KRect rt = pWnd->GetRect();
		KUIWnd* pSelectWnd = GetChild( "skillfund_select" );
		if( pSelectWnd )
		{
			pSelectWnd->MovePos( rt.left, rt.top );
			pSelectWnd->SetShow( true );
		}
	}
}

void SUISkillTreeFundWnd::SetClickIconData( int nJopIndex, const char* lpCtrName )
{
	int nX(0), nY(0);
	GetIndex_X_Y( nJopIndex, lpCtrName, nX, nY );

	if( nY < 0 || nY >= c_nSkillHeightCnt )	return;

	m_sClickData.strCtrName = lpCtrName;
	m_sClickData.nX = nX;
	m_sClickData.nY = nY;
	m_sClickData.nSkillID = GetSkillID( nJopIndex, nX, nY );
}

void SUISkillTreeFundWnd::GetIndex_X_Y( int nJopIndex, const char* lpCtrName, int& nX, int& nY )
{
	std::string strCtrName = lpCtrName;

	int nPos = strCtrName.find("_");
	if( nPos != -1 )
	{
		strCtrName.erase(0, nPos+1);
		std::string strTemp_X( strCtrName.c_str() ), strTemp_Y( strCtrName.c_str() );

		int _nPos = strCtrName.rfind("_");
		if( _nPos != -1 )
		{
			strTemp_X.erase(0, _nPos+1);
			strTemp_Y.erase(_nPos, strTemp_Y.size());

			nX = ::atoi( strTemp_X.c_str() );
			nY = ::atoi( strTemp_Y.c_str() );
		}
	}
}

int SUISkillTreeFundWnd::GetSkillID( int nJopIndex, int nX, int nY )
{
	if( nY < 0 || nY >= c_nSkillHeightCnt )	return -1;

	switch( nX )
	{
	case 0:		return	m_SkillTreeDisplay[nJopIndex][nY]->skill1_id;		break;
	case 1:		return	m_SkillTreeDisplay[nJopIndex][nY]->skill2_id;		break;
	case 2:		return	m_SkillTreeDisplay[nJopIndex][nY]->skill3_id;		break;
	case 3:		return	m_SkillTreeDisplay[nJopIndex][nY]->skill4_id;		break;
	case 4:		return	m_SkillTreeDisplay[nJopIndex][nY]->skill5_id;		break;
	}
	return -1;
}

void SUISkillTreeFundWnd::InitClickIconData()
{
	m_sClickData.strCtrName.clear();
	m_sClickData.nSkillID = 0;
	m_sClickData.nX = 0;
	m_sClickData.nY = 0;

	KUIWnd* pSelectWnd = GetChild( "skillfund_select" );
	if( pSelectWnd )
		pSelectWnd->SetShow( false );
}

const char* SUISkillTreeFundWnd::GetJopTreeImage( int nJopID )
{
	/// 2011.02.24 - prodongi
	/*
	switch( nJopID )
	{
	case 300:	return c_lpAsura_0;			break;	//= "static_player_skilltree_asura_00_bb";	//스테퍼
	case 302:	return c_lpAsura_1_mgc;		break;	//= "static_player_skilltree_asura_01_pp";	//매지션
	case 303:	return c_lpAsura_1_smr;		break;	//= "static_player_skilltree_asura_01_ss";	//서모너
	case 301:	return c_lpAsura_1_std;		break;	//= "static_player_skilltree_asura_01_ww";	//스트라이더
	case 311:	return c_lpAsura_2_rgr;		break;	//= "static_player_skilltree_asura_02_hh";	//레인저
	case 313:	return c_lpAsura_2_dmg;		break;	//= "static_player_skilltree_asura_02_pd";	//다크매지션
	case 312:	return c_lpAsura_2_ssr;		break;	//= "static_player_skilltree_asura_02_pp";	//소서러
	case 314:	return c_lpAsura_2_bsm;		break;	//= "static_player_skilltree_asura_02_ss";	//배틀서모너
	case 310:	return c_lpAsura_2_asn;		break;	//= "static_player_skilltree_asura_02_ww";	//어쌔신

	case 200:	return c_lpDeva_0;			break;	//= "static_player_skilltree_deva_00_bb";	//가이드
	case 202:	return c_lpDeva_1_clr;		break;	//= "static_player_skilltree_deva_01_pp";	//클레릭
	case 203:	return c_lpDeva_1_tmr;		break;	//= "static_player_skilltree_deva_01_ss";	//테이머
	case 201:	return c_lpDeva_1_ptr;		break;	//= "static_player_skilltree_deva_01_ww";	//파이터
	case 212:	return c_lpDeva_2_mge;		break;	//= "static_player_skilltree_deva_02_pm";	//메이지
	case 213:	return c_lpDeva_2_prt;		break;	//= "static_player_skilltree_deva_02_pp";	//프리스트
	case 214:	return c_lpDeva_2_brd;		break;	//= "static_player_skilltree_deva_02_ss";	//브리더
	case 210:	return c_lpDeva_2_nit;		break;	//= "static_player_skilltree_deva_02_wn";	//나이트
	case 211:	return c_lpDeva_2_wr;		break;	//= "static_player_skilltree_deva_02_ww";	//워리어

	case 100:	return c_lpGaia_0;			break;	//= "static_player_skilltree_gaia_00_bb";	//방랑자
	case 102:	return c_lpGaia_1_jss;		break;	//= "static_player_skilltree_gaia_01_pp";	//주술사
	case 103:	return c_lpGaia_1_yss;		break;	//= "static_player_skilltree_gaia_01_ss";	//야수사
	case 101:	return c_lpGaia_1_tsa;		break;	//= "static_player_skilltree_gaia_01_ww";	//투사
	case 111:	return c_lpGaia_2_gsa;		break;	//= "static_player_skilltree_gaia_02_hh";	//궁사
	case 112:	return c_lpGaia_2_mds;		break;	//= "static_player_skilltree_gaia_02_pp";	//마도사
	case 113:	return c_lpGaia_2_mts;		break;	//= "static_player_skilltree_gaia_02_pw";	//마투사
	case 114:	return c_lpGaia_2_mss;		break;	//= "static_player_skilltree_gaia_02_ss";	//마수사
	case 110:	return c_lpGaia_2_js;		break;	//= "static_player_skilltree_gaia_02_ww";	//전사
	}
	*/
	std::map<int, char const*>::iterator it = m_treeImageList.find(nJopID);
	if (it == m_treeImageList.end())
		return NULL;
	return it->second;
}

void SUISkillTreeFundWnd::SkillUP( int nJopIndex, const char* lpCtrName )
{
	int nX(0), nY(0);
	GetIndex_X_Y( nJopIndex, lpCtrName, nX, nY );
	if( nY < 0 || nY >= c_nSkillHeightCnt )	return;

	SIMSG_UI_ACT_LEARN_SKILL msg;
	msg.handle = m_PlayerInfoMgr.GetPlayerHandle();
	msg.nSkillID = GetSkillID( nJopIndex, nX, nY );
	msg.nSkillLv = m_SkillSlotMgr.GetBaseSkillLevel( msg.nSkillID, msg.handle ) + 1;
	m_pGameManager->ProcMsgAtStatic(&msg);
}

void SUISkillTreeFundWnd::refreshTP()
{
	KUIWnd* child = GetChild("skill_trait_00");
	if (child)
	{
		SetChildCaption( "skill_trait_point", CStringUtil::StringFormat( "<font:font_02><size:9><hcenter>%d", m_PlayerInfoMgr.GetTP()).c_str() );
		std::string aniName;
		if ( m_PlayerInfoMgr.GetTP() > 5 )
			aniName = CStringUtil::StringFormat("game_panel_titanium_skill_trait_point_0%d", 5);
		else
			aniName = CStringUtil::StringFormat("game_panel_titanium_skill_trait_point_0%d", m_PlayerInfoMgr.GetTP());
		child->SetBack(c_szDEF_SPR_NAME, aniName.c_str());
	}
	
}