#include "stdafx.h"
#include "KTypes.h"
//#include "Util.h"
#include "SUIDefine.h"
#include "SStringDB.h"
#include "SItemDB.h"
#include "SInventoryMgr.h"
#include "SGameSystem.h"
//#include "SUIWnd.h"
#include "SUIDisplayInfo.h"
#include "KUIControlStatic.h"
//#include "SUIUtil.h"
#include "SDebug_Util.h"
// 2010.05.11 - prodongi
#include "SSummonSlotMgr.h"
#include "SCreatureDB.h"
// 2010.07.27 - prodongi
#include "SGameSystem.h"
#include "SGameAvatarEx.h"
#include "SGameUIMgr.h"
#include "SMessengerMgr.h"
// 2010.08.06 - prodongi
#include "SPlayerInfoMgr.h"
#include "SSKillSlot.h"
// 2010.09.17 - prodongi
#include "SCreatureEnhanceDB.h"
#include "SGameMessage.h"	/// 2011.01.20 - prodongi
#include "SUISysMsgDefine.h"
#include "SSkillDB.h"	/// 2011.08.03 - prodongi

#include "SGameManager.h"
#include "KResourceManager.h"

extern SGameSystem* g_pCurrentGameSystem;

// helper -----------------------------------------------------------------------------------------

using namespace sui;

std::string sui::helper::int_to_comma_numeric( __int64 number )
{
	return CStringUtil::GetCommaNumberString( number );
}
__int64 sui::helper::comma_numeric_to_int( const char* number )
{
	std::string num( number );
	num.erase( std::remove( num.begin(), num.end(), ',' ), num.end() );
	return ::_atoi64( num.c_str() );
}
std::string sui::helper::indexed_id( const char* format, int index )
{
	std::string id;
	XStringUtil::Format( id, format, index );
	return id;
}

// null property

property null_property;

// sonador #2.1.2.4.3	팻 조작 UI 연동
// property array ---------------------------------------------------------------------------------

property_array::property_array()
{
}
property_array::property_array( const property_array& other )
{
	_copy( other );
}
property_array& property_array::operator = ( const property_array& rhs )
{
	if( this == &rhs )
		return *this;
	_copy( rhs );
	return *this;
}
property_array::~property_array() 
{ 
	sui::wipe_seq( m_properties );
}
property_array& property_array::add( property* prop )
{
	m_properties.push_back( prop );
	return *this;
}
property& property_array::get( const char* name )
{
	if( !m_properties.empty() )
	{
		properties_t::iterator found = std::find_if( m_properties.begin(), m_properties.end(), property::finder( name ) );
		if( found != m_properties.end() )
			return **found;
	}
	return null_property;
}
property& property_array::at( int index )
{
	if( index < 0 && index >= m_properties.size() )
		return null_property;
	return *m_properties.at( index );
}
property& property_array::operator[]( int index )
{
	return at( index );
}
property& property_array::operator[]( const char* name )
{
	return get( name );
}
int property_array::size() const 
{
	return m_properties.size();
}
bool property_array::empty() const
{
	return m_properties.empty();
}
property_array::iterator property_array::begin() 
{
	return m_properties.begin();
}
property_array::iterator property_array::end()
{
	return m_properties.end();
}
property_array::const_iterator property_array::begin() const
{
	return m_properties.begin();
}
property_array::const_iterator property_array::end() const
{
	return m_properties.end();
}
void property_array::_copy( const property_array& other )
{
	sui::wipe_seq( m_properties );
	if( other.empty() )
		return;
	property_array::const_iterator ci = other.begin(), ce = other.end();
	for( ; ci != ce; ++ci )
	{
		const property* other_prop = *ci;
		if( other_prop )
		{
			property* this_prop = new property( *other_prop );
			add( this_prop );
		}
	}
}

// null updatable window

kui_updatable_window null_updatable_window;

// updatable window array -------------------------------------------------------------------------

kui_updatable_window_array::kui_updatable_window_array()
{
}
kui_updatable_window_array::~kui_updatable_window_array()
{
	clear();
}
kui_updatable_window_array& kui_updatable_window_array::add( kui_updatable_window* window )
{
	m_windows.push_back( window );
	return *this;
}
kui_updatable_window& kui_updatable_window_array::get( const char* name )
{
	if( !m_windows.empty() )
	{
		window_container_t::iterator found = std::find_if( m_windows.begin(), m_windows.end(), kui_updatable_window::finder( name ) );
		if( found != m_windows.end() )
			return **found;
	}
	return null_updatable_window;
}
kui_updatable_window& kui_updatable_window_array::at( int index )
{
	if( index < 0 && index >= m_windows.size() )
		return null_updatable_window;
	return *m_windows.at( index );
}
kui_updatable_window& kui_updatable_window_array::operator[]( int index )
{
	return at( index );
}
kui_updatable_window& kui_updatable_window_array::operator[]( const char* name )
{
	return get( name );
}
int kui_updatable_window_array::size() const
{
	return m_windows.size();
}
bool kui_updatable_window_array::empty() const
{
	return m_windows.empty();
}
kui_updatable_window_array::iterator kui_updatable_window_array::begin()
{
	return m_windows.begin();
}
kui_updatable_window_array::iterator kui_updatable_window_array::end()
{
	return m_windows.end();
}
kui_updatable_window_array::const_iterator kui_updatable_window_array::begin() const
{
	return m_windows.begin();
}
kui_updatable_window_array::const_iterator kui_updatable_window_array::end() const
{
	return m_windows.end();
}
void kui_updatable_window_array::clear()
{
	sui::wipe_seq( m_windows );
}
void kui_updatable_window_array::update()
{
	std::for_each( begin(), end(), std::mem_fun( &kui_updatable_window::update ) );
}

// proxy_list -------------------------------------------------------------------------------------
	
proxy_list::proxy_list( SUIWnd* window, const char* id, int limit, int item_offset ) 
	: m_id( id )
	, m_limit( limit )	
	, m_item_offset( item_offset )
	, m_offset( 0 )
	, m_current_index( INVALID_VALUE )
	, m_saved_offset( 0 )
	, m_saved_index( INVALID_VALUE )
	, m_window( window )
	, m_scroll( 0 )
	, m_selection_mask( 0 )
	, m_selection_mask_origin_offset( 0 )
	, m_proc_mouse( true )
{
	m_control_matrix.reserve( limit );
	for( int i = 0; i < limit; ++i )
		m_control_matrix.push_back( new control_row_t );
}
proxy_list::~proxy_list()
{
	wipe_seq( m_items );
	
	control_matrix_t::iterator iRow = m_control_matrix.begin(), iRowEnd = m_control_matrix.end();
	for( ; iRow != iRowEnd; ++iRow )
	{
		control_row_t* row = *iRow;
		if( row )
		{
			control_row_t::iterator iProp = row->begin(), iPropEnd = row->end();
			for( ; iProp != iPropEnd; ++iProp )
			{
				kui_window_property* prop = *iProp;
				if( prop ) 
					delete prop;
			}
			delete row;
		}
	}
}
void proxy_list::initialize( const char* selectable_id, const char* selection_mask_id, const char* scroll_id )
{
	_init_selectables( selectable_id );
	_init_selection_mask( selection_mask_id );
	_init_scroll( scroll_id );
}
void proxy_list::clear()
{
	sui::wipe_seq( m_items );
	m_offset = 0;
	_update_scroll_range();
	_select_item_by( INVALID_VALUE );
}
void proxy_list::proc_pumpup( LPCSTR id, DWORD message, DWORD lparam, DWORD	wparam )
{			
	switch( message )
	{
	case KUI_MESSAGE::KSCROLL_SELECT:
		{
			if( m_scroll && ::stricmp( id, m_scroll->GetID() ) == 0 )
			{
				int pos = int( lparam );
				pos = std::max( pos, 0 );
				pos = std::min( pos, (int)m_items.size() - 1 );
				m_offset = pos;
				update_data();
			}
		}
		break;
	}
}
void proxy_list::proc_mouse( DWORD msg, int x, int y )
{
	if( !m_proc_mouse )
		return;

	if( m_window->IsInRect( x, y ) )
	{
		switch( msg )
		{
		case KLBUTTON_DOWN:
			{
				int index = _mouse_to_index( x, y );				
				if( INVALID_VALUE != index )
				{
					_select_item_by( index );
					m_window->PumpUpMessage( m_id, KUI_MESSAGE::KLIST_ITEM_CLICK, static_cast< DWORD >( m_current_index ), static_cast< DWORD >( index ) );
				}
			}
			break;
		case KLBUTTON_DBLCLK:
			{
				int index = _mouse_to_index( x, y );				
				if( index != INVALID_VALUE )
				{
					_select_item_by( index );
					m_window->PumpUpMessage( m_id, KUI_MESSAGE::KLIST_ITEM_LDBLCLK, static_cast< DWORD >( m_current_index ), static_cast< DWORD >( index ) );
				}
			}
			break;
		/// 2011.05.12 - prodongi
		case KRBUTTON_DOWN:
			{
				int index = _mouse_to_index( x, y );				
				if( index != INVALID_VALUE )
				{
					m_window->PumpUpMessage( m_id, KUI_MESSAGE::KICON_RCLICK, static_cast< DWORD >( _to_item_index(index) ), 0 );
				}
			}
			break;
		default:
			break;
		}
	}
}
void proxy_list::activate_mouse_proc( bool activity )
{
	if( m_proc_mouse != activity )
	{
		m_proc_mouse = activity;
		if( !m_proc_mouse )
		{
			_locate_selection_mask_at( INVALID_VALUE );
		}
	}
}
void proxy_list::save_state()
{
	m_saved_offset = m_offset;
	m_saved_index = m_current_index;
}
void proxy_list::load_state()
{
	m_offset = _normalize_offset( m_saved_offset );

	if( m_scroll )
		m_scroll->SetPosition( m_offset );

	int index_delta = m_offset - m_saved_offset;
	_select_item_by( _to_control_index( m_saved_index + index_delta ) );
}
proxy_list::this_t& proxy_list::add( item_t* item )
{
	m_items.push_back( item );
	_update_scroll_range();
	return *this;
}
void proxy_list::remove( item_t* item )
{
	m_items.erase( std::remove( m_items.begin(), m_items.end(), item ), m_items.end() );
	_update_scroll_range();
}
int proxy_list::size() const 
{
	return m_items.size();
}
bool proxy_list::empty() const 
{
	return m_items.empty();
}
proxy_list::iterator proxy_list::begin() 
{
	return m_items.begin();
}
proxy_list::iterator proxy_list::end()
{
	return m_items.end();
}
proxy_list::iterator proxy_list::visible_begin()
{
	if( !m_items.empty() )
		return m_items.begin() + m_offset;
	return m_items.end();
}
proxy_list::iterator proxy_list::visible_end()
{
	if( !m_items.empty() )
	{
		int visible_end = _get_visible_end_index();
		if( visible_end == m_items.size() )
			return m_items.end();
		return m_items.begin() + visible_end;
	}
	return m_items.end();
}
proxy_list::item_t* proxy_list::at( int item_index )
{	
	if( item_index < 0 || item_index >= m_items.size() )
		return 0;
	return m_items.at( item_index );
}
proxy_list::item_t* proxy_list::operator[ ]( int item_index )
{
	return at( item_index );
}
void proxy_list::next_page()
{
	if( m_items.empty() )
		return;
	int next_page = page() + 1;
	if( next_page >= page_end() )
		return;
	_set_offset_by( next_page );
	update_data();
}
void proxy_list::prev_page()
{
	if( m_items.empty() )
		return;
	int prev_page = page() - 1;
	if( prev_page < page_begin() )
		return;
	_set_offset_by( prev_page );
	update_data();
}
int proxy_list::page_begin() const
{
	if( m_items.empty() )
		return INVALID_VALUE;
	return 0;
}
int proxy_list::page_end() const
{
	if( m_items.empty() )
		return INVALID_VALUE;
	return static_cast< int >( m_items.size() - 1 ) / m_limit + 1;
}
int proxy_list::page() const
{
	int page = _get_page_from( m_offset );
	if( !_is_valid_page( page ) )
		return INVALID_VALUE;
	return page;
}
void proxy_list::update_data() 
{
	item_container_t::iterator i_item = visible_begin();
	item_container_t::iterator i_item_end = visible_end();

	// foreach all row
	for( int index = 0; index < m_limit; ++index )
	{
		control_row_t* row = m_control_matrix.at( index );
		control_row_t::iterator i_wnd = row->begin(), i_wnd_end = row->end();

		// foreach all control in a row
		for( ; i_wnd != i_wnd_end; ++i_wnd )
		{
			property item_prop;
			kui_window_property* wnd_prop = static_cast< kui_window_property* >( *i_wnd );
			if( i_item != i_item_end )
			{
				item_t* item = *i_item;
				item_prop = item->get( wnd_prop->get_name() );
			}
			wnd_prop->on_update( item_prop );
		}
		if( i_item != i_item_end )
			++i_item;
	}
	
	_locate_selection_mask_at( _to_control_index( m_current_index ) );
}
property* proxy_list::get_window_property( int row, const char* column_id )
{
	property* prop = 0;
	if( row >= 0 && row < m_control_matrix.size() )
	{
		control_row_t* cont = m_control_matrix.at( row );
		control_row_t::iterator found = std::find_if( cont->begin(), cont->end(), property::finder( column_id ) );
		if( found != cont->end() )
			prop = *found;
	}
	return prop;
}
void proxy_list::_init_scroll( const char* window_id )
{
	if( !window_id )
		return;
	m_scroll = dynamicCast< KUIControlScrollBase* >( m_window->GetChild( window_id ) );
	// TODO: temporary
	m_window->SetChildAsTop( window_id );
}
void proxy_list::_init_selectables( const char* window_id )
{
	if( !window_id )
		return;

	std::string indexed_id_orig	= helper::indexed_id( window_id , 0 );

	KUIWnd* wnd = m_window->GetChild( indexed_id_orig.c_str() );
	if( wnd == 0 )
		return;

	m_window->SetChildAsTop( indexed_id_orig.c_str() );
	m_selectables.push_back( wnd );

	RECT region_offset;
	region_offset.left	= 0;
	region_offset.right	= 0;

	// n = 1 : our original control index ...
	for( int n = 1; n < m_limit; ++n )
	{
		int offset				= n * m_item_offset;
		region_offset.top		= offset;
		region_offset.bottom	= offset;
		m_selectables.push_back( m_window->CopyControl( indexed_id_orig.c_str(), helper::indexed_id( window_id, n ).c_str(), region_offset ) );
	}			
}
void proxy_list::_init_selection_mask( const char* selection_mask_id )
{
	if( !selection_mask_id )
		return;

	m_selection_mask = m_window->GetChild( selection_mask_id );
	if( m_selection_mask )
	{
		m_window->SetChildAsTop( selection_mask_id );
		m_selection_mask_origin_offset = m_selection_mask->GetRect().top - m_window->GetRect().top;
		_select_item_by();
	}
	else
	{
		m_selection_mask_origin_offset = 0;
	}
}
int proxy_list::_normalize_offset( int offset )
{
	int result = 0;
	int offset_limit = m_items.size() - m_limit + 1;	
	if( offset_limit > 0 )
	{
		if( offset < offset_limit )
			result = offset;
		else if( offset >= offset_limit )
			result = offset - ( offset - offset_limit + 1 );
	}
	return result;
}
bool proxy_list::_is_valid_index( int control_index ) const 
{
	return ( control_index < 0 || control_index >= m_limit ) ? false : true;
}
bool proxy_list::_is_visible_index( int control_index ) const
{
	int item_index = _to_item_index( control_index );
	return ( item_index < m_offset || item_index >= _get_visible_end_index() ) ? false : true;
}
int proxy_list::_get_visible_end_index() const
{
	return std::min( m_offset + m_limit, m_items.size() );
}
int proxy_list::_to_item_index( int control_index ) const 
{
	return control_index + m_offset;
}
int proxy_list::_to_control_index( int item_index ) const
{
	return item_index - m_offset;
}
int proxy_list::_mouse_to_index( int x, int y ) const 
{
	selectables_t::const_iterator i = m_selectables.begin(), e = m_selectables.end();
	for( int index = 0; i != e; ++i, ++index )
	{
		KUIWnd* window = *i;
		if( window && window->IsInRect( x, y ) )
			return index;
	}
	return INVALID_VALUE;
}
int proxy_list::_change_current_index( int new_item_index )
{
	if( m_current_index != new_item_index )
	{
		int old_item_index = m_current_index;
		m_current_index = new_item_index;
		m_window->PumpUpMessage( m_id, KUI_MESSAGE::KLIST_ITEM_CHANGE, static_cast< DWORD >( new_item_index ), static_cast< DWORD >( old_item_index ) );
	}
	m_window->PumpUpMessage( m_id, KUI_MESSAGE::KLIST_ITEM_SELECT, static_cast< DWORD >( m_current_index ), 0 );
	return m_current_index;
}
int proxy_list::_get_page_from( int item_index ) const
{
	if( m_items.empty() )
		return INVALID_VALUE;
	return item_index / m_limit;
}
bool proxy_list::_is_valid_page( int page ) const
{	
	if( page == INVALID_VALUE )
		return false;
	return ( page < page_begin() || page >= page_end() ) ? false : true;
}
void proxy_list::_set_offset_by( int page )
{
	if( !_is_valid_page( page ) )
		return;
	m_offset = page * m_limit;
}
int proxy_list::_select_item_by( int control_index )
{
	_locate_selection_mask_at( control_index );

	if( control_index == INVALID_VALUE || !_is_valid_index( control_index ) || !_is_visible_index( control_index ) )
	{
		return _change_current_index( INVALID_VALUE );
	}

	return _change_current_index( _to_item_index( control_index ) );
}
void proxy_list::_locate_selection_mask_at( int control_index )
{
	if( !m_selection_mask )
		return;
	if( control_index == INVALID_VALUE || !_is_valid_index( control_index ) || !_is_visible_index( control_index ) )
	{
		m_selection_mask->SetShow( false );
		return;
	}
	m_selection_mask->SetShow( true );
	int x = m_selection_mask->GetRect().left;
	int y = m_window->GetRect().top + m_selection_mask_origin_offset + control_index * m_item_offset;
	m_selection_mask->MovePos( x, y );
}
void proxy_list::_update_scroll_range()
{
	if( m_scroll == 0 )
		return;

	int range = m_items.size() - m_limit + 1;
	if( range >= 0 && range < m_items.size() )
		m_scroll->SetMaxRange( range );
	else
		m_scroll->SetMaxRange( 0 );
}

void tickable::set_ticker( ticker* _ticker )
{
	m_ticker = _ticker;
}

bool ticker::append_tickable( tickable* _tickable )
{
	if( _tickable )
	{
		ticker* tickable_ticker = _tickable->get_ticker();
		if( tickable_ticker != this )
		{
			if( tickable_ticker )
			{
				tickable_ticker->remove_tickable( _tickable );
			}
			_tickable->set_ticker( this );
			if( is_on_tick() )
				_tickable->on_enter();
			if( m_lock )
				m_candidates.push( _tickable );
			else
				m_tickables.push_back( _tickable );
			return true;
		}
	}
	return false;
}

bool ticker::remove_tickable( tickable* _tickable )
{
	if( _tickable )
	{
		ticker* tickable_ticker = _tickable->get_ticker();
		if( tickable_ticker == this )
		{
			if( is_on_tick() )
				_tickable->on_leave();
			_tickable->set_ticker( 0 );
			if( m_lock )
				m_garbages.push( _tickable );
			else
				remove_seq( m_tickables, _tickable );
			return true;
		}
	}
	return false;
}

void ticker::tick( DWORD time )
{
	m_time = time;

	// ticking
	m_lock = true;
	if( !m_tickables.empty() )
		std::for_each( m_tickables.begin(), m_tickables.end(), std::mem_fun( &tickable::on_tick ) );
	m_lock = false;

	// remove garbages
	while( !m_garbages.empty() )
	{
		tickable* _tickable = m_garbages.front();
		m_garbages.pop();
		remove_seq( m_tickables, _tickable );
	}

	// push cadidates
	while( !m_candidates.empty() )
	{
		tickable* _tickable = m_candidates.front();
		m_candidates.pop();
		m_tickables.push_back( _tickable );
	}
}

void ticker::enter()
{
	m_is_on_tick = true;
}

void ticker::leave()
{
	m_is_on_tick = false;
}

void ticker::on_enter()
{
	enter();
	tickable_vector_t::iterator i = m_tickables.begin(), e = m_tickables.end();
	for( ; i != e; ++i )
	{
		tickable* tickable_pointer = *i;
		if( tickable_pointer )
			tickable_pointer->on_enter();
	}
}

void ticker::on_leave()
{
	leave();
	tickable_vector_t::iterator i = m_tickables.begin(), e = m_tickables.end();
	for( ; i != e; ++i )
	{
		tickable* tickable_pointer = *i;
		if( tickable_pointer )
			tickable_pointer->on_leave();
	}
}

void fixed_rate_ticker::on_tick()
{
	DWORD time_diff = m_ticker->time() - m_time;
	if( time_diff >= m_frequency )
		ticker::on_tick();
}

void fixed_rate_ticker::on_enter()
{
	// initialize timer
	if( m_ticker )
		m_time = m_ticker->time();
	ticker::on_enter();
}

void fixed_rate_ticker::on_leave()
{	
	ticker::on_leave();
	// reset timer
	m_time = 0;
}

void fixed_rate_one_time_ticker::on_tick()
{
	DWORD time_diff = m_ticker->time() - m_time;
	if( time_diff >= m_frequency )
	{
		ticker::on_tick();
		if( m_ticker )
			m_ticker->remove_tickable( this );
	}
}

void conditional_fixed_rate_one_time_ticker::on_tick()
{
	if( m_satisfaction )
	{
		DWORD time_diff = m_ticker->time() - m_time;
		if( time_diff >= m_frequency )
		{
			ticker::on_tick();
			if( m_ticker )
				m_ticker->remove_tickable( this );
		}
	}
}

void conditional_fixed_rate_one_time_ticker::on_enter()
{
	fixed_rate_ticker::on_enter();
	m_satisfaction = false;
}

void conditional_fixed_rate_one_time_ticker::satisfy()
{
	m_satisfaction = true;
	if( m_ticker )
		m_time = m_ticker->time();
}

// ##2.1.2.12
void Page::SetButton( KUIControl* pPrevButton, KUIControl* pNextButton )
{
	m_pPrevButton = pPrevButton;
	m_pNextButton = pNextButton;
}
void Page::Update( int nCurrentPage )
{
	m_nCurrentPage	= nCurrentPage;
}
void Page::Update( int nCurrentPage, int nEndPage ) 
{			
	m_nCurrentPage	= nCurrentPage;
	m_nEndPage		= nEndPage;

	// normalize button
	if( m_pNextButton )
	{
		if( _IsEnd() )
			m_pNextButton->Disable();
		else
			m_pNextButton->Enable();
	}
	if( m_pPrevButton )
	{
		if( _IsBegin() )
			m_pPrevButton->Disable();
		else
			m_pPrevButton->Enable();
	}
}
int Page::Current() const
{
	return _GetNormalizedPage( m_nCurrentPage );
}
int Page::End() const
{
	return m_nEndPage;
}
int Page::Next() const
{
	return _GetNormalizedPage( m_nCurrentPage + 1 );
}
int Page::Prev() const
{					
	return _GetNormalizedPage( m_nCurrentPage - 1 );
}	
int Page::_GetNormalizedPage( int nPage ) const
{
	if( nPage > m_nEndPage )
		nPage = m_nEndPage;
	if( nPage < 1 )
		nPage = 1;
	return nPage;
}	
bool Page::_IsEnd() const
{
	return ( m_nCurrentPage >= m_nEndPage ) ? true : false;
}
bool Page::_IsBegin() const
{
	return ( m_nCurrentPage <= 1 ) ? true : false;
}
/// 2011.01.20 - prodongi
void sMarkState::sInfo::setStateSlot(SStateSlot const* slot)
{
	m_stateCode		= slot->GetStateCode();
	m_endTime		= slot->GetEndTime();
	m_stateLevel	= slot->GetStateLevel();
	m_toggleSkill	= slot->IsToggleSkill();
	m_stateValue	= slot->GetStateValue();
}

void sMarkState::hideAll()
{
	for (int i = 0; i < MAX; ++i)	m_info[i].m_show = false;	
}

void sMarkState::hideAllControl(KUIWnd* wnd)
{
	wnd->SetChildShow("mark_state_04");
	wnd->SetChildShow("mark_state_03");
	wnd->SetChildShow("mark_state_02");
	wnd->SetChildShow("mark_state_01");
}

void sMarkState::updateMarkStateList(KUIWnd* wnd, SUIDisplayInfo* displayInfo, SGameAvatarEx* avatar)
{
	if (!avatar)
		return ;

	m_info[eState::FREEPASS].m_show = false;
	m_info[eState::PC].m_show = false;

	vec_state_slot const& markStateList = avatar->getMarkStateList();
	for (size_t i = 0; i < markStateList.size(); ++i)
	{
		int state_code = markStateList[i]->GetStateCode();

		SStateSlot const* slot = markStateList[i];

		if (9004 == slot->GetStateCode())	
		{
			sMarkState::sInfo* info = m_info + sMarkState::FREEPASS;
			info->m_show = true;
			info->setStateSlot(slot);
		}
		else if (9005 == slot->GetStateCode() || 9006 == slot->GetStateCode())
		{
			sMarkState::sInfo* info = m_info + sMarkState::PC;
			info->m_show = true;
			info->setStateSlot(slot);
		}
	}	

	sortMarkState(wnd, displayInfo);
}

void sMarkState::updateMarkStatusList(KUIWnd* wnd, SUIDisplayInfo* displayInfo, int status)
{
	m_info[eState::PVP].m_show = false;
	m_info[eState::PK].m_show = false;

	if (SMSG_MARK_STATUS_CHANGE::PVP & status)
	{
		m_info[eState::PVP].m_show = true;
	}

	if (SMSG_MARK_STATUS_CHANGE::PK_NORMAL & status)
	{
		m_info[eState::PK].m_show = true;
		m_info[eState::PK].m_status = status;
	}
	else if (SMSG_MARK_STATUS_CHANGE::PK_DEMONIAC & status)
	{
		m_info[eState::PK].m_show = true;
		m_info[eState::PK].m_status = status;
	}

	sortMarkState(wnd, displayInfo);
}

/// 2011.01.19 - prodongi
void sMarkState::sortMarkState(KUIWnd* wnd, SUIDisplayInfo* displayInfo)
{
	hideAllControl(wnd);

	int controlIndex = 0;
	for (int i = 0; i < eState::MAX; ++i)
	{
		sMarkState::sInfo* info = m_info + i;
		if (info->m_show)
		{
			std::string controlName = CStringUtil::StringFormat("mark_state_%02d", controlIndex+1);
			KUIControl* control = dynamicCast<KUIControl*>(wnd->GetChild(controlName.c_str()));
			control->SetShow(true);

			if (i == eState::PVP)
			{
				control->SetBack(wnd->GetSprName(), "common_mark_state_pvp_normal");
				control->SetTooltip(S(7235));
				info->m_strMarkControlName = controlName;
			}
			else if (i == eState::PK)
			{
				if (SMSG_MARK_STATUS_CHANGE::PK_NORMAL & info->m_status)
				{
					control->SetBack(wnd->GetSprName(), "common_mark_state_pk_normal");
					control->SetTooltip(S(7236));
				}
				else if (SMSG_MARK_STATUS_CHANGE::PK_DEMONIAC & info->m_status)
				{
					control->SetBack(wnd->GetSprName(), "common_mark_state_pk_demoniac");
					control->SetTooltip(S(7237));
				}

				info->m_strMarkControlName = controlName;
			}
			else if (i == eState::FREEPASS)
			{
				control->SetBack(wnd->GetSprName(), "common_mark_state_freepass_90");
				control->SetTooltip(displayInfo->GetStateToolTipText(info->m_stateCode, info->m_endTime, info->m_stateLevel, info->m_stateValue, info->m_toggleSkill).c_str() );

				info->m_strMarkControlName = controlName;
			}
			else if (i == eState::PC)
			{
				control->SetBack(wnd->GetSprName(), "common_mark_state_pcbangpremium");
				control->SetTooltip( displayInfo->GetStateToolTipText( info->m_stateCode, info->m_endTime, info->m_stateLevel, info->m_stateValue, info->m_toggleSkill).c_str() );

				info->m_strMarkControlName = controlName;
			}
			else
				__noop;

			++controlIndex;
		}
	}
}


//-----------------------------------------------------------------------------------------------------------------
// 시쿠르트 이용권 ( FREEPASS )의 위에 마우스가 있는가?
//-----------------------------------------------------------------------------------------------------------------
bool sMarkState::IsInRectFreePass( KUIWnd* pDestWnd, const KPoint ptMouse )
{
	if( NULL == pDestWnd )
		return false;
	
	sMarkState::sInfo* pInfo( &m_info[eState::FREEPASS] );
	if( NULL == pInfo )
		return false;
	
	if( false == pInfo->m_show )
		return false;

	KUIControl* pControl( dynamicCast<KUIControl*>( pDestWnd->GetChild( pInfo->m_strMarkControlName.c_str() ) ) );

	if( pControl )
		return pControl->GetRect().IsInRect( ptMouse.x, ptMouse.y );

	return false;
}


//-----------------------------------------------------------------------------------------------------------------
// 시쿠르트 이용권 ( FREEPASS )의 남은 시간 툴팁 갱신
//-----------------------------------------------------------------------------------------------------------------
void sMarkState::UpdateFreePassEndTimeTooltip( KUIWnd* pDestWnd, SUIDisplayInfo* pDisplayInfo )
{
	if( NULL == pDestWnd )
		return ;

	sMarkState::sInfo* pInfo( &m_info[eState::FREEPASS] );

	if( NULL == pInfo )
		return ;
	
	if( false == pInfo->m_show )
		return ;

	KUIControl* pControl( dynamicCast<KUIControl*>( pDestWnd->GetChild( pInfo->m_strMarkControlName.c_str() ) ) );

	if( pControl )
		pControl->SetTooltip( pDisplayInfo->GetStateToolTipText( pInfo->m_stateCode, pInfo->m_endTime, pInfo->m_stateLevel, pInfo->m_stateValue, pInfo->m_toggleSkill).c_str() );
}


sOpacityMouseChecker::~sOpacityMouseChecker()
{
	m_childList.clear();
}

void sOpacityMouseChecker::open()
{
	setAlpha(0.0f);
	changeAlpha();
}

void sOpacityMouseChecker::update(DWORD dwTime, int x, int y, SUIWnd* wnd)
{
	if (!wnd)
		return ;

	float t = (float)dwTime/1000.0f;
	float s = t * m_alphaV;
	if (wnd->IsInRect(x, y))
	{
		setAlpha(m_alpha + s);
	}
	else
	{
		setAlpha(m_alpha - s);
	}

	changeAlpha();
}

void sOpacityMouseChecker::setAlpha(float alpha)
{
	if (fabs(alpha-m_alpha) < FLT_EPSILON)
	{
		return ;
	}
	if (1.0f < alpha)		alpha = 1.0f;
	else if (0.0f > alpha)	alpha = 0.0f;
	m_alpha = alpha;
}

void sOpacityMouseChecker::addChild(SUIWnd* parent, char const* id)
{
	KUIWnd* wnd = parent->GetChild(id);
	if (id && wnd)
		m_childList.push_back(wnd);
}

void sOpacityMouseChecker::setShow(bool show)
{
	std::vector<KUIWnd*>::iterator it = m_childList.begin();
	for (; it != m_childList.end(); ++it)
		(*it)->SetShow(show);
}

void sOpacityMouseChecker::changeAlpha()
{
	std::vector<KUIWnd*>::iterator it = m_childList.begin();
	for (; it != m_childList.end(); ++it)
		(*it)->ChangeAlpha(m_alpha);
}



// 2010.05.11 - prodongi
void getEnhanceIconName(char* enhanceIconName, SCreatureInfo const* info, int enhance)
{
	// 2010.08.31 - prodongi
	getEnhanceIconName(enhanceIconName, info->GetID(), enhance);
}

// 2010.08.31 - prodongi
void getEnhanceIconName(char* enhanceIconName, ENC_INT creatureId, int enhance)
{
	char const* iconName = GetCreatureDB().GetIconName(creatureId);
	if (0 == enhance)
	{
		strcpy(enhanceIconName, (iconName) ? iconName : "");
		return ;
	}

	sprintf(enhanceIconName, "%s_ultimate01", iconName);

	//gmpbigsun( 20130411 ) : 파일이 존재하지 않는다면 강화전이름으로
	SPRITE_SET * pSprSet = KSpriteManager::GetManager()->GetSpriteSet( enhanceIconName );
	if( NULL == pSprSet )
		strcpy( enhanceIconName, iconName );
}

// 2010.05.13 - prodongi
std::string getItemName(int itemId)
{
	const ItemBaseEx_info * pItemBase = GetItemDB().GetItemData( itemId );
	if (!pItemBase) return "";
	return GetStringDB().GetString( pItemBase->nNameId );
}

// 2010.06.09 - prodongi
void getIconNameAtDurability(SInventorySlot const* slot, std::string& iconName)
{
	if (!slot) return ;

	// 2010.07.06 - prodongi
	/*
	iconName = GetItemDB().GetIconName(slot->GetItemCode());

	if (ItemBase::TYPE_CARD == GetItemDB().GetUseType(slot->GetItemCode()) &&
		ItemBase::GROUP_SUMMONCARD == GetItemDB().GetGroup(slot->GetItemCode()))
	{
		// 강화된 카드 일경우에 내구도가 0이면 사용할수 없는 카드로 변경해준다
		if (0 != slot->GetEnhance())
		{
			if (0 == slot->GetEtherealDurability())
				iconName += "_uesless";
		}
	}
	*/
//	getIconNameAtDurability(slot->GetItemCode(), slot->GetEnhance(), slot->GetEtherealDurability(), iconName);
	getIconNameAtDurability(slot, 0, iconName);
}

// 2010.07.06 - prodongi
void getIconNameAtDurability(ItemBase::ItemCode itemCode, int enhance, int etherealDurability, std::string& iconName, int nFlag, int nSummonID )
{
	if( IsInstanceUnstackable( nFlag ) )
	{
		// 봉인된 크리쳐카드
		const _SUMMON_INFO_FILE* pSummonInfo = GetCreatureDB().GetCreatureData( nSummonID );
		if( pSummonInfo )
		{
			iconName = pSummonInfo->face_file_name;
		}
	}
	else
	{
		iconName = GetItemDB().GetIconName(itemCode);
	}

	// 2010.07.14 - prodongi
	/*
	if (ItemBase::TYPE_CARD == GetItemDB().GetUseType(itemCode) &&
		ItemBase::GROUP_SUMMONCARD == GetItemDB().GetGroup(itemCode))
	{
		// 강화된 카드 일경우에 내구도가 0이면 사용할수 없는 카드로 변경해준다
		if (0 != enhance)
		{
			if (0 == etherealDurability)
				iconName += "_uesless";
		}
	}
	*/
	if (isExhaustedSummonCard(itemCode, enhance, etherealDurability))
		iconName += "_uesless";
}

void getIconNameAtDurability(ItemBase::ItemCode itemCode, int enhance, int etherealDurability, std::string& iconName, XFlag<int> tFlag, int nSummonID )
{
	if( IsInstanceUnstackable( tFlag ) )
	{
		// 봉인된 크리쳐카드
		const _SUMMON_INFO_FILE* pSummonInfo = GetCreatureDB().GetCreatureData( nSummonID );
		if( pSummonInfo )
		{
			iconName = pSummonInfo->face_file_name;
		}
	}
	else
	{
		iconName = GetItemDB().GetIconName(itemCode);
	}

	// 2010.07.14 - prodongi
	/*
	if (ItemBase::TYPE_CARD == GetItemDB().GetUseType(itemCode) &&
		ItemBase::GROUP_SUMMONCARD == GetItemDB().GetGroup(itemCode))
	{
		// 강화된 카드 일경우에 내구도가 0이면 사용할수 없는 카드로 변경해준다
		if (0 != enhance)
		{
			if (0 == etherealDurability)
				iconName += "_uesless";
		}
	}
	*/
	if (isExhaustedSummonCard(itemCode, enhance, etherealDurability))
		iconName += "_uesless";
}

void getIconNameAtDurability( SInventorySlot const* pSlot, int nTmep, std::string& iconName )
{
	int nItemCode = pSlot->GetItemCode();
	int nEnhance = pSlot->GetEnhance();
	int nEtherealDurability = pSlot->GetEtherealDurability();

	if( pSlot->GetXFlag().IsOn( ItemInstance::ITEM_FLAG_SUMMON ) )		//봉인된 크리쳐 카드
	{
		//gmpbigsun( 20130326 ) : 봉카의 경우 face_file_name이 슬롯icon
		const _SUMMON_INFO_FILE* pSummonInfo = GetCreatureDB().GetCreatureData( pSlot->GetSummonID() );
		if( pSummonInfo )
		{
			// 1. 봉인된 크리쳐의 color_id를 얻는다.
			// 2. "icon_card_creature_" + "color_id" 를 합성한다.
			iconName = pSummonInfo->face_file_name;
		}
	}
	else
	{
		iconName = GetItemDB().GetIconName(nItemCode);
	}

	if (isExhaustedSummonCard(nItemCode, nEnhance, nEtherealDurability))
		iconName += "_uesless";
}

bool setIconNameEquipment_ENHANCE( KUIControlMultiIcon* icon, ENC_INT itemCode, const int nEnhance )
{
	const ItemBaseEx_info* pItem = GetItemDB().GetItemData( itemCode );
	if (pItem)
	{
		std::string strTemp;

		if( pItem->nType == ItemBase::TYPE_CARD && 
			pItem->nGroup == ItemBase::GROUP_SUMMONCARD )
			return false;

		switch (nEnhance)
		{
		case 1:		strTemp = "game_mark_enhence01";	break;
		case 2:		strTemp = "game_mark_enhence02";	break;
		case 3:		strTemp = "game_mark_enhence03";	break;
		case 4:		strTemp = "game_mark_enhence04";	break;
		case 5:		strTemp = "game_mark_enhence05";	break;
		case 6:		strTemp = "game_mark_enhence06";	break;
		case 7:		strTemp = "game_mark_enhence07";	break;
		case 8:		strTemp = "game_mark_enhence08";	break;
		case 9:		strTemp = "game_mark_enhence09";	break;
		case 10:	strTemp = "game_mark_enhence10";	break;
		case 11:	strTemp = "game_mark_enhence11";	break;
		case 12:	strTemp = "game_mark_enhence12";	break;
		case 13:	strTemp = "game_mark_enhence13";	break;
		case 14:	strTemp = "game_mark_enhence14";	break;
		case 15:	strTemp = "game_mark_enhence15";	break;
		case 16:	strTemp = "game_mark_enhence16";	break;
		case 17:	strTemp = "game_mark_enhence17";	break;
		case 18:	strTemp = "game_mark_enhence18";	break;
		case 19:	strTemp = "game_mark_enhence19";	break;
		case 20:	strTemp = "game_mark_enhence20";	break;
		case 21:	strTemp = "game_mark_enhence21";	break;
		case 22:	strTemp = "game_mark_enhence22";	break;
		case 23:	strTemp = "game_mark_enhence23";	break;
		case 24:	strTemp = "game_mark_enhence24";	break;
		case 25:	strTemp = "game_mark_enhence25";	break;
		default:	return false;
		}

		icon->SetIcon( 7, c_szDEF_SPR_NAME, strTemp.c_str() );
	}

	return false;
}

bool getIconNameSummonCard_BORDER( std::string& strTemp, int nSummonID, int nEnhance, int nDurability )
{
	if( false == strTemp.empty() )
		strTemp.clear();

	//테두리가 내구도 표현까지 추가댐
	if( nEnhance != 0 && nDurability == 0 )
	{
		strTemp = "game_panel_creaturecard_useless";
		return true;
	}

	BYTE byRank( SummonBase::RATE_BASIC );

	//크리쳐 카드가 벨트에 장착 되어 있으면, E 표시
	const _SUMMON_INFO_FILE* pSummonInfo = GetCreatureDB().GetCreatureData( nSummonID );
	if( pSummonInfo )
	{	
		//1.희귀 등급에 따라 테두리 결정
		byRank = GetCreatureDB().GetRate( nSummonID );  
		switch( byRank )
		{
			case SummonBase::RATE_BASIC:			strTemp = "game_panel_creaturecard_rank_0";		return true;
			case SummonBase::RATE_NORMAL_BASIC:		strTemp = "game_panel_creaturecard_rank_1";		return true;
			case SummonBase::RATE_SPECIAL_BASIC:	strTemp = "game_panel_creaturecard_rank_2";		return true;
			case SummonBase::RATE_NORMAL_RARE:		strTemp = "game_panel_creaturecard_rank_3";		return true;
			case SummonBase::RATE_SPECIAL_RARE:		strTemp = "game_panel_creaturecard_rank_4";		return true;
			case SummonBase::RATE_UNIQUE:			strTemp = "game_panel_creaturecard_rank_5";		return true;

			// AziaMafia Pet Rarity
			case SummonBase::RATE_VERACRUZ:			strTemp = "game_panel_creaturecard_rank_6";		return true;
			case SummonBase::RATE_PHANTOM:			strTemp = "game_panel_creaturecard_rank_7";		return true;
			case SummonBase::RATE_AURA:				strTemp = "game_panel_creaturecard_rank_8";		return true;
			case SummonBase::RATE_SHINNY:			strTemp = "game_panel_creaturecard_rank_9";		return true;
			case SummonBase::RATE_GALAXY:			strTemp = "game_panel_creaturecard_rank_10";		return true;

			default:
				{
					SDEBUGLOG( "[Summon DB] Unknown creature grade. - [%u]", byRank );
					assert( NULL );
				}
				break;
		}
	}

	return false;
}

bool getIconNameSummonCard_FORMATION( std::string& strTemp, AR_HANDLE nHandle )
{
	if( false == strTemp.empty() )	
		strTemp.clear();

	if( g_pCurrentGameSystem->GetCreatureSlotMgr().IsExistCreatureCard( nHandle ) )
	{
		strTemp = "common_mark_titanium_creature"; 
		return true;
	}

	return false;
}

bool getIconNameSummonCard_BELT( std::string& strTemp, AR_HANDLE nHandle )
{
	if (false == strTemp.empty())
		strTemp.clear();

	if (g_pCurrentGameSystem->GetInventoryMgr().IsBeltSlotCard( nHandle ))
	{
		strTemp = "common_mark_titanium_belt";
		return true;
	}

	return false;
}

bool getIconNameSummonCard_STAGE( std::string& strTemp, const int nSummonID, const int nEnhance )
{
	if( false == strTemp.empty() )
		strTemp.clear();

	_SUMMON_INFO_FILE* pCreature = GetCreatureDB().GetCreatureData( nSummonID );
	if( pCreature )
	{
		switch( nEnhance )
		{
		case 1:	strTemp = "game_mark_creature_evolution_01";		return true;
		case 2:	strTemp = "game_mark_creature_evolution_02";		return true;
		case 3:	strTemp = "game_mark_creature_evolution_03";		return true;
		case 4:	strTemp = "game_mark_creature_evolution_04";		return true;
		case 5:	strTemp = "game_mark_creature_evolution_05";		return true;
		default:	return false;
		}
	}

	return false;
}

// 2010.07.14 - prodongi
bool isExhaustedSummonCard(ItemBase::ItemCode itemCode, int enhance, int etherealDurability)
{
	if (ItemBase::TYPE_CARD == GetItemDB().GetUseType(itemCode) &&
		ItemBase::GROUP_SUMMONCARD == GetItemDB().GetGroup(itemCode))
	{
		// 강화된 카드 일경우에 내구도가 0이면 사용할수 없는 카드로 변경해준다
		if (0 != enhance)
		{
			if (0 == etherealDurability)
				return true;
		}
	}
	return false;
}

EquipItemAddtionalIconSetter::EquipItemAddtionalIconSetter( KUIControlMultiIcon* pIcon, ItemBase::ItemCode nItemCode, int nEnhance, int nEtherealDurability, XFlag<int> xFlag )
{
	SetIcon( pIcon, nItemCode, nEnhance, nEtherealDurability, xFlag );
}

EquipItemAddtionalIconSetter::EquipItemAddtionalIconSetter( KUIControlMultiIcon* pIcon, SInventorySlot* pSlot )
{
	SetIcon( pIcon, pSlot->GetItemCode(), pSlot->GetEnhance(), pSlot->GetItem()->ethereal_durability, pSlot->GetXFlag() );
}

void	EquipItemAddtionalIconSetter::SetIcon( KUIControlMultiIcon* pIcon, ItemBase::ItemCode nItemCode, int nEnhance, int nEtherealDurability, XFlag<int> xFlag )
{
	SGameAvatarEx* pOwner = g_pCurrentGameSystem->GetLocalPlayer();

	::setIconNameEquipment_ENHANCE( pIcon, nItemCode, nEnhance );
	if (pOwner) ::setCantWearIcon( pIcon, nItemCode, pOwner->GetJobID(), pOwner->GetRace(), pOwner->GetLevel(), xFlag, g_pCurrentGameSystem->GetSkillSlotMgr() );
	::setDurabilityIcon( pIcon, nItemCode, nEtherealDurability );
	::setEnhanceFailedIcon( pIcon, xFlag );
}

bool isWearableDecoItem( const ItemBaseEx_info* pItem )
{
	// 꾸미기 무기/방패일 경우 장착 위치에 대응하는 장비 위치에 현재 장착하고있는 아이템과 타입이 맞는지 체크
	if( pItem->WearType == ItemBase::WEAR_DECO_WEAPON || pItem->WearType == ItemBase::WEAR_DECO_SHIELD )
	{
		SGameAvatarEx* pOwner = g_pCurrentGameSystem->GetLocalPlayer();
		ItemBase::ItemWearType nRelativePos = ( pItem->WearType == ItemBase::WEAR_DECO_WEAPON ) ? ItemBase::WEAR_WEAPON : ItemBase::WEAR_LEFTHAND;
		SInventorySlot* pWearItem = g_pCurrentGameSystem->GetInventoryMgr().GetItemInfo( nRelativePos );
		if( pWearItem == NULL )
		{
			return false;
		}

		int nWearClass = GetItemDB().GetItemData( pWearItem->GetItemCode() )->nClass;
		switch( nWearClass )
		{
		case ItemBase::CLASS_ONEHAND_SWORD:	if( pItem->nClass != ItemBase::CLASS_DECO_ONEHAND_SWORD	) return false; break;
		case ItemBase::CLASS_TWOHAND_SWORD:	if( pItem->nClass != ItemBase::CLASS_DECO_TWOHAND_SWORD	) return false; break;
		case ItemBase::CLASS_DAGGER:		if( pItem->nClass != ItemBase::CLASS_DECO_DAGGER		) return false; break;
		case ItemBase::CLASS_TWOHAND_SPEAR:	if( pItem->nClass != ItemBase::CLASS_DECO_TWOHAND_SPEAR	) return false; break;
		case ItemBase::CLASS_TWOHAND_AXE:	if( pItem->nClass != ItemBase::CLASS_DECO_TWOHAND_AXE	) return false; break;
		case ItemBase::CLASS_ONEHAND_MACE:	if( pItem->nClass != ItemBase::CLASS_DECO_ONEHAND_MACE	) return false; break;
		case ItemBase::CLASS_TWOHAND_MACE:	if( pItem->nClass != ItemBase::CLASS_DECO_TWOHAND_MACE	) return false; break;
		case ItemBase::CLASS_HEAVY_BOW:		if( pItem->nClass != ItemBase::CLASS_DECO_HEAVY_BOW		) return false; break;
		case ItemBase::CLASS_LIGHT_BOW:		if( pItem->nClass != ItemBase::CLASS_DECO_LIGHT_BOW		) return false; break;
		case ItemBase::CLASS_CROSSBOW:		if( pItem->nClass != ItemBase::CLASS_DECO_CROSSBOW		) return false; break;
		case ItemBase::CLASS_ONEHAND_STAFF:	if( pItem->nClass != ItemBase::CLASS_DECO_ONEHAND_STAFF	) return false; break;
		case ItemBase::CLASS_TWOHAND_STAFF:	if( pItem->nClass != ItemBase::CLASS_DECO_TWOHAND_STAFF	) return false; break;
		case ItemBase::CLASS_ONEHAND_AXE:	if( pItem->nClass != ItemBase::CLASS_DECO_ONEHAND_AXE	) return false; break;
		case ItemBase::CLASS_SHIELD:		if( pItem->nClass != ItemBase::CLASS_DECO_SHIELD		) return false; break;
		default:
			return false;
		}
	}

	return true;
}

bool isWearableSkillCardItem( const ItemBaseEx_info* pItem, SSkillSlotMgr& SkillSlotMgr )
{
	if( ItemBase::GROUP_SKILLCARD == pItem->nGroup )
	{
		if( SkillSlotMgr.GetSkillSlot( pItem->nSkillID ) == NULL )
		{
			return false;
		}
	}

	return true;
}

void setCantWearIcon(KUIControlMultiIcon* icon, ENC_INT itemCode, int nJobID, int nRace, int nLevel, XFlag<int> xFlag, SSkillSlotMgr& SkillSlotMgr )
{
	const ItemBaseEx_info* pItem = GetItemDB().GetItemData( itemCode );

	//////////////////////////////////////////////////////////////////////////
	// 장비품 아님
	if( pItem->WearType == ItemBase::WEAR_CANTWEAR && pItem->nCode != 804000 )
	{
		return;
	}

	// 크리처 장비(크리처 전용장비와 카드화된 아이템) 무시
	if( pItem->WearType == ItemBase::WEAR_SUMMON_ONLY || xFlag.IsOn( ItemInstance::ITEM_FLAG_CARD ) )
	{
		return;
	}
	//////////////////////////////////////////////////////////////////////////

	if( isWearableSkillCardItem( pItem, SkillSlotMgr ) == false ||
		isWearableDecoItem( pItem ) == false ||
		SItemDB::IsWearable( pItem, nJobID, nRace, nLevel ) == false )	// 착용불가
	{
		icon->SetIcon( 3, c_szDEF_SPR_NAME, "static_cant_wear_item" );
	}
}

// 2010.07.20 - prodongi
void setDurabilityIcon(KUIControlMultiIcon* icon, ENC_INT itemCode, int etherealDurability)
{
	/// 2011.08.03 스킬카드는 내구도를 갖지 않고, 3 layer를 equip으로 쓰고 있다. - prodongi
	if( GetItemDB().GetUseType(itemCode) == ItemBase::TYPE_CARD )
	{
		if (GetItemDB().GetGroup(itemCode) == ItemBase::GROUP_SKILLCARD)
			return; 
	}

	const ItemBaseEx_info * pItemBase = GetItemDB().GetItemData(itemCode);
	if(pItemBase)
	{
		if(pItemBase->nEthereal_durability > 0)
		{
			// pItemBase->nGrade가 0이면 에테리얼 스톤으로 간주해서 깨진 아이템으로 표시해주지 않는다
			/// 2010.10.05 보스카드도 nGrade가 0이기 때문에 보스 카드 체크를 추가 해줘야 된다- prodongi
			if (etherealDurability == 0)
			{
				if (pItemBase->nGrade > 0 || 
					GetItemDB().GetGroup(itemCode) == ItemBase::GROUP_BOSSCARD)
				{
					icon->SetIcon( 3, c_szDEF_SPR_NAME, "static_Durability_item_destroy" );
				}
			}
		}
	}
}

void setEnhanceFailedIcon(KUIControlMultiIcon* icon, XFlag<int> xFlag)
{
	if( xFlag.IsOn( ItemInstance::ITEM_FLAG_FAILED ) ) // 강화 실패 작
	{
		icon->SetIcon( 3, c_szDEF_SPR_NAME, "static_enhance_failed_item" );
	}
}

// 2010.06.11 - prodongi
bool checkUseEqualHairTypeItem(ItemBase const* item)
{
	if (123 == item->nOptType[0])
	{
		int itemHairId = item->dOptVar1[0];
		SGameAvatarEx* pLocalPlayer = g_pCurrentGameSystem->GetLocalPlayer();
		int curHairId = pLocalPlayer->GetHair();
		if (101 == curHairId || 102 == curHairId)
		{
			if (101 == itemHairId || 102 == itemHairId)
			{
				_oprint("don't use equal default hair item\n");
				return true;
			}
		}
		else if (103 == curHairId || 104 == curHairId)
		{
			if (103 == itemHairId || 104 == itemHairId)
			{
				_oprint("don't use equal default hair item\n");
				return true;
			}
		}
		else if (105 == curHairId || 106 == curHairId)
		{
			if (105 == itemHairId || 106 == itemHairId)
			{
				_oprint("don't use equal default hair item\n");
				return true;
			}
		}
	}
	return false;
}

// 2010.07.27 - prodongi
bool checkEnableUseItem(ItemBase const* item, int itemCode, SUIDisplayInfo* displayInfo, int& msgId)
{
	msgId = SYS_MSG_USE_ITEM_FAIL;	/// 기본

	// 소환의 깃털
	if (112 == item->nOptType[0])
	{
		// 2011.10.18 : servantes : SPartyMgr 관리 클래스 CPartyListMgr
		CPartyListMgr* partMgr = dynamicCast<CPartyListMgr*>(GameUIMgrInstance.GetUIMgr( SGameUIInstance::PARTY_MGR ));
		if (0 == partMgr->GetMemberCount())
			return false;

		int optVar_1 = (int)item->dOptVar1[0];
		if (8 == optVar_1)
		{
			if (1 >= partMgr->GetLoginMemberCount())
			{
				return false;
			}
		}
		else if (1 == optVar_1)
		{
			// 2010.08.06 - prodongi
			AR_HANDLE selectedHandle;
			SPlayerInfoMgr* playerInfoMgr = displayInfo->GetPlayerInfoManager();
			if (playerInfoMgr->GetTarget())
				selectedHandle = playerInfoMgr->GetTarget();
			else
				selectedHandle = displayInfo->GetPartyHandle();

			if (!selectedHandle)
				return false;
			SGameAvatarEx* localPlayer = g_pCurrentGameSystem->GetLocalPlayer();
			if (selectedHandle == localPlayer->GetArID())
				return false;
			if (!partMgr->IsExistLoginMember(selectedHandle))
			{
				return false;
			}
		}
	}

	/// 2011.07.20 인스턴스 던전에서 귀환의 깃털 사용 - prodongi
	if (910006 == itemCode)
	{
		if (PLAYER_IN_INSTANCE_DUNGEON_AUTO == displayInfo->GetPlayerInfoManager()->GetCurrentLocation())
		{
			msgId = SYS_MSG_INVALID_ACT_IN_DUN;
			return false;
		}
	}

	return true;
}

// 2010.08.20 - prodongi
void setStaticWndGage(KUIWnd* wnd, int maxSize, float percent)
{
	KRect rt = wnd->GetRect();
	rt.right = rt.left + (int)((float)maxSize * percent);
	wnd->Resize( rt );
}

// 2010.09.17 - prodongi
float getEquipCardDurPercent(SInventorySlot const* slot)
{
	int slotDurability = slot->GetEtherealDurability();
	int maxDurability = slot->getMaxEtherealDurability();
	if (0 < maxDurability)
		return (float)slotDurability/(float)maxDurability;
	return 0.0f;
}

// 2010.09.17 - prodongi
/*
	Level 0 : 0.0 <= p < 0.33;
	Level 1 : 0.33 <= p < 0.66;
	Level 2 : 0.66 <= p <= 1.0;
*/
int getEquipCardDurPercentLevel(SInventorySlot const* slot)
{
	float p = getEquipCardDurPercent(slot);

	if (0.0f <= p && 0.33f > p)			return 0;
	else if (0.33f <= p && 0.66f > p)	return 1;
	else if (0.66f <= p && 1.0f >= p )	return 2;

	return 0;
}

// 2010.09.17 - prodongi
float getCreatureCardDurPercent(SInventorySlot const* slot, int enhance)
{
	return getCreatureCardDurPercent(slot->GetEtherealDurability(), enhance);
}

/// 2011.03.29 - prodongi
float getCreatureCardDurPercent(int etherealDurability, int enhance)
{
	int slotDurability = etherealDurability;
	int maxDurability = GetCreatureEnhanceDB().getCardDurability(enhance);

	if (0 < maxDurability)
		return (float)slotDurability/(float)maxDurability;
	return 0.0f;
}

// 2010.09.17 - prodongi
/*
	Level 0 : 0.0 <= p < 0.33;
	Level 1 : 0.33 <= p < 0.66;
	Level 2 : 0.66 <= p <= 1.0;
*/
int getCreatureCardDurPercentLevel(SInventorySlot const* slot, int enhance)
{
	return getCreatureCardDurPercentLevel(slot->GetEtherealDurability(), enhance);
}

/// 2011.03.29 - prodongi
int getCreatureCardDurPercentLevel(int etherealDurability, int enhance)
{
	float p = getCreatureCardDurPercent(etherealDurability, enhance);

	if (0.0f <= p && 0.33f > p)			return 0;
	else if (0.33f <= p && 0.66f > p)	return 1;
	else if (0.66f <= p && 1.0f >= p )	return 2;

	return 0;
}

/// 2010.12.17 - prodongi
void setChildControlEnable(KUIWnd* parent, char const* childId, bool enable)
{
	KUIControl* control = dynamicCast<KUIControl*>(parent->GetChild(childId));
	if (!control)
		return ;

	if (enable)	control->Enable();
	else		control->Disable();
}

std::string expToString(__int64 exp)
{
	std::string str = "";
	
	if (exp > c_nEXPMLimit)
	{
		exp /= 1000000;
		str += CStringUtil::StringFormat( "%I64d<#4ad55d>M<#ffffff>", exp);
	}
	else if(exp > c_nEXPKLimit )
	{
		exp /= 1000;
		str += CStringUtil::StringFormat( "%I64d<#fafa01>K<#ffffff>", exp);
	}
	else
	{
		str += CStringUtil::StringFormat( "%I64d", exp);
	}

	return str;
}

/// 2011.02.09 - prodongi
void jpToString(__int64 jp, std::string& str)
{
	str = "<font:font_01><size:9><shd><right>";

	if (jp > c_nJPMLimit)
	{
		jp /= 1000000;
		str += CStringUtil::StringFormat( "%I64dM", jp);
	}
	else if( jp > c_nJPKLimit )
	{
		jp /= 1000;
		str += CStringUtil::StringFormat( "%I64dK", jp);
	}
	else
	{
		str += CStringUtil::StringFormat( "%I64d", jp);
	}
}

/// 2011.03.07 - prodongi
void convertMagicTypeToString(int type, std::string& str)
{
	int strId = 0;
	switch(type)
	{
	case StateInfo::ET_FIRE:	//화속성
		strId =  7083;
		break;
	case StateInfo::ET_WATER:	//수속성
		strId = 7084;
		break;
	case StateInfo::ET_WIND:	//풍속성
		strId = 7085;
		break;
	case StateInfo::ET_EARTH:	//토속성
		strId = 7086;
		break;
	case StateInfo::ET_LIGHT:	//명속성
		strId = 7087;
		break;
	case StateInfo::ET_DARK:	//암속성
		strId = 7088;
		break;
	case StateInfo::ET_ALL:
		strId = 7089;
		break;
	default:
		strId = 7082;
		break;
	}
	str = S(strId);
}

/// 2011.03.18 - prodongi
void getNpcIconAniName(std::string& str, unsigned int type, unsigned int status)
{
	if( status == 0 )
	{
		if (0 == type)		str = "common_mark_minimap_npc";
		else if (1 == type)	str = "common_mark_minimap_npc_merchant";
		else if (2 == type) str = "common_mark_minimap_npc_telepoter";
		/// 2011.06.14 - prodongi
		else if (3 == type) str = "common_mark_minimap_npc_guide";
		else if (4 == type) str = "common_mark_minimap_npc_laktrader";
		/// 2011.08.03 - prodongi
		else if (5 == type) str = "common_mark_minimap_npc_warehouse";
		else if (6 == type) str = "common_mark_minimap_npc_auction";
		return ;
	}

	if( status & TS_ENTER::NPCInfo::FLAG_HAS_STARTABLE_QUEST )
	{
		str = "common_mark_minimap_npc_quest01";
	}

	if( status & TS_ENTER::NPCInfo::FLAG_HAS_IN_PROGRESS_QUEST )
	{
		str = "common_mark_minimap_npc_quest02";
	}

	if( status & TS_ENTER::NPCInfo::FLAG_HAS_FINISHABLE_QUEST )
	{
		str = "common_mark_minimap_npc_quest03";
	}
}

/// 2011.07.21 - prodongi
void getDungeonGateIconAniName(std::string& str, int type)
{
	/// 인스턴스 던전
	if (1 == type)
	{
		str = "common_mark_minimap_npc_dungeon";
	}
	/// 일반 던전
	else if (2 == type)
	{
		str = "common_mark_minimap_npc_dungeon";
	}
}

bool setHPGaugeTexture(int percent, KUIControlGauge* pGauge, int nPixelHeight)
{
	if(pGauge == NULL)
		return false;

	char const* aniName = NULL;
	if( nPixelHeight == 4 )
	{
		if ( percent > 50 )		aniName = "common_gauge_titanium_player_hp100_himini";
		else if( percent > 20 )	aniName = "common_gauge_titanium_player_hp50_himini";
		else						aniName = "common_gauge_titanium_player_hp20_himini";
	}
	else if( nPixelHeight == 5 )
	{
		if ( percent > 50 )		aniName = "common_gauge_titanium_player_hp100_mini";
		else if( percent > 20 )	aniName = "common_gauge_titanium_player_hp50_mini";
		else						aniName = "common_gauge_titanium_player_hp20_mini";
	}
	else if( nPixelHeight == 11 )
	{
		if ( percent > 50 )		aniName = "common_gauge_titanium_player_hp100_middle";
		else if( percent > 20 )	aniName = "common_gauge_titanium_player_hp50_middle";
		else						aniName = "common_gauge_titanium_player_hp20_middle";
	}

	if (aniName)
	{
		if( stricmp( pGauge->GetAniName(), aniName ) != 0 )
			pGauge->SetBack( "ui_frame.spr", aniName );
	}

	return true;
}

/// 2011.04.22 - prodongi
bool isLastBR(char const* str)
{
	if (!str)
		return false;
	int size = strlen(str);
	if (size < strlen("<br>"))
		return false;

	if (str[size-1] != '>')
		return false;

	char temp[10];
	int start, end;
	bool closed = true;
	for (int i = size-1; i > 0; --i)
	{
		if (str[i] == '>')
		{
			closed = false;
			end = i;
		}
		else if (str[i] == '<')
		{
			start = i;
			closed = true;

			int copyLen = min(end - start + 1, 10);
			strncpy(temp, str+start, copyLen);
			temp[copyLen] = 0x00;
			if (0 == strcmp(temp, "<br>"))
				return true;
			if (0 == strcmp(temp, "<BR>"))
				return true;
		}
		else
		{
			if (closed)
				return false;
		}
	}

	return false;
}

/// 2011.04.27 - prodongi
bool isFirstBR(char const* str)
{
	if (!str)
		return false;
	int size = strlen(str);
	if (size < strlen("<br>"))
		return false;

	if (str[0] != '<')
		return false;

	char temp[10];
	int start, end;
	bool closed = true;
	for (int i = 0; i < size; ++i)
	{
		if (str[i] == '<')
		{
			closed = false;
			start = i;
		}
		else if (str[i] == '>')
		{
			end = i;
			closed = true;

			int copyLen = min(end - start + 1, 10);
			strncpy(temp, str+start, copyLen);
			temp[copyLen] = 0x00;
			if (0 == strcmp(temp, "<br>"))
				return true;
			if (0 == strcmp(temp, "<BR>"))
				return true;
		}
		else
		{
			if (closed)
				return false;
		}
	}

	return false;
}

/// 2011.08.03 - prodongi
bool setSkillCardIcon(KUIControlMultiIcon* icon, int itemCode, bool isEquip)
{
	if (!icon)	return false;

	if( GetItemDB().GetUseType(itemCode) != ItemBase::TYPE_CARD )
		return false;
	if( GetItemDB().GetGroup(itemCode) != ItemBase::GROUP_SKILLCARD )
		return false;

	ItemBaseEx_info const* item = GetItemDB().GetItemData(itemCode);
	if (item)
	{
		SkillBaseEx* skill = GetSkillDB().GetSkillData(item->nSkillID);
		if (skill)
		{
			icon->SetIcon(0, c_szDEF_SPR_NAME, skill->icon_file_name);

			int jp = skill->GetNeedJopPoint(1);

			std::string raceIconName;
			int limit = item->nLimit;

			if (0 > jp)
			{
				raceIconName = "icon_card_tpskill";
			}
			else if (ItemBase::LIMIT_DEVA & limit && 
					 ItemBase::LIMIT_ASURA & limit && 
					 ItemBase::LIMIT_GAIA & limit)
			{
				raceIconName = "icon_card_skill";
			}
			else if (ItemBase::LIMIT_DEVA & limit)
			{
				raceIconName = "icon_card_devaskill";
			}
			else if (ItemBase::LIMIT_ASURA & limit)
			{
				raceIconName = "icon_card_asuraskill";
			}
			else if (ItemBase::LIMIT_GAIA & limit)
			{
				raceIconName = "icon_card_gaiaskill";
			}

			icon->SetIcon(2, c_szDEF_SPR_NAME, raceIconName.c_str());
		}
	}

	icon->SetIcon( 3, c_szDEF_SPR_NAME, isEquip ? "common_mark_titanium_equipicon" : NULL);

	return true;
}

bool setSummonCardIcon( KUIControlMultiIcon* pIcon, SInventorySlot const* pSlot )
{
	if( NULL == pIcon || NULL == pSlot )
		return false;

	int nItemCode = pSlot->GetItemCode();
	if( GetItemDB().GetUseType(nItemCode) != ItemBase::TYPE_CARD || GetItemDB().GetGroup(nItemCode) != ItemBase::GROUP_SUMMONCARD )
		return false;

	if( IsInstanceUnstackable( (SInventorySlot*)pSlot ) )
	{
		int nSummonID = pSlot->GetSummonID();
		const _SUMMON_INFO_FILE* pSummonInfo = GetCreatureDB().GetCreatureData( nSummonID );

		if( pSummonInfo )
		{	
			std::string strTemp;

			//0. 본체
			getIconNameAtDurability(pSlot, strTemp);
			pIcon->SetIcon( 0, c_szDEF_SPR_NAME, strTemp.c_str());

			//1. 등급마크
			getIconNameSummonCard_BORDER( strTemp, pSlot->GetSummonID(), pSlot->GetEnhance(), pSlot->GetEtherealDurability() );
			pIcon->SetIcon( 4, c_szDEF_SPR_NAME, strTemp.c_str() );

			//2. 강화마크
			getIconNameSummonCard_FORMATION( strTemp, pSlot->GetHandle() );
			pIcon->SetIcon( 6, c_szDEF_SPR_NAME, strTemp.c_str() );

			//3. 진화마크
			getIconNameSummonCard_STAGE( strTemp, pSlot->GetSummonID(), pSlot->GetEnhance() );
			pIcon->SetIcon( 7, c_szDEF_SPR_NAME, strTemp.c_str() );

			return true;
		}
	}

	return false;
}


bool setSummonCardIcon( KUIControlMultiIcon* pIcon, int nItemCode, int nSummonID, int nEnhance, int nFlag, int nDurability )
{
	if( NULL == pIcon )
		return false;

	if( GetItemDB().GetUseType(nItemCode) != ItemBase::TYPE_CARD || GetItemDB().GetGroup(nItemCode) != ItemBase::GROUP_SUMMONCARD )
		return false;

	if( IsInstanceUnstackable( nFlag ) )
	{
		std::string strTemp;

		const _SUMMON_INFO_FILE* pSummonInfo = GetCreatureDB().GetCreatureData( nSummonID );
		if( pSummonInfo )
		{	
			std::string strTemp;

			//0. 본체
			getIconNameAtDurability(nItemCode, nEnhance, nDurability, strTemp, nFlag, nSummonID );
			pIcon->SetIcon( 0, c_szDEF_SPR_NAME, strTemp.c_str());

			//1. 등급마크
			getIconNameSummonCard_BORDER( strTemp, nSummonID, nEnhance, nDurability );
			pIcon->SetIcon( 4, c_szDEF_SPR_NAME, strTemp.c_str() );

			//2. 강화마크
			getIconNameSummonCard_FORMATION( strTemp, nEnhance );
			pIcon->SetIcon( 6, c_szDEF_SPR_NAME, strTemp.c_str() );

			//3. 진화마크
			getIconNameSummonCard_STAGE( strTemp, nSummonID, nEnhance );
			pIcon->SetIcon( 7, c_szDEF_SPR_NAME, strTemp.c_str() );

			return true;
		}
	}

	return false;
}

bool setSummonCardIcon( KUIControlMultiIcon* pIcon, int nItemCode, int nSummonID, int nEnhance, XFlag<int> tFlag, int nDurability )
{
	if( NULL == pIcon )
		return false;

	if( GetItemDB().GetUseType(nItemCode) != ItemBase::TYPE_CARD || GetItemDB().GetGroup(nItemCode) != ItemBase::GROUP_SUMMONCARD )
		return false;

	if( IsInstanceUnstackable( tFlag ) )
	{
		const _SUMMON_INFO_FILE* pSummonInfo = GetCreatureDB().GetCreatureData( nSummonID );
		if( pSummonInfo )
		{	
			std::string strTemp;

			//0. 본체
			getIconNameAtDurability(nItemCode, nEnhance, nDurability, strTemp, tFlag, nSummonID );
			pIcon->SetIcon( 0, c_szDEF_SPR_NAME, strTemp.c_str());

			//1. 등급마크
			getIconNameSummonCard_BORDER( strTemp, nSummonID, nEnhance, nDurability );
			pIcon->SetIcon( 5, c_szDEF_SPR_NAME, strTemp.c_str() );

			//2. 강화마크
			getIconNameSummonCard_FORMATION( strTemp, nEnhance );
			pIcon->SetIcon( 6, c_szDEF_SPR_NAME, strTemp.c_str() );

			//3. 진화마크
			getIconNameSummonCard_STAGE( strTemp, nSummonID, nEnhance );
			pIcon->SetIcon( 7, c_szDEF_SPR_NAME, strTemp.c_str() );

			return true;
		}
	}

	return false;
}

bool setSummonCardIconForPortrait( KUIControlMultiIcon* pIcon, SInventorySlot const* pSlot )		//초상화 슬롯을 위한
{
	if( NULL == pIcon || NULL == pSlot )
		return false;

	int nItemCode = pSlot->GetItemCode();
	if( GetItemDB().GetUseType(nItemCode) != ItemBase::TYPE_CARD || GetItemDB().GetGroup(nItemCode) != ItemBase::GROUP_SUMMONCARD )
		return false;

	if( IsInstanceUnstackable( (SInventorySlot*)pSlot ) )
	{
		int nSummonID = pSlot->GetSummonID();
		const _SUMMON_INFO_FILE* pSummonInfo = GetCreatureDB().GetCreatureData( nSummonID );

		if( pSummonInfo )
		{	
			std::string strTemp;

			//0. 본체
			getIconNameAtDurability(pSlot, strTemp);
			pIcon->SetIcon( 0, c_szDEF_SPR_NAME, strTemp.c_str());

			//1. 등급마크
			getIconNameSummonCard_BORDER( strTemp, nSummonID, pSlot->GetEnhance(), pSlot->GetEtherealDurability() );
			pIcon->SetIcon( 1, c_szDEF_SPR_NAME, strTemp.c_str() );

			return true;
		}
	}

	return false;
}

void ResetMultiIcon( KUIControlMultiIcon* pIcon, const int nBegin, const int nEnd )
{
	if( NULL == pIcon )
		return;

	for( int i = nBegin; i < nEnd; ++i )
	{
		pIcon->SetIcon( i, NULL );
	}
}


/// 2011.10.21 - prodongi
bool isEmptyCreatureCard(int itemCode, XFlag<int> const& xFlag)
{
	if( GetItemDB().GetUseType(itemCode) == ItemBase::TYPE_CARD )
	{
		if( GetItemDB().GetGroup( itemCode ) == ItemBase::GROUP_SUMMONCARD )
		{	
			bool isSummon = xFlag.IsOn( ItemInstance::ITEM_FLAG_SUMMON );
			if (!isSummon)
			{
				return true;
			}
		}
	}

	return false;
}

sEmptyControlRegionChecker::~sEmptyControlRegionChecker()
{
	m_controlList.clear();
}

void sEmptyControlRegionChecker::add(KUIWnd* control)
{
	if (!control)
		return ;
	m_controlList.push_back(control);
}

bool sEmptyControlRegionChecker::isIn(int x, int y) const
{
	std::list<KUIWnd*>::const_iterator it = m_controlList.begin();
	for (; it != m_controlList.end(); ++it)
	{
		if ((*it)->IsInRect(x, y))
			return true;
	}

	return false;
}


int refreshItemDurability(SInventorySlot* pSlot, KUIWnd* pGauge, float fGaugeWidth)
{
	int nResult = 0;
	if( pSlot == NULL || pGauge == NULL || fGaugeWidth < 0.0f )
		return nResult;

	// 내구도 게이지 SpriteSet.   내구없는 일반아이템,  33%,  66%,  100%.
	const char * g_arrGaugeAni[] =
	{
		"common_guage_titanium_line_lightgrey",  "common_guage_titanium_line_red",
		"common_guage_titanium_line_cyan", "common_guage_titanium_line_yellowgreen", "gauge_repair_line_grey"
	};

	enum ITEM_STATE
	{
		ITEM_STATE_NONE	   = -1,// 장비X.
		ITEM_STATE_GENERAL = 0,	// 일반.
		ITEM_STATE_UPPER,		// 상급.
		ITEM_STATE_BROKEN,		// 부서진 상급.		
	};

	ITEM_STATE itemState = ITEM_STATE::ITEM_STATE_NONE;

	pGauge->SetShow(false);

	float per = 0.0f;
	int   nIndexAni = 0;

	if ( GetItemDB().GetGroup( pSlot->GetItemCode() ) == ItemBase::GROUP_SUMMONCARD )
	{
		// AziaMafia Off Dura Pets
		if( pSlot->GetEnhance() > 0 )
		{
			per = (float)pSlot->GetEtherealDurability() / (float)GetCreatureEnhanceDB().getCardDurability( pSlot->GetEnhance() );
			per = per > 0.99f ? 1.0f : per;
			pGauge->SetShow(true);

			if( per < 0.33f )		// red.
				nIndexAni = 1;    
			else if( per < 0.66f )  // cyan.
				nIndexAni = 2;	
			else					// yellowgreen.	
				nIndexAni = 3;

			nResult = 1;   // 내구도 있음
		}
		else
		{
			per       = 1.0f;
			nIndexAni = 0;  // 내구도가 없을 경우 lightgrey 로
			pGauge->SetShow(true);
			nResult = 1;   // 내구도 없음
		}


	}
	else
	{
		const ItemBaseEx_info * pItemBase = GetItemDB().GetItemData( pSlot->GetItemCode() );
		if(pItemBase && pSlot->GetEtherealDurability() > 0.0f && pSlot->getMaxEtherealDurability() > 0.0f)
		{
			// 상급아이템.
			if(pSlot->getMaxEtherealDurability() > 0)
			{
				int crrEthereal = pSlot->GetEtherealDurability();
				int maxEthereal = pSlot->getMaxEtherealDurability();
				if( crrEthereal > 0 )
				{
					itemState = ITEM_STATE::ITEM_STATE_UPPER;
					per = (float)crrEthereal / (float)maxEthereal;
				}
				else
				{
					itemState = ITEM_STATE::ITEM_STATE_BROKEN;
					//per = 0.0f;
				}
			}
			// 일반아이템.
			else
				itemState = ITEM_STATE::ITEM_STATE_GENERAL;

			nIndexAni = 4; // 내구도에 따른 SpriteSet Index;
			switch( itemState )
			{
			// 장비X.
			case ITEM_STATE::ITEM_STATE_NONE:
				{
					nIndexAni = 4;
					break;
				}
			// 일반아이템.
			case ITEM_STATE::ITEM_STATE_GENERAL:
				{
					nIndexAni = 0;
					pGauge->SetAniName( "common_mark_titanium_repair_none" );
					break;
				}
			// 상급아이템.
			case ITEM_STATE::ITEM_STATE_UPPER:
				{
					if( per < 0.33f )		// red.
						nIndexAni = 1;    
					else if( per < 0.66f )  // cyan.
						nIndexAni = 2;	
					else					// yellowgreen.	
						nIndexAni = 3;
					break;
				}
			// 파괴된아이템.
			case ITEM_STATE_BROKEN:
				{
					nIndexAni = 4;		
					pGauge->SetAniName( "common_mark_titanium_repair_zero" );
					break;
				}
			}

			// 아이템 내구도 비율 계산
			per = (float)pSlot->GetEtherealDurability() / (float)pSlot->getMaxEtherealDurability();
			per = per > 0.99f ? 1.0f : per;
			pGauge->SetShow(true);
			nResult = 1;   // 내구도 있음
		}
		else
		{
			per       = 1.0f;
			nIndexAni = 0;  // 내구도가 없을 경우 lightgrey 로
			pGauge->SetShow(true);
			nResult = 1;   // 내구도 없음
		}
	}

	KRect rt = pGauge->GetRect();
	rt.right = rt.left + fGaugeWidth * per;
	pGauge->Resize( rt );

	pGauge->SetAniName( g_arrGaugeAni[ nIndexAni ] );

	return nResult;
}

void UISendStringMessage(SGameManager* pGameManager, int nToUI, const char* pSendStr, bool bForceSend)
{
	if(pGameManager == NULL || pSendStr == NULL)
		return ;

	SUIWnd* pWnd = pGameManager->GetSUI( nToUI );
	if( pWnd == NULL )
		return ;

	// bForceSend ( false ) : UI가 열려있으면 메세지 보낸다
	// bForceSend ( true  ) : UI가 열려있지 않아도 강제로 메세지 보낸다
	if( bForceSend == false )
	{
		if( pWnd->IsShow() == true )
			pGameManager->PostMsgAtDynamic( new SIMSG_UI_SEND_DATA( (SIMSG_TOGGLE_UIWINDOW::_UIWINDOW_TYPE)nToUI, pSendStr ) );
	}
	else
	{
		pGameManager->PostMsgAtDynamic( new SIMSG_UI_SEND_DATA( (SIMSG_TOGGLE_UIWINDOW::_UIWINDOW_TYPE)nToUI, pSendStr ) );
	}
}