1552 lines
41 KiB
C++
1552 lines
41 KiB
C++
#pragma once
|
|
|
|
#include <toolkit/XStringUtil.h>
|
|
//#include "KUIControl.h"
|
|
#include "KUIControlScroll.h"
|
|
#include "KUIControlGauge.h"
|
|
#include <queue>
|
|
//#include <vector>
|
|
#include "enc.h"
|
|
#include "ItemBase.h"
|
|
#include <mmo/ArType.h>
|
|
|
|
class SUIDisplayInfo;
|
|
class SUIWnd; // sonador #2.1.2.4.3 팻 조작 UI 연동
|
|
// 2010.05.11 - prodongi
|
|
class SCreatureInfo;
|
|
// 2010.06.09 - prodongi
|
|
class SInventorySlot;
|
|
// 2010.07.20 - prodongi
|
|
class KUIControlMultiIcon;
|
|
class SGameAvatarEx;
|
|
class SUIDisplayInfo;
|
|
class SSkillSlotMgr;
|
|
class SCreatureSlotMgr;
|
|
|
|
class SGameManager;
|
|
|
|
namespace sui {
|
|
|
|
namespace helper {
|
|
|
|
/// convert numeric to comma numeric...
|
|
std::string int_to_comma_numeric( __int64 number );
|
|
/// convert comma numeric to numeric...
|
|
__int64 comma_numeric_to_int( const char* number );
|
|
/// convert string to indexed string( 'abc_%d' -> 'abc_01' )
|
|
std::string indexed_id( const char* format, int index );
|
|
|
|
}
|
|
|
|
///< sequence container wiper
|
|
template< class _Ct >
|
|
inline void wipe_seq( _Ct& container )
|
|
{
|
|
typedef typename _Ct::iterator iterator;
|
|
iterator end = container.end();
|
|
for( iterator itor = container.begin(); itor != end; ++itor )
|
|
if( *itor ) delete *itor;
|
|
container.clear();
|
|
}
|
|
|
|
template< class _Ct, class _Ty >
|
|
inline void remove_seq( _Ct& container, const _Ty& value )
|
|
{
|
|
container.erase( std::remove( container.begin(), container.end(), value ), container.end() );
|
|
}
|
|
|
|
template< typename T >
|
|
struct type2type
|
|
{
|
|
typedef T type_value;
|
|
};
|
|
|
|
// sonador 7.0.25 proxy_list 정렬 타입 불일치 문제 수정
|
|
template< int T >
|
|
struct int2type
|
|
{
|
|
enum { value = T };
|
|
};
|
|
|
|
/// tree control proxy
|
|
template< class _Elem >
|
|
class proxy_tree
|
|
{
|
|
public:
|
|
|
|
typedef _Elem element_t;
|
|
|
|
struct node
|
|
{
|
|
typedef std::vector< node* > nodes_t;
|
|
|
|
node() : m_parent( 0 ), m_right( 0 ), m_depth( 0 ), m_folded_state( true )
|
|
{
|
|
}
|
|
node( const element_t& _element ) : m_element( _element ), m_parent( 0 ), m_right( 0 ), m_depth( 0 ), m_folded_state( true )
|
|
{
|
|
}
|
|
~node()
|
|
{
|
|
wipe_seq( m_children );
|
|
}
|
|
node* add( node* item )
|
|
{
|
|
if( item )
|
|
{
|
|
// setup right hand side...
|
|
if( !m_children.empty() )
|
|
{
|
|
nodes_t::reverse_iterator ri = m_children.rbegin();
|
|
assert( (*ri)->m_right == 0 );
|
|
(*ri)->m_right = item;
|
|
}
|
|
|
|
m_children.push_back( item );
|
|
item->m_parent = this;
|
|
item->on_add();
|
|
//item->m_depth = m_depth + 1;
|
|
}
|
|
return this;
|
|
}
|
|
int depth() const
|
|
{
|
|
return m_depth;
|
|
}
|
|
int size_children() const
|
|
{
|
|
return m_children.size();
|
|
}
|
|
bool empty() const
|
|
{
|
|
return m_children.empty();
|
|
}
|
|
int size() const
|
|
{
|
|
struct nodeCounter {
|
|
nodeCounter() : result( 1 ) {} // it's me =)
|
|
void operator()( const node* item ) { result += item->size(); }
|
|
int result;
|
|
};
|
|
return std::for_each( m_children.begin(), m_children.end(), nodeCounter() ).result;
|
|
}
|
|
int size_visible() const
|
|
{
|
|
struct VisibleNodeCounter {
|
|
VisibleNodeCounter() : result( 1 ) {} // it's me =)
|
|
void operator()( const node* item ) {
|
|
result += ( item->folded() ) ? 1 : item->size_visible();
|
|
}
|
|
int result;
|
|
};
|
|
return std::for_each( m_children.begin(), m_children.end(), VisibleNodeCounter() ).result;
|
|
}
|
|
void fold()
|
|
{
|
|
m_folded_state = true;
|
|
}
|
|
void unfold()
|
|
{
|
|
m_folded_state = false;
|
|
}
|
|
void toggle()
|
|
{
|
|
m_folded_state = !m_folded_state;
|
|
}
|
|
bool folded() const
|
|
{
|
|
return m_folded_state;
|
|
}
|
|
node* find( const element_t& element )
|
|
{
|
|
if( m_element == element ) return this;
|
|
if( !m_children.empty() )
|
|
{
|
|
nodes_t::iterator _i = m_children.begin(), _e = m_children.end();
|
|
for( ; _i != _e; ++_i )
|
|
{
|
|
node* _node = (*_i)->find( element );
|
|
if( _node ) return _node;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
const element_t& get_element() const
|
|
{
|
|
return m_element;
|
|
}
|
|
element_t& get_element()
|
|
{
|
|
return m_element;
|
|
}
|
|
typename nodes_t::iterator begin()
|
|
{
|
|
return m_children.begin();
|
|
}
|
|
typename nodes_t::iterator end()
|
|
{
|
|
return m_children.end();
|
|
}
|
|
node* next()
|
|
{
|
|
if( !m_children.empty() )
|
|
return *m_children.begin();
|
|
return next_without_children();
|
|
}
|
|
node* next_visible()
|
|
{
|
|
node* it = next();
|
|
while( it )
|
|
{
|
|
if( it->is_visible() )
|
|
return it;
|
|
it = it->next();
|
|
}
|
|
return 0;
|
|
}
|
|
node* next_visible_index( int index )
|
|
{
|
|
int loop = 0;
|
|
node* it = next_visible();
|
|
while( it )
|
|
{
|
|
if( index <= loop++ )
|
|
break;
|
|
it = it->next_visible();
|
|
}
|
|
return it;
|
|
}
|
|
|
|
private:
|
|
|
|
void on_add()
|
|
{
|
|
m_depth = m_parent->depth() + 1;
|
|
nodes_t::iterator i = m_children.begin(), e = m_children.end();
|
|
for( ; i != e; ++i )
|
|
{
|
|
(*i)->on_add();
|
|
}
|
|
}
|
|
bool is_visible() const { return m_parent ? !m_parent->folded() : false; }
|
|
node* next_without_children()
|
|
{
|
|
if( m_right )
|
|
return m_right;
|
|
if( m_parent )
|
|
return m_parent->next_without_children();
|
|
return 0;
|
|
}
|
|
|
|
element_t m_element;
|
|
int m_depth;
|
|
node* m_parent;
|
|
node* m_right;
|
|
nodes_t m_children;
|
|
bool m_folded_state;
|
|
};
|
|
proxy_tree() : m_root( 0 ), m_selected( 0 )
|
|
{
|
|
m_root = new node();
|
|
m_root->unfold();
|
|
}
|
|
~proxy_tree()
|
|
{
|
|
SAFE_DELETE( m_root );
|
|
}
|
|
node* root() { return m_root; }
|
|
const node* root() const { return m_root; }
|
|
node* operator->() { return m_root; }
|
|
const node* operator->() const { return m_root; }
|
|
node& operator*() { return *m_root; }
|
|
const node& operator*() const { return *m_root; }
|
|
|
|
private:
|
|
|
|
node* m_root;
|
|
node* m_selected;
|
|
};
|
|
|
|
class property
|
|
{
|
|
public:
|
|
|
|
enum CLASSID {
|
|
CID_NONE,
|
|
CID_BOOLEAN,
|
|
CID_CHAR,
|
|
CID_UCHAR,
|
|
CID_WORD,
|
|
CID_DWORD,
|
|
CID_INT,
|
|
CID_UINT,
|
|
CID_INT64,
|
|
CID_FLOAT,
|
|
CID_POINTER,
|
|
CID_RESOURCE,
|
|
CID_STRING,
|
|
};
|
|
|
|
struct finder
|
|
{
|
|
finder( const char* name ) : name_for_search( name ) {}
|
|
bool operator () ( const property* arg )
|
|
{
|
|
return ( ::stricmp( name_for_search, arg->get_name() ) == 0 ) ? true : false;
|
|
}
|
|
const char* name_for_search;
|
|
};
|
|
|
|
struct AbstractResource
|
|
{
|
|
virtual ~AbstractResource() {}
|
|
virtual void* get_resource() = 0;
|
|
virtual AbstractResource* clone() = 0;
|
|
};
|
|
|
|
/** 프로퍼티에 리소스를 등록하기 위한 클래스( 리소스는 값으로 취급할 수 없다... )
|
|
리소스로 등록되는 클래스는 반드시 복사 생성자를 정의하고 있어야 합니다. */
|
|
template< typename T >
|
|
struct Resource : public AbstractResource
|
|
{
|
|
Resource( T* resource ) : AbstractResource(), m_resource( new T( *resource ) )
|
|
{
|
|
}
|
|
virtual ~Resource()
|
|
{
|
|
SAFE_DELETE( m_resource );
|
|
}
|
|
virtual AbstractResource* clone()
|
|
{
|
|
return new Resource< T >( m_resource );
|
|
}
|
|
virtual void* get_resource()
|
|
{
|
|
return reinterpret_cast< void* >( m_resource );
|
|
}
|
|
T* m_resource;
|
|
};
|
|
|
|
property() : m_name( 0 ), m_class( CID_NONE )
|
|
{
|
|
m_value.int_value = 0;
|
|
}
|
|
property( const char* name ) : m_name( name ), m_class( CID_NONE )
|
|
{
|
|
m_value.int_value = 0;
|
|
}
|
|
property( const property& rhs ) : m_name( rhs.m_name ), m_class( CID_NONE )
|
|
{
|
|
m_value.int_value = 0;
|
|
copy( rhs );
|
|
}
|
|
virtual ~property()
|
|
{
|
|
wipe();
|
|
}
|
|
property& operator = ( const property& rhs )
|
|
{
|
|
copy( rhs );
|
|
return *this;
|
|
}
|
|
bool operator == ( const property& rhs ) const
|
|
{
|
|
return !::strcmp( m_name, rhs.get_name() );
|
|
}
|
|
bool is_valid() const
|
|
{
|
|
return ( m_name == 0 || m_class == CID_NONE ) ? false : true;
|
|
}
|
|
virtual void copy( const property& other )
|
|
{
|
|
wipe();
|
|
m_name = other.m_name;
|
|
if( other.m_class == CID_STRING )
|
|
{
|
|
char* buffer;
|
|
other.get_value( buffer );
|
|
set_value( buffer );
|
|
}
|
|
else if( other.m_class == CID_RESOURCE )
|
|
{
|
|
m_class = other.m_class;
|
|
AbstractResource* otherAbsResource = reinterpret_cast< AbstractResource* >( other.m_value.pointer_value );
|
|
if( otherAbsResource )
|
|
{
|
|
AbstractResource* myAbsResource = otherAbsResource->clone();
|
|
m_value.pointer_value = reinterpret_cast< void* >( myAbsResource );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_class = other.m_class;
|
|
m_value = other.m_value;
|
|
}
|
|
}
|
|
void wipe()
|
|
{
|
|
if( m_class == CID_STRING )
|
|
{
|
|
char* buffer = reinterpret_cast< char* >( m_value.pointer_value );
|
|
SAFE_DELETE_ARRAY( buffer );
|
|
m_value.pointer_value = 0;
|
|
}
|
|
else if( m_class == CID_RESOURCE )
|
|
{
|
|
AbstractResource* resource = reinterpret_cast< AbstractResource* >( m_value.pointer_value );
|
|
SAFE_DELETE( resource );
|
|
m_value.pointer_value = 0;
|
|
}
|
|
m_class = CID_NONE;
|
|
m_value.int_value = 0;
|
|
}
|
|
const char* get_name() const
|
|
{
|
|
return m_name;
|
|
}
|
|
void set_name( const char* name )
|
|
{
|
|
m_name = name;
|
|
}
|
|
CLASSID get_class() const
|
|
{
|
|
return m_class;
|
|
}
|
|
|
|
/// setter
|
|
template< typename T >
|
|
property& set_resource( T* resource )
|
|
{
|
|
wipe();
|
|
m_class = CID_RESOURCE;
|
|
if( resource )
|
|
{
|
|
Resource< T >* res = new Resource< T >( resource );
|
|
m_value.pointer_value = reinterpret_cast< void* >( res );
|
|
}
|
|
return *this;
|
|
}
|
|
template< typename T >
|
|
property& set_value( T value )
|
|
{
|
|
wipe();
|
|
m_class = CID_POINTER;
|
|
m_value.pointer_value = reinterpret_cast< void* >( value );
|
|
return *this;
|
|
}
|
|
template< >
|
|
property& set_value< bool >( bool value )
|
|
{
|
|
wipe();
|
|
m_class = CID_BOOLEAN;
|
|
m_value.bool_value = value;
|
|
return *this;
|
|
}
|
|
template< >
|
|
property& set_value< char >( char value )
|
|
{
|
|
wipe();
|
|
m_class = CID_CHAR;
|
|
m_value.char_value = value;
|
|
return *this;
|
|
}
|
|
template< >
|
|
property& set_value< unsigned char >( unsigned char value )
|
|
{
|
|
wipe();
|
|
m_class = CID_UCHAR;
|
|
m_value.uchar_value = value;
|
|
return *this;
|
|
}
|
|
template< >
|
|
property& set_value< WORD >( WORD value )
|
|
{
|
|
wipe();
|
|
m_class = CID_WORD;
|
|
m_value.word_value = value;
|
|
return *this;
|
|
}
|
|
template< >
|
|
property& set_value< DWORD >( DWORD value )
|
|
{
|
|
wipe();
|
|
m_class = CID_DWORD;
|
|
m_value.dword_value = value;
|
|
return *this;
|
|
}
|
|
template< >
|
|
property& set_value< float >( float value )
|
|
{
|
|
wipe();
|
|
m_class = CID_FLOAT;
|
|
m_value.float_value = value;
|
|
return *this;
|
|
}
|
|
template< >
|
|
property& set_value< int >( int value )
|
|
{
|
|
wipe();
|
|
m_class = CID_INT;
|
|
m_value.int_value = value;
|
|
return *this;
|
|
}
|
|
template< >
|
|
property& set_value< unsigned int >( unsigned int value )
|
|
{
|
|
wipe();
|
|
m_class = CID_UINT;
|
|
m_value.uint_value = value;
|
|
return *this;
|
|
}
|
|
template< >
|
|
property& set_value< __int64 >( __int64 value )
|
|
{
|
|
wipe();
|
|
m_class = CID_INT64;
|
|
m_value.int64_value = value;
|
|
return *this;
|
|
}
|
|
template< >
|
|
property& set_value< const char* >( const char* value )
|
|
{
|
|
wipe();
|
|
m_class = CID_STRING;
|
|
int len = ::strlen( value );
|
|
char* buffer = new char[ len + 1 ];
|
|
::strcpy( buffer, value );
|
|
m_value.pointer_value = reinterpret_cast< void* >( buffer );
|
|
return *this;
|
|
}
|
|
template< >
|
|
property& set_value< char* >( char* value )
|
|
{
|
|
wipe();
|
|
m_class = CID_STRING;
|
|
int len = ::strlen( value );
|
|
char* buffer = new char[ len + 1 ];
|
|
::strcpy( buffer, value );
|
|
m_value.pointer_value = reinterpret_cast< void* >( buffer );
|
|
return *this;
|
|
}
|
|
|
|
/// getter
|
|
template< typename T >
|
|
void get_resource( T*& resource ) const
|
|
{
|
|
assert( m_class == CID_RESOURCE );
|
|
AbstractResource* absResource = reinterpret_cast< AbstractResource* >( m_value.pointer_value );
|
|
if( absResource )
|
|
{
|
|
resource = reinterpret_cast< T* >( absResource->get_resource() );
|
|
}
|
|
}
|
|
template< typename T >
|
|
void get_value( T& value ) const
|
|
{
|
|
assert( m_class == CID_POINTER );
|
|
value = reinterpret_cast< T >( m_value.pointer_value );
|
|
}
|
|
template< >
|
|
void get_value< bool >( bool& value ) const
|
|
{
|
|
assert( m_class == CID_BOOLEAN );
|
|
value = m_value.bool_value;
|
|
}
|
|
template< >
|
|
void get_value< char >( char& value ) const
|
|
{
|
|
assert( m_class == CID_CHAR );
|
|
value = m_value.char_value;
|
|
}
|
|
template< >
|
|
void get_value< unsigned char >( unsigned char& value ) const
|
|
{
|
|
assert( m_class == CID_UCHAR );
|
|
value = m_value.uchar_value;
|
|
}
|
|
template< >
|
|
void get_value< WORD >( WORD& value ) const
|
|
{
|
|
assert( m_class == CID_WORD );
|
|
value = m_value.word_value;
|
|
}
|
|
template< >
|
|
void get_value< DWORD >( DWORD& value ) const
|
|
{
|
|
assert( m_class == CID_DWORD );
|
|
value = m_value.dword_value;
|
|
}
|
|
template< >
|
|
void get_value< float >( float& value ) const
|
|
{
|
|
assert( m_class == CID_FLOAT );
|
|
value = m_value.float_value;
|
|
}
|
|
template< >
|
|
void get_value< int >( int& value ) const
|
|
{
|
|
assert( m_class == CID_INT );
|
|
value = m_value.int_value;
|
|
}
|
|
template< >
|
|
void get_value< unsigned int >( unsigned int& value ) const
|
|
{
|
|
assert( m_class == CID_UINT );
|
|
value = m_value.uint_value;
|
|
}
|
|
template< >
|
|
void get_value< __int64 >( __int64& value ) const
|
|
{
|
|
assert( m_class == CID_INT64 );
|
|
value = m_value.int64_value;
|
|
}
|
|
template< >
|
|
void get_value< char* >( char*& value ) const
|
|
{
|
|
assert( m_class == CID_STRING );
|
|
value = reinterpret_cast< char* >( m_value.pointer_value );
|
|
}
|
|
template< >
|
|
void get_value< std::string >( std::string& value ) const
|
|
{
|
|
assert( m_class == CID_STRING );
|
|
value = reinterpret_cast< char* >( m_value.pointer_value );
|
|
}
|
|
|
|
void* get_resource() const
|
|
{
|
|
assert( m_class == CID_RESOURCE );
|
|
AbstractResource* absResource = reinterpret_cast< AbstractResource* >( m_value.pointer_value );
|
|
if( absResource )
|
|
return absResource->get_resource();
|
|
return 0;
|
|
}
|
|
void* get_pointer_value() const
|
|
{
|
|
assert( m_class == CID_POINTER );
|
|
return m_value.pointer_value;
|
|
}
|
|
bool get_boolean_value() const
|
|
{
|
|
assert( m_class == CID_BOOLEAN );
|
|
return m_value.bool_value;
|
|
}
|
|
char get_char_value() const
|
|
{
|
|
assert( m_class == CID_CHAR );
|
|
return m_value.char_value;
|
|
}
|
|
unsigned char get_uchar_value() const
|
|
{
|
|
assert( m_class == CID_UCHAR );
|
|
return m_value.uchar_value;
|
|
}
|
|
WORD get_word_value() const
|
|
{
|
|
assert( m_class == CID_WORD );
|
|
return m_value.word_value;
|
|
}
|
|
DWORD get_dword_value() const
|
|
{
|
|
assert( m_class == CID_DWORD );
|
|
return m_value.dword_value;
|
|
}
|
|
float get_float_value() const
|
|
{
|
|
assert( m_class == CID_FLOAT );
|
|
return m_value.float_value;
|
|
}
|
|
int get_int_value() const
|
|
{
|
|
assert( m_class == CID_INT );
|
|
return m_value.int_value;
|
|
}
|
|
unsigned int get_uint_value() const
|
|
{
|
|
assert( m_class == CID_UINT );
|
|
return m_value.uint_value;
|
|
}
|
|
__int64 get_int64_value() const
|
|
{
|
|
assert( m_class == CID_INT64 );
|
|
return m_value.int64_value;
|
|
}
|
|
const char* get_string_value() const
|
|
{
|
|
assert( m_class == CID_STRING );
|
|
return reinterpret_cast< const char* >( m_value.pointer_value );
|
|
}
|
|
|
|
protected:
|
|
|
|
union value_type {
|
|
bool bool_value;
|
|
char char_value;
|
|
unsigned char uchar_value;
|
|
WORD word_value;
|
|
DWORD dword_value;
|
|
int int_value;
|
|
unsigned int uint_value;
|
|
__int64 int64_value;
|
|
float float_value;
|
|
void* pointer_value;
|
|
};
|
|
|
|
CLASSID m_class;
|
|
const char* m_name;
|
|
value_type m_value;
|
|
};
|
|
|
|
static property null_property;
|
|
|
|
/// property array
|
|
class property_array
|
|
{
|
|
public:
|
|
typedef std::vector< property* > properties_t;
|
|
typedef properties_t::iterator iterator;
|
|
typedef properties_t::const_iterator const_iterator;
|
|
property_array();
|
|
property_array( const property_array& other );
|
|
property_array& operator = ( const property_array& rhs );
|
|
virtual ~property_array();
|
|
property_array& add( property* prop );
|
|
property& get( const char* name );
|
|
property& at( int index );
|
|
property& operator[]( int index );
|
|
property& operator[]( const char* name );
|
|
int size() const;
|
|
bool empty() const;
|
|
iterator begin();
|
|
iterator end();
|
|
const_iterator begin() const;
|
|
const_iterator end() const;
|
|
protected:
|
|
void _copy( const property_array& other );
|
|
properties_t m_properties;
|
|
};
|
|
|
|
/// property for updatable window
|
|
class kui_window_property : public property
|
|
{
|
|
public:
|
|
kui_window_property( const char* name ) : property( name ) {}
|
|
kui_window_property( const kui_window_property& rhs ) : property( rhs ) {}
|
|
virtual ~kui_window_property() {}
|
|
virtual void on_update( property& data ) = 0;
|
|
KUIWnd* get_window()
|
|
{
|
|
return reinterpret_cast< KUIWnd* >( get_pointer_value() );
|
|
}
|
|
virtual kui_window_property& set_value( KUIWnd* value )
|
|
{
|
|
property::set_value< KUIWnd* >( value );
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
// soandor #2.1.2.4.3 팻 조작 UI 연동
|
|
/// updatable widow
|
|
class kui_updatable_window
|
|
{
|
|
public:
|
|
|
|
struct finder
|
|
{
|
|
finder( const char* name ) : name_for_search( name ) {}
|
|
bool operator () ( const kui_updatable_window* arg )
|
|
{
|
|
return ( ::stricmp( name_for_search, arg->get_name() ) == 0 ) ? true : false;
|
|
}
|
|
const char* name_for_search;
|
|
};
|
|
|
|
kui_updatable_window() : m_window( 0 ), m_data( "" ) {}
|
|
kui_updatable_window( kui_window_property* window ) : m_window( window ), m_data( window->get_name() ) {}
|
|
virtual ~kui_updatable_window()
|
|
{
|
|
SAFE_DELETE( m_window );
|
|
}
|
|
virtual void update()
|
|
{
|
|
if( !m_window )
|
|
return;
|
|
m_window->on_update( m_data );
|
|
}
|
|
const char* get_name() const
|
|
{
|
|
if( !m_window )
|
|
return 0;
|
|
return m_window->get_name();
|
|
}
|
|
void set_window( kui_window_property* window )
|
|
{
|
|
SAFE_DELETE( m_window );
|
|
m_window = window;
|
|
m_data.set_name( window->get_name() );
|
|
}
|
|
KUIWnd* get_window()
|
|
{
|
|
if( !m_window )
|
|
return 0;
|
|
return m_window->get_window();
|
|
}
|
|
template< typename T >
|
|
void set_data( T data )
|
|
{
|
|
m_data.set_value( data );
|
|
}
|
|
template< typename T >
|
|
void get_data( T& data ) const
|
|
{
|
|
m_data.get_value( data );
|
|
}
|
|
template< typename T >
|
|
void set_resource( T* resource )
|
|
{
|
|
m_data.set_resource( resource );
|
|
}
|
|
template< typename T >
|
|
void get_resource( T* resource ) const
|
|
{
|
|
m_data.get_resource( T* resource );
|
|
}
|
|
|
|
protected:
|
|
|
|
kui_window_property* m_window;
|
|
property m_data;
|
|
};
|
|
|
|
static kui_updatable_window null_updatable_window;
|
|
|
|
/// updatable window array
|
|
class kui_updatable_window_array
|
|
{
|
|
public:
|
|
typedef std::vector< kui_updatable_window* > window_container_t;
|
|
typedef window_container_t::iterator iterator;
|
|
typedef window_container_t::const_iterator const_iterator;
|
|
kui_updatable_window_array();
|
|
~kui_updatable_window_array();
|
|
kui_updatable_window_array& add( kui_updatable_window* window );
|
|
kui_updatable_window& get( const char* name );
|
|
kui_updatable_window& at( int index );
|
|
kui_updatable_window& operator[]( int index );
|
|
kui_updatable_window& operator[]( const char* name );
|
|
int size() const;
|
|
bool empty() const;
|
|
iterator begin();
|
|
iterator end();
|
|
const_iterator begin() const;
|
|
const_iterator end() const;
|
|
void clear();
|
|
virtual void update();
|
|
protected:
|
|
window_container_t m_windows;
|
|
/// disabled...
|
|
kui_updatable_window_array( const kui_updatable_window_array& other );
|
|
kui_updatable_window_array& operator = ( const kui_updatable_window_array& rhs );
|
|
};
|
|
|
|
/// list control proxy
|
|
class proxy_list
|
|
{
|
|
public:
|
|
|
|
enum { INVALID_VALUE = -1 };
|
|
|
|
typedef property_array item_t;
|
|
typedef proxy_list this_t;
|
|
typedef std::vector< item_t* > item_container_t;
|
|
typedef std::vector< kui_window_property* > control_row_t;
|
|
typedef std::vector< control_row_t* > control_matrix_t;
|
|
typedef std::vector< KUIWnd* > selectables_t;
|
|
typedef item_container_t::iterator iterator;
|
|
|
|
// ctor and dtor
|
|
proxy_list( SUIWnd* window, const char* id, int limit, int item_offset = 0 );
|
|
~proxy_list();
|
|
|
|
// public interface
|
|
void initialize( const char* selectable_id = 0, const char* selection_mask_id = 0, const char* scroll_id = 0 );
|
|
void clear();
|
|
void update_data();
|
|
|
|
// kui method
|
|
void proc_pumpup( LPCSTR id, DWORD message, DWORD lparam, DWORD wparam );
|
|
void proc_mouse( DWORD msg, int x, int y );
|
|
void activate_mouse_proc( bool activity );
|
|
|
|
// list method
|
|
void save_state();
|
|
void load_state();
|
|
this_t& add( item_t* item );
|
|
void remove( item_t* item );
|
|
template< class _Pred >
|
|
void remove_if( _Pred pred )
|
|
{
|
|
m_items.erase( std::remove_if( begin(), end(), pred ), m_items.end() );
|
|
_update_scroll_range();
|
|
}
|
|
bool empty() const;
|
|
int size() const;
|
|
iterator begin();
|
|
iterator end();
|
|
iterator visible_begin();
|
|
iterator visible_end();
|
|
item_t* at( int item_index );
|
|
item_t* operator[ ]( int item_index );
|
|
int get_offset() const { return m_offset; } // #2.1.2.4.3
|
|
void next_page();
|
|
void prev_page();
|
|
int page_begin() const;
|
|
int page_end() const;
|
|
int page() const;
|
|
// { sonador 7.0.25 proxy_list 정렬 타입 불일치 문제 수정
|
|
template< typename _Ty, typename _Pr >
|
|
void sort( const char* column_name, _Pr pred )
|
|
{
|
|
std::sort( begin(), end(), sort_column< _Ty, _Pr, false >( column_name, pred ) );
|
|
}
|
|
template< typename _Ty, typename _Pr >
|
|
void sort_resource( const char* column_name, _Pr pred )
|
|
{
|
|
std::sort( begin(), end(), sort_column< _Ty, _Pr, true >( column_name, pred ) );
|
|
}
|
|
template< typename _Ty, typename _Pr >
|
|
void stable_sort( const char* column_name, _Pr pred )
|
|
{
|
|
std::stable_sort( begin(), end(), sort_column< _Ty, _Pr, false >( column_name, pred ) );
|
|
}
|
|
template< typename _Ty, typename _Pr >
|
|
void stable_sort_resource( const char* column_name, _Pr pred )
|
|
{
|
|
std::stable_sort( begin(), end(), sort_column< _Ty, _Pr, true >( column_name, pred ) );
|
|
}
|
|
// }
|
|
// control method
|
|
template< typename property_t >
|
|
bool add_column( const char* window_id, property_t* origin_property )
|
|
{
|
|
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 false;
|
|
|
|
m_window->SetChildAsTop( indexed_id_orig.c_str() );
|
|
m_control_matrix.at( 0 )->push_back( &( origin_property->set_value( 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_control_matrix.at( n )->push_back( &( new property_t( *origin_property ) )->set_value( m_window->CopyControl( indexed_id_orig.c_str(), helper::indexed_id( window_id, n ).c_str(), region_offset ) ) );
|
|
}
|
|
return true;
|
|
}
|
|
property* get_window_property( int row, const char* column_id );
|
|
|
|
private:
|
|
|
|
// sonador 7.0.25 proxy_list 정렬 타입 불일치 문제 수정
|
|
template< typename _Ty, typename _Pr, bool _IsRes = false >
|
|
struct sort_column {
|
|
sort_column( const char* column_name, const _Pr& pred ) : m_column_name( column_name ), m_pred( pred ) {}
|
|
bool operator () ( item_t* lhs, item_t* rhs ) const {
|
|
property& lhs_column = lhs->get( m_column_name );
|
|
property& rhs_column = rhs->get( m_column_name );
|
|
if( !rhs_column.is_valid() ) return false;
|
|
if( !lhs_column.is_valid() ) return true;
|
|
return compare_property( lhs_column, rhs_column, int2type< _IsRes >() );
|
|
}
|
|
bool compare_property( const property& lhs, const property& rhs, int2type< false > ) const {
|
|
_Ty lhs_value, rhs_value;
|
|
lhs.get_value< _Ty >( lhs_value );
|
|
rhs.get_value< _Ty >( rhs_value );
|
|
return m_pred( lhs_value, rhs_value );
|
|
}
|
|
bool compare_property( const property& lhs, const property& rhs, int2type< true > ) const {
|
|
_Ty *lhs_value, *rhs_value;
|
|
lhs.get_resource< _Ty >( lhs_value );
|
|
rhs.get_resource< _Ty >( rhs_value );
|
|
return m_pred( *lhs_value, *rhs_value );
|
|
}
|
|
const char* m_column_name;
|
|
const _Pr& m_pred;
|
|
};
|
|
|
|
void _init_scroll( const char* window_id );
|
|
void _init_selectables( const char* window_id );
|
|
void _init_selection_mask( const char* selection_mask_id );
|
|
int _normalize_offset( int offset );
|
|
bool _is_valid_index( int control_index ) const;
|
|
bool _is_visible_index( int control_index ) const;
|
|
int _get_visible_end_index() const;
|
|
int _to_item_index( int control_index ) const;
|
|
int _to_control_index( int item_index ) const;
|
|
int _mouse_to_index( int x, int y ) const;
|
|
int _change_current_index( int new_item_index );
|
|
int _get_page_from( int item_index ) const;
|
|
bool _is_valid_page( int page ) const;
|
|
void _set_offset_by( int page );
|
|
int _select_item_by( int control_index = INVALID_VALUE );
|
|
void _locate_selection_mask_at( int control_index = INVALID_VALUE );
|
|
void _update_scroll_range();
|
|
|
|
const char* m_id;
|
|
const unsigned int m_limit;
|
|
const unsigned int m_item_offset;
|
|
int m_offset;
|
|
int m_current_index;
|
|
int m_saved_offset;
|
|
int m_saved_index;
|
|
SUIWnd* m_window;
|
|
KUIControlScrollBase* m_scroll;
|
|
KUIWnd* m_selection_mask;
|
|
int m_selection_mask_origin_offset;
|
|
selectables_t m_selectables;
|
|
item_container_t m_items;
|
|
control_matrix_t m_control_matrix;
|
|
bool m_proc_mouse;
|
|
};
|
|
|
|
template< typename _Ty >
|
|
class spin_cache
|
|
{
|
|
public:
|
|
|
|
enum { INITIAL_INDEX = -1 };
|
|
typedef std::vector< _Ty > cache_t;
|
|
typedef typename cache_t::iterator iterator;
|
|
|
|
spin_cache( int maxCache ) : m_maxCache( maxCache ), m_index( INITIAL_INDEX )
|
|
{
|
|
}
|
|
void push( const _Ty& value )
|
|
{
|
|
m_cache.insert( m_cache.begin(), value );
|
|
normalizeCache();
|
|
while( overflow() )
|
|
{
|
|
m_cache.pop_back();
|
|
}
|
|
resetIndex();
|
|
}
|
|
void clear()
|
|
{
|
|
resetIndex();
|
|
m_cache.clear();
|
|
}
|
|
bool empty() const
|
|
{
|
|
return m_cache.empty();
|
|
}
|
|
iterator next()
|
|
{
|
|
normalizeIndex( ++m_index );
|
|
return isValid( m_index ) ? m_cache.begin() + m_index : m_cache.end();
|
|
}
|
|
iterator prev()
|
|
{
|
|
normalizeIndex( --m_index );
|
|
return isValid( m_index ) ? m_cache.begin() + m_index : m_cache.end();
|
|
}
|
|
iterator begin()
|
|
{
|
|
return m_cache.begin();
|
|
}
|
|
iterator end()
|
|
{
|
|
return m_cache.end();
|
|
}
|
|
void pop_front()
|
|
{
|
|
if( !m_cache.empty() )
|
|
{
|
|
m_cache.erase( m_cache.begin() );
|
|
}
|
|
}
|
|
void pop_back()
|
|
{
|
|
if( !m_cache.empty() )
|
|
{
|
|
m_cache.pop_back();
|
|
}
|
|
}
|
|
|
|
protected:
|
|
|
|
bool overflow() const { return ( m_cache.size() > m_maxCache ) ? true : false; }
|
|
void normalizeCache()
|
|
{
|
|
typedef std::vector< std::string > cache_t;
|
|
cache_t new_cache;
|
|
new_cache.reserve( m_maxCache );
|
|
cache_t::iterator i = m_cache.begin(), e = m_cache.end();
|
|
for( ; i != e; ++i )
|
|
{
|
|
cache_t::iterator i_found = std::find( new_cache.begin(), new_cache.end(), *i );
|
|
if( i_found != new_cache.end() )
|
|
continue;
|
|
new_cache.push_back( *i );
|
|
}
|
|
m_cache.clear();
|
|
m_cache.assign( new_cache.begin(), new_cache.end() );
|
|
}
|
|
void normalizeIndex( int& index )
|
|
{
|
|
if( index < 0 )
|
|
index = m_cache.size() - 1;
|
|
else if( index >= m_cache.size() )
|
|
index = 0;
|
|
}
|
|
void resetIndex()
|
|
{
|
|
m_index = INITIAL_INDEX;
|
|
}
|
|
bool isValid( int index )
|
|
{
|
|
return ( index < 0 || index >= m_cache.size() ) ? false : true;
|
|
}
|
|
|
|
std::vector< std::string > m_cache;
|
|
const int m_maxCache;
|
|
int m_index;
|
|
|
|
};
|
|
|
|
class ticker;
|
|
class tickable
|
|
{
|
|
public:
|
|
tickable() : m_ticker( 0 ) {}
|
|
virtual ~tickable() {}
|
|
// transitive methods
|
|
virtual void on_tick() = 0;
|
|
virtual void on_enter() = 0;
|
|
virtual void on_leave() = 0;
|
|
ticker* get_ticker() { return m_ticker; }
|
|
protected:
|
|
friend class ticker;
|
|
void set_ticker( ticker* _ticker );
|
|
ticker* m_ticker;
|
|
};
|
|
|
|
class ticker : public tickable
|
|
{
|
|
public:
|
|
ticker() : tickable(), m_time( 0 ), m_is_on_tick( false ), m_lock( false ) {}
|
|
virtual ~ticker() {}
|
|
virtual void on_tick() { tick( m_ticker->time() ); }
|
|
virtual void on_enter();
|
|
virtual void on_leave();
|
|
virtual void tick( DWORD time );
|
|
virtual void enter();
|
|
virtual void leave();
|
|
bool append_tickable( tickable* _tickable );
|
|
bool remove_tickable( tickable* _tickable );
|
|
DWORD time() const { return m_time; }
|
|
bool is_on_tick() const { return m_is_on_tick; }
|
|
protected:
|
|
typedef std::vector< tickable* > tickable_vector_t;
|
|
typedef std::queue< tickable* > tickable_queue_t;
|
|
tickable_vector_t m_tickables;
|
|
tickable_queue_t m_candidates;
|
|
tickable_queue_t m_garbages;
|
|
DWORD m_time;
|
|
bool m_is_on_tick;
|
|
bool m_lock;
|
|
};
|
|
|
|
class fixed_rate_ticker : public ticker
|
|
{
|
|
public:
|
|
fixed_rate_ticker( DWORD frequency ) : ticker(), m_frequency( frequency )
|
|
{
|
|
}
|
|
virtual ~fixed_rate_ticker() {}
|
|
virtual void on_tick();
|
|
virtual void on_enter();
|
|
virtual void on_leave();
|
|
DWORD frequency() const { return m_frequency; }
|
|
protected:
|
|
DWORD m_frequency;
|
|
};
|
|
|
|
class fixed_rate_one_time_ticker : public fixed_rate_ticker
|
|
{
|
|
public:
|
|
fixed_rate_one_time_ticker( DWORD frequency ) : fixed_rate_ticker( frequency )
|
|
{
|
|
}
|
|
virtual ~fixed_rate_one_time_ticker() {}
|
|
virtual void on_tick();
|
|
};
|
|
|
|
class conditional_fixed_rate_one_time_ticker : public fixed_rate_ticker
|
|
{
|
|
public:
|
|
conditional_fixed_rate_one_time_ticker( DWORD frequency ) : fixed_rate_ticker( frequency ), m_satisfaction( false )
|
|
{
|
|
}
|
|
virtual ~conditional_fixed_rate_one_time_ticker() {}
|
|
virtual void on_tick();
|
|
virtual void on_enter();
|
|
void satisfy();
|
|
bool m_satisfaction;
|
|
};
|
|
|
|
struct Action
|
|
{
|
|
virtual ~Action() {}
|
|
virtual void operator()() = 0;
|
|
};
|
|
struct ActionEnableControl : public Action
|
|
{
|
|
ActionEnableControl( KUIControl* pControl ) : Action(), m_pControl( pControl ) {}
|
|
virtual void operator()() { if( m_pControl ) m_pControl->Enable(); }
|
|
KUIControl* m_pControl;
|
|
};
|
|
struct ActionDisableControl : public Action
|
|
{
|
|
ActionDisableControl( KUIControl* pControl ) : Action(), m_pControl( pControl ) {}
|
|
void operator()() { if( m_pControl ) m_pControl->Disable(); }
|
|
KUIControl* m_pControl;
|
|
};
|
|
struct ActionShowControl : public Action
|
|
{
|
|
ActionShowControl( KUIControl* pControl ) : Action(), m_pControl( pControl ) {}
|
|
void operator()() { if( m_pControl ) m_pControl->SetShow( true ); }
|
|
KUIControl* m_pControl;
|
|
};
|
|
struct ActionHideControl : public Action
|
|
{
|
|
ActionHideControl( KUIControl* pControl ) : Action(), m_pControl( pControl ) {}
|
|
void operator()() { if( m_pControl ) m_pControl->SetShow( false ); }
|
|
KUIControl* m_pControl;
|
|
};
|
|
|
|
class ActionBinder : public tickable
|
|
{
|
|
public:
|
|
ActionBinder( Action* pOnEnter, Action* pOnTick, Action* pOnLeave )
|
|
: tickable()
|
|
, m_pOnEnterAction( pOnEnter )
|
|
, m_pOnTickAction( pOnTick )
|
|
, m_pOnLeaveAction( pOnLeave )
|
|
{
|
|
}
|
|
virtual ~ActionBinder()
|
|
{
|
|
SAFE_DELETE( m_pOnTickAction );
|
|
SAFE_DELETE( m_pOnEnterAction );
|
|
SAFE_DELETE( m_pOnLeaveAction );
|
|
}
|
|
virtual void on_tick()
|
|
{
|
|
if( m_pOnTickAction )
|
|
(*m_pOnTickAction)();
|
|
}
|
|
virtual void on_enter()
|
|
{
|
|
if( m_pOnEnterAction )
|
|
(*m_pOnEnterAction)();
|
|
}
|
|
virtual void on_leave()
|
|
{
|
|
if( m_pOnLeaveAction )
|
|
(*m_pOnLeaveAction)();
|
|
}
|
|
private:
|
|
Action* m_pOnEnterAction;
|
|
Action* m_pOnTickAction;
|
|
Action* m_pOnLeaveAction;
|
|
};
|
|
|
|
class Page
|
|
{
|
|
public:
|
|
Page() : m_nCurrentPage( 1 ), m_nEndPage( 1 ), m_pPrevButton( 0 ), m_pNextButton( 0 )
|
|
{
|
|
}
|
|
void SetButton( class KUIControl* pPrevButton, class KUIControl* pNextButton );
|
|
void Update( int nCurrentPage );
|
|
void Update( int nCurrentPage, int nEndPage );
|
|
int Current() const;
|
|
int End() const;
|
|
int Next() const;
|
|
int Prev() const;
|
|
private:
|
|
int _GetNormalizedPage( int nPage ) const;
|
|
bool _IsEnd() const;
|
|
bool _IsBegin() const;
|
|
int m_nCurrentPage;
|
|
int m_nEndPage;
|
|
class KUIControl* m_pPrevButton;
|
|
class KUIControl* m_pNextButton;
|
|
};
|
|
|
|
/// 2011.01.20 - prodongi
|
|
/// 2010.01.20 메인 프레임과 타겟 창에 쓰이는 마크 아이콘 구조체 - prodongi
|
|
struct sMarkState
|
|
{
|
|
enum eState
|
|
{
|
|
PC = 0,
|
|
FREEPASS,
|
|
PK,
|
|
PVP,
|
|
MAX
|
|
};
|
|
|
|
struct sInfo
|
|
{
|
|
bool m_show;
|
|
|
|
// 프리패스/pc방에서만 쓰인다
|
|
int m_stateCode;
|
|
AR_TIME m_endTime;
|
|
int m_stateLevel;
|
|
bool m_toggleSkill;
|
|
int m_stateValue; ///< 지속효과 관련 추가값
|
|
|
|
// pk status에만 쓰인다
|
|
int m_status;
|
|
|
|
std::string m_strMarkControlName; // 매칭 되어있는 컨트롤 마크 이름 ( 이름은 sortMarkState() 할때마다 바뀜 )
|
|
|
|
sInfo()
|
|
: m_show( false )
|
|
, m_stateCode( NULL )
|
|
, m_endTime( NULL )
|
|
, m_stateLevel( NULL )
|
|
, m_toggleSkill( NULL )
|
|
, m_stateValue( NULL )
|
|
, m_strMarkControlName( "" )
|
|
{
|
|
}
|
|
|
|
void setStateSlot( class SStateSlot const* slot );
|
|
|
|
};
|
|
|
|
void updateMarkStateList(KUIWnd* wnd, SUIDisplayInfo* displayInfo, SGameAvatarEx* avatar);
|
|
void updateMarkStatusList(KUIWnd* wnd, SUIDisplayInfo* displayInfo, int status);
|
|
void sortMarkState(KUIWnd* wnd, SUIDisplayInfo* displayInfo);
|
|
void hideAllControl(KUIWnd* wnd);
|
|
void hideAll( void );
|
|
|
|
bool IsInRectFreePass( KUIWnd* pDestWnd, const KPoint ptMouse );
|
|
void UpdateFreePassEndTimeTooltip( KUIWnd* pDestWnd, SUIDisplayInfo* pDisplayInfo );
|
|
|
|
sInfo m_info[ eState::MAX ];
|
|
};
|
|
|
|
/// 2011.12.12 마우스 영역 체크로 투명/불투명 효과를 주는 구조체 - prodongi
|
|
struct sOpacityMouseChecker
|
|
{
|
|
sOpacityMouseChecker() : m_alphaV(3.0f), m_alpha(0.0f) {}
|
|
~sOpacityMouseChecker();
|
|
void open();
|
|
void update(DWORD dwTime, int x, int y, SUIWnd* wnd);
|
|
void setAlpha(float alpha);
|
|
void addChild(SUIWnd* parent, char const* id);
|
|
void setShow(bool show);
|
|
void changeAlpha();
|
|
|
|
float m_alphaV;
|
|
float m_alpha;
|
|
std::vector<KUIWnd*> m_childList;
|
|
};
|
|
|
|
} // namespace util
|
|
|
|
/// 2012.05.02 클래스의 함수포인터를 등록해서 함수를 호출해주는 템플릿 - prodongi
|
|
template <typename T, typename KEY = std::string>
|
|
struct cClassFuncP
|
|
{
|
|
typedef void (T::*fp)();
|
|
typedef std::map<KEY, fp> map_fp;
|
|
|
|
~cClassFuncP()
|
|
{
|
|
m_funcList.clear();
|
|
}
|
|
void add(KEY const& id, fp _fp)
|
|
{
|
|
map_fp::iterator it = m_funcList.find(id);
|
|
if (it != m_funcList.end())
|
|
return ;
|
|
|
|
m_funcList[id] = _fp;
|
|
}
|
|
void del(KEY const& id)
|
|
{
|
|
map_fp::iterator it = m_funcList.find(id);
|
|
if (it == m_funcList.end())
|
|
return ;
|
|
|
|
m_funcList.erase(id);
|
|
}
|
|
void call(KEY const& id, T* owner)
|
|
{
|
|
map_fp::iterator it = m_funcList.find(id);
|
|
if (it == m_funcList.end())
|
|
return ;
|
|
|
|
fp fn = it->second;
|
|
(owner->*fn)();
|
|
}
|
|
map_fp m_funcList;
|
|
};
|
|
|
|
template <typename T, typename P, typename KEY = std::string>
|
|
struct cClassParamFuncP
|
|
{
|
|
typedef void (T::*fp)(P);
|
|
typedef std::map<KEY, fp> map_fp;
|
|
|
|
~cClassParamFuncP()
|
|
{
|
|
m_funcList.clear();
|
|
}
|
|
void add(KEY const& id, fp _fp)
|
|
{
|
|
map_fp::iterator it = m_funcList.find(id);
|
|
if (it != m_funcList.end())
|
|
return ;
|
|
|
|
m_funcList[id] = _fp;
|
|
}
|
|
void del(KEY const& id)
|
|
{
|
|
map_fp::iterator it = m_funcList.find(id);
|
|
if (it == m_funcList.end())
|
|
return ;
|
|
|
|
m_funcList.erase(id);
|
|
}
|
|
void call(KEY const& id, T* owner, P param)
|
|
{
|
|
map_fp::iterator it = m_funcList.find(id);
|
|
if (it == m_funcList.end())
|
|
return ;
|
|
|
|
fp fn = it->second;
|
|
(owner->*fn)(param);
|
|
}
|
|
map_fp m_funcList;
|
|
};
|
|
|
|
/// 2012.05.09 x, y가 m_emptyRegionControl영역에 있는지 체크하는 구조체 - prodongi
|
|
struct sEmptyControlRegionChecker
|
|
{
|
|
~sEmptyControlRegionChecker();
|
|
bool isIn(int x, int y) const;
|
|
void add(KUIWnd* control);
|
|
|
|
private:
|
|
std::list<KUIWnd*> m_controlList;
|
|
};
|
|
|
|
class EquipItemAddtionalIconSetter
|
|
{
|
|
public:
|
|
EquipItemAddtionalIconSetter( KUIControlMultiIcon* pIcon, ItemBase::ItemCode nItemCode, int nEnhance, int nEtherealDurability, XFlag<int> xFlag );
|
|
EquipItemAddtionalIconSetter( KUIControlMultiIcon* pIcon, SInventorySlot* pSlot );
|
|
|
|
private:
|
|
|
|
void SetIcon( KUIControlMultiIcon* pIcon, ItemBase::ItemCode nItemCode, int nEnhance, int nEtherealDurability, XFlag<int> xFlag );
|
|
|
|
};
|
|
|
|
|
|
// 2010.05.11 강화 크리쳐의 아이콘 이름을 구한다 - prodongi
|
|
void getEnhanceIconName(char* enhanceIconName, SCreatureInfo const* info, int enhance);
|
|
// 2010.08.31 - prodongi
|
|
void getEnhanceIconName(char* enhanceIconName, ENC_INT creatureId, int enhance);
|
|
// 2010.05.13 순수하게 아이템 이름만 뽑는다 - prodongi
|
|
std::string getItemName(int itemId);
|
|
// 2010.06.09 내구도에 따른 아이콘 이름 뽑는다 - prodongi
|
|
void getIconNameAtDurability(SInventorySlot const* slot, std::string& iconName);
|
|
// 2010.07.06 - prodongi
|
|
void getIconNameAtDurability(ItemBase::ItemCode itemCode, int enhance, int etherealDurability, std::string& iconName, int nFlag = 0, int nSummonID = 0 );
|
|
void getIconNameAtDurability(ItemBase::ItemCode itemCode, int enhance, int etherealDurability, std::string& iconName, XFlag<int> tFlag, int nSummonID = 0 );
|
|
// 2013.03.18 - gmpbigsun
|
|
void getIconNameAtDurability(SInventorySlot const* slot, int nTmep, std::string& iconName);
|
|
|
|
bool setIconNameEquipment_ENHANCE( KUIControlMultiIcon* icon, ENC_INT itemCode, const int nEnhance );
|
|
// 봉인카드 테두리아이콘 이름얻기
|
|
bool getIconNameSummonCard_BORDER( std::string& strTemp, const int nSummonID, int nEnhance = 0, int nDurability = 0 );
|
|
bool getIconNameSummonCard_BELT( std::string& strTemp, AR_HANDLE nHandle );
|
|
bool getIconNameSummonCard_FORMATION( std::string& strTemp, AR_HANDLE nHandle );
|
|
bool getIconNameSummonCard_STAGE( std::string& strTemp, const int nSummonID, const int nEnhance );
|
|
|
|
// 2010.07.14 파괴된 크리쳐 카드인지 아닌지- prodongi
|
|
bool isExhaustedSummonCard(ItemBase::ItemCode itemCode, int enhance, int etherealDurability);
|
|
// 착용 불가능한 꾸미기 아이템 인가?
|
|
bool isWearableDecoItem( const ItemBaseEx_info* pItem );
|
|
// 착용 불가능한 아이템 아이콘 설정
|
|
void setCantWearIcon(KUIControlMultiIcon* icon, ENC_INT itemCode, int nJobID, int nRace, int nLevel, XFlag<int> xFlag, SSkillSlotMgr& SkillSlotMgr );
|
|
// 2010.07.20 깨진 아이템 아이콘 설정- prodongi
|
|
void setDurabilityIcon(KUIControlMultiIcon* icon, ENC_INT itemCode, int etherealDurability);
|
|
// 강화 실패 아이템 아이콘 설정
|
|
void setEnhanceFailedIcon(KUIControlMultiIcon* icon, XFlag<int> xFlag);
|
|
// 2010.06.11 사용할려는 아이템이 동일한 타입인지 체크 - prodongi
|
|
bool checkUseEqualHairTypeItem(ItemBase const* item);
|
|
// 2010.07.27 아이템의 사용 가능 조건을 체크 - prodongi
|
|
bool checkEnableUseItem(ItemBase const* item, int itemCode, SUIDisplayInfo* displayInfo, int& msgId);
|
|
|
|
// 2010.08.20 set control gage - prodongi
|
|
void setStaticWndGage(KUIWnd* wnd, int maxSize, float percent);
|
|
// 2010.09.17 장착 카드 내구도 퍼센트 - prodongi
|
|
float getEquipCardDurPercent(SInventorySlot const* slot);
|
|
// 2010.09.17 장착 카드 내구도 퍼센트 단계- prodongi
|
|
int getEquipCardDurPercentLevel(SInventorySlot const* slot);
|
|
float getCreatureCardDurPercent(SInventorySlot const* slot, int enhance); // 2010.09.17 카드 내구도 퍼센트 - prodongi
|
|
float getCreatureCardDurPercent(int etherealDurability, int enhance); /// 2011.03.29 - prodongi
|
|
int getCreatureCardDurPercentLevel(SInventorySlot const* slot, int enhance);// 2010.09.17 장착 아이템 내구도 퍼센트 단계- prodongi
|
|
int getCreatureCardDurPercentLevel(int etherealDurability, int enhance); /// 2011.03.29 - prodongi
|
|
/// 2010.12.17 - prodongi
|
|
void setChildControlEnable(KUIWnd* parent, char const* childId, bool enable);
|
|
std::string expToString(__int64 exp);
|
|
/// 2011.02.09 - prodongi
|
|
void jpToString(__int64 jp, std::string& str);
|
|
void convertMagicTypeToString(int type, std::string& str); /// 2011.03.07 왜 속성을 magic으로 쓰고들 있나?? - prodongi
|
|
void getNpcIconAniName(std::string& str, unsigned int type = 0, unsigned int status = 0); /// 2011.03.18 npc의 아이콘 ani name을 얻어온다 - prodongi
|
|
void getDungeonGateIconAniName(std::string& str, int type); /// 2011.07.21 - prodongi
|
|
// 2012.02.03 - servantes : 백분율에 따라 게이지의 텍스처를 바꿔 준다
|
|
// int nPixelHeight : 텍스처가 4,5 .. 펙셀짜리로 여러가지가 있다. 이 중 선택한다, UI 툴 또는 UI 담당자에게 확인
|
|
bool setHPGaugeTexture(int percent, KUIControlGauge* pGauge, int nPixelHeight = 4);
|
|
bool isLastBR(char const* str); /// 2011.04.22 <br>이 str 맨 마지막 태그 안에 들어 있는지 체크
|
|
bool isFirstBR(char const* str);/// 2011.04.27 <br>이 str 맨 처음 태그 안에 들어 있는지 체크
|
|
bool setSkillCardIcon(KUIControlMultiIcon* icon, int itemCode, bool isEquip = false); /// 2011.08.03 - prodongi
|
|
// 2013. 03. 22 - gmpbigsun : 봉인카드에 대한 아이콘처리
|
|
bool setSummonCardIcon( KUIControlMultiIcon* pIcon, SInventorySlot const* pslot );
|
|
bool setSummonCardIcon( KUIControlMultiIcon* pIcon, int nItemCode, int nSummonID, int nEnhance, int nFlag, int nDurability = 0 );
|
|
bool setSummonCardIcon( KUIControlMultiIcon* pIcon, int nItemCode, int nSummonID, int nEnhance, XFlag<int> tFlag, int nDurability = 0 );
|
|
bool setSummonCardIconForPortrait( KUIControlMultiIcon* pIcon, SInventorySlot const* pSlot ); //20130409 편성창 오른쪽 초상화
|
|
void ResetMultiIcon( KUIControlMultiIcon* pIcon, const int nBegin, const int nEnd );
|
|
|
|
bool isEmptyCreatureCard(int itemCode, XFlag<int> const& xFlag); /// 2011.10.21 빈카드인지 - prodongi
|
|
|
|
// Azia Mafia ++
|
|
bool isWearableSkillCardItem(const ItemBaseEx_info* pItem, SSkillSlotMgr& SkillSlotMgr);
|
|
//
|
|
|
|
// return cost
|
|
// 0 : error
|
|
// 1 : 내구도 있음
|
|
// 2 : 내구도 없음
|
|
int refreshItemDurability(SInventorySlot* pSlot, KUIWnd* pGauge, float fGaugeWidth);
|
|
void UISendStringMessage(SGameManager* pGameManager, int nToUI, const char* pSendStr, bool bForceSend = false);
|