#include "stdafx.h"
#include "KUIControlStatic.h"
#include "KUIControlGauge.h"
#include "KUIControlEdit.h"
#include "KUIControlButton.h"
#include "SGameManager.h"
#include "SGameMessage.h"
//#include "SGameMessageUI.h"
#include "SUIPartyWndDual.h"    // 2011.11.14 - servantes
#include "SUIPartyTypes.h" // 2011.11.14 - servantes
#include "SUIPartyStateWnd.h"
#include "SUIDisplayInfo.h"
#include "SUISysMsgDefine.h"
#include <toolkit/XStringUtil.h>
#include "SStringDB.h"
#include "SJobDB.h"
#include "SItemDB.h"
#include "SGameOption.h"
#include "SPlayerInfoMgr.h"
#include "SMessengerMgr.h"
#include "SUIPartyWndMgr.h"
//#include "Util.h"
#include "SChatType.h"
#include "SGameAvatarEx.h"
#include "SGame.h"
#include "SCreatureDB.h"
#include "ErrorCode/ErrorCode.h"	// sonador 3.5.1	던전 시즈 레벨 제한
#include <kfile/KFileManager.h>
#include "SUIPartyStateSetWnd.h"
#include "IHuntaHolicSystem.h" // #2.1.2.11.1
// 2010.08.31 - prodongi
#include "SSummonSlotMgr.h"
//#include "SUIUtil.h"
#include "SGameCreature.h"
#include "SGameSystem.h"


extern SGameSystem* g_pCurrentGameSystem;
extern void MsgSplit( const char* szMsg, STR_LIST& vecText, const wchar_t* lpDelimiter, bool bProcSpecialCharacter=false );

namespace
{
	const int c_nStateDelta		= 32;		//지속효과 리사이즈 단위
	const int c_nStateDeltaSmall= 20;		//지속효과 리사이즈 단위
	const int c_nMaxLine	= 8;		// 보여주는 최대 라인수
	const int c_nPartyWndWidthSize		= 138;
	const int c_nDelta				= 32; //32;		// 리사이즈 단위
	const int c_nDeltaSmall			= 26; //22;		// 리사이즈 단위
	const int c_nCreatureDelta		= 24; //24;		// 소환수 Max Height Size
	const int c_nCreatureDeltaSmall	= 16; //14;		// 소환수 Max Height Size

	const char* c_lpStateSetID			= "state_set%02d";
	const char* c_lpCreatureStateSetID	= "Creature_state_set%02d";
}

SUIPartyStateWnd::SUIPartyStateWnd( SGameManager* pGameManager, SUIDisplayInfo* pDisplayInfo ) 
: SUIWnd( pGameManager )
, m_pDisplayInfo( pDisplayInfo )
, m_bLeftRender(true), m_bStateRender(true)
{
	m_pLinkPartyUI = NULL;  // 2011.11.14 - servantes : 연결된 파티창 포인터
	m_bSizeBig = true; // 2011.11.14 - servantes : 버프 크기 변환플래그

	for( int i(0); i<SLOT_MAXLINE; ++i )
	{
		/// 2011.12.21 기본 값을 false로 한다 - prodongi
		//m_MemberStateRender[i] = false;
		//m_CreatureStateRender[i] = false;
		m_vecCreatureList[i].hCreature1st = NULL;
		m_vecCreatureList[i].hCreature2nd = NULL;
		m_vecCreatureList[i].hMaster      = NULL;
	}
}

void SUIPartyStateWnd::ClearCtr()
{
}

bool SUIPartyStateWnd::InitControls( KPoint kPos )
{
	std::string strID, strID2;
	KRect rt(0,0,100,30);

	SUIPartyStateSetWnd* pStateSetWnd(NULL);
	for( int i(0); i<c_nMaxLine; ++i )
	{
		strID = CStringUtil::StringFormat(c_lpStateSetID, i);
		strID2 = CStringUtil::StringFormat(c_lpCreatureStateSetID, i);

		pStateSetWnd = new SUIPartyStateSetWnd(m_pGameManager, m_pDisplayInfo, this, m_pManager, strID.c_str(), rt );
		AddChild(pStateSetWnd);

		pStateSetWnd = new SUIPartyStateSetWnd(m_pGameManager, m_pDisplayInfo, this, m_pManager, strID2.c_str(), KRect(rt.left, rt.top+c_nStateDelta, rt.right, rt.bottom+c_nStateDelta) );
		pStateSetWnd->SetNegativeStateCnt( 10 );
		AddChild(pStateSetWnd);

		rt.top += c_nStateDelta;
		rt.bottom += c_nStateDelta;
	}

	SetCorrectionRect(KRect(0,0,0,0));   // 2011.11.17 - servantes : 보정영역이라는데 필요 없는것 같아 값을 0으로 설정

	return SUIWnd::InitControls(kPos);
}

bool SUIPartyStateWnd::InitData( bool bReload )
{
	return SUIWnd::InitData(bReload);
}

void SUIPartyStateWnd::OnNotifyUIWindowOpen( bool bOpen, bool bLimitWnd )
{
	SUIWnd::OnNotifyUIWindowOpen(bOpen);

	if( bOpen )
	{
		RefreshSlots();
	}
}

void SUIPartyStateWnd::ProcMsgAtStatic( SGameMessage* pMsg )
{
	switch( pMsg->nType )
	{
	case IMSG_UI_SEND_DATA:
		{
			SIMSG_UI_SEND_DATA *pData = (SIMSG_UI_SEND_DATA *)pMsg;
			
			if( pData->m_strString == "party_update" )
			{
				//RefreshSlots();
			}
			else if( pData->m_strString == "add_creature" )
			{
				pMsg->bUse = true;

				AddCreature( pData->m_dwData );
				RefreshSlots();
			}
			else if( pData->m_strString == "add_creature_index" )
			{
				// 2010.08.30 - prodongi
				//AddCreature( (int)pData->m_nNumber.getAmount() );
				RefreshSlots();
				//setRenderCreatureUI((int)pData->m_nNumber.getAmount(), true);
			}
			else if( pData->m_strString == "remove_creature" )
			{
				RemoveCreature( pData->m_dwData );
				RefreshSlots();
			}
			else if( pData->m_strString == "remove_creature_index" )
			{
				// 2010.08.30 - prodongi
				//RemoveCreature( (int)pData->m_nNumber.getAmount() );
				//setRenderCreatureUI((int)pData->m_nNumber.getAmount(), false);
				RefreshSlots();
			}
			else if (pData->m_strString == "show_wnd")
			{
				SetShow(true);
			}
			else if (pData->m_strString == "hide_wnd")
			{
				SetShow(false);
			}
			else if (pData->m_strString == "refresh")
			{
				SetShow(true);
				_RefreshSlots();
				Move((int)pData->m_nNumber.getAmount(), (int)pData->m_nNumber2.getAmount());    // 2011.12.20 - servantes : 버프위치 조정
			}
			else if( pData->m_strString == "state_all_on" )
			{
				if(m_bSizeBig != (bool)pData->m_dwData)  // 2011.12.20 - servantes : 창의 크기에 따라 버프 크기 변경
				{
					if(pData->m_dwData == PARTY_UI_SIZE_SMALL)
						ChangeSizeStateWnd(false);
					else
						ChangeSizeStateWnd(true);
				}

				setShowParent(true);
				SetShow(true);
				//setRenderAllState(true);
				m_bStateRender = true;
				RefreshSlots();

				Move((int)pData->m_nNumber.getAmount(), (int)pData->m_nNumber2.getAmount());    // 2011.12.20 - servantes : 버프위치 조정
			}
			else if( pData->m_strString == "state_all_off" )
			{
				setShowParent(false);
				SetShow(false);
				//setRenderAllState(false);
				m_bStateRender = false;
				DisableAllSlots();
			}
			else if( pData->m_strString == "one_state_on" )
			{
				if( pData->m_nNumber2>=0 && pData->m_nNumber2<SLOT_MAXLINE )
				{
					//setRenderState(true, pData->m_nNumber.getAmount(), pData->m_nNumber2.getAmount());
					setShowParent(true);
					SetShow(true);
					m_bStateRender = true;
					RefreshSlot( pData->m_nNumber2.getAmount() );
				//	RefreshSlots();

				//	Move((int)pData->m_nNumber.getAmount(), (int)pData->m_nNumber2.getAmount());    // 2011.12.20 - servantes : 버프위치 조정
				}
			}
			else if( pData->m_strString == "one_state_off" )
			{
				if( pData->m_nNumber2>=0 && pData->m_nNumber2<SLOT_MAXLINE )
				{
					//setRenderState(false, pData->m_nNumber.getAmount(), pData->m_nNumber2.getAmount());
					RefreshSlots();
				}
			}
			else if( pData->m_strString == "position" )  // 2011.12.20 - servantes : 창의 크기에 따라 버프 크기 변경 및 위치 조정
			{
				if(m_bSizeBig != (bool)pData->m_dwData)  // 창의 크기에 따라 버프 크기 변경
				{
					if(pData->m_dwData == PARTY_UI_SIZE_SMALL)
						ChangeSizeStateWnd(false);
					else
						ChangeSizeStateWnd(true);
				}

				_RefreshSlots();
				Move((int)pData->m_nNumber.getAmount(), (int)pData->m_nNumber2.getAmount());    // 버프위치 조정
			}
			pMsg->bUse = true;
			/// 2011.11.17 - prodongi
			/*
			else if( pData->m_strString == "open_private_menu" )
			{
				if( pData->m_dwData < 0 || pData->m_dwData >= SLOT_MAXLINE )
					break;

				SIMSG_UI_OPEN_PRIVATE_MENU Msg;

				if( pData->m_strText == "player" )
				{
					Msg.m_bPlayer = true;
					Msg.m_bRender = m_MemberStateRender[pData->m_dwData];
				}
				else if( pData->m_strText == "creature" )
				{
					Msg.m_bPlayer = false;
					Msg.m_bRender = m_CreatureStateRender[pData->m_dwData];
				}

				Msg.m_nIndex = pData->m_dwData;
				Msg.m_nX = pData->m_nNumber.getAmount();
				Msg.m_nY = pData->m_nNumber2.getAmount();

				m_pGameManager->ProcMsgAtStatic( &Msg );
			}
			*/
		}
		break;
	case MSG_CHATTING:
		{
			SMSG_CHATTING* pChatMsg = ( SMSG_CHATTING* )pMsg;

			if( pChatMsg->nChatType == CHAT_PARTY_SYSTEM )
			{
				/*
				if( m_PartyMgr.IsExist() && m_PartyMgr.GetMemberCount() > 0 )
				{
					RefreshSlots();
				}
				else
				{
					ClearCreatureList();
					DisableAllSlots();
				}*/
			}

			pMsg->bUse = true;
		}
		break;
	case IMSG_UI_MOVE:
		{
			SIMSG_UI_MOVE* pMoveMsg = ( SIMSG_UI_MOVE* )pMsg;

		//	Move( pMoveMsg->m_nX, pMoveMsg->m_nY+2 );  // 2011.11.11 - servantes : 위치 보정을 위해서 2을 더하지 않는다
			Move( pMoveMsg->m_nX, pMoveMsg->m_nY );
			
			pMsg->bUse = true;
		}
		break;
	case IMSG_UI_STATE_UPDATE:
		{
			SIMSG_UI_STATE_UPDATE* pStateUpdate = ( SIMSG_UI_STATE_UPDATE* )pMsg;
			
			SUIPartyStateSetWnd* pWnd = GetChildWnd( pStateUpdate->m_hPlayer );
			if( pWnd )
				pWnd->StateUpdate(pMsg);

			pMsg->bUse = true;
		}
		break;
	case IMSG_UI_STATE_LIST_UPDATE:
		{
			SIMSG_UI_STATE_LIST_UPDATE* pStateListUpdate = ( SIMSG_UI_STATE_LIST_UPDATE* )pMsg;
			
			SUIPartyStateSetWnd* pWnd = GetChildWnd( pStateListUpdate->hPlayer );
			if( pWnd )
				pWnd->StateListUpdate(pMsg);

			pMsg->bUse = true;
		}
		break;

	case MSG_ENTER:
		{
			SMSG_ENTER* pEnter = (SMSG_ENTER*)pMsg;

			if( pEnter->ObjType == TS_ENTER::GAME_SUMMON )
				if( ChangeCreature( pEnter->handle ) )
					RefreshSlots();
			else if( pEnter->ObjType == TS_ENTER::GAME_PLAYER )
				if( ChangeMasterCreature( pEnter->handle ) )
					RefreshSlots();
			pMsg->bUse = true;
		}
		break;

	case MSG_LEAVE:
		{
			SMSG_LEAVE* pLeave = (SMSG_LEAVE*)pMsg;
			if( LeaveCreature( pLeave->handle ) == -1 )
				LeaveMaster( pLeave->handle );
			pMsg->bUse = true;
		}
		break;
	}
}

bool SUIPartyStateWnd::ChangeCreature( AR_HANDLE handle )
{
	AR_HANDLE hMaster = GetMaster( handle );
	int nIndex = m_PartyMgr.GetMemberIndex( hMaster );
	if( hMaster &&  nIndex >= 0 && nIndex < c_nMaxLine )
	{
		if( m_vecCreatureList[nIndex].hMaster == hMaster )
		{
			m_vecCreatureList[nIndex].hCreature1st = handle;
			//m_vecCreatureList[nIndex].bRender = true;
			//m_vecCreatureList[nIndex].bRenderUI = true; // 2010.08.30 - prodongi
			return true;
		}
	}

	for( int i(0); i<c_nMaxLine; ++i )
	{
		if( m_vecCreatureList[i].hMaster == hMaster )
		{
			m_vecCreatureList[i].hCreature1st = handle;
			//m_vecCreatureList[i].bRender = true;
			//m_vecCreatureList[i].bRenderUI = true;	// 2010.08.30 - prodongi
			return true;
		}
	}
	return false;
}

AR_HANDLE SUIPartyStateWnd::getMainCreature(SGameAvatarEx* master)
{
	if (!master)
		return 0;

	//AR_HANDLE hCreature;
	SPlayerSlot* slot = m_PartyMgr.FindMember(master->GetArID(), GetPartyName());
	if (slot)
		return slot->GetMainCreatureHandle();
	
	return master->GetCreature();
}

AR_HANDLE SUIPartyStateWnd::getMainCreature(AR_HANDLE hMaster)
{
	return getMainCreature(GetObject( hMaster ));
}

bool SUIPartyStateWnd::ChangeMasterCreature( AR_HANDLE hMaster )
{
	int nIndex = m_PartyMgr.GetMemberIndex( hMaster );
	if( hMaster &&  nIndex >= 0 && nIndex < c_nMaxLine )
	{
		SGameAvatarEx* pMaster = GetObject( hMaster );
		if( pMaster )
		{
			m_vecCreatureList[nIndex].hMaster = hMaster;
			m_vecCreatureList[nIndex].hCreature1st = getMainCreature(pMaster);
			//m_vecCreatureList[nIndex].bRender = true;
			//m_vecCreatureList[nIndex].bRenderUI = true;	// 2010.08.30 - prodongi
			return true;
		}
	}
	return false;
}

void SUIPartyStateWnd::InitBuffFlag()
{
	/*
	for(int i=0; i<SLOT_MAXLINE; i++)
	{
		m_MemberStateRender  [ i ] = false;
		m_CreatureStateRender[ i ] = false;
	}
	*/

	std::vector<SPlayerSlot*>& vecMemberList = m_PartyMgr.GetMemberList(&m_strPartyName);
	int nIndex(0);
	/*
	size_t nMemberSize = vecMemberList.size();
	for( int i(0); i<nMemberSize; ++i )
	{
		m_vecCreatureList[ i ].bRender   = false;
		m_vecCreatureList[ i ].bRenderUI = false;
	}
	*/
}

void SUIPartyStateWnd::SetCreatureMaster( int nPos, AR_HANDLE hMaster )
{
	if( nPos < 0 || nPos >= c_nMaxLine )	return;

	m_vecCreatureList[nPos].hMaster = hMaster;
	SGameAvatarEx* pMaster = GetObject( hMaster );
	if( pMaster )
	{
		AR_HANDLE hCreature = getMainCreature(pMaster);
		SGameAvatarEx* pCreature = GetObject( hCreature );

		if( pCreature && pCreature->IsActivated() )
		{
			// 2010.08.30 - prodongi
			//if (!m_vecCreatureList[nPos].bRender && !m_vecCreatureList[nPos].bRenderUI)
			//	m_vecCreatureList[nPos].bRenderUI = true;

			 m_vecCreatureList[nPos].hCreature1st = hCreature;
			// 2010.08.12 - prodongi
			//m_vecCreatureList[nPos].bRender = true;
		}
		else
		{
			m_vecCreatureList[nPos].hCreature1st = NULL;
			m_vecCreatureList[nPos].hCreature2nd = NULL;   // 2011.11.12 - servantes : NULL 처리
		}
	}
/*
	if( m_vecCreatureList[nPos].hCreature1st == NULL )
	{
		m_vecCreatureList[nPos].bRender = false;
		m_vecCreatureList[nPos].bRenderUI = false;	// 2010.08.30 - prodongi
	}
	*/
}

int SUIPartyStateWnd::AddCreature( AR_HANDLE handle )
{
	AR_HANDLE hMaster = GetMaster( handle );
	int nIndex = m_PartyMgr.GetMemberIndex( hMaster );
	if( hMaster &&  nIndex >= 0 && nIndex < c_nMaxLine )
	{
		m_vecCreatureList[nIndex].hMaster = hMaster;
		m_vecCreatureList[nIndex].hCreature1st = handle;
		return nIndex;
	}
	else
	{
		return -1;
	}
	return -1;
}

SGameAvatarEx* SUIPartyStateWnd::GetPlayerPtr( int nIndex )
{
	if( nIndex < 0 || nIndex >= m_PartyMgr.GetMemberCount() )
		return NULL;

	//순차분배 수정: 파티장이 0번 슬롯에 나오던 부분을 자기 위치에 나오도록 수정
	//2009-02-23: hunee
	std::vector<SPlayerSlot*> vecMemberList;
	vecMemberList = m_PartyMgr.GetMemberList();
	if( vecMemberList[nIndex] )
	{
		return GetObject( vecMemberList[nIndex]->GetHandle() );
	}

	return NULL;
}

void SUIPartyStateWnd::LeaveMaster( AR_HANDLE hMaster )
{
	int nIndex = m_PartyMgr.GetMemberIndex( hMaster );
	if( hMaster &&  nIndex >= 0 && nIndex < c_nMaxLine )
	{
		if( m_vecCreatureList[nIndex].hMaster == hMaster )
		{
			m_vecCreatureList[nIndex].hMaster = NULL;
			m_vecCreatureList[nIndex].hCreature1st = NULL;
			//m_vecCreatureList[nIndex].bRender = false;
			//m_vecCreatureList[nIndex].bRenderUI = false;	// 2010.08.30 - prodongi
		}
	}
}

int SUIPartyStateWnd::LeaveCreature( AR_HANDLE handle )
{
	for( int i(0); i<c_nMaxLine; ++i )
	{
		if( m_vecCreatureList[i].hCreature1st == handle )
		{
			m_vecCreatureList[i].hCreature1st = NULL;
			//m_vecCreatureList[i].bRender = false;
			//m_vecCreatureList[i].bRenderUI = false;	// 2010.08.30 - prodongi
			return i;
		}
	}
	return -1;
}

int SUIPartyStateWnd::RemoveCreature( AR_HANDLE handle )
{
	for( int i(0); i<c_nMaxLine; ++i )
	{
		if( m_vecCreatureList[i].hCreature1st == handle )
		{
			m_vecCreatureList[i].hCreature1st = NULL;   // 2011.11.12 - servantes : NULL 처리
			m_vecCreatureList[i].hCreature2nd = NULL;   // 2011.11.12 - servantes : NULL 처리
			//m_vecCreatureList[i].bRender = false;
			//m_vecCreatureList[i].bRenderUI = false;	// 2010.08.30 - prodongi
			return i;
		}
	}
	return -1;
}

/*
// 2010.08.30 - prodongi
void SUIPartyStateWnd::setRenderCreatureUI(int index, bool render)
{
	if( index < 0 || index >= c_nMaxLine )
		return;
	m_vecCreatureList[index].bRenderUI = render;
}
*/
void SUIPartyStateWnd::PumpUpMessage( LPCSTR lpszControlID, DWORD nMessage, DWORD lparam, DWORD wparam )
{
	switch(nMessage)
	{
	case KUI_MESSAGE::KBUTTON_CLICK:
		{
		}
		break;
	}

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

void SUIPartyStateWnd::ClearCreatureList()
{
	for( int i(0); i<c_nMaxLine; ++i )
	{
		m_vecCreatureList[i].hCreature1st = NULL;
		m_vecCreatureList[i].hCreature2nd = NULL;  // 2011.11.12 - servantes : NULL 처리
		m_vecCreatureList[i].hMaster = NULL;
		//m_vecCreatureList[i].bRender = false;
		//m_vecCreatureList[i].bRenderUI = false;	// 2010.08.30 - prodongi
	}
}

AR_HANDLE SUIPartyStateWnd::GetMaster( AR_HANDLE handle )
{
	SGameAvatarEx* pCreature = GetObject( handle );
	if( pCreature && pCreature->GetObjType() == TS_ENTER::GAME_SUMMON )
		return pCreature->GetMaster();
	return 0;
}

SGameAvatarEx* SUIPartyStateWnd::GetMasterPtr( AR_HANDLE handle )
{
	SGameAvatarEx* pCreature = GetObject( handle );
	if( pCreature && pCreature->GetObjType() == TS_ENTER::GAME_SUMMON )
		return GetObject( pCreature->GetMaster() );
	return NULL;
}

SGameAvatarEx* SUIPartyStateWnd::GetObject( AR_HANDLE handle )
{
	SGame* pGame = m_pGameManager->GetActiveGame();
	if( !pGame || pGame->GetGameType() != GAME_TYPE_WORLD )
		return NULL;

	return (SGameAvatarEx*)(pGame->GetGameObject(handle));
}

void SUIPartyStateWnd::Move( int nX, int nY )
{
	int nResolution_Width = GetGameOption().GetResolution_Width();

	int nTempX( nX );
	int nWidth( GetRect().GetWidth() );
	bool bMoveRight( !IsRenderStateLeft(nTempX+nWidth) );

	if( bMoveRight )
	{
		int  nAddWidth=0;
		if(m_pLinkPartyUI)
		{
			if(m_pLinkPartyUI->GetUISizeState() == PARTY_UI_SIZE_SMALL)
				nAddWidth = 97;
			else
				nAddWidth = 138;
		}

	//	nTempX = nTempX - (nWidth+c_nPartyWndWidthSize);
		nTempX = nTempX - (nWidth + nAddWidth);

		if( m_bLeftRender )
		{
			SUIPartyStateSetWnd* pStateSetWnd(NULL);
			for( int i(0); i<c_nMaxLine; ++i )
			{
				pStateSetWnd = dynamicCast<SUIPartyStateSetWnd*>(GetChild( CStringUtil::StringFormat( c_lpStateSetID, i ).c_str() ));
				if( pStateSetWnd )
					pStateSetWnd->SwapPos(false);

				pStateSetWnd = dynamicCast<SUIPartyStateSetWnd*>(GetChild( CStringUtil::StringFormat( c_lpCreatureStateSetID, i ).c_str() ));
				if( pStateSetWnd )
					pStateSetWnd->SwapPos(false);
			}
			m_bLeftRender = false;
		}
	}
	else if( !m_bLeftRender )
	{
		SUIPartyStateSetWnd* pStateSetWnd(NULL);
		for( int i(0); i<c_nMaxLine; ++i )
		{
			pStateSetWnd = dynamicCast<SUIPartyStateSetWnd*>(GetChild( CStringUtil::StringFormat( c_lpStateSetID, i ).c_str() ));
			if( pStateSetWnd )
				pStateSetWnd->SwapPos(true);

			pStateSetWnd = dynamicCast<SUIPartyStateSetWnd*>(GetChild( CStringUtil::StringFormat( c_lpCreatureStateSetID, i ).c_str() ));
			if( pStateSetWnd )
				pStateSetWnd->SwapPos(true);
		}
		m_bLeftRender = true;
	}

	MovePos( nTempX, nY );

//	m_pGameManager->PostMsgAtDynamic( new SIMSG_UI_SEND_DATA( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_PARTY, "position", number_t(nTempX), number_t(nY) ) );
}

bool SUIPartyStateWnd::IsRenderStateLeft( int nRight/*=-1*/ )
{
	int nResolution_Width = GetGameOption().GetResolution_Width();
	if( nRight == -1 )	nRight = GetRect().right;

	return nRight < nResolution_Width;
}

void SUIPartyStateWnd::RefreshSlot(int id)
{
	if( !m_bStateRender )
		return;

	bool bExist = m_PartyMgr.IsExist(&m_strPartyName);
	int nCount( m_PartyMgr.GetMemberCount(&m_strPartyName) );
	if( !bExist || nCount <= 0 )
		return;

	RefreshEnableSlot(id);

	nCount = min( c_nMaxLine, nCount );
	ChangeSize( nCount );
}


void SUIPartyStateWnd::RefreshSlots()
{
	DisableAllSlots();

	/// 2011.12.21 코드 재사용을 위해 함수로 뺌 - prodongi
	_RefreshSlots();
	/*
	if( !m_bStateRender )
		return;

	bool bExist = m_PartyMgr.IsExist(&m_strPartyName);
	int nCount( m_PartyMgr.GetMemberCount(&m_strPartyName) );
	if( !bExist || nCount <= 0 )
		return;
	
	RefreshEnableSlots();

	nCount = min( c_nMaxLine, nCount );
	ChangeSize( nCount );
	*/
}

void SUIPartyStateWnd::_RefreshSlots()
{
	if( !m_bStateRender )
		return;

	bool bExist = m_PartyMgr.IsExist(&m_strPartyName);
	int nCount( m_PartyMgr.GetMemberCount(&m_strPartyName) );
	if( !bExist || nCount <= 0 )
		return;
	
	RefreshEnableSlots();

	nCount = min( c_nMaxLine, nCount );
	ChangeSize( nCount );
}

void SUIPartyStateWnd::RefreshEnableSlots()
{
	std::vector<SPlayerSlot*>& vecMemberList = m_PartyMgr.GetMemberList(&m_strPartyName);

	std::vector<SPlayerSlot*>::const_iterator it = vecMemberList.begin();
	int nCount = static_cast<int>( vecMemberList.size() );
	nCount = min( c_nMaxLine, nCount );
	
	int nIndex(0);
	size_t nMemberSize = vecMemberList.size();
	for( int i(0); i<nMemberSize; ++i )
	{
		//if( vecMemberList[i]->IsLeader() ) continue;

		SetSlotData_N_Enable( nIndex, vecMemberList[i], false );
		SetCreatureMaster( nIndex, vecMemberList[i]->GetHandle() );
		// 2010.08.30 - prodongi
		//if( m_vecCreatureList[nIndex].bRender )
		//if (m_vecCreatureList[nIndex].bRender && m_vecCreatureList[nIndex].bRenderUI)
		if (m_pLinkPartyUI && m_pLinkPartyUI->isShowCreature(nIndex) && m_pLinkPartyUI->isShowCreatureBuff(nIndex))
			SetSlotData_N_Enable( nIndex, m_vecCreatureList[nIndex].hCreature1st, true );
		else if (0 == m_vecCreatureList[nIndex].hCreature1st)	/// 2011.12.21 핸들이 없으면 안보이게 해야 된다 - prodongi
			SetSlotData_N_Enable( nIndex, m_vecCreatureList[nIndex].hCreature1st, true );
		nIndex++;
	}
}

void SUIPartyStateWnd::RefreshEnableSlot(int id)
{
	if(id < 0 || id >= c_nMaxLine)
		return ;

	std::vector<SPlayerSlot*>& vecMemberList = m_PartyMgr.GetMemberList(&m_strPartyName);

	std::vector<SPlayerSlot*>::const_iterator it = vecMemberList.begin();
	int nCount = static_cast<int>( vecMemberList.size() );
	nCount = min( c_nMaxLine, nCount );
	if(id >= nCount)
		return ;
	
	SetSlotData_N_Enable( id, vecMemberList[ id ], false );
	SetCreatureMaster   ( id, vecMemberList[ id ]->GetHandle() );

	SetSlotData_N_Enable( id, m_vecCreatureList[ id ].hCreature1st, true );
/*	
	//if (m_vecCreatureList[ id ].bRender && m_vecCreatureList[ id ].bRenderUI)
	if (m_pLinkPartyUI->isShowCreature(id) && m_pLinkPartyUI->isShowCreatureBuff(id))
		SetSlotData_N_Enable( id, m_vecCreatureList[ id ].hCreature1st, true );
	else if (0 == m_vecCreatureList[ id ].hCreature1st)	/// 2011.12.21 핸들이 없으면 안보이게 해야 된다 - prodongi
		SetSlotData_N_Enable( id, m_vecCreatureList[ id ].hCreature1st, true );
		*/
}

void SUIPartyStateWnd::RefreshCreatureSlots()
{
	int nIndex(-1);
	for( int i(0); i<c_nMaxLine; ++i )
	{
		if( m_vecCreatureList[i].hMaster )
		{
			nIndex = m_PartyMgr.GetMemberIndex( m_vecCreatureList[i].hMaster, &m_strPartyName );
			if( nIndex>=0 && nIndex != i && nIndex < c_nMaxLine )
			{
				m_vecCreatureList[nIndex].hCreature1st = m_vecCreatureList[i].hCreature1st;
				m_vecCreatureList[nIndex].hMaster = m_vecCreatureList[i].hMaster;
			}
		}
	}
}

void SUIPartyStateWnd::RefreshCreatureSlot(int id)
{
	if( m_vecCreatureList[ id ].hMaster == NULL )
		return ;

	int nIndex = m_PartyMgr.GetMemberIndex( m_vecCreatureList[ id ].hMaster, &m_strPartyName );
	if( nIndex>=0 && nIndex != id && nIndex < c_nMaxLine )
	{
		m_vecCreatureList[ nIndex ].hCreature1st = m_vecCreatureList[ id ].hCreature1st;
		m_vecCreatureList[ nIndex ].hMaster      = m_vecCreatureList[ id ].hMaster;
	}
}

void SUIPartyStateWnd::DisableAllSlots()
{
	AR_HANDLE hNULL(NULL);
	for( int i = 0; i < c_nMaxLine; i++ )
	{
		SetSlotData_N_Enable(i, hNULL, true);
		SetSlotData_N_Enable(i, hNULL, false);
	}
}

void SUIPartyStateWnd::SetSlotData_N_Enable( int nIndex, SPlayerSlot* pSlot, bool bCreature )
{
	if( nIndex<0 || nIndex>=c_nMaxLine )	return;

	if( pSlot )
		SetSlotData_N_Enable( nIndex, pSlot->GetHandle(), bCreature );
}

void SUIPartyStateWnd::SetSlotData_N_Enable( int nIndex, AR_HANDLE handle, bool bCreature )
{
	if( nIndex<0 || nIndex>=c_nMaxLine )	return;

	SUIPartyStateSetWnd* pStateSetWnd(NULL);
	if( bCreature )
		pStateSetWnd = dynamicCast<SUIPartyStateSetWnd*>(GetChild( CStringUtil::StringFormat( c_lpCreatureStateSetID, nIndex ).c_str() ));
	else
		pStateSetWnd = dynamicCast<SUIPartyStateSetWnd*>(GetChild( CStringUtil::StringFormat( c_lpStateSetID, nIndex ).c_str() ));

	if( pStateSetWnd )
	{
		if (!handle)
		{
			pStateSetWnd->SetShow(false);
			return ;
		}

		pStateSetWnd->SetPlayer( handle );

		/*
		bool bShow( pStateSetWnd->IsLogin() );
		if( bCreature )
			bShow = (m_CreatureStateRender[nIndex] && bShow);
		else
			bShow = (m_MemberStateRender[nIndex] && bShow);
		*/
		bool bShow = false;
		if (pStateSetWnd->IsLogin() && m_pLinkPartyUI)
		{
			if (bCreature)
			{
				if (m_pLinkPartyUI->isShowCreature(nIndex) && m_pLinkPartyUI->isShowCreatureBuff(nIndex))
					bShow = true;
			}
			else
			{
				if (m_pLinkPartyUI->isShowPlayerBuff(nIndex))
					bShow = true;
			}
		}
		
		pStateSetWnd->SetShow( bShow );
		if( bShow )
			pStateSetWnd->RefreshAllStateSlot();
	}
}

void SUIPartyStateWnd::ChangeSize( int nCount )
{
	//SPlayerSlot* pSlot = m_PartyMgr.GetLeaderInfo();
	
	int nPos_Y( GetRect().top + 1 );

	//파티장 맨위로 가는부분 수정시 크리쳐 슬롯 위치 지대로 못 잡는 부분 수정
	//2009-05-27: hunee
	std::vector<SPlayerSlot*>& vecMemberList = m_PartyMgr.GetMemberList(&m_strPartyName);
	size_t nMemberSize = vecMemberList.size();

	if(m_bSizeBig)     // 2011.11.14 - servantes : 버프 크기 변환플래그
	{
		for( int i(0); i<nMemberSize; ++i )
		{
			MoveStateWindow(i, nPos_Y, false);
			nPos_Y += c_nDelta;

			//if( m_vecCreatureList[i].bRender )
			if (m_pLinkPartyUI && m_pLinkPartyUI->isShowCreature(i))
			{
				MoveStateWindow(i, nPos_Y, true);
				nPos_Y += c_nCreatureDelta;
			}
		}
	}
	else
	{
		for( int i(0); i<nMemberSize; ++i )
		{
			MoveStateWindow(i, nPos_Y, false);
			nPos_Y += c_nDeltaSmall;

			//if( m_vecCreatureList[i].bRender )
			if (m_pLinkPartyUI && m_pLinkPartyUI->isShowCreature(i))
			{
				MoveStateWindow(i, nPos_Y, true);
				nPos_Y += c_nCreatureDeltaSmall;
			}
		}
	}

	KRect rcNew = GetRect();
	rcNew.bottom = nPos_Y + 5;
	Resize( rcNew );
//	SetCorrectionRect( rcNew, false );
}

bool SUIPartyStateWnd::IsAddCreature( AR_HANDLE handle, bool bMaster/*=false*/ )
{
	if( handle == NULL )	return false;

	for( int i(0); i<c_nMaxLine; ++i )
	{
		if( bMaster && m_vecCreatureList[i].hMaster == handle )
			if( m_vecCreatureList[i].hCreature1st != NULL )
				return true;

		if( !bMaster && m_vecCreatureList[i].hCreature1st == handle )
			if( m_vecCreatureList[i].hMaster != NULL )
				return true;
	}
	return false;
}

void SUIPartyStateWnd::MoveStateWindow( int nIndex, int nY, bool Creature )
{
	SUIPartyStateSetWnd* pStateSetWnd(NULL);

	if( Creature )
	{
		pStateSetWnd = dynamicCast<SUIPartyStateSetWnd*>(GetChild( CStringUtil::StringFormat( c_lpCreatureStateSetID, nIndex ).c_str() ));
		if( pStateSetWnd )
			pStateSetWnd->MovePos( pStateSetWnd->GetRect().left, nY );
	}
	else
	{
		pStateSetWnd = dynamicCast<SUIPartyStateSetWnd*>(GetChild( CStringUtil::StringFormat( c_lpStateSetID, nIndex ).c_str() ));
		if( pStateSetWnd )
			pStateSetWnd->MovePos( pStateSetWnd->GetRect().left, nY );
	}
}

SUIPartyStateSetWnd* SUIPartyStateWnd::GetChildWnd( AR_HANDLE handle )
{
	SUIPartyStateSetWnd* pStateSetWnd(NULL);
	for( int i(0); i<c_nMaxLine; ++i )
	{
		pStateSetWnd = dynamicCast<SUIPartyStateSetWnd*>(GetChild( CStringUtil::StringFormat( c_lpStateSetID, i ).c_str() ));
		if( pStateSetWnd && pStateSetWnd->IsEqualPlayer(handle) )
			return pStateSetWnd;
	}

	for( int i(0); i<c_nMaxLine; ++i )
	{
		pStateSetWnd = dynamicCast<SUIPartyStateSetWnd*>(GetChild( CStringUtil::StringFormat( c_lpCreatureStateSetID, i ).c_str() ));
		if( pStateSetWnd && pStateSetWnd->IsEqualPlayer(handle) )
			return pStateSetWnd;
	}
	return NULL;
}

DWORD SUIPartyStateWnd::OnMouseMessage(DWORD dwMessage, int x, int y)
{
	return SUIWnd::OnMouseMessage( dwMessage, x, y );
}

void SUIPartyStateWnd::ChangeSizeStateWnd(bool bBig)
{
	m_bSizeBig = bBig;

	SUIPartyStateSetWnd* pStateSetWnd;
	KRect rt = GetRect();
	if(bBig)
		rt.top += 1;

	for( int i(0); i<c_nMaxLine; ++i )
	{		
		pStateSetWnd = dynamicCast<SUIPartyStateSetWnd*>(GetChild( CStringUtil::StringFormat( c_lpCreatureStateSetID, i ).c_str() ));
		if( pStateSetWnd )
		{
		//	pStateSetWnd->Resize(rt);
			pStateSetWnd->MovePos(rt.left, rt.top);
			if(bBig)
				pStateSetWnd->ChangeSizeStateWnd(true);
			else
				pStateSetWnd->ChangeSizeStateWnd(false);
		}

		pStateSetWnd = dynamicCast<SUIPartyStateSetWnd*>(GetChild( CStringUtil::StringFormat( c_lpStateSetID, i ).c_str() ));
		if( pStateSetWnd )
		{
		//	pStateSetWnd->Resize(rt);
			pStateSetWnd->MovePos(rt.left, rt.top);
			if(bBig)
				pStateSetWnd->ChangeSizeStateWnd(true);
			else
				pStateSetWnd->ChangeSizeStateWnd(false);
		}

		if(bBig)
		{
			rt.top    += c_nStateDelta;
			rt.bottom += c_nStateDelta;
		}
		else
		{
			rt.top    += c_nStateDeltaSmall;
			rt.bottom += c_nStateDeltaSmall;
		}
	}
}
/*
void SUIPartyStateWnd::setRenderAllState(bool render)
{
	for( int i(0); i<SLOT_MAXLINE; ++i )
	{
		m_MemberStateRender[i] = render;
		m_CreatureStateRender[i] = render;
	}
}
*/
/*
void SUIPartyStateWnd::setRenderState(bool render, int objType, int index)
{
	if( objType == TS_ENTER::GAME_PLAYER )
	{
		m_MemberStateRender[index]	 = render;
	}
	else if( objType == TS_ENTER::GAME_SUMMON )
	{
		m_CreatureStateRender[index] = render;
	}
}
*/
void SUIPartyStateWnd::setShowParent(bool show)
{
	SUIPartyStateWndMgr* parent = dynamicCast<SUIPartyStateWndMgr*>(GetParent());
	if (!parent)
		return ;
	parent->SetShow(show);
}

void SUIPartyStateWnd::setCreatureListHandle(int index, AR_HANDLE masterHandle, AR_HANDLE firstCreatureHandle)
{
	if (0 > index || index >= SLOT_MAXLINE)
		return ;

	PartyCreatureInfo* info = m_vecCreatureList + index;
	info->hMaster = masterHandle;
	info->hCreature1st = firstCreatureHandle;
	info->hCreature2nd = 0;
	//info->bRender = true;
	//info->bRenderUI = true;
}

//============================================================================================================================================
// SUIPartyStateWndMgr
//============================================================================================================================================
std::string  g_strToProcessPartyName = "";     // 2011.11.09 - servantes : 메세지 처리할 파티 이름

SUIPartyStateWndMgr::SUIPartyStateWndMgr( SGameManager* pGameManager, SUIDisplayInfo* pDisplayInfo )
: SUIWnd( pGameManager ), m_pDisplayInfo ( pDisplayInfo )
{
}

SUIPartyStateWndMgr::~SUIPartyStateWndMgr()
{
	ClearWnd();
}

SUIWnd* SUIPartyStateWndMgr::CreateWnd( const char* szFile, KUIWndManager* pWndManager, KPoint kPos, int nWindowID )
{
	SUIWnd::CreateWnd( szFile, pWndManager, kPos, nWindowID );

	m_pManager = pWndManager;

	// 2011.11.12 - servantes : 포커스 받지 않도록 플래그 추가
	DWORD dwFlag = GetFlag();
	SetFlag(dwFlag | KFLAG_NO_GET_FOCUS);

	InitWnd();

	SetShow(true);

	KRect rt;
	rt.left   = 0;
	rt.right  = GetGameOption().GetResolution_Width();
	rt.top    = 0;
	rt.bottom = GetGameOption().GetResolution_Height();
	this->Resize(rt);

	return this;
}

void SUIPartyStateWndMgr::InitWnd()
{
	char buf[64];
	int h = GetGameOption().GetResolution_Height();
	for(int x=0; x<8; x++)
	{
		sprintf(buf, "temp_buff_party_%d", x);

		SUIPartyStateWnd* pWnd = new SUIPartyStateWnd(m_pGameManager, m_pDisplayInfo);
		pWnd->CreateWnd("window_main_party_state.nui", m_pManager, KPoint(0, 0), x);
		pWnd->SetParent(this);
		pWnd->MovePos(0, 0);
		pWnd->SetShow(false);
		pWnd->OnNotifyUIWindowOpen(false);
		pWnd->SetPartyName(buf);

		AddWnd(pWnd);
		AddChild(pWnd);
	}
}

bool SUIPartyStateWndMgr::InitControls( KPoint kPos )
{
	return SUIWnd::InitControls( kPos );
}

void SUIPartyStateWndMgr::PumpUpMessage( LPCSTR lpszControlID, DWORD nMessage, DWORD lparam, DWORD wparam )
{
	int k=0;
	k=0;
	SUIWnd::PumpUpMessage( lpszControlID, nMessage, lparam, wparam );
}

int SUIPartyStateWndMgr::AddCreature( SGameMessage* pMsg )
{
	SIMSG_UI_SEND_DATA* pData = (SIMSG_UI_SEND_DATA *)pMsg;

	std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
	std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
	for(; itS != itE; itS++)
	{
		SUIPartyStateWnd* pStateWnd = itS->second;
		int id = pStateWnd->AddCreature( pData->m_dwData );
		if( id > -1 )
		{
			pStateWnd->RefreshSlots();
			return id;
		}
	}
	return -1;
}

int SUIPartyStateWndMgr::RemoveCreature( SGameMessage* pMsg )
{
	SIMSG_UI_SEND_DATA* pData = (SIMSG_UI_SEND_DATA *)pMsg;

	std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
	std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
	for(; itS != itE; itS++)
	{
		SUIPartyStateWnd* pStateWnd = itS->second;
		int id = pStateWnd->RemoveCreature( pData->m_dwData );
		if( id > -1 )
		{
			pStateWnd->RefreshSlots();
			return id;
		}
	}
	return -1;
}

void SUIPartyStateWndMgr::RemoveMaster( SGameMessage* pMsg )
{
	SIMSG_UI_SEND_DATA* pData = (SIMSG_UI_SEND_DATA *)pMsg;

	std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
	std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
	for(; itS != itE; itS++)
	{
		SUIPartyStateWnd* pStateWnd = itS->second;
		pStateWnd->LeaveMaster( pData->m_dwData);
		pStateWnd->RefreshSlots();
	}
}

void SUIPartyStateWndMgr::ProcMsgAtStatic( SGameMessage* pMsg )
{
	switch(pMsg->nType)
	{
	case IMSG_UI_SEND_DATA:
		{
			SIMSG_UI_SEND_DATA* pData = (SIMSG_UI_SEND_DATA *)pMsg;
			if( pData->m_strString == "set_party_name" )   // 2011.11.09 - servantes : 파티 이름 설정
			{
				g_strToProcessPartyName = pData->m_strText;
				pMsg->bUse = true;
			}
			else if( pData->m_strString == "buff_size_force")
			{
				SUIPartyStateWnd* p = FindWnd(pData->m_strText.c_str());
				if(p)
				{
					p->ChangeSizeStateWnd((bool)pData->m_dwData);
				}
				pMsg->bUse = true;
			}
			else if( pData->m_strString == "buff_size")
			{
				SUIPartyStateWnd* p = FindWnd(pData->m_strText.c_str());
				if(p)
				{
					bool bSizeBigFlag = (bool)pData->m_dwData;
					if(p->GetBuffSizeBigFalg() != bSizeBigFlag)
						ChangeSizeStateWnd(pData->m_strText.c_str(), bSizeBigFlag);
				}
				pMsg->bUse = true;
			}
			else if( pData->m_strString == "small_buff" )
			{
				ChangeSizeStateWnd(pData->m_strText.c_str(), false);
				pMsg->bUse = true;
			}
			else if( pData->m_strString == "big_buff" )
			{
				ChangeSizeStateWnd(pData->m_strText.c_str(), true);
				pMsg->bUse = true;
			}
			else if( pData->m_strString == "show_buff" )
			{
				SetShow(true);

				int id = m_PartyMgr.FindPartyID( &pData->m_strText );
				if(id < 0)
					return ;  // 해당 파티가 없다는 뜻

				SUIPartyStateWnd* pStateWnd = FindWnd( id );

				if(pStateWnd)
				{
					pStateWnd->SetPartyName(pData->m_strText.c_str());
					if( pStateWnd->GetLinkPartyUIPtr() == NULL )
					{
						SUIPartyWndMgr* pPartyWndMgr = (SUIPartyWndMgr*)this->m_pGameManager->GetSUI(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_PARTY);
						if(pPartyWndMgr)
						{
							int id;
							SUIPartyDualWnd* pWnd = pPartyWndMgr->FindWnd( pData->m_strText.c_str(), id );
							if(pWnd)
								pStateWnd->SetLinkPartyUIPtr( pWnd );  // 파티창 UI 포인터
						}
					}
					pStateWnd->SetShow(true);
					pStateWnd->OnNotifyUIWindowOpen(true);
					pStateWnd->Move((int)pData->m_nNumber.getAmount(), (int)pData->m_nNumber2.getAmount());
				}
/*
				SUIPartyStateWnd* pStateWnd = FindWnd(pData->m_strText.c_str());
				if(pStateWnd)
				{
					SUIPartyWndMgr* pUIPartyMgr = dynamicCast< SUIPartyWndMgr * >(m_pGameManager->GetSUI(SIMSG_TOGGLE_UIWINDOW::_UIWINDOW_TYPE::UIWINDOW_PARTY));
					if(pUIPartyMgr == NULL)
					{
						pMsg->bUse = true;
						break;
					}

					int _temp;
					SUIPartyDualWnd* pWnd = pUIPartyMgr->FindWnd(pData->m_strText.c_str(), _temp);
					if(pWnd)
					{
						POINT pt = pWnd->GetBuffRenderPos();
						pStateWnd->SetShow(true);
						pStateWnd->OnNotifyUIWindowOpen(true);
						pStateWnd->Move((int)pt.x, (int)pt.y);
					}
				}
*/
				pMsg->bUse = true;
			}
			else if( pData->m_strString == "hide_buff" || pData->m_strString == "hide_wnd" )
			{
				int id = m_PartyMgr.FindPartyID( &pData->m_strText );
				if(id < 0)
					return ;  // 해당 파티가 없다는 뜻

				SUIPartyStateWnd* pStateWnd = FindWnd( id );

				if(pStateWnd)
				{
					pStateWnd->SetPartyName(pData->m_strText.c_str());
					if( pStateWnd->GetLinkPartyUIPtr() == NULL )
					{
						SUIPartyWndMgr* pPartyWndMgr = (SUIPartyWndMgr*)this->m_pGameManager->GetSUI(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_PARTY);
						if(pPartyWndMgr)
						{
							int id;
							SUIPartyDualWnd* pWnd = pPartyWndMgr->FindWnd( pData->m_strText.c_str(), id );
							if(pWnd)
								pStateWnd->SetLinkPartyUIPtr( pWnd );  // 파티창 UI 포인터
						}
					}
					pStateWnd->SetShow(false);
					pStateWnd->OnNotifyUIWindowOpen(false);
				}
				pMsg->bUse = true;
			}
			else if( pData->m_strString == "hide_all_buff" )
			{
				std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
				std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
				for(; itS != itE; itS++)
				{
					SUIPartyStateWnd* p = itS->second;
					p->SetShow(false);
					p->OnNotifyUIWindowOpen(false);
				}
				pMsg->bUse = true;
			}
			else if( pData->m_strString == "sync_party_delete" )
			{
				SUIPartyStateWnd* pStateWnd = FindWnd(pData->m_strText.c_str());
				if(pStateWnd)
				{
					pStateWnd->ClearCreatureList();
					pStateWnd->DisableAllSlots();
					pStateWnd->SetShow(false);
					pStateWnd->OnNotifyUIWindowOpen(false);

					pStateWnd->SetLinkPartyUIPtr( NULL );
				}
				pMsg->bUse = true;
			}
			//else if( pData->m_strString == "sync_party_name" )
			//{
			//	SUIPartyStateWnd* pStateWnd = FindWnd( (int)pData->m_dwData );
			//	if(pStateWnd)
			//	{
			//		pStateWnd->SetShow(true);
			//		pStateWnd->SetPartyName(pData->m_strText.c_str());
			//		
			//		if(pData->m_strText.size())
			//		{
			//			SUIPartyWndMgr* pPartyWndMgr = (SUIPartyWndMgr*)this->m_pGameManager->GetSUI(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_PARTY);
			//			if(pPartyWndMgr)
			//			{
			//				int id;
			//				SUIPartyDualWnd* pWnd = pPartyWndMgr->FindWnd( pData->m_strText.c_str(), id );
			//				if(pWnd == NULL)
			//					return ;
			//				pStateWnd->SetLinkPartyUIPtr( pWnd );  // 파티창 UI 포인터

			//				if(pWnd->GetUISizeState() == PARTY_UI_SIZE_SMALL)
			//					pStateWnd->ChangeSizeStateWnd(true);
			//				else
			//					pStateWnd->ChangeSizeStateWnd(false);

			//				pStateWnd->RefreshEnableSlots();
			//			}
			//		}
			//	}
			//	pMsg->bUse = true;
			//}
			else if( pData->m_strString == "add_creature" )
			{
				AddCreature( pMsg ); //pData->m_dwData );
				g_strToProcessPartyName = "";   // 2011.11.10 - servantes : 파티 이름 초기화
				pMsg->bUse = true;
			}
			else if( pData->m_strString == "remove_creature" )
			{
				RemoveCreature( pMsg ); //pData->m_dwData );
				g_strToProcessPartyName = "";   // 2011.11.10 - servantes : 파티 이름 초기화
				pMsg->bUse = true;
			}
			else if( pData->m_strString == "remove_player" )
			{
				RemoveMaster( pMsg );
				g_strToProcessPartyName = "";   // 2011.11.10 - servantes : 파티 이름 초기화
				pMsg->bUse = true;
			}
			else if (pData->m_strString == "member_creature_info")
			{
				std::vector<std::string> textList;
				MsgSplit(pData->m_strText.c_str(), textList, L"|");
				setMemberCreatureInfo(textList);
				textList.clear();
			}
			/// 2011.11.17 - prodongi
			else
			{
				SUIPartyStateWnd* p = FindWnd(pData->m_strText.c_str());
				if(p)
				{
					p->ProcMsgAtStatic( pMsg );

					g_strToProcessPartyName = "";   // 2011.11.10 - servantes : 파티 이름 초기화
					pMsg->bUse = true;
				}
			}
			pMsg->bUse = true;
			break;
		}
	case MSG_CHATTING:
		{
			SMSG_CHATTING* pChatMsg = ( SMSG_CHATTING* )pMsg;

			if( pChatMsg->nChatType == CHAT_PARTY_SYSTEM )
			{
				STR_LIST vecText;
				MsgSplit( pChatMsg->strText.c_str(), vecText, L"|" );
				if ("DESTROY" == vecText[0])
				{
					HideAndClearWnd(vecText[1].c_str());
				}
				else if ("CREATE" == vecText[0])
				{
					SetShow(true);

					SetShowStateWndFlag( &vecText[1], false );
					InitStateWndBuffFlag( &vecText[1] );
				}
				else if ("JOIN" == vecText[0])
				{
					/// 2012.06.08 2021.06.08 " // JOIN|파티명|캐릭터명" 공대 파티와 일반 파티와 통일됨 - prodongi
					const char* pMyName = g_pCurrentGameSystem->GetLocalPlayer()->GetName();
					if( vecText[2].compare( pMyName ) == 0 )
					{
						SetShow( true );

						InitStateWndBuffFlag( &vecText[1] );
					}
				}
				else if ("KICK" == vecText[0])
				{
					if(g_pCurrentGameSystem)
					{
						const char* pMyName = g_pCurrentGameSystem->GetLocalPlayer()->GetName();
						if( vecText[2].compare( pMyName ) == 0 )
							SetShow( false );
					}
				}
				else if ("LEAVE" == vecText[0])
				{
					if(g_pCurrentGameSystem)
					{
						const char* pMyName = g_pCurrentGameSystem->GetLocalPlayer()->GetName();
						if( vecText[1].compare( pMyName ) == 0 )
							SetShow( false );
					}
				}
				else if ("PROMOTE" == vecText[0])
				{
					RefreshStateWnd();
				}
				vecText.clear();


				/*
				if( m_PartyMgr.IsExist() && m_PartyMgr.GetMemberCount() > 0 )
				{
				void SUIPartyStateWndMgr::RefreshStateWnd()
				{
					std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
					std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
					for(; itS != itE; itS++)
					{
						SUIPartyStateWnd* p = itS->second;

						p->RefreshSlots();
					}
				}
				else
				{
					std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
					std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
					for(; itS != itE; itS++)
					{
						SUIPartyStateWnd* p = itS->second;

						p->ClearCreatureList();
						p->DisableAllSlots();
					}
				}*/
			}

			pMsg->bUse = true;
		}
		break;
	case IMSG_UI_MOVE:
		{
			SIMSG_UI_MOVE* pMoveMsg = ( SIMSG_UI_MOVE* )pMsg;

			SUIPartyStateWnd* p = FindWnd(g_strToProcessPartyName.c_str());
			if(p)
			{
				p->ProcMsgAtStatic( pMsg );

				g_strToProcessPartyName = "";   // 2011.11.10 - servantes : 파티 이름 초기화
				pMsg->bUse = true;
			}
		}
		break;
	case IMSG_UI_STATE_UPDATE:
		{
			SIMSG_UI_STATE_UPDATE* pStateUpdate = ( SIMSG_UI_STATE_UPDATE* )pMsg;

			std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
			std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
			for(; itS != itE; itS++)
			{
				SUIPartyStateWnd* p = itS->second;

				SUIPartyStateSetWnd* pWnd = p->GetChildWnd( pStateUpdate->m_hPlayer );
				if( pWnd )
				{
					if( pWnd->StateUpdate(pMsg) == true )
						break;
				}
			}
			g_strToProcessPartyName = "";   // 2011.11.10 - servantes : 파티 이름 초기화
			pMsg->bUse = true;
		}
		break;
	case IMSG_UI_STATE_LIST_UPDATE:
		{
			SIMSG_UI_STATE_LIST_UPDATE* pStateListUpdate = ( SIMSG_UI_STATE_LIST_UPDATE* )pMsg;

			std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
			std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
			for(; itS != itE; itS++)
			{
				SUIPartyStateWnd* p = itS->second;

				SUIPartyStateSetWnd* pWnd = p->GetChildWnd( pStateListUpdate->hPlayer );
				if( pWnd )
				{
					if( pWnd->StateListUpdate(pMsg) == true )
						break;
				}
			}
			g_strToProcessPartyName = "";   // 2011.11.10 - servantes : 파티 이름 초기화
			pMsg->bUse = true;
		}
		break;
	case MSG_ENTER:
		{
			SMSG_ENTER* pEnter = (SMSG_ENTER*)pMsg;

			/// 2012.01.11 크리처는 setMemberCreatureInfo 에서 설정해 준다- prodongi
			if( pEnter->ObjType == TS_ENTER::GAME_SUMMON )
			{
				std::string partyName;
				SPlayerSlot* slot = m_PartyMgr.FindMemberByCreature(pEnter->handle, partyName);
				if (slot)
				{
					setMemberCreatureInfo(slot->GetHandle(), slot->GetMainCreatureHandle(), partyName.c_str());
				}
/*
				std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
				std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
				for(; itS != itE; itS++)
				{
					SUIPartyStateWnd* pWnd = itS->second;
					if( pWnd->ChangeCreature( pEnter->handle ) )
					{
						pWnd->RefreshSlots();
						break;
					}
				}
				*/
			}
			else if( pEnter->ObjType == TS_ENTER::GAME_PLAYER )
			{
				std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
				std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
				for(; itS != itE; itS++)
				{
					SUIPartyStateWnd* pWnd = itS->second;
					if( pWnd->ChangeMasterCreature( pEnter->handle ) )
					{
						pWnd->RefreshSlots();
						break;
					}
				}
			}
			pMsg->bUse = true;
		}
		break;

	case MSG_LEAVE:
		{
			SMSG_LEAVE* pLeave = (SMSG_LEAVE*)pMsg;
			std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
			std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
			for(; itS != itE; itS++)
			{
				SUIPartyStateWnd* pWnd = itS->second;
				if( pWnd->LeaveCreature( pLeave->handle ) == -1 )
				{
					pWnd->LeaveMaster( pLeave->handle );
					break;
				}
			}
			pMsg->bUse = true;
		}
		break;
	}
}

void SUIPartyStateWndMgr::SetShowStateWndFlag(std::string* pPartyName, bool bShow)
{
	if(pPartyName == NULL)
		return ;

	int id = m_PartyMgr.FindPartyID( pPartyName );
	if(id < 0)
		return ;  // 해당 파티가 없다는 뜻

	SUIPartyWndMgr* pPartyWndMgr = (SUIPartyWndMgr*)this->m_pGameManager->GetSUI(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_PARTY);
	if(pPartyWndMgr)
	{
		SUIPartyStateWnd* p = FindWnd( id );
		if(p)
		{
			p->SetShow(bShow);
		}
	}
}

void SUIPartyStateWndMgr::InitStateWndBuffFlag(std::string* pPartyName)
{
	if(pPartyName == NULL)
		return ;

	int id = m_PartyMgr.FindPartyID( pPartyName );
	if(id < 0)
		return ;  // 해당 파티가 없다는 뜻

	SUIPartyWndMgr* pPartyWndMgr = (SUIPartyWndMgr*)this->m_pGameManager->GetSUI(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_PARTY);
	if(pPartyWndMgr)
	{
		SUIPartyStateWnd* p = FindWnd( id );
		if(p)
		{
			p->InitBuffFlag();
		}
	}
}

void SUIPartyStateWndMgr::HideAndClearWnd(char const* partyName)
{
	std::string localPlayerName = g_pCurrentGameSystem->getLocalPlayerName();
	SPartyMgr* localParty = m_PartyMgr.FindPartyByPlayerName(&localPlayerName);
	if (!localParty || strcmp(localParty->GetPartyName(), partyName) == 0)
	{
		std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
		std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
		for(; itS != itE; itS++)
		{
			SUIPartyStateWnd* pStateWnd = itS->second;
			pStateWnd->ClearCreatureList();
			pStateWnd->DisableAllSlots();
			pStateWnd->SetShow(false);
			pStateWnd->OnNotifyUIWindowOpen(false);
			pStateWnd->SetLinkPartyUIPtr( NULL );
		}
		SetShow(false);
	}
}

void SUIPartyStateWndMgr::OnNotifyUIWindowOpen( bool bOpen, bool bLimitWnd )
{
	SUIWnd::OnNotifyUIWindowOpen(bOpen);
}

DWORD SUIPartyStateWndMgr::OnMouseMessage(DWORD dwMessage, int x, int y)
{
	if( dwMessage == KLBUTTON_DOWN )
		return KMR_GET_PASS;

	return SUIWnd::OnMouseMessage( dwMessage, x, y );
}

void SUIPartyStateWndMgr::RemoveParty(const char* pstrPartyName)
{
	if(pstrPartyName == NULL)
		return ;

	std::string str = pstrPartyName;
	std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
	std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
	for(; itS != itE; itS++)
	{
		SUIPartyStateWnd* pWnd = itS->second;
		if( *pWnd->GetPartyName() == str )
		{
			RemoveChild((KUIWnd*)pWnd);
			m_mapWnd.erase(itS);   // 지운다
			break;
		}
	}
}

void SUIPartyStateWndMgr::AddWnd(SUIPartyStateWnd* pWnd)
{
	if(pWnd)
		m_mapWnd.insert(std::make_pair(*pWnd->GetPartyName(), pWnd));
}
/*
int SUIPartyStateWndMgr::GetBuffVisible(const char* strPartName, bool bChar, int id_slot, bool& bShow)
{
	SUIPartyStateWnd* pWnd = FindWnd(strPartName);
	if(pWnd == NULL)
		return -1;
	
	if(bChar == true)
		bShow = pWnd->GetCharacterBuffFlag(id_slot);
	else
		bShow = pWnd->GetCreatureBuffFlag(id_slot);

	return 1;
}
*/
SUIPartyStateWnd* SUIPartyStateWndMgr::FindWnd(const char* pstrName)
{
	if(pstrName == NULL)
		return NULL;

	std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
	std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
	for(; itS != itE; itS++)
	{
		SUIPartyStateWnd* p = itS->second;
		std::string pstr = *p->GetPartyName();
		if( pstr.compare( pstrName ) == 0 )
			return p;
	}
	return NULL;
}

SUIPartyStateWnd* SUIPartyStateWndMgr::FindWnd(int id)
{
	if(id < 0)
		return NULL;

	int k=0;
	std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
	std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
	for(; itS != itE; itS++, k++)
	{
		if(k == id)
		{
			SUIPartyStateWnd* p = itS->second;
			return p;
		}
	}
	return NULL;
}

void SUIPartyStateWndMgr::ClearWnd()
{
	std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
	std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
	for(; itS != itE; itS++)
	{
		SUIPartyStateWnd* p = itS->second;
	}
	m_mapWnd.clear();
}

void SUIPartyStateWndMgr::ChangeSizeStateWnd(const char* pPartyName, bool bBig)
{
	SUIPartyStateWnd* pWnd = FindWnd(pPartyName);
	if(pWnd == NULL)
		return ;

	KRect rt = pWnd->GetRect();

	POINT pt = {rt.left, rt.top};
	if( pWnd->GetLinkPartyUIPtr() )
		pt = pWnd->GetLinkPartyUIPtr()->GetBuffRenderPos();

	if(bBig)
	{
		rt.right  = rt.left + (10 * 10);  // 10(버프 개수) X 10(버프 크기)
		rt.bottom = rt.top  + (3  * 10);  // 3(버프 나오는 줄 개수) X 10(버프 크기)
		pWnd->Resize(rt);
		pWnd->ChangeSizeStateWnd(true);
		pWnd->MovePos(pt.x, pt.y);
	}
	else
	{
		rt.right  = rt.left + (10 * 7);   // 10(버프 개수) X 7(버프 크기)
		rt.bottom = rt.top  + (3  * 7);   // 3(버프 나오는 줄 개수) X 7(버프 크기)
		pWnd->Resize(rt);
		pWnd->ChangeSizeStateWnd(false);
		pWnd->MovePos(pt.x, pt.y);
	}
}

void SUIPartyStateWndMgr::RefreshStateWnd()
{
	std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
	std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
	for(; itS != itE; itS++)
	{
		SUIPartyStateWnd* p = itS->second;

		p->RefreshSlots();
	}
}

void SUIPartyStateWndMgr::setMemberCreatureInfo(std::vector<std::string> const& textList)
{
	char* endPtr;
	AR_HANDLE hMainCreature = ::strtoul( textList[ 2 ].c_str(), &endPtr, 10 );
	AR_HANDLE hMaster = ::strtoul(textList[1].c_str(), &endPtr, 10);

	setMemberCreatureInfo(hMaster, hMainCreature, textList[0].c_str());
}

void SUIPartyStateWndMgr::setMemberCreatureInfo(AR_HANDLE hMaster, AR_HANDLE hMainCreature, char const* partyName)
{
	std::string _partyName = partyName;
	std::map<std::string, SUIPartyStateWnd*>::iterator itE = m_mapWnd.end();
	std::map<std::string, SUIPartyStateWnd*>::iterator itS = m_mapWnd.begin();
	for(; itS != itE; itS++)
	{
		SUIPartyStateWnd* pWnd = itS->second;
		if (0 == pWnd->GetPartyName()->compare(_partyName))
		{
			int index = m_PartyMgr.GetMemberIndex( hMaster, &_partyName);
			if( index >= 0 && index < c_nMaxLine )
			{
				pWnd->setCreatureListHandle(index, hMaster, hMainCreature);
				pWnd->RefreshSlot(index);
				break;
			}
		}
	}
}