#include "stdafx.h"
#include "KUIDragAndDrop.h"
#include "KUIControlStatic.h"
#include "KUIWndManager.h"
#include "KUIControlButton.h"
#include "KUIControlClockBox.h"
#include "KUIControlQuickEffect.h"
#include "SUIQuickSlotWnd.h"
#include "SGameManager.h"
#include "SGameMessage.h"
//#include "SGameMessageUI.h"
#include "SGameWorldKeymapping.h"
#include "SGameOption.h"
#include "SSummonSlotMgr.h"
#include "SInventoryMgr.h"
#include "SStringDB.h"
#include "SSkillDB.h"
#include "SItemDB.h"
#include "SUIDisplayInfo.h"
#include "SSkillSlot.h"
#include "UIHelper.h"
// 2010.07.20 - prodongi
//#include "SUIUtil.h"
#include "SGameSystem.h"
extern SGameSystem * g_pCurrentGameSystem;

namespace
{
	const char* c_szIconSlotName	= "icon_slot";
	const char* c_szIconEffecttName	= "icon_effect";
	const char* c_szClockSlotName	= "clock_slot";
	const char* c_szStaticSlotCount	= "static_slotcount"; //아이템 중첩 갯수
	const char* c_szStaticText		= "static_text"; //단축키

	// 2010.04.20 정리 - prodongi
	//const char* c_szTooltipSprName = c_szDEF_SPR_NAME;

	// 2010.04.20 정리 - prodongi
	/*
	const int c_nCreatureDelta  = 60;
	const int c_nCreatureHeight = 484;
	*/

	const float c_HighlightKeymapString = 1.0f;
	const float c_DefaultKeymapString = 0.3f;

	// 2010.04.20 정리 - prodongi
	/*
	const int c_nDifferenceHeight = 50;
	int c_nOriginalPosY;
	*/	
};

SUIQuickSlotWnd::SUIQuickSlotWnd( SGameManager* pGameManager, SUIDisplayInfo* pDisplayInfo )
	: SUIWnd( pGameManager ), m_pDisplayInfo( pDisplayInfo ), m_nDragIndex(-1), m_curLayer(DEFAULT_LAYER),
	m_mouseX(0), m_mouseY(0)
{
	m_pSlotControlIDs = new SLOT_INFO[ SUIDisplayInfo::c_nQuickSlotCount ];
	for( int n( 0 ); n < SUIDisplayInfo::c_nQuickSlotCount; ++n )
	{
		std::string strNum = CStringUtil::StringFormat( "%02d", n );		
		m_pSlotControlIDs[ n ].strIconControl			= c_szIconSlotName + strNum;
		m_pSlotControlIDs[ n ].strClockControl			= c_szClockSlotName + strNum;
		m_pSlotControlIDs[ n ].strStaticCountControl	= c_szStaticSlotCount + strNum;
		m_pSlotControlIDs[ n ].strIconEffectControl		= c_szIconEffecttName + strNum;
		m_pSlotControlIDs[ n ].strStaticText			= c_szStaticText + strNum;

	}

	// 2010.04.20 정리 - prodongi
	/*
	m_nQuickSlotState = QUICKSLOTSTATE_ALL;
	m_nQuickSlotOrder = QUICKSLOTORDER_A;

	c_nOriginalPosY = -1;
	*/

	for (int i = 0; i < TOTAL_LAYER; ++i)
	{
		// 2010.05.18 - prodongi
		sLayerAlphaInfo* info = m_layerAlphaInfo + i;
		info->m_alphaLevel = 0;
		info->m_alpha = levelToAlpha(info->m_alphaLevel);
		//m_layerAlphaLevel[i] = 0;
		//m_layerAlpha[i] = levelToAlpha(m_layerAlphaLevel[i]);
	}

	loadIni();
}

SUIQuickSlotWnd::~SUIQuickSlotWnd()
{
	saveIni();
	delete [] m_pSlotControlIDs;

	// 2011.05.17 - servantes
	GetGameOption().SetQuickHozX( GetRect().left );
	GetGameOption().SetQuickHozY( GetRect().top );
}

bool SUIQuickSlotWnd::InitControls( KPoint kPos )
{
//	SetChildShow( c_szCheckButtonDefault, true );

	
	for( int nSlot( 0 ); nSlot < SUIDisplayInfo::c_nQuickSlotCount; ++nSlot )
	{
		KUIControlMultiIcon* pIconSlotControl = dynamicCast<KUIControlMultiIcon*>(GetChild( m_pSlotControlIDs[ nSlot ].strIconControl.c_str() ));
		if( NULL != pIconSlotControl )
		{
			// 아이템 multi icon 레이어 설정, 툴팁 스프라이트 설정
			pIconSlotControl->SetIconLayer( 8 );

			// clock 컨트롤 생성
			KUIWND_CREATE_ARG ClockCreateArg( "clockbox", m_pSlotControlIDs[ nSlot ].strClockControl.c_str(), "", pIconSlotControl->GetRect(), 0, KFLAG_NO_GET_MESSAGE, this, "", c_szDEF_SPR_NAME, m_pManager );

			KUIControlClockBox* pClockControl = (KUIControlClockBox*)m_pManager->CreateControl( ClockCreateArg );
			pClockControl->SetColor( c_ColorClockControl );
		}
	}

	for( int nSlot( 0 ); nSlot < SUIDisplayInfo::c_nQuickSlotCount; ++nSlot )
	{
		KUIControlMultiIcon* pIconSlotControl = dynamicCast<KUIControlMultiIcon*>(GetChild( m_pSlotControlIDs[ nSlot ].strIconControl.c_str() ));

		if(pIconSlotControl)
		{
			KRect rt( pIconSlotControl->GetRect() );
			//SetMovePos( CStringUtil::StringFormat( "icon_effect%02d", nSlot ).c_str(), rt.left-27, rt.top-27 );
			//SetChildAsTop( CStringUtil::StringFormat( "icon_effect%02d", nSlot ).c_str() );
			SetMovePos( m_pSlotControlIDs[nSlot].strIconEffectControl.c_str(), rt.left-27, rt.top-27 );
			SetChildAsTop( m_pSlotControlIDs[nSlot].strIconEffectControl.c_str() );
		}

		//일단 키맵핑표시 text는 반투명으로..
		SetChildAlpha(m_pSlotControlIDs[ nSlot ].strStaticText.c_str(),c_DefaultKeymapString);		
	}
	
	m_vSkillStatus.clear();
	return SUIWnd::InitControls( kPos );
}
bool SUIQuickSlotWnd::InitData( bool bReload )
{
	// 2010.04.20 정리 - prodongi
	//m_nCreatureQuick = 0;
	m_bDraging = false;

	// prodongi
//	RefreshQuickSlots();
//	SetQuickSlotState(QUICKSLOTSTATE_ALL, QUICKSLOTORDER_A);
	initLayer();

	return SUIWnd::InitData(bReload);
}
void SUIQuickSlotWnd::OnNotifyUIWindowOpen( bool bOpen, bool bLimitWnd )
{
	SUIWnd::OnNotifyUIWindowOpen(bOpen);

	if(bOpen == false)   // 2011.05.17 - servantes
	{
		GetGameOption().SetQuickHozX( GetRect().left );
		GetGameOption().SetQuickHozY( GetRect().top );
	}
}
void* SUIQuickSlotWnd::Perform( KID id, KArg& msg )
{
	_CID( UI_BEGIN_DRAG );
	_CID( UI_SEND_DROP );
	_CID( UI_RECV_DROP );

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

		int nSlotIndex = GetSlotIndex( szControlID );
		m_nDragIndex = nSlotIndex;
		if( 0 <= nSlotIndex && nSlotIndex < SUIDisplayInfo::c_nQuickSlotCount )
		{
			// 비어있지 않은 슬롯만
			//bool bDefault( IsDefaultSlot(szControlID) );
			//QUICKSLOT_BTNSTATE ButtonState(QUICKSLOT_DEFAULT);
			//if( !bDefault )	ButtonState = m_SelectedButtonState;

			if( !m_pDisplayInfo->IsEmptyQuickSlot( nSlotIndex ) )
			{
				KUIControlMultiIcon* pWndMultiIcon = dynamicCast<KUIControlMultiIcon*>(GetChild( szControlID ));
				if( NULL != pWndMultiIcon )
				{
					const KUIControlMultiIcon::ICON_INFO& rIconInfo = pWndMultiIcon->GetIconInfoByLayer(0);

					m_pDisplayInfo->SetUIDragInfo( new SUIQuickSlotDragInfo( nSlotIndex ) );

					m_pDragAndDropIcon->SetStateIcon( pWndMultiIcon->GetSprName(), rIconInfo.sAniName.c_str(), rIconInfo.nFrameIndex, 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 && SUIDragInfo::DRAGTYPE_QUICKSLOT == pUIDragInfo->m_type )
		{
			m_nDragIndex = -1;
			SUIQuickSlotDragInfo* pQuickSlotDragInfo = (SUIQuickSlotDragInfo*)pUIDragInfo;

			// 동일한 창이 아닌 곳에 드롭했다면 슬롯을 비운다.
			if( pSendMsg->sRecvDropParentID != std::string(GetID()) )
			{
				// 슬롯을 비운다.
				int nSlotIndex = pQuickSlotDragInfo->m_nSlotIndex;
				m_pDisplayInfo->SetQuickSlot( nSlotIndex );
				m_pDisplayInfo->SaveQuickSlots();
				// Drag & Drop 정보 제거
				m_pDisplayInfo->SetUIDragInfo();

				RefreshQuickEffect( nSlotIndex );

/*				// 삭제됨-- D&D에서 버튼 release후에 메시지가 안 남으므로 비 실용적...
			} else if (m_pDisplayInfo->GetBackupedQuickSlot()!=NULL) {					// 같은 창 + 다른 슬롯을 덮어씌웠음
				// 새로운 D&D info 추가
				const char* szControlID = GetID();
				KUIControlMultiIcon* pWndMultiIcon = (KUIControlMultiIcon*)GetChild( szControlID );
				if( NULL != pWndMultiIcon )
				{
					const KUIControlMultiIcon::ICON_INFO& rIconInfo = pWndMultiIcon->GetIconInfoByLayer(0);

					m_pDisplayInfo->SetUIDragInfo( new SUIQuickSlotDragInfo( pQuickSlotDragInfo->m_ButtonState, -1 ) );
					m_pDragAndDropIcon->SetStateIcon( pWndMultiIcon->GetSprName(), rIconInfo.sAniName.c_str(), rIconInfo.nFrameIndex, STATE_NORMAL );
				}
*/

			}
			else
			{
				m_pDisplayInfo->SetUIDragInfo();
			}

		}
		return NULL;
	}
	else if ( id == id_UI_RECV_DROP )
	{
		KUISendRecvDropMessage* pRecvMsg = static_cast<KUISendRecvDropMessage*>( &msg );

		m_bDraging = false;

		int nDropIndex = GetSlotIndex( pRecvMsg->sRecvDropControlID.c_str() );
		//bool bDefault( IsDefaultSlot(pRecvMsg->sRecvDropControlID.c_str()) );	//디폴트 슬롯에 드롭했는가?
		//QUICKSLOT_BTNSTATE ButtonState(QUICKSLOT_DEFAULT);
		//if( !bDefault )	ButtonState = m_SelectedButtonState;

		if( 0 <= nDropIndex && nDropIndex < SUIDisplayInfo::c_nQuickSlotCount )
		{
			const SUIDragInfo* pUIDragInfo = m_pDisplayInfo->GetUIDragInfo();
			if( NULL != pUIDragInfo )
			{
				// 퀵슬롯에서 드래그 한 경우
				if( SUIDragInfo::DRAGTYPE_QUICKSLOT == pUIDragInfo->m_type )
				{
					const SUIQuickSlotDragInfo* pQuickSlotDragInfo = (SUIQuickSlotDragInfo*)pUIDragInfo;

					// 다른 슬롯에 드롭한 경우
					//if( ButtonState != pQuickSlotDragInfo->m_ButtonState || nDropIndex != pQuickSlotDragInfo->m_nSlotIndex )
					//문제 있음 주의바람
					if( nDropIndex != pQuickSlotDragInfo->m_nSlotIndex )
//					if( m_CurrentButtonState != pQuickSlotDragInfo->m_ButtonState || nDropIndex != pQuickSlotDragInfo->m_nSlotIndex )
					{
						//토글상태를 옮기기 위한것..
						//nDropIndex 새로 갈놈..
						//m_nSlotIndex 원래 자리...
						KUIControlQuickEffect *pSlotEffect1 = dynamicCast<KUIControlQuickEffect*>(GetChild( m_pSlotControlIDs[ nDropIndex ].strIconEffectControl.c_str() ));
						KUIControlQuickEffect *pSlotEffect2 = dynamicCast<KUIControlQuickEffect*>(GetChild( m_pSlotControlIDs[ pQuickSlotDragInfo->m_nSlotIndex ].strIconEffectControl.c_str() ));

						bool t1,t2;
						if(pSlotEffect1 && pSlotEffect2)
						{
							t1 = pSlotEffect1->IsToggleOn();
							t2 = pSlotEffect2->IsToggleOn();
						}

						// 새 슬롯에 옮기고 기존 슬롯은 제거한다.
						m_pDisplayInfo->SetQuickSlot( nDropIndex, pQuickSlotDragInfo );
						m_pDisplayInfo->SaveQuickSlots();

						if(pSlotEffect1 && pSlotEffect2 && !( t1 && t2) )
						{
							pSlotEffect1->ToggleOn(t2);
							pSlotEffect2->ToggleOn(t1);
						}

						
						RefreshQuickEffect( nDropIndex );
						RefreshQuickEffect( pQuickSlotDragInfo->m_nSlotIndex );

						m_pGameManager->StartSound( m_pDisplayInfo->GetDragMaterialSound() );
					}
				}
				else
				{
					// 퀵 슬롯 설정
					m_pDisplayInfo->SetQuickSlot( nDropIndex, pUIDragInfo );
					m_pDisplayInfo->SaveQuickSlots();

					RefreshQuickEffect( nDropIndex );

					m_pGameManager->StartSound( m_pDisplayInfo->GetDragMaterialSound(), 50 );
				}
			}
		}
		return NULL;
	}
	return SUIWnd::Perform( id, msg );
}

void SUIQuickSlotWnd::ToggleSkillByUser(int nSlot)
{
	if( m_nDragIndex != nSlot && !m_bDraging && 0 <= nSlot && nSlot < SUIDisplayInfo::c_nQuickSlotCount )
	{
		const SUIQuickSlotInfo * pSlotInfo = m_pDisplayInfo->GetQuickSlot( nSlot );
		if(pSlotInfo)
		{
			if(pSlotInfo->m_type == SUIQuickSlotInfo::QSLOTTYPE_SKILL)
			{						
				const SUIQuickSlotSkillInfo * pSkillInfo = (const SUIQuickSlotSkillInfo *)pSlotInfo;

				if(pSkillInfo->m_bPlayer)//일단 크리쳐 스킬만..
					return;
				int nStatus = GetSkillStatus( pSkillInfo->m_hTarget, pSkillInfo->m_nSkillID );

				if(	nStatus == STATE_TOGGLE_ON	||	nStatus == STATE_TOGGLE_OFF )
					return;

				if( !m_CreatureSlotMgr.IsExistSummonedCreature( pSkillInfo->m_hTarget ) )	// 소환되지 않은 크리쳐면 실행안되게..
					return;

				SkillBaseEx * pSkillBase = GetSkillDB().GetSkillData( pSkillInfo->m_nSkillID );
				if( pSkillBase == NULL ) 			
					return;	

				if( pSkillBase->IsToggle() ) 
					return;
				if( pSkillBase->IsHarmful() == false ) 
					return;
				if( pSkillBase->IsPassive() ) 
					return;

				

				if( !IsToggleOnByUserSkillStatus( pSkillInfo->m_hTarget, pSkillInfo->m_nSkillID ) )
				{
					//			UpdateSkillStatus(pSkillInfo->m_hTarget, pSkillInfo->m_nSkillID, STATE_TOGGLE_ON_BY_USER);				
					UpdateSkillToggle(pSkillInfo->m_hTarget, pSkillInfo->m_nSkillID, STATE_TOGGLE_ON_BY_USER);				
					UpdateEffect(pSkillInfo->m_hTarget, pSkillInfo->m_nSkillID, STATE_TOGGLE_ON_BY_USER);
				}
				else
				{
					//			UpdateSkillStatus(pSkillInfo->m_hTarget, pSkillInfo->m_nSkillID, STATE_TOGGLE_OFF_BY_USER );
					UpdateSkillToggle(pSkillInfo->m_hTarget, pSkillInfo->m_nSkillID, STATE_TOGGLE_OFF_BY_USER);				
					UpdateEffect(pSkillInfo->m_hTarget, pSkillInfo->m_nSkillID, STATE_TOGGLE_OFF_BY_USER);
				}

			}	

		}
	}
}

void SUIQuickSlotWnd::PumpUpMessage( LPCSTR lpszControlID, DWORD nMessage, DWORD lparam, DWORD wparam )
{
	switch( nMessage )
	{
	case KUI_MESSAGE::KBUTTON_CLICK:
		{
			/* prodongi
			if( 0 == ::_stricmp( "button_quickslot_up", lpszControlID ) )				
				SetQuickSlotState(QUICKSLOTSTATE_ALL, m_nQuickSlotOrder);
			else if( 0 == ::_stricmp( "button_quickslot_down", lpszControlID ) )				
				SetQuickSlotState(QUICKSLOTSTATE_SINGLE, m_nQuickSlotOrder);
			else if( 0 == ::_stricmp( "button_quickslot_change", lpszControlID ) )
				SetQuickSlotState( m_nQuickSlotState, m_nQuickSlotOrder == QUICKSLOTORDER_A ? QUICKSLOTORDER_B : QUICKSLOTORDER_A);
			*/
			if (0 == _stricmp("button_quickslot_up", lpszControlID) || 0 == _stricmp("button_quickslot_down", lpszControlID))
				modifyLayer();
		}
		break;
	case KUI_MESSAGE::KICON_CLICK:
		{
//			m_pGameManager->StartSound( "ui_button_click.wav" );

			int nSlotIndex = GetSlotIndex( lpszControlID );
			if( m_nDragIndex != nSlotIndex && !m_bDraging && 0 <= nSlotIndex && nSlotIndex < SUIDisplayInfo::c_nQuickSlotCount )
			{
				//if( IsDefaultSlot(lpszControlID) )
				//	m_pDisplayInfo->UseQuickSlot( QUICKSLOT_DEFAULT, nSlotIndex );
				//else	m_pDisplayInfo->UseQuickSlot( m_SelectedButtonState, nSlotIndex );
				m_pDisplayInfo->UseQuickSlot( nSlotIndex );
			}
		}
		break;
	
	case KUI_MESSAGE::KICON_RCLICK:
		{			
			int nSlotIndex = GetSlotIndex( lpszControlID );
			ToggleSkillByUser(nSlotIndex);					
		}
		break;

	case KUI_MESSAGE::KCHECK_CHANGE:
		{
			/*if( 0 == ::_stricmp( c_szCheckButtonAlt    , lpszControlID ) )		m_SelectedButtonState = QUICKSLOT_ALT;
			else if( 0 == ::_stricmp( c_szCheckButtonShift  , lpszControlID ) ) m_SelectedButtonState = QUICKSLOT_SHIFT;
			else if( 0 == ::_stricmp( c_szCheckButtonControl, lpszControlID ) ) m_SelectedButtonState = QUICKSLOT_CONTROL;

			ChangeButtonState(m_SelectedButtonState);*/
//			PostButtonSelectChangeMsg();

			if (strstr(lpszControlID, "slider_titamium_quickslot_transparent"))
			{
				setLayerAlpha(lpszControlID, true);
				//setLayerAlpha(lpszControlID, true, m_isMouseFocusOn ? false : true);
			}
		}
		break;

	case KUI_MESSAGE::KGENWND_MOVE:
		{
			LimitMoveWnd();

			//if( ::_stricmp( lpszControlID, "quickslot_v" ) == 0 )
			//{
			//	GetGameOption().SetQuickVerX( GetRect().left );
			//	GetGameOption().SetQuickVerY( GetRect().top );
			//}
			//else 
			// 2011.05.17 - servantes 움직일 때마다 계속저장 느리다. 열고 닫고 소멸자에서 저장
		//	if( ::_stricmp( lpszControlID, "quickslot_h" ) == 0 )
		//	{
		//		GetGameOption().SetQuickHozX( GetRect().left );
		//		GetGameOption().SetQuickHozY( GetRect().top );
		//	}
		}
		break;
	}
	SUIWnd::PumpUpMessage( lpszControlID, nMessage, lparam, wparam );
}

void SUIQuickSlotWnd::UpdateToggleEffect(AR_HANDLE caster, int nSkillID, int bToggle )
{		
	UpdateSkillToggle( caster, nSkillID, ((bToggle==1) ? STATE_TOGGLE_ON : STATE_TOGGLE_OFF) );
	
	for( int nSlot( 0 ); nSlot < SUIDisplayInfo::c_nQuickSlotCount; ++nSlot )
	{
		const SUIQuickSlotInfo* pSlot = m_pDisplayInfo->GetQuickSlot( nSlot );
		if(pSlot)
		{
			if(pSlot->m_type == SUIQuickSlotInfo::QSLOTTYPE_SKILL)
			{
				const SUIQuickSlotSkillInfo * pSkillInfo = (const SUIQuickSlotSkillInfo *)pSlot;
				
				if(pSkillInfo->m_hTarget == caster && pSkillInfo->m_nSkillID == nSkillID)
				{
					/*UpdateSkillToggle( caster, nSkillID, ((bToggle==1) ? STATE_TOGGLE_ON : STATE_TOGGLE_OFF) );
	
					//KUIControlQuickEffect * pSlotEffect = (KUIControlQuickEffect*)GetChild( CStringUtil::StringFormat( "icon_effect%02d", nSlot ).c_str() );*/
					KUIControlQuickEffect * pSlotEffect = dynamicCast<KUIControlQuickEffect*>(GetChild( m_pSlotControlIDs[ nSlot ].strIconEffectControl.c_str() ));
					if( pSlotEffect ) 
						pSlotEffect->ToggleOn( bToggle );				
				}
			}
		}
	}
}

const int SUIQuickSlotWnd::GetSkillStatusNumber( AR_HANDLE caster, int nSkillID )
{
	for( unsigned int i(0); m_vSkillStatus.size()>i; ++i )
	{	
		if( m_vSkillStatus[i].nSkillID == nSkillID && m_vSkillStatus[i].caster == caster)
			return i;
	}

	return -1;
}

const int SUIQuickSlotWnd::GetSkillStatus( AR_HANDLE caster, int nSkillID )
{
	for( unsigned int i(0); m_vSkillStatus.size()>i; ++i )
	{	
		if( m_vSkillStatus[i].nSkillID == nSkillID && m_vSkillStatus[i].caster == caster)
			return m_vSkillStatus[i].GetStatus();
	}

	//한번도 쓰지 않은 스킬들
	return STATE_NONE;
}

const bool SUIQuickSlotWnd::IsToggleOnByUserSkillStatus( AR_HANDLE caster, int nSkillID )
{
	for( unsigned int i(0); m_vSkillStatus.size()>i; ++i )
	{	
		if( m_vSkillStatus[i].nSkillID == nSkillID && m_vSkillStatus[i].caster == caster)
			return m_vSkillStatus[i].bToggleByUser;
	}

	//한번도 쓰지 않은 스킬들
	return false;
}

void SUIQuickSlotWnd::UpdateSkillToggle( AR_HANDLE caster, int nSkillID, int nStatus )
{
	for( unsigned int i(0); m_vSkillStatus.size()>i; ++i )
	{	
		if( m_vSkillStatus[i].nSkillID == nSkillID && m_vSkillStatus[i].caster == caster)
		{
			m_vSkillStatus[i].SetStatus(nStatus);
			return;
		}
	}

	_SKILL_STATUS skill_status;
	skill_status.Init();
	skill_status.nSkillID = nSkillID;
	skill_status.SetStatus(nStatus);
	skill_status.caster = caster;

	m_vSkillStatus.push_back( skill_status );
}

void SUIQuickSlotWnd::UpdateSkillStatus(AR_HANDLE caster, int nSkillID, int nStatus )
{
	for( unsigned int i(0); m_vSkillStatus.size()>i; ++i )
	{	
		if( m_vSkillStatus[i].nSkillID == nSkillID && m_vSkillStatus[i].caster == caster)
		{
			if( nStatus == TS_SC_SKILL::FIRE )
			{
				if(	m_vSkillStatus[i].GetStatus() != STATE_TOGGLE_ON 
					&& m_vSkillStatus[i].GetStatus() != STATE_TOGGLE_ON_BY_USER )

					m_vSkillStatus[i].SetStatus(STATE_FIRE);
			}
			else if( nStatus == TS_SC_SKILL::CASTING )
			{
				if(	m_vSkillStatus[i].GetStatus() != STATE_TOGGLE_ON 
					&& m_vSkillStatus[i].GetStatus() != STATE_TOGGLE_ON_BY_USER )
					m_vSkillStatus[i].SetStatus(STATE_CASTING);
			}
			else if( nStatus == TS_SC_SKILL::CANCEL )
			{
				if(	m_vSkillStatus[i].GetStatus() != STATE_TOGGLE_ON 
					&& m_vSkillStatus[i].GetStatus() != STATE_TOGGLE_ON_BY_USER )
					m_vSkillStatus[i].SetStatus(STATE_CANCEL);
			}
			return;
		}
	}

	_SKILL_STATUS skill_status;
	skill_status.Init();
	skill_status.nSkillID = nSkillID;
	skill_status.caster = caster;

		 if( nStatus == TS_SC_SKILL::FIRE	 )		skill_status.SetStatus(STATE_FIRE);
	else if( nStatus == TS_SC_SKILL::CASTING )		skill_status.SetStatus(STATE_CASTING);
	else if( nStatus == TS_SC_SKILL::CANCEL  )		skill_status.SetStatus(STATE_CANCEL);
	

	m_vSkillStatus.push_back( skill_status );
}

void SUIQuickSlotWnd::UpdateEffect( AR_HANDLE caster, int nSkillID, int nSkillStatus )
{
	// Let's make it again (?)
	for( int nSlot( 0 ); nSlot < SUIDisplayInfo::c_nQuickSlotCount; ++nSlot )
	{
		const SUIQuickSlotInfo* pSlot = m_pDisplayInfo->GetQuickSlot( nSlot );
		if(pSlot)
		{
			if(pSlot->m_type == SUIQuickSlotInfo::QSLOTTYPE_SKILL)
			{
				const SUIQuickSlotSkillInfo * pSkillInfo = (const SUIQuickSlotSkillInfo *)pSlot;
				
				if(pSkillInfo->m_hTarget == caster)					
					RefreshQuickEffect(nSlot);	
			}
		}
	}
}

void SUIQuickSlotWnd::Process(DWORD dwTime)
{
	SUIWnd::Process( dwTime );

	bool inWindow = isInWindow();
	checkMouseFocusOn(inWindow);
	updateLayerAlphaAni(dwTime - m_dwTime);
	updateTextHightlight(inWindow);

	m_dwTime = dwTime;
 
	static DWORD s_dwDelay = 0;
	static int nPrevSlot = 0;
	if( (m_dwTime - s_dwDelay) > 3000) // AziaMafia FixSkill  = if( (m_dwTime - s_dwDelay) > 3000 )
	{
		s_dwDelay = m_dwTime;
		for( int i(0); i < SUIDisplayInfo::c_nQuickSlotCount; ++i )
		{
			int nSlot = nPrevSlot+i;
			if(nSlot>=SUIDisplayInfo::c_nQuickSlotCount)
				nSlot -= SUIDisplayInfo::c_nQuickSlotCount;

			const SUIQuickSlotInfo* pSlot = m_pDisplayInfo->GetQuickSlot( nSlot );
		
			if(pSlot)
			{
				if(pSlot->m_type == SUIQuickSlotInfo::QSLOTTYPE_SKILL)
				{
					const SUIQuickSlotSkillInfo * pSkillInfo = (const SUIQuickSlotSkillInfo *)pSlot;
					
					if( !pSkillInfo->m_bPlayer)
					{
						if( m_pDisplayInfo->IsCreatureBattleMode( pSkillInfo->m_hTarget ) 
							&& m_CreatureSkillSlotMgr.IsUseSkill(pSkillInfo->m_hTarget, pSkillInfo->m_nSkillID) == false
							&& std::find( m_vecCreatureCastingStatus.begin(), m_vecCreatureCastingStatus.end(), pSkillInfo->m_hTarget ) == m_vecCreatureCastingStatus.end() ) 
						{
							if(IsToggleOnByUserSkillStatus(pSkillInfo->m_hTarget, pSkillInfo->m_nSkillID))
							{
								if(m_pDisplayInfo->UseSkillByToggle(pSkillInfo->m_nSkillID, pSkillInfo->m_nSkillLevel, pSkillInfo->m_bPlayer, pSkillInfo->m_hTarget ))																	
								{
									nPrevSlot = nSlot+1;
									if( nPrevSlot >= SUIDisplayInfo::c_nQuickSlotCount )
										nPrevSlot -= SUIDisplayInfo::c_nQuickSlotCount;

									//s_dwDelay = m_dwTime;		
									break;
								}
								else
								{
									_oprint("Some shit happened\n");
								}
							}
						}
					}
				}
			}
		}
	}
}

void SUIQuickSlotWnd::ProcMsgAtStatic( SGameMessage* pMsg )
{
	switch( pMsg->nType )
	{		
	case MSG_EQUIP_SUMMON:
		{
			bool bSave = false;
			for( int nSlot(0); nSlot < SUIDisplayInfo::c_nQuickSlotCount; ++nSlot )
			{
				const SUIQuickSlotInfo* pSlot = m_pDisplayInfo->GetQuickSlot( nSlot );
				
				if(pSlot)
				{
					if(pSlot->m_type == SUIQuickSlotInfo::QSLOTTYPE_SKILL)
					{
						const SUIQuickSlotSkillInfo * pSkillInfo = (const SUIQuickSlotSkillInfo *)pSlot;
						if(!pSkillInfo->m_bPlayer)
						{							
							if( m_CreatureSlotMgr.GetEquipedCardIndexByCreature( pSkillInfo->m_hTarget ) < 0)
							{																							
								m_pDisplayInfo->SetQuickSlot( nSlot, NULL, 0);
								bSave = true;
							}
						}
					}
				}
			}

			RefreshQuickSlots();
			if(bSave)
				m_pDisplayInfo->SaveQuickSlots();
		}
		break;
	case MSG_AURA:
		{
			SMSG_AURA*	pAuraMsg = (SMSG_AURA*)pMsg;
			UpdateToggleEffect(pAuraMsg->caster, pAuraMsg->skill_id, pAuraMsg->status );
		}
		break;

	case MSG_SKILL_EVENT:
		{
			SMSG_SKILL_EVENT*	pSkillEvent = (SMSG_SKILL_EVENT*)pMsg;
			bool bEndCasting = false;

			switch( pSkillEvent->status_type )
			{
			case TS_SC_SKILL::FIRE:
				{
					std::vector<int> vecSkillList;
					//_oprint("[Skill event] FIRE\n");

					if( pSkillEvent->data_owner == SMSG_SKILL_EVENT::OWNER_LOCAL_PLAYER )																						
						m_SkillSlotMgr.GetIdenticalCoolTimeGroup( pSkillEvent->skill_id, vecSkillList );					
					else if( pSkillEvent->data_owner == SMSG_SKILL_EVENT::OWNER_LOCAL_CREATURE )
						vecSkillList.push_back( pSkillEvent->skill_id );
						//m_CreatureSkillSlotMgr.GetQuickslotID( pSkillEvent->caster, pSkillEvent->skill_id, vecSkillList );
					
					for( int i(0); i<vecSkillList.size(); ++i )
					{
						UpdateSkillStatus( pSkillEvent->caster, vecSkillList[i], TS_SC_SKILL::FIRE );
						UpdateEffect( pSkillEvent->caster, vecSkillList[i], TS_SC_SKILL::FIRE );
					}

					vecSkillList.clear();
					bEndCasting = true;

				}
				break;
			case TS_SC_SKILL::CASTING:
				{					

					if( pSkillEvent->data_owner == SMSG_SKILL_EVENT::OWNER_LOCAL_PLAYER 
						|| pSkillEvent->data_owner == SMSG_SKILL_EVENT::OWNER_LOCAL_CREATURE )
					{
						if( pSkillEvent->cast.nErrorCode != 0 )	
						{
							bEndCasting = true;
						}
						else
						{						
							UpdateSkillStatus( pSkillEvent->caster, pSkillEvent->skill_id, TS_SC_SKILL::CASTING );
							UpdateEffect( pSkillEvent->caster, pSkillEvent->skill_id, TS_SC_SKILL::CASTING );

							bEndCasting = false;
						}
					}
				}
				break;
			case TS_SC_SKILL::CANCEL:
				{
					if( pSkillEvent->data_owner == SMSG_SKILL_EVENT::OWNER_LOCAL_PLAYER 
						|| pSkillEvent->data_owner == SMSG_SKILL_EVENT::OWNER_LOCAL_CREATURE )
					{
						UpdateSkillStatus( pSkillEvent->caster, pSkillEvent->skill_id, TS_SC_SKILL::CANCEL );
						UpdateEffect( pSkillEvent->caster, pSkillEvent->skill_id, TS_SC_SKILL::CANCEL );

						bEndCasting = true;
					}
				}
				break;
			case TS_SC_SKILL::REGION_FIRE:
			case TS_SC_SKILL::COMPLETE:
				{
					bEndCasting = true;
				}
				break;
			}
			
			
			/*if( pSkillEvent->caster != m_CreatureSlotMgr.GetActiveCreatureQuickSlot() )	
				break;*/
			if( pSkillEvent->data_owner != SMSG_SKILL_EVENT::OWNER_LOCAL_CREATURE ) 
				break;

			_oprint("creature id - %d / skill id - %d / status %d \n",pSkillEvent->caster, pSkillEvent->skill_id, pSkillEvent->status_type);

			std::vector< AR_HANDLE >::iterator result;
			result = std::find( m_vecCreatureCastingStatus.begin(), m_vecCreatureCastingStatus.end(), pSkillEvent->caster);

			if(bEndCasting)
			{
				if( result != m_vecCreatureCastingStatus.end())								
					m_vecCreatureCastingStatus.erase(result);									
			}
			else
			{
				if( result == m_vecCreatureCastingStatus.end())								
					m_vecCreatureCastingStatus.push_back(pSkillEvent->caster);								
			}
		}
		break;

	case IMSG_HOTKEY_EX:
		{
			SIMSG_HOTKEY_EX* pHotKey = dynamicCast<SIMSG_HOTKEY_EX*>(pMsg);
			int nSlotIndex = -1;
			
			for(int i=SLOT1_01;i<=SLOT8_12; i++)
			{
				if(GetGameKeymapping().GetHotKeyState(i) == KEYSTATE::DOWN)	
				{
					nSlotIndex = i-SLOT1_01;
					break;
				}
			}
			
			if( nSlotIndex >= 0)
				m_pDisplayInfo->UseQuickSlot( nSlotIndex );


			// 2010.07.05 안쓰는 키 삭제 - prodongi
			//if(GetGameKeymapping().GetHotKeyState(HOTKEYCODE::SLOTCHANGE) == KEYSTATE::DOWN)
			//{
				/*
				
			if( 0 == ::_stricmp( "button_quickslot_up", lpszControlID ) )				
				SetQuickSlotState(QUICKSLOTSTATE_ALL, m_nQuickSlotOrder);
			else if( 0 == ::_stricmp( "button_quickslot_down", lpszControlID ) )				
				SetQuickSlotState(QUICKSLOTSTATE_SINGLE, m_nQuickSlotOrder);
			else if( 0 == ::_stricmp( "button_quickslot_change", lpszControlID ) )
				SetQuickSlotState( m_nQuickSlotState, m_nQuickSlotOrder == QUICKSLOTORDER_A ? QUICKSLOTORDER_B : QUICKSLOTORDER_A);

				*/
				// change는 안함 - prodongi
				// SetQuickSlotState( m_nQuickSlotState, m_nQuickSlotOrder == QUICKSLOTORDER_A ? QUICKSLOTORDER_B : QUICKSLOTORDER_A);
				/*if(m_nQuickSlotState == QUICKSLOTSTATE_A)
					SetQuickSlotState(QUICKSLOTSTATE_B);
				else if(m_nQuickSlotState == QUICKSLOTSTATE_B)
					SetQuickSlotState(QUICKSLOTSTATE_A);*/
			//}
			//else 
			if(GetGameKeymapping().GetHotKeyState(HOTKEYCODE::SLOTUPDOWN) == KEYSTATE::DOWN)
			{
				// prodongi
//				SetQuickSlotState(m_nQuickSlotState == QUICKSLOTSTATE_ALL ? QUICKSLOTSTATE_SINGLE : QUICKSLOTSTATE_ALL, m_nQuickSlotOrder);
				modifyLayer();

				/*if(m_nQuickSlotState == QUICKSLOTSTATE_BOTH)
					SetQuickSlotState(QUICKSLOTSTATE_A);
				else 
					SetQuickSlotState(QUICKSLOTSTATE_BOTH);*/
			}

		}
		break;
	case MSG_SKILLCARD_INFO:
	case IMSG_REFRESH_QUICKSLOT:
		{
			RefreshQuickSlots();			
		}
		break;
	case MSG_UNSUMMON:

		{
			/// 캐스팅 중인 크리쳐 정보 갱신
			for( int nSlot(0); nSlot < SUIDisplayInfo::c_nQuickSlotCount; ++nSlot )
			{
				const SUIQuickSlotInfo* pSlot = m_pDisplayInfo->GetQuickSlot( nSlot );
				
				if(pSlot)
				{
					if(pSlot->m_type == SUIQuickSlotInfo::QSLOTTYPE_SKILL)
					{
						const SUIQuickSlotSkillInfo * pSkillInfo = (const SUIQuickSlotSkillInfo *)pSlot;
						if(!pSkillInfo->m_bPlayer)
						{							
							if( m_CreatureSlotMgr.GetEquipedCardIndexByCreature( pSkillInfo->m_hTarget ) < 0)
							{
								std::vector< AR_HANDLE >::iterator result;
								result = std::find( m_vecCreatureCastingStatus.begin(), m_vecCreatureCastingStatus.end(), pSkillInfo->m_hTarget);
								if( result != m_vecCreatureCastingStatus.end())								
									m_vecCreatureCastingStatus.erase(result);								
							}
						}
					}
				}
			}

			RefreshQuickSlots();
		}
		break;
	case IMSG_UI_MOVE:
		{
		}
		break;
	case MSG_ADDED_SKILL_LIST:
		//break;
	case MSG_SKILL_LIST:
		{
			SMSG_SKILL_LIST* pSkill_List = (SMSG_SKILL_LIST*)pMsg;
			/// 2011.07.04 - prodongi
			if (pSkill_List->isRefresh())
			{	//스킬 퀵 슬롯 삭제
				// 2010.08.04 - prodongi
				//m_pDisplayInfo->ClearSkillQuickSlots();
				m_pDisplayInfo->ClearSkillQuickSlots(pSkill_List->target);
				RefreshQuickSlots();
			}
		}
		break;
	case IMSG_UI_SEND_DATA:
		{
			SIMSG_UI_SEND_DATA* pSkill_List = (SIMSG_UI_SEND_DATA*)pMsg;
			if( pSkill_List->m_strString == "skillup" )
			{
				for( int nSlot(0); nSlot < SUIDisplayInfo::c_nQuickSlotCount; ++nSlot )
				{		
					SUIQuickSlotInfo* pSlot = (SUIQuickSlotInfo*)m_pDisplayInfo->GetQuickSlot( nSlot );

					if(pSlot)
					{					
						if(pSlot->m_type == SUIQuickSlotInfo::QSLOTTYPE_SKILL)					
						{
							SUIQuickSlotSkillInfo * pSkillInfo = (SUIQuickSlotSkillInfo *)pSlot;

							if(pSkillInfo->m_nSkillID != pSkill_List->m_nNumber.getAmount() || !pSkillInfo->m_bPlayer)
								continue;

							int nUseLevel = 1;

							SSkillSlot* pCrrSkill = NULL;
							if(pSkillInfo->m_bPlayer)							
								pCrrSkill = m_SkillSlotMgr.GetSkillSlot( pSkill_List->m_nNumber.getAmount() );																						
							
							if( pCrrSkill )								
								nUseLevel = pCrrSkill->GetUseLevel();							

							m_pDisplayInfo->SetQuickSlotSkillLv( pSkill_List->m_nNumber.getAmount(), nUseLevel, true );
						}
					}
				}

				RefreshQuickSlots();
				m_pDisplayInfo->SaveQuickSlots();
			}
		}
		break;
	case IMSG_SET_KEYMAPPING:
		{
			SIMSG_SET_KEYMAPPING* pSKMsg = (SIMSG_SET_KEYMAPPING*)pMsg;
			
			for( int n( 0 ); n < SUIDisplayInfo::c_nQuickSlotCount; ++n )
			{					
				std::string sz;
				sz = "<vcenter><GLOW><top><right><#ffffff><size:8>";
				sz += GetGameKeymapping().GetHotKeyStringInfo2(n+HOTKEYCODE::SLOT1_01);
				//SetChildCaption( m_pSlotControlIDs[ n ].strStaticText.c_str(), sz.c_str());
								
				KUIControl *wnd = dynamicCast<KUIControl *>(GetChild( m_pSlotControlIDs[ n ].strStaticText.c_str() ));
				if(wnd)
				{
					wnd->SetCaption( sz.c_str() );
					wnd->UpdateCaption();
				}				
			}

			//SetKeymapping();			
		}
		break;
	case IMSG_MOUSEMOVE:
		{
			SIMSG_MOUSEMOVE* pMouseMove = (SIMSG_MOUSEMOVE* )pMsg;
	
			m_mouseX = ((int)(short)LOWORD(pMouseMove->lParam));
			m_mouseY = ((int)(short)HIWORD(pMouseMove->lParam));
		}
		break;
	}
}
/*
bool SUIQuickSlotWnd::IsDefaultSlot( const char* szControlID )
{
	if( m_pSlotControlIDs == NULL ) return false;

	for( int i(0); i<SUIDisplayInfo::c_nQuickSlotCtrCount; ++i )
	{
		if( ::_stricmp( m_pSlotControlIDs[i].strIconControl.c_str(), szControlID ) == 0 )
		{
			if( i>=12 )	return false;
		}
	}
	return true;
}
*/

void SUIQuickSlotWnd::MovePos(int posx, int posy)
{
	SUIWnd::MovePos(posx, posy);
	// 2010.04.20 정리 - prodongi
	/*	
	if(m_nQuickSlotState == QUICKSLOTSTATE_ALL)
		c_nOriginalPosY = GetRect().top;
	else
		c_nOriginalPosY = GetRect().top - c_nDifferenceHeight;
		*/

	SetQuickSlotState();

	// prodongi
//	m_pGameManager->PostMsgAtDynamic( new SIMSG_UI_QUICKSLOT_STATECHANGE( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_CHATTING, this->GetRect().top, m_nQuickSlotState, m_nQuickSlotOrder ) );
	syncChattingWndPos();
	// 2010.05.18 - prodongi
	setWndRectAtLayer();
	initLayerRect();
}

int SUIQuickSlotWnd::GetSlotIndex( const char* szControlID )
{
	if( m_pSlotControlIDs == NULL ) return false;

	for( int nIndex( 0 ); nIndex < SUIDisplayInfo::c_nQuickSlotCount; ++nIndex )
	{
		if( 0 == ::_stricmp( m_pSlotControlIDs[ nIndex ].strIconControl.c_str(), szControlID ) )
		{
			//if( nIndex >= 12 )	nIndex -= 12;
			return nIndex;
		}
	}
	return (-1);
}

void SUIQuickSlotWnd::ChangePosY(const char *control1, const char *control2)
{
	KUIWnd *wnd1, *wnd2;
	wnd1 = GetChild(control1);
	wnd2 = GetChild(control2);
	//wnd3 = NULL;
	if(wnd1 && wnd2)
	{		
		int y = wnd2->GetRect().top;
		wnd2->MovePos(wnd2->GetRect().left,wnd1->GetRect().top);
		wnd1->MovePos(wnd1->GetRect().left,y);
	}
}

void SUIQuickSlotWnd::SetChildEnable(const char *wndname, bool enable)
{
	KUIControl *twnd = dynamicCast<KUIControl *>(GetChild(wndname));
	if(twnd) 
	{
		if(enable)
			twnd->Enable();
		else
			twnd->Disable();
	}
}

void SUIQuickSlotWnd::SetChildEnableShow(const char *wndname, bool enableshow)
{
	SetChildShow(wndname, enableshow);
	SetChildEnable(wndname, enableshow);
}

//void SUIQuickSlotWnd::SetQuickSlotState(int u)
void SUIQuickSlotWnd::SetQuickSlotState(/*int state, int order*/)
{
	setLayer(m_curLayer);
	/* 2010.04.20 setLayer 함수로 대체함 - prodongi
	return ;

	//if(m_nQuickSlotState == u)
	//if(m_nQuickSlotState == state && m_nQuickSlotOrder == order)
		//return;
	m_nQuickSlotState = state;
	m_nQuickSlotOrder = order;

	bool bChanged = false;

	KUIWnd *wnd1, *wnd2, *wnd3;
	wnd1 = GetChild("static_common_outframe_gold01");
	wnd2 = GetChild("static_common_outframe_gold03");
	wnd3 = NULL;

	if(!(wnd1 && wnd2))
		return;

	if(wnd2->GetRect().top > wnd1->GetRect().top)
	{
		if(order == QUICKSLOTORDER_A 
		|| state == QUICKSLOTSTATE_ALL)
			bChanged = true;
	}
	else
	{
		if(order == QUICKSLOTORDER_B)
			bChanged = true;
	}
	

	//4개....
	if(bChanged)
	{		
		ChangePosY("static_common_outframe_gold01","static_common_outframe_gold03");
		ChangePosY("static_common_outframe_gold02","static_common_outframe_gold04");
		ChangePosY("static_common_inframe_linebox01","static_common_inframe_linebox03");
		ChangePosY("static_common_inframe_linebox02","static_common_inframe_linebox04");
		ChangePosY("static_quickslot_numberpanel01","static_quickslot_numberpanel03");
		ChangePosY("static_quickslot_numberpanel02","static_quickslot_numberpanel04");
		ChangePosY("static_common_inframe_blackround01","static_common_inframe_blackround03");
		ChangePosY("static_common_inframe_blackround02","static_common_inframe_blackround04");

		for( int n( 0 ); n < SUIDisplayInfo::c_nQuickSlotCount/2; ++n )
		{
			//std::string strNum = CStringUtil::StringFormat( "%02d", n );
			ChangePosY(m_pSlotControlIDs[ n ].strIconControl.c_str(), m_pSlotControlIDs[ n+SUIDisplayInfo::c_nQuickSlotCount/2 ].strIconControl.c_str());
			ChangePosY(m_pSlotControlIDs[ n ].strStaticCountControl.c_str(), m_pSlotControlIDs[ n+SUIDisplayInfo::c_nQuickSlotCount/2 ].strStaticCountControl.c_str());
			ChangePosY(m_pSlotControlIDs[ n ].strIconEffectControl.c_str(), m_pSlotControlIDs[ n+SUIDisplayInfo::c_nQuickSlotCount/2 ].strIconEffectControl.c_str());
			ChangePosY(m_pSlotControlIDs[ n ].strStaticText.c_str(), m_pSlotControlIDs[ n+SUIDisplayInfo::c_nQuickSlotCount/2 ].strStaticText.c_str());
			ChangePosY(m_pSlotControlIDs[ n ].strClockControl.c_str(), m_pSlotControlIDs[ n+SUIDisplayInfo::c_nQuickSlotCount/2 ].strClockControl.c_str());
		}

	}


	bool bViewLineA = true;
	bool bViewLineB = true;

	if(state == QUICKSLOTSTATE_ALL)	
	{
		//SetChildShow("button_quickslot_change", false);
		//KUIControl *twnd = (KUIControl *)GetChild("button_quickslot_change");
		//if(twnd) 
			//twnd->Disable();
		SetChildEnable("button_quickslot_change", false);
		SetChildShow("button_quickslot_up", false);
		SetChildShow("button_quickslot_down", true);
	}
	else
	{	
		//SetChildShow("button_quickslot_change", true);
		//KUIControl *twnd = (KUIControl *)GetChild("button_quickslot_change");
		//if(twnd) 
		//	twnd->Enable();
		SetChildEnable("button_quickslot_change", true);
		SetChildShow("button_quickslot_up", true);
		SetChildShow("button_quickslot_down", false);

		if(wnd2->GetRect().top < wnd1->GetRect().top)
			bViewLineA = true;
		else 
			bViewLineA = false;

		bViewLineB = !bViewLineA;		
	}

	SetChildShow("static_common_outframe_gold01", bViewLineA);
	SetChildShow("static_common_outframe_gold02", bViewLineA);
	SetChildShow("static_common_outframe_gold03", bViewLineB);
	SetChildShow("static_common_outframe_gold04", bViewLineB);
	SetChildShow("static_common_inframe_linebox01", bViewLineA);
	SetChildShow("static_common_inframe_linebox02", bViewLineA);
	SetChildShow("static_common_inframe_linebox03", bViewLineB);
	SetChildShow("static_common_inframe_linebox04", bViewLineB);
	SetChildShow("static_quickslot_numberpanel01", bViewLineA);
	SetChildShow("static_quickslot_numberpanel02", bViewLineA);
	SetChildShow("static_quickslot_numberpanel03", bViewLineB);
	SetChildShow("static_quickslot_numberpanel04", bViewLineB);
	SetChildShow("static_common_inframe_blackround01", bViewLineA);
	SetChildShow("static_common_inframe_blackround02", bViewLineA);
	SetChildShow("static_common_inframe_blackround03", bViewLineB);
	SetChildShow("static_common_inframe_blackround04", bViewLineB);

		
	for( int n( 0 ); n < SUIDisplayInfo::c_nQuickSlotCount; ++n )
	{			
		bool b = bViewLineA; 
		if(n>=SUIDisplayInfo::c_nQuickSlotCount/2)
			b = bViewLineB;

		SetChildShow(m_pSlotControlIDs[ n ].strIconControl.c_str(), b);
		SetChildShow(m_pSlotControlIDs[ n ].strStaticCountControl.c_str(), b);
		SetChildShow(m_pSlotControlIDs[ n ].strIconEffectControl.c_str(), b);
		SetChildShow(m_pSlotControlIDs[ n ].strStaticText.c_str(), b);
		SetChildShow(m_pSlotControlIDs[ n ].strClockControl.c_str(), b);		
	}


	KRect asdfrect = GetRect();
	if(state == QUICKSLOTSTATE_ALL)
	{
		if(asdfrect.top != c_nOriginalPosY)		
			this->SetRect(KRect(GetRect().left, c_nOriginalPosY, GetRect().right, GetRect().bottom));				
	}
	else
	{
		if(asdfrect.top == c_nOriginalPosY)		
			this->SetRect(KRect(GetRect().left, c_nOriginalPosY+c_nDifferenceHeight, GetRect().right, GetRect().bottom));				
	}
	
	// prodongi
	//m_pGameManager->PostMsgAtDynamic( new SIMSG_UI_QUICKSLOT_STATECHANGE( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_CHATTING, this->GetRect().top , m_nQuickSlotState, m_nQuickSlotOrder) );
	syncChattingWndPos();
	
	RefreshQuickSlots(); 
*/
}

void SUIQuickSlotWnd::RefreshQuickSlots()
{
	if( m_pSlotControlIDs == NULL ) 
		return;

	bool bView = false;

	std::vector<bool> vec_bCanUserToggle;

	for(int i=0;i<m_vSkillStatus.size();i++)
		vec_bCanUserToggle.push_back(false);

	for( int nSlot(0); nSlot < SUIDisplayInfo::c_nQuickSlotCount; ++nSlot )
	{
		bView = false;

		const QUICKSLOT_DISPLAYINFO*	pQuickSlotDispInfo( NULL );
		const SUIQuickSlotInfo*			pSlot( NULL );

		int								nCtrIndex(nSlot);

		if( m_pDisplayInfo )
		{
			pQuickSlotDispInfo	= m_pDisplayInfo->GetQuickSlotDisplayInfo( nSlot );
			pSlot				= m_pDisplayInfo->GetQuickSlot( nSlot );
		}

		KUIControlMultiIcon* pItemIconControl( dynamicCast<KUIControlMultiIcon*>(GetChild( m_pSlotControlIDs[ nCtrIndex ].strIconControl.c_str() )) );

		if( NULL != pItemIconControl )
		{
			ResetMultiIcon( pItemIconControl, 0, 8 );

			if( NULL != pQuickSlotDispInfo )
			{
				if(pItemIconControl->IsShow())
					bView = true;

				/// 2011.08.04 - prodongi
				bool isSkillCardSet = false;
				bool bIsSummonCard = false;
				if (SUIQuickSlotInfo::QSLOTTYPE_ITEM == pSlot->m_type)
				{
					SUIQuickSlotItemInfo const* itemInfo = dynamicCast<SUIQuickSlotItemInfo const*>(pSlot);
					if (itemInfo)
					{
						SInventorySlot* pSlot = m_InventoryMgr.GetItemInfo( itemInfo->m_hItem );
						if( pSlot )
						{
							if( setSkillCardIcon(pItemIconControl, pSlot->GetItemCode(), pQuickSlotDispInfo->bEquip))
								isSkillCardSet = true;

							//sun
							if( setSummonCardIcon( pItemIconControl, pSlot ) )
								bIsSummonCard = true;
						}
					}
				}

				// 2012. 3. 27 - marine 수량이 0인 소모성 아이템일 경우에는 원래 아이템 이미지, 빈아이템표시 ▧(오른쪽하단), 반투명 회색 이미지 를 사용한다.
				if( SUIQuickSlotInfo::QSLOTTYPE_EMPTYITEM == pSlot->m_type)
				{
					pItemIconControl->SetIcon( 0, c_szDEF_SPR_NAME, pQuickSlotDispInfo->strAniName.c_str() );
					pItemIconControl->SetIcon( 1, c_szDEF_SPR_NAME, "common_mark_titanium_empty_item");		// 빈 슬롯 표시
					pItemIconControl->SetIcon( 2, c_szDEF_SPR_NAME, "common_panel_titanium_empty_item");	// 빈 아이템 표시(알파먹은 회색이미지)
				}
				else if(!isSkillCardSet && !bIsSummonCard)
				{
					pItemIconControl->SetIcon( 0, c_szDEF_SPR_NAME, pQuickSlotDispInfo->strAniName.c_str() );
					pItemIconControl->SetIcon( 1, c_szDEF_SPR_NAME, pQuickSlotDispInfo->bEquip ? "common_mark_titanium_equipicon" : NULL );
				}
				else
					__noop;

				pItemIconControl->SetTooltip( pQuickSlotDispInfo->strTooltip.c_str() );
				pItemIconControl->Enable();
				pItemIconControl->ChangeAlpha(getSlotAlphaAtCurStatus(nSlot));

				if( GetChild(m_pSlotControlIDs[ nSlot ].strIconControl.c_str()) )
					SetChildShow( m_pSlotControlIDs[ nSlot ].strIconEffectControl.c_str(), GetChild(m_pSlotControlIDs[ nSlot ].strIconControl.c_str())->IsShow() ); 

				if( pQuickSlotDispInfo->nCount > 0 )
				{
					SetChildCaption( m_pSlotControlIDs[ nCtrIndex ].strStaticCountControl.c_str(), CStringUtil::StringFormat( "%s<shadow><RIGHT><size:8>%d", S(6425), pQuickSlotDispInfo->nCount ).c_str() );

					if(pItemIconControl->IsShow())
						SetChildShow( m_pSlotControlIDs[ nCtrIndex ].strStaticCountControl.c_str(), pQuickSlotDispInfo->nCount.getAmount() > 0 );
				}
				else
				{
					if(pItemIconControl->IsShow())
						SetChildShow( m_pSlotControlIDs[ nCtrIndex ].strStaticCountControl.c_str(), pQuickSlotDispInfo->nCount.getAmount() > 0 );
				}

				//sfreer 2009.03.25 소환수 스킬일경우 소환수가 소환되었는지 확인함 sfreer
				if(pSlot)
				{					
					if(pSlot->m_type == SUIQuickSlotInfo::QSLOTTYPE_SKILL)					
					{
						SUIQuickSlotSkillInfo * pSkillInfo = (SUIQuickSlotSkillInfo *)pSlot;
						if( pSkillInfo && !pSkillInfo->m_bPlayer)
						{
							{
								int d = GetSkillStatusNumber( pSkillInfo->m_hTarget, pSkillInfo->m_nSkillID );
								if(d >=0)
									vec_bCanUserToggle[d] = true;
							}

							//소환되지 않았다면 퀵슬롯아이콘 Disable 및 자동공격 취소할것.
							if( !m_CreatureSlotMgr.IsExistSummonedCreature( pSkillInfo->m_hTarget ) )
							{
								pItemIconControl->Disable();
								pItemIconControl->ChangeAlpha(.5);			

								SetChildShow( m_pSlotControlIDs[ nSlot ].strIconEffectControl.c_str(), false );
							}	
						}
						// 아래코드는 player의 스킬에 관한 코드인데, 크리쳐 스킬에서 호출되어서 else로 수정함 - prodongi
						else
						{
							///

							if	(pSkillInfo->m_nSkillID==6101 || pSkillInfo->m_nSkillID==6102)
							{
								// 장착 부스트 아이템과 스킬이 일치하는지 검사
								pSkillInfo->m_bEnable = true;

							}	else

							if (!m_SkillSlotMgr.IsExistSkillLevel(pSkillInfo->m_nSkillID, pSkillInfo->m_nSkillLevel, pSkillInfo->m_hTarget))
							{
								pItemIconControl->Disable();
								pItemIconControl->ChangeAlpha(.5);

								pSkillInfo->m_bEnable = false;

								SetChildShow( m_pSlotControlIDs[ nSlot ].strIconEffectControl.c_str(), false );
							}
							else
							{
								pSkillInfo->m_bEnable = true;
							}
						}
					}
					else if(pSlot->m_type == SUIQuickSlotInfo::QSLOTTYPE_ITEM)
					{
						const SUIQuickSlotItemInfo* pItemInfo = (const SUIQuickSlotItemInfo *)pSlot;
					
						if( pItemInfo )
						{
							SInventorySlot*		pInventorySlot( m_InventoryMgr.GetItemInfo( pItemInfo->m_hItem ) );
							TS_ITEM_INFO*		pInventoryItemInfo( pInventorySlot->GetItem() );

							if( pInventorySlot && pInventoryItemInfo )
							{
								EquipItemAddtionalIconSetter icon_setter( pItemIconControl, pInventorySlot );
							}
						}
					}
				}			
			}
			else
			{
				pItemIconControl->SetIcon( 0, c_szDEF_SPR_NAME, "static_common_itemslot" );
				pItemIconControl->SetTooltip( "" );
				SetChildShow( m_pSlotControlIDs[ nCtrIndex ].strStaticCountControl.c_str(), false );
				SetChildShow( m_pSlotControlIDs[ nCtrIndex ].strIconEffectControl.c_str(), false ); 
			}
		}

	
		KUIControlClockBox* pClockControl = dynamicCast<KUIControlClockBox*>(GetChild( m_pSlotControlIDs[ nCtrIndex ].strClockControl.c_str() ));
		if( NULL != pClockControl )
		{
			DWORD	dwCurrentTime( NULL ), 
					dwMaxTime( NULL );

			if( m_pDisplayInfo && m_pDisplayInfo->GetQuickSlotClockInfo( nSlot, dwCurrentTime, dwMaxTime ) )
			{
				pClockControl->SetShow(bView);
				pClockControl->SetCurTime( dwCurrentTime );
				pClockControl->SetMaxTime( dwMaxTime );
				pClockControl->Begin();
			}
			else
				pClockControl->Init();
		}

		
	}

	//퀵슬롯에서 스킬 아이콘이 모두 제거 되면 그 스킬의 자동공격은 취소하도록 한다.
	//이것은 그것을 위한 코드이다. sfreer 2009.04.
	for(int i=0;i<vec_bCanUserToggle.size();i++)
	{
		if(vec_bCanUserToggle[i] == false && m_vSkillStatus[i].bToggleByUser)
		{
			if(m_vSkillStatus[i].GetStatus() == STATE_TOGGLE_ON_BY_USER)
				m_vSkillStatus[i].SetStatus(STATE_TOGGLE_OFF_BY_USER);

			m_vSkillStatus[i].bToggleByUser = false;
		}
	}
		
	vec_bCanUserToggle.clear();
}


void SUIQuickSlotWnd::RefreshQuickEffect( int nSlot )
{
	//큇슬롯 상태 설정
	int nCtrIndex(nSlot);
	
	//KUIControlQuickEffect * pSlotEffect = (KUIControlQuickEffect*)GetChild( CStringUtil::StringFormat( "icon_effect%02d", nCtrIndex ).c_str() );
	KUIControlQuickEffect * pSlotEffect = dynamicCast<KUIControlQuickEffect*>(GetChild( m_pSlotControlIDs[ nSlot ].strIconEffectControl.c_str() ));
	if( !pSlotEffect ) return;

	const SUIQuickSlotInfo * pSlotInfo = m_pDisplayInfo->GetQuickSlot( nSlot );
	if( pSlotInfo == NULL ) 
	{
		pSlotEffect->Cancel();
		return;
	}

	if(pSlotInfo->m_type == SUIQuickSlotInfo::QSLOTTYPE_SKILL)
	//|| pSlotInfo->m_type == SUIQuickSlotInfo::QSLOTTYPE_CREATURE_SKILL)			
	{
		const SUIQuickSlotSkillInfo * pSkillInfo = (const SUIQuickSlotSkillInfo *)pSlotInfo;
		int nStatus = GetSkillStatus( pSkillInfo->m_hTarget, pSkillInfo->m_nSkillID );
		
		/*if(pSkillInfo->m_bPlayer)
			GetSkillStatus(0, pSkillInfo->m_nSkillID );
		else*/

		KUIControlMultiIcon* pItemIconControl = dynamicCast<KUIControlMultiIcon*>(GetChild( m_pSlotControlIDs[ nCtrIndex ].strIconControl.c_str() ));

		if( NULL != pItemIconControl )
		{
			if(pItemIconControl->IsShow())
				pSlotEffect->SetShow( true );
		}

		if( nStatus == STATE_NONE )
		{
			pSlotEffect->Cancel();
		}
		else if( nStatus == STATE_CASTING )
		{
			if( !pSlotEffect->IsToggleOn() )
			{
				pSlotEffect->Cast(0);
			}
		}
		else if( nStatus == STATE_FIRE )
		{
			if( !pSlotEffect->IsToggleOn() )
			{
				pSlotEffect->Cancel();
			}
		}
		else if( nStatus == STATE_CANCEL )
		{
			if( !pSlotEffect->IsToggleOn() )
				pSlotEffect->Cancel();
		}
		else if( nStatus == STATE_TOGGLE_ON 
				|| nStatus == STATE_TOGGLE_ON_BY_USER )
		{
			if( !pSlotEffect->IsToggleOn() )
				pSlotEffect->ToggleOn(true);
		}
		else if( nStatus == STATE_TOGGLE_OFF 
				|| nStatus == STATE_TOGGLE_OFF_BY_USER)
		{
			pSlotEffect->ToggleOn(false);
		}	
	}
	else	//아이템, 조작 아이콘등은 
	{
		pSlotEffect->SetShow( false );
		pSlotEffect->Cancel();
	}
}

void SUIQuickSlotWnd::modifyLayer()
{
	setLayer((m_curLayerDirUp) ? m_curLayer + 1 : m_curLayer - 1);
}

void SUIQuickSlotWnd::setLayerAlpha(char const* controlID, bool update)
{
	int alphaLevel = 0;
	if (strstr(controlID, "_d"))		
		alphaLevel = 3;
	else if (strstr(controlID, "_c"))
		alphaLevel = 2;
	else if (strstr(controlID, "_b"))
		alphaLevel = 1;
	else if (strstr(controlID, "_a"))
		alphaLevel = 0;

	float alpha = levelToAlpha(alphaLevel);

	char const* L = controlID + strlen(controlID) - 1;
	int group = atoi(L) - 1;
	int layer = group >> 1;

	// 2010.05.18 - prodongi
	setLayerAlpha(layer, alpha, update, m_layerAlphaInfo[layer].m_isMouseFocusOn ? false : true);
	//setLayerAlpha(layer, alpha, update, apply);
	setAlphaCheckButtonState(layer, alphaLevel);
}

void SUIQuickSlotWnd::setLayerAlpha(int layer, float alpha, bool update, bool apply)
{
	if (0.0f > alpha)		alpha = 0.0f;
	else if (1.0f < alpha)	alpha = 1.0f;
	if (update)
	{
		// 2010.05.18 - prodongi
		m_layerAlphaInfo[layer].m_alpha = alpha;
		//m_layerAlpha[layer] = alpha;
	}
	if (apply)
		setLayerFunc(layer, &SUIQuickSlotWnd::SetChildAlpha, alpha, true, c_DefaultKeymapString);
}

void SUIQuickSlotWnd::initLayer()
{
	m_layerAlphaAniV = 2.0f;
//	m_isMouseFocusOn = false;
//	m_isLayerAlphaAni = false;
	setLayer(m_curLayer);
	setLayerDir(true);

	for (int layer = 0; layer < TOTAL_LAYER; ++layer)
	{
		// 2010.05.18 - prodongi
		sLayerAlphaInfo* info = m_layerAlphaInfo + layer;
		setLayerAlpha(layer, info->m_alpha);
		setAlphaCheckButtonState(layer, info->m_alphaLevel);
		info->m_tempAlpha = 1.0f;
		info->m_isMouseFocusOn = false;
		info->m_isAlphaAni = false;

		/*
		setLayerAlpha(i, m_layerAlpha[i]);
		setAlphaCheckButtonState(i, m_layerAlphaLevel[i]);
		m_tempLayerAlpha[i] = 1.0f;
		*/
	}	
}

void SUIQuickSlotWnd::setLayerDir(bool up)
{
	m_curLayerDirUp = up;

	if (up)
	{
		SetChildShow("button_quickslot_down", false);
		SetChildShow("button_quickslot_up", true);
	}
	else
	{
		SetChildShow("button_quickslot_down", true);
		SetChildShow("button_quickslot_up", false);
	}
}

void SUIQuickSlotWnd::setLayerShow(int beginLayer, int endLayer, bool show)
{
	for (int layer = beginLayer; layer < endLayer; ++layer)
	{
		setLayerFunc(layer, &SUIQuickSlotWnd::SetChildShow, show, false, 0.0f);
	}
}

void SUIQuickSlotWnd::setLayer(int layer)
{
	if (0 > layer) layer = 0;
	else if (TOTAL_LAYER < layer) layer = TOTAL_LAYER - 1;
//	if (layer == m_curLayer)
//		return ;

	m_curLayer = layer;

	// show layer
	setLayerShow(0, m_curLayer+1, true);
	setLayerShow(m_curLayer + 1, TOTAL_LAYER, false);

	// layer dir
	if (TOTAL_LAYER - 1 == m_curLayer)	setLayerDir(false);
	else if (0 == m_curLayer)			setLayerDir(true);

	setLayerView();

	// move chatting window position
	syncChattingWndPos();
	// 2010.05.18 - prodongi
	setWndRectAtLayer();
	RefreshQuickSlots(); 	
}

void SUIQuickSlotWnd::setLayerView()
{
	int i;
	char wndName[128];
	for (i = 0; i < m_curLayer+1; ++i)
	{
		sprintf(wndName, "guage_titamium_quickslot_view_%02d", i+1);
		SetChildShow(wndName, true);
	}
	for (; i < TOTAL_LAYER; ++i)
	{
		sprintf(wndName, "guage_titamium_quickslot_view_%02d", i+1);
		SetChildShow(wndName, false);
	}
}

void SUIQuickSlotWnd::checkMouseFocusOn(bool inWindow)
{
	// 2010.05.18 - prodongi

	for (int layer = 0; layer <= m_curLayer; ++layer)
	{
		sLayerAlphaInfo* info = m_layerAlphaInfo + layer;
		if (inWindow && info->isInRect(m_mouseX, m_mouseY))
		{
			if (!info->m_isMouseFocusOn)
			{
				info->m_isMouseFocusOn = true;
				info->setLayerAlphaAni(true);
				setLayerAlpha(layer, 1.0f, false);
			}
		}
		else
		{
			if (info->m_isMouseFocusOn)
			{
				info->m_isMouseFocusOn = false;
				info->setLayerAlphaAni(true);
				setLayerAlpha(layer, info->m_alpha, false);
			}
		}
	}

	/*
	if (inWindow)
	{
		if (!m_isMouseFocusOn)
		{
			m_isMouseFocusOn = true;
			setLayerAlphaAni(true);
			for (int layer = 0; layer <= m_curLayer; ++layer)
			{
				setLayerAlpha(layer, 1.0f, false);
			}
		}
	}
	else
	{
		if (m_isMouseFocusOn)
		{
			m_isMouseFocusOn = false;
			setLayerAlphaAni(true);
			for (int layer = 0; layer <= m_curLayer; ++layer)
			{
				// 2010.05.18 - prodongi
				setLayerAlpha(layer, m_layerAlphaInfo[layer].m_alpha, false);
				//setLayerAlpha(layer, m_layerAlpha[layer], false);
			}
		}
	}
	*/
}

bool SUIQuickSlotWnd::isInWindow()
{
	// 2010.05.18 - prodongi
	return IsInRect(m_mouseX, m_mouseY);
	/*
	KRect rect;
	KUIWnd* wnd;

	wnd = GetChild("static_common_outframe_gold01");
	rect.bottom = wnd->GetRect().bottom;
	rect.left = wnd->GetRect().left;

	wnd = GetChild("static_common_outframe_gold02");
	rect.right = wnd->GetRect().right;

	char wndName[128];
	sprintf(wndName, "static_common_outframe_gold%02d", layerToGroup(m_curLayer, 0)+1);
	wnd = GetChild(wndName);
	rect.top = wnd->GetRect().top;

	return rect.IsInRect(m_mouseX, m_mouseY);
	*/
}

void SUIQuickSlotWnd::setLayerAlphaAni(bool /*ani*/)
{
	/*
	if (ani == m_isLayerAlphaAni) return ;

	m_isLayerAlphaAni = ani;
	for (int layer = 1; layer < TOTAL_LAYER; ++layer)
	{
		if (m_isMouseFocusOn)
			m_tempLayerAlpha[layer] = m_layerAlpha[layer];
		else
			m_tempLayerAlpha[layer] = 1.0f;
	}
	*/
}

void SUIQuickSlotWnd::setAlphaCheckButtonState(int layer, int alphaLevel)
{
	if (0 > alphaLevel)			alphaLevel = 0;
	else if (3 < alphaLevel)	alphaLevel = 0;
	// 2010.05.18 - prodongi
	m_layerAlphaInfo[layer].m_alphaLevel = alphaLevel;
	//m_layerAlphaLevel[layer] = alphaLevel;

	char wndName[128];
	int startGroup = layerToGroup(layer, 0);
	for (int group = 0; group < LAYER_GROUP_NUM; ++group)
	{
		for (int level = 0; level < 4; ++level)
		{
			sprintf(wndName, "slider_titamium_quickslot_transparent_%c%02d", 'a'+level, startGroup + group + 1);
			setCheckBox(this, wndName, false);
		}
	}

	sprintf(wndName, "slider_titamium_quickslot_transparent_%c%02d", 'a'+alphaLevel, startGroup+1);
	setCheckBox(this, wndName, true);

	sprintf(wndName, "slider_titamium_quickslot_transparent_%c%02d", 'a'+alphaLevel, startGroup+2);
	setCheckBox(this, wndName, true);
}

void SUIQuickSlotWnd::syncChattingWndPos() const
{
	char wndName[128];
	sprintf(wndName, "static_common_outframe_gold%02d", layerToGroup(m_curLayer, 0)+1);
	KUIWnd* wnd = GetChild(wndName);
	if (!wnd)
	{
		assert(0 && "failed static_common_outframe_gold GetChild");
		return ;
	}
	m_pGameManager->PostMsgAtDynamic( new SIMSG_UI_QUICKSLOT_STATECHANGE( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_CHATTING, wnd->GetRect().top , 0, 0) );
}

// 2010.05.18 - prodongi
void SUIQuickSlotWnd::setWndRectAtLayer()
{
	KRect newRect = GetRect();
	char wndName[128];
	KUIWnd* wnd;
	// top
	sprintf(wndName, "static_common_outframe_gold%02d", layerToGroup(m_curLayer, 0)+1);
	wnd = GetChild(wndName);
	newRect.top = wnd->GetRect().top;
	// bottom
	sprintf(wndName, "static_common_outframe_gold%02d", layerToGroup(0, 0)+1);
	wnd = GetChild(wndName);
	newRect.bottom = wnd->GetRect().bottom;
	SetRect(newRect);
}

void SUIQuickSlotWnd::initLayerRect()
{
	char wndName[128];
	KRect mainRect = GetRect();
	for (int layer = 0; layer < TOTAL_LAYER; ++layer)
	{
		sLayerAlphaInfo* info = m_layerAlphaInfo + layer;
		sprintf(wndName, "static_common_outframe_gold%02d", layerToGroup(layer, 0)+1);
		KUIWnd* wnd = GetChild(wndName);
		if (wnd)
		{
			info->m_rect.left = mainRect.left;
			info->m_rect.right = mainRect.right;
			info->m_rect.top = wnd->GetRect().top;
			info->m_rect.bottom = wnd->GetRect().bottom;
		}
	}
}

void SUIQuickSlotWnd::updateLayerAlphaAni(DWORD elapsedtime)
{
//	if (!m_isLayerAlphaAni) return ;

	//bool end = true;
	float t = (float)elapsedtime * 0.001f;
	float s = m_layerAlphaAniV * t;
	for (int layer = 1; layer <= m_curLayer/*TOTAL_LAYER*/; ++layer)
	{
		// 2010.05.18 - prodongi
		sLayerAlphaInfo* info = m_layerAlphaInfo + layer;
		if (!info->m_isAlphaAni) 
			continue;
		bool end = true;
		float& tempAlpha = info->m_tempAlpha;
		//float& tempAlpha = m_tempLayerAlpha[layer];
		if (info->m_isMouseFocusOn)
		//if (m_isMouseFocusOn)
		{
			tempAlpha += s;
			if (tempAlpha >= 1.0f)	tempAlpha = 1.0f;
			else					end = false;
		}
		else
		{
			tempAlpha -= s;
			// 2010.05.18 - prodongi
			if (tempAlpha <= info->m_alpha)	tempAlpha = info->m_alpha;
			else							end = false;
			/*
			if (tempAlpha <= m_layerAlpha[layer])	tempAlpha = m_layerAlpha[layer];
			else									end = false;
			*/
		}
		setLayerAlpha(layer, tempAlpha, false);
		// 2010.05.18 - prodongi
		if (end)
			info->setLayerAlphaAni(false);
	}
//	if (end)
//		setLayerAlphaAni(false);
}

void SUIQuickSlotWnd::updateTextHightlight(bool inWindow)
{
	// 2010.05.18 - prodongi
	if(inWindow)
	{
		int slotCount = 0;
		for (int layer = 0; layer < TOTAL_LAYER; ++layer)
		{
			if (!m_layerAlphaInfo[layer].isInRect(m_mouseX, m_mouseY))
			{
				slotCount += LAYER_GROUP_NUM * c_nQuickSlotCount;
				continue;
			}

			for (int group = 0; group < LAYER_GROUP_NUM; ++group)
			{
				for (int slot = 0; slot < c_nQuickSlotCount; ++slot, ++slotCount)
				{
					KUIControl *wnd = dynamicCast<KUIControl *>(GetChild( m_pSlotControlIDs[ slotCount ].strStaticText.c_str() ));
					if(wnd)
					{
						if(wnd->IsInRect(m_mouseX, m_mouseY))
							wnd->ChangeAlpha(c_HighlightKeymapString);							
						else
						{
							if (m_layerAlphaInfo[layer].m_isAlphaAni)
							{
								// 2010.05.18 - prodongi
								float a = m_layerAlphaInfo[layer].m_tempAlpha;
								//						float a = m_tempLayerAlpha[layer];
								if (c_DefaultKeymapString < a)	a = c_DefaultKeymapString;
								wnd->ChangeAlpha(a);
							}
							else
							{
								wnd->ChangeAlpha(c_DefaultKeymapString);
							}
						}

					}
				}
			}
		}

/*
		for(int n( 0 ); n <  SUIDisplayInfo::c_nQuickSlotCount; ++n )
		{
			KUIControl *wnd = (KUIControl *)GetChild( m_pSlotControlIDs[ n ].strStaticText.c_str() );
			if(wnd)
			{
				if(wnd->IsInRect(m_mouseX, m_mouseY))
					wnd->ChangeAlpha(c_HighlightKeymapString);							
				else
				{
					if (m_isLayerAlphaAni)
					{
						int layer = groupToLayer(n/c_nQuickSlotCount);
						// 2010.05.18 - prodongi
						float a = m_layerAlphaInfo[layer].m_tempAlpha;
//						float a = m_tempLayerAlpha[layer];
						if (c_DefaultKeymapString < a)	a = c_DefaultKeymapString;
						wnd->ChangeAlpha(a);
					}
					else
					{
						wnd->ChangeAlpha(c_DefaultKeymapString);
					}
				}

			}
		}
		*/
	}	
}

void SUIQuickSlotWnd::saveIni()
{
	FILE* file = fopen ("quickslot.ini", "w");
	if (file)
	{
		char buffer[MAX_PATH];
		// 2010.06.14 - prodongi
		sprintf(buffer, "%d %d %d %d %d", m_curLayer, m_layerAlphaInfo[0].m_alphaLevel, m_layerAlphaInfo[1].m_alphaLevel,
													  m_layerAlphaInfo[2].m_alphaLevel, m_layerAlphaInfo[3].m_alphaLevel);
		/*
		// 2010.05.18 - prodongi
		sprintf(buffer, "%d %d %d %d %d", m_curLayer, m_layerAlphaInfo[0].m_alpha, m_layerAlphaInfo[1].m_alpha,
													  m_layerAlphaInfo[2].m_alpha, m_layerAlphaInfo[3].m_alpha);
													  */
		/*
		sprintf(buffer, "%d %d %d %d %d", m_curLayer, m_layerAlphaLevel[0], m_layerAlphaLevel[1], 
													 m_layerAlphaLevel[2], m_layerAlphaLevel[3]);
													 */
		fwrite(buffer, strlen(buffer), 1, file);
		fclose(file);
	}
}

void SUIQuickSlotWnd::loadIni()
{
	FILE* file = fopen ("quickslot.ini", "r");
	if (file)
	{
		char buffer[MAX_PATH];
		fread(buffer, MAX_PATH, 1, file);
		// 2010.05.18 - prodongi
		sscanf(buffer, "%d %d %d %d %d", &m_curLayer, &m_layerAlphaInfo[0].m_alphaLevel, &m_layerAlphaInfo[1].m_alphaLevel, 
													  &m_layerAlphaInfo[2].m_alphaLevel, &m_layerAlphaInfo[3].m_alphaLevel);
		/*
		sscanf(buffer, "%d %d %d %d %d", &m_curLayer, &m_layerAlphaLevel[0], &m_layerAlphaLevel[1], 
													&m_layerAlphaLevel[2], &m_layerAlphaLevel[3]);
													*/
		fclose(file);

		for (int i = 0; i < TOTAL_LAYER; ++i)
		{
			// 2010.05.18 - prodongi
			m_layerAlphaInfo[i].m_alpha = levelToAlpha(m_layerAlphaInfo[i].m_alphaLevel);
//			m_layerAlpha[i] = levelToAlpha(m_layerAlphaLevel[i]);
		}
	}
}

float SUIQuickSlotWnd::levelToAlpha(int alphaLevel) const
{
	switch (alphaLevel)
	{
	case 0:	return 1.0f;
	case 1: return 0.5f;
	case 2: return 0.1f;
	case 3: return 0.0f;
	}
	return 1.0f;
}

float SUIQuickSlotWnd::getSlotAlphaAtCurStatus(int slot) const
{
	// 2010.05.18 - prodongi
	int layer = slotToLayer(slot);
	return m_layerAlphaInfo[layer].getSlotAlphaAtCurStatus();

	/*
	float alpha;
	if (m_isMouseFocusOn)
	{
		if (m_isLayerAlphaAni)	alpha = m_tempLayerAlpha[slotToLayer(slot)];
		else					alpha = 1.0f;
	}
	else
	{
		if (m_isLayerAlphaAni)	alpha = m_tempLayerAlpha[slotToLayer(slot)];
		else					alpha =  m_layerAlpha[slotToLayer(slot)];
	}
	return alpha;
	*/
}

void SUIHQuickSlotWnd::PumpUpMessage( LPCSTR lpszControlID, DWORD nMessage, DWORD lparam, DWORD wparam )
{
	switch(nMessage)
	{
	case KUI_MESSAGE::KBUTTON_CLICK:
		{

		}
		break;
	}
	SUIQuickSlotWnd::PumpUpMessage( lpszControlID, nMessage, lparam, wparam );
}

void SUIVQuickSlotWnd::PumpUpMessage( LPCSTR lpszControlID, DWORD nMessage, DWORD lparam, DWORD wparam )
{
	switch(nMessage)
	{
	case KUI_MESSAGE::KBUTTON_CLICK:
		{
			
		}
		break;
	}
	SUIQuickSlotWnd::PumpUpMessage( lpszControlID, nMessage, lparam, wparam );
}