1131 lines
36 KiB
C++
1131 lines
36 KiB
C++
#pragma once
|
|
|
|
#include <queue>
|
|
|
|
//#include "SUIWnd.h"
|
|
#include "SUIProperty.h" // sonador #2.1.2.4.3 팻 조작 UI 연동
|
|
|
|
// forward declaration
|
|
class SUIDisplayInfo;
|
|
class SUIAuctionSearchWnd;
|
|
class SUIAuctionRegisterWnd;
|
|
class SUIAuctionTenderWnd;
|
|
class SUIAuctionDepositWnd;
|
|
class KUIControIStringList;
|
|
class KUIControlEdit;
|
|
class KUIControlCheck;
|
|
class SInventorySlot;
|
|
|
|
/// auction components
|
|
namespace auction {
|
|
|
|
namespace rule {
|
|
|
|
const DWORD DEFAULT_REQ_DELAY = 1000;
|
|
const DWORD SEARCH_REQ_DELAY = 3000;
|
|
const int INPUT_NUMBER_LIMIT = 17; // 숫자 12개 "," 3개
|
|
const unsigned __int64 MAX_PRICE = 9223372036854775807; ///< 아이템 최대 가격
|
|
|
|
const __int64 PRICE_COLOR_CUT_1 = 1000000000000; // Price color division section 1
|
|
const __int64 PRICE_COLOR_CUT_2 = 100000000000; // Price color division section 2
|
|
const __int64 PRICE_COLOR_CUT_3 = 10000000000; // Price color division section 3
|
|
const __int64 PRICE_COLOR_CUT_4 = 1000000000; // Price color division section 4
|
|
const __int64 PRICE_COLOR_CUT_5 = 100000000; // Price color division section 5
|
|
const __int64 PRICE_COLOR_CUT_6 = 10000000; // Price color division section 6
|
|
const __int64 PRICE_COLOR_CUT_7 = 1000000; // Price color division section 7
|
|
|
|
//AziaMafia HDV Taxe Time
|
|
|
|
const float COMMISSION_SHORT_RATIO = 0.03f;
|
|
const float COMMISSION_MIDDLE_RATIO = 0.04f;
|
|
const float COMMISSION_LONG_RATIO = 0.05f;
|
|
const float PURCHASE_RATIO = 0.0f;
|
|
const float TENDER_RATIO = 0.01f;
|
|
/*
|
|
const float COMMISSION_SHORT_RATIO = 0.00f;
|
|
const float COMMISSION_MIDDLE_RATIO = 0.00f;
|
|
const float COMMISSION_LONG_RATIO = 0.00f;
|
|
const float PURCHASE_RATIO = 0.0f;
|
|
const float TENDER_RATIO = 0.01f;
|
|
*/
|
|
//AziaMafia HDV Taxe Time
|
|
|
|
|
|
|
|
enum DURATION {
|
|
DUR_SHORT,
|
|
DUR_MIDDLE,
|
|
DUR_LONG,
|
|
DUR_MAX,
|
|
};
|
|
|
|
void NormalizeBasePrice( money_t& nPrice );
|
|
void NormalizePurchasePrice( money_t& nPrice );
|
|
std::string GetColorTagByPrice( money_t nGold );
|
|
KColor GetColorValueByPrice( money_t nGold );
|
|
money_t GetBiddablePrice( money_t nBasePrice );
|
|
money_t GetPurchasePriceBasedOn( money_t nBasePrice );
|
|
money_t GetGuaranteeBasedOn( DURATION dur, money_t nBasePrice );
|
|
money_t GetPriceFrom( KUIControlEdit* pEdit );
|
|
void SetPriceTo( KUIControlEdit* pEdit, money_t nPrice );
|
|
void SetPriceTo( KUIControlStatic* pStatic, money_t nPrice );
|
|
|
|
}
|
|
|
|
template< typename T >
|
|
struct ColumnCompareLessThen { bool operator()( const T& lhs, const T& rhs ) const { return lhs < rhs; } };
|
|
|
|
template< typename T >
|
|
struct ColumnCompareMoreThen { bool operator()( const T& lhs, const T& rhs ) const { return rhs < lhs; } };
|
|
|
|
struct RankCompareLessThen { bool operator()( const std::string& lhs, const std::string& rhs ) const
|
|
{ if (lhs == GetStringDB().GetString( 6370 )) return true; if (rhs == GetStringDB().GetString( 6370 )) return false; return lhs < rhs; } };
|
|
struct RankCompareMoreThen { bool operator()( const std::string& lhs, const std::string& rhs ) const
|
|
{ if (lhs == GetStringDB().GetString( 6370 )) return false; if (rhs == GetStringDB().GetString( 6370 )) return true; else return rhs < lhs; } };
|
|
|
|
|
|
const char* GetAuctionDuration( int nAuctionDurationType );
|
|
const char* GetAuctionStatus( unsigned char ucAuctionStatus );
|
|
const char* GetAuctionBiddedStatus( unsigned char ucAuctionBiddedStatus );
|
|
const char* GetAuctionDepositStatus( unsigned char ucAuctionKeepingType );
|
|
|
|
class kui_window_item_icon_property : public sui::kui_window_property
|
|
{
|
|
public:
|
|
kui_window_item_icon_property( const char* name, SUIDisplayInfo* display, SUIWnd* pParent, SInventoryMgr& inven )
|
|
: kui_window_property( name ), m_display( display ), m_pParent( pParent ), m_InventoryMgr( inven ) {}
|
|
kui_window_item_icon_property( const kui_window_item_icon_property& rhs )
|
|
: kui_window_property( rhs ), m_display( rhs.m_display ), m_pParent( rhs.m_pParent ), m_InventoryMgr( rhs.m_InventoryMgr ) {}
|
|
virtual ~kui_window_item_icon_property() {}
|
|
virtual void on_update( property& data );
|
|
virtual sui::kui_window_property& set_value( KUIWnd* value );
|
|
protected:
|
|
SUIDisplayInfo* m_display;
|
|
SUIWnd* m_pParent;
|
|
class SInventoryMgr& m_InventoryMgr;
|
|
};
|
|
|
|
class kui_window_purchase_price_caption_property : public sui::kui_window_caption_property
|
|
{
|
|
public:
|
|
kui_window_purchase_price_caption_property( const char* name, const char* caption_decorator = 0, const char* alternative_string = 0 )
|
|
: kui_window_caption_property( name, caption_decorator )
|
|
, m_alternative_string( alternative_string )
|
|
{
|
|
}
|
|
kui_window_purchase_price_caption_property( const kui_window_purchase_price_caption_property& rhs )
|
|
: kui_window_caption_property( rhs )
|
|
, m_alternative_string( rhs.m_alternative_string )
|
|
{}
|
|
virtual ~kui_window_purchase_price_caption_property() {}
|
|
virtual void get_caption_string( property& data, std::string& caption )
|
|
{
|
|
//assert( data.get_class() == CID_INT );
|
|
if( data.get_class() == CID_INT )
|
|
{
|
|
int nPurchasePrice = data.get_int_value();
|
|
if( nPurchasePrice > 0 )
|
|
caption += sui::helper::int_to_comma_numeric( nPurchasePrice );
|
|
}
|
|
else if( data.get_class() == CID_INT64 )
|
|
{
|
|
money_t nPurchasePrice = money_t( data.get_int64_value() );
|
|
if( nPurchasePrice > 0 )
|
|
caption += sui::helper::int_to_comma_numeric( nPurchasePrice.getAmount() );
|
|
}
|
|
else
|
|
caption += m_alternative_string;
|
|
}
|
|
protected:
|
|
std::string m_alternative_string;
|
|
};
|
|
|
|
class kui_window_limittime_caption_property : public sui::kui_window_caption_property
|
|
{
|
|
public:
|
|
kui_window_limittime_caption_property( const char* name, const char* caption_decorator = 0 ) : kui_window_caption_property( name, caption_decorator ) {}
|
|
kui_window_limittime_caption_property( const kui_window_limittime_caption_property& rhs ) : kui_window_caption_property( rhs ) {}
|
|
virtual ~kui_window_limittime_caption_property() {}
|
|
virtual void get_caption_string( property& data, std::string& caption )
|
|
{
|
|
assert( data.get_class() == CID_INT );
|
|
int nDuration = data.get_int_value();
|
|
const char* szDuration = GetAuctionDuration( nDuration );
|
|
if( szDuration )
|
|
caption += szDuration;
|
|
}
|
|
};
|
|
|
|
class kui_window_status_caption_property : public sui::kui_window_caption_property
|
|
{
|
|
public:
|
|
kui_window_status_caption_property( const char* name, const char* caption_decorator = 0 ) : kui_window_caption_property( name, caption_decorator ) {}
|
|
kui_window_status_caption_property( const kui_window_status_caption_property& rhs ) : kui_window_caption_property( rhs ) {}
|
|
virtual ~kui_window_status_caption_property() {}
|
|
virtual void get_caption_string( property& data, std::string& caption )
|
|
{
|
|
assert( data.get_class() == CID_UCHAR );
|
|
unsigned char status = data.get_uchar_value();
|
|
const char* szStatus = GetAuctionStatus( status );
|
|
if( szStatus )
|
|
caption += szStatus;
|
|
}
|
|
};
|
|
|
|
class kui_window_bidded_status_caption_property : public sui::kui_window_caption_property
|
|
{
|
|
public:
|
|
kui_window_bidded_status_caption_property( const char* name, const char* caption_decorator = 0 ) : kui_window_caption_property( name, caption_decorator ) {}
|
|
kui_window_bidded_status_caption_property( const kui_window_bidded_status_caption_property& rhs ) : kui_window_caption_property( rhs ) {}
|
|
virtual ~kui_window_bidded_status_caption_property() {}
|
|
virtual void get_caption_string( property& data, std::string& caption )
|
|
{
|
|
assert( data.get_class() == CID_UCHAR );
|
|
unsigned char status = data.get_uchar_value();
|
|
const char* szStatus = GetAuctionBiddedStatus( status );
|
|
if( szStatus )
|
|
caption += szStatus;
|
|
}
|
|
};
|
|
|
|
class kui_window_deposit_status_caption_property : public sui::kui_window_caption_property
|
|
{
|
|
public:
|
|
struct StatusInfo
|
|
{
|
|
StatusInfo( int nKeepingType, bool bIsExistRelatedItem = false, int nRelatedItemCode = 0, int nRelatedItemEnhance = 0, int nRelatedItemLevel = 0 )
|
|
: keeping_type ( nKeepingType )
|
|
, is_exist_related_item ( bIsExistRelatedItem )
|
|
, related_item_code ( nRelatedItemCode )
|
|
, related_item_enhance ( nRelatedItemEnhance )
|
|
, related_item_level ( nRelatedItemLevel )
|
|
{
|
|
}
|
|
StatusInfo( const StatusInfo& other )
|
|
: keeping_type ( other.keeping_type )
|
|
, is_exist_related_item ( other.is_exist_related_item )
|
|
, related_item_code ( other.related_item_code )
|
|
, related_item_enhance ( other.related_item_enhance )
|
|
, related_item_level ( other.related_item_level )
|
|
{
|
|
}
|
|
// sonador 7.0.25 proxy_list 정렬 타입 불일치 문제 수정
|
|
bool operator < ( const StatusInfo& rhs ) const
|
|
{
|
|
return keeping_type < rhs.keeping_type;
|
|
}
|
|
unsigned char keeping_type; ///< 보관 타입(AuctionBase.h의 enum KEEPING_TYPE 참조)
|
|
bool is_exist_related_item; ///< 관련 아이템 정보가 있는가?
|
|
ItemBase::ItemCode related_item_code; ///< 관련 아이템 코드(보관 아이템이 돈일 경우만 사용됨)
|
|
int related_item_enhance; ///< 관련 아이템 강화 레벨(보관 아이템이 돈일 경우만 사용됨)
|
|
int related_item_level; ///< 관련 아이템 대장작 레벨(보관 아이템이 돈일 경우만 사용됨)
|
|
};
|
|
kui_window_deposit_status_caption_property( const char* name, const char* caption_decorator = 0 ) : kui_window_caption_property( name, caption_decorator ) {}
|
|
kui_window_deposit_status_caption_property( const kui_window_deposit_status_caption_property& rhs ) : kui_window_caption_property( rhs ) {}
|
|
virtual ~kui_window_deposit_status_caption_property() {}
|
|
virtual void get_caption_string( property& data, std::string& caption );
|
|
};
|
|
|
|
class kui_window_storabletime_caption_property : public sui::kui_window_caption_property
|
|
{
|
|
public:
|
|
kui_window_storabletime_caption_property( const char* name, const char* caption_decorator = 0 ) : kui_window_caption_property( name, caption_decorator ) {}
|
|
kui_window_storabletime_caption_property( const kui_window_storabletime_caption_property& rhs ) : kui_window_caption_property( rhs ) {}
|
|
virtual ~kui_window_storabletime_caption_property() {}
|
|
virtual void get_caption_string( property& data, std::string& caption )
|
|
{
|
|
assert( data.get_class() == CID_INT );
|
|
int second = data.get_int_value();
|
|
int day = (int)( (float)second / 86400.0f );
|
|
|
|
if( day > 0 )
|
|
{
|
|
char buffer[ 32 ];
|
|
itoa( day, buffer, 10 );
|
|
caption += buffer;
|
|
caption += S( 9103 ); // 일
|
|
}
|
|
else
|
|
{
|
|
caption += S( 9104 ); // 하루 이내
|
|
}
|
|
}
|
|
};
|
|
|
|
class NoticeBox
|
|
{
|
|
public:
|
|
NoticeBox( DWORD dwFrequency = 10000 ) : m_dwCurrentTime( 0 ), m_dwFrequency( dwFrequency ), m_nIndex( 0 ), m_pOutput( 0 )
|
|
{
|
|
}
|
|
~NoticeBox()
|
|
{
|
|
}
|
|
|
|
void Initialize( KUIWnd* pOutput );
|
|
void Process( DWORD dwTime );
|
|
void RandomShuffle();
|
|
NoticeBox& Append( const char* lpszTip );
|
|
NoticeBox& AppendUrgent( const char* lpszTip );
|
|
bool IsFrozen() const;
|
|
void Freeze( const char* lpszTip );
|
|
void Warm();
|
|
void Pass();
|
|
void Output( const char* lpszTip );
|
|
|
|
private:
|
|
|
|
int _GetNextIndex();
|
|
|
|
typedef std::vector< std::string > tip_container_t;
|
|
typedef std::queue< std::string > urgent_tip_container_t;
|
|
|
|
DWORD m_dwCurrentTime;
|
|
DWORD m_dwFrequency;
|
|
tip_container_t m_ctTips;
|
|
urgent_tip_container_t m_ctUrgentTipsQueue;
|
|
int m_nIndex;
|
|
KUIWnd* m_pOutput;
|
|
std::string m_strFreezeMessage;
|
|
};
|
|
|
|
// #2.1.2.12
|
|
|
|
struct ActionEnableProxyListMouseProc : public sui::Action
|
|
{
|
|
ActionEnableProxyListMouseProc( sui::proxy_list& ProxyList ) : Action(), m_ProxyList( ProxyList ) {}
|
|
void operator()() { m_ProxyList.activate_mouse_proc( true ); }
|
|
sui::proxy_list& m_ProxyList;
|
|
};
|
|
struct ActionDisableProxyListMouseProc : public sui::Action
|
|
{
|
|
ActionDisableProxyListMouseProc( sui::proxy_list& ProxyList ) : Action(), m_ProxyList( ProxyList ) {}
|
|
void operator()() { m_ProxyList.activate_mouse_proc( false ); }
|
|
sui::proxy_list& m_ProxyList;
|
|
};
|
|
struct ActionClearProxyList : public sui::Action
|
|
{
|
|
ActionClearProxyList( sui::proxy_list& ProxyList ) : Action(), m_ProxyList( ProxyList ) {}
|
|
void operator()() { m_ProxyList.clear(); m_ProxyList.update_data(); }
|
|
sui::proxy_list& m_ProxyList;
|
|
};
|
|
struct ActionNotice : public sui::Action
|
|
{
|
|
ActionNotice( NoticeBox& noticeBox, const char* lpszMessage ) : m_NoticeBox( noticeBox ), m_strMessage( lpszMessage ) {}
|
|
void operator()() { m_NoticeBox.AppendUrgent( m_strMessage.c_str() ); }
|
|
std::string m_strMessage;
|
|
NoticeBox& m_NoticeBox;
|
|
};
|
|
struct ActionMsgPost : public sui::Action
|
|
{
|
|
ActionMsgPost( SGameManager* pGameManager ) : Action(), m_pGameManager( pGameManager ), m_pMessage( 0 ) {}
|
|
virtual ~ActionMsgPost()
|
|
{
|
|
SAFE_DELETE( m_pMessage );
|
|
}
|
|
virtual void operator()()
|
|
{
|
|
if( m_pMessage )
|
|
{
|
|
m_pGameManager->PostMsgAtDynamic( m_pMessage );
|
|
m_pMessage = 0;
|
|
}
|
|
}
|
|
void SetMsg( SGameMessage* pMessage )
|
|
{
|
|
SAFE_DELETE( m_pMessage );
|
|
m_pMessage = pMessage;
|
|
}
|
|
protected:
|
|
SGameManager* m_pGameManager;
|
|
SGameMessage* m_pMessage;
|
|
};
|
|
|
|
class LazyMsgProc : public sui::ticker
|
|
{
|
|
public:
|
|
struct TypeSatisfier {
|
|
TypeSatisfier( int nMsgType ) : m_nMsgType( nMsgType ) {}
|
|
virtual ~TypeSatisfier() {}
|
|
virtual bool IsSatisfied( SGameMessage* pMessage ) { return ( pMessage->nType == m_nMsgType ) ? true : false; }
|
|
int m_nMsgType;
|
|
};
|
|
struct ResultSatisfier : public TypeSatisfier
|
|
{
|
|
ResultSatisfier( int nRequestMsgID ) : TypeSatisfier( MSG_RESULT ), m_nRequestMsgID( nRequestMsgID ) {}
|
|
virtual ~ResultSatisfier() {}
|
|
virtual bool IsSatisfied( SGameMessage* pMessage );
|
|
int m_nRequestMsgID;
|
|
};
|
|
struct LazyMsg
|
|
{
|
|
LazyMsg() : delay( 0 ), message( 0 ) {}
|
|
~LazyMsg() { SAFE_DELETE( message ); }
|
|
void Clear() { delay = 0; message = 0; }
|
|
void Set( DWORD dwDelay, SGameMessage* pMessage ) { delay = dwDelay; SAFE_DELETE( message ); message = pMessage; }
|
|
DWORD delay;
|
|
SGameMessage* message;
|
|
};
|
|
virtual void Process( DWORD dwTime )
|
|
{
|
|
ticker::tick( dwTime );
|
|
if( _IsIdle() && m_LazyMessage.message )
|
|
{
|
|
m_pPostAction->SetMsg( m_LazyMessage.message );
|
|
_DoActionsInFrequency( m_LazyMessage.delay );
|
|
m_LazyMessage.Clear();
|
|
}
|
|
}
|
|
void PostMsgAtDynamic( SGameMessage* pMessage, DWORD dwDelay = auction::rule::DEFAULT_REQ_DELAY )
|
|
{
|
|
if( _IsIdle() )
|
|
{
|
|
m_pPostAction->SetMsg( pMessage );
|
|
_DoActionsInFrequency( dwDelay );
|
|
}
|
|
else
|
|
{
|
|
m_LazyMessage.Set( dwDelay, pMessage );
|
|
|
|
// notice waiting message & freeze notice box
|
|
m_NoticeBox.Pass();
|
|
m_NoticeBox.Freeze( S( 9108 ) );
|
|
}
|
|
}
|
|
void CancelLazyMessage()
|
|
{
|
|
if( m_LazyMessage.message )
|
|
{
|
|
m_LazyMessage.message = 0;
|
|
m_LazyMessage.delay = 0;
|
|
}
|
|
}
|
|
void AppendAction( sui::ActionBinder* pAction )
|
|
{
|
|
m_ActionBinders.push_back( pAction );
|
|
m_ActionTicker.append_tickable( pAction );
|
|
}
|
|
void AppendSatisfier( TypeSatisfier* pSatisfier )
|
|
{
|
|
m_Satisfiers.push_back( pSatisfier );
|
|
}
|
|
void ProcMsgAtStatic( SGameMessage* pMessage )
|
|
{
|
|
if( !m_Satisfiers.empty() )
|
|
{
|
|
// ticking condition is satisfid ?
|
|
|
|
std::vector< TypeSatisfier* >::iterator i = m_Satisfiers.begin(), e = m_Satisfiers.end();
|
|
for( ; i != e; ++i )
|
|
{
|
|
TypeSatisfier* pSatisfier = *i;
|
|
if( pSatisfier && pSatisfier->IsSatisfied( pMessage ) )
|
|
{
|
|
_Satisfy();
|
|
|
|
// warm notice box & show next message
|
|
if( m_NoticeBox.IsFrozen() )
|
|
{
|
|
m_NoticeBox.Warm();
|
|
m_NoticeBox.Pass();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_Satisfy();
|
|
|
|
// warm notice box & show next message
|
|
if( m_NoticeBox.IsFrozen() )
|
|
{
|
|
m_NoticeBox.Warm();
|
|
m_NoticeBox.Pass();
|
|
}
|
|
}
|
|
}
|
|
|
|
// ctor & dtor
|
|
LazyMsgProc( SGameManager* pGameManager, NoticeBox& noticeBox )
|
|
: m_pGameManager ( pGameManager )
|
|
, m_NoticeBox ( noticeBox )
|
|
, m_pPostAction ( 0 )
|
|
, m_pPoster ( 0 )
|
|
, m_pCurrentFreqTicker ( 0 )
|
|
{
|
|
m_pPostAction = new ActionMsgPost( pGameManager );
|
|
m_pPoster = new sui::ActionBinder( m_pPostAction, 0, 0 );
|
|
AppendAction( m_pPoster );
|
|
enter();
|
|
}
|
|
~LazyMsgProc()
|
|
{
|
|
sui::wipe_seq( m_ActionBinders );
|
|
sui::wipe_seq( m_Satisfiers );
|
|
sui::wipe_seq( m_FreqTickers );
|
|
leave();
|
|
}
|
|
|
|
private:
|
|
|
|
typedef sui::conditional_fixed_rate_one_time_ticker freq_ticker_t;
|
|
SGameManager* m_pGameManager;
|
|
NoticeBox& m_NoticeBox;
|
|
LazyMsg m_LazyMessage;
|
|
ActionMsgPost* m_pPostAction;
|
|
sui::ActionBinder* m_pPoster;
|
|
sui::ticker m_ActionTicker;
|
|
freq_ticker_t* m_pCurrentFreqTicker;
|
|
std::vector< sui::ActionBinder* > m_ActionBinders;
|
|
std::vector< TypeSatisfier* > m_Satisfiers;
|
|
std::vector< freq_ticker_t* > m_FreqTickers;
|
|
|
|
void _DoActionsInFrequency( DWORD dwFrequency )
|
|
{
|
|
if( m_pCurrentFreqTicker )
|
|
remove_tickable( m_pCurrentFreqTicker );
|
|
m_pCurrentFreqTicker = _GetFreqTicker( dwFrequency );
|
|
if( m_pCurrentFreqTicker )
|
|
{
|
|
m_pCurrentFreqTicker->append_tickable( &m_ActionTicker );
|
|
append_tickable( m_pCurrentFreqTicker );
|
|
}
|
|
}
|
|
freq_ticker_t* _GetFreqTicker( DWORD dwFrequency )
|
|
{
|
|
if( !m_FreqTickers.empty() )
|
|
{
|
|
std::vector< sui::conditional_fixed_rate_one_time_ticker* >::iterator i = m_FreqTickers.begin(), e = m_FreqTickers.end();
|
|
for( ; i != e; ++i )
|
|
{
|
|
sui::conditional_fixed_rate_one_time_ticker* pFreqTicker = *i;
|
|
if( pFreqTicker && dwFrequency == pFreqTicker->frequency() )
|
|
return pFreqTicker;
|
|
}
|
|
}
|
|
freq_ticker_t* pFreqTicker = new sui::conditional_fixed_rate_one_time_ticker( dwFrequency );
|
|
m_FreqTickers.push_back( pFreqTicker );
|
|
return pFreqTicker;
|
|
}
|
|
void _Satisfy()
|
|
{
|
|
if( m_pCurrentFreqTicker )
|
|
m_pCurrentFreqTicker->satisfy();
|
|
}
|
|
bool _IsIdle() const
|
|
{
|
|
return m_ActionTicker.is_on_tick() ? false : true;
|
|
}
|
|
|
|
};
|
|
|
|
class CategoryInterface : public SUIWnd
|
|
{
|
|
public:
|
|
|
|
CategoryInterface( SGameManager* pGameManager ) : SUIWnd( pGameManager ) {}
|
|
virtual ~CategoryInterface() {}
|
|
virtual void RefreshCategory() = 0;
|
|
};
|
|
|
|
// { 3.1.5 검색 카테고리 수정.sonador
|
|
// namespace dummy auction category resource
|
|
/*namespace acr {
|
|
|
|
class AuctionCategoryResourceDB
|
|
{
|
|
public:
|
|
struct CategoryInfo
|
|
{
|
|
CategoryInfo()
|
|
: category_id ( 0 )
|
|
, sub_category_id ( -1 )
|
|
, name_id ( 0 )
|
|
, local_flag ( 0 )
|
|
{
|
|
}
|
|
int category_id;
|
|
int sub_category_id;
|
|
int name_id;
|
|
int local_flag;
|
|
|
|
// help methods
|
|
bool is_main_category() const { return ( sub_category_id == -1 ) ? true : false; }
|
|
bool is_sub_category() const { return !is_main_category(); }
|
|
};
|
|
typedef std::vector< CategoryInfo* > category_info_container_t;
|
|
|
|
AuctionCategoryResourceDB()
|
|
{
|
|
Load();
|
|
}
|
|
~AuctionCategoryResourceDB()
|
|
{
|
|
sui::wipe_seq( m_CategoryInfos );
|
|
}
|
|
void GetCategoryInfo( category_info_container_t& out, int nLocalFlag )
|
|
{
|
|
category_info_container_t::iterator it = m_CategoryInfos.begin(), end = m_CategoryInfos.end();
|
|
for( ; it != end; ++it )
|
|
{
|
|
CategoryInfo* pInfo = *it;
|
|
if( pInfo && pInfo->local_flag == nLocalFlag )
|
|
{
|
|
out.push_back( pInfo );
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
void Load()
|
|
{
|
|
// import dummy resource for testing
|
|
CategoryInfo* pInfo = 0;
|
|
// #1
|
|
pInfo = new CategoryInfo;
|
|
pInfo->category_id = 0;
|
|
pInfo->sub_category_id = -1;
|
|
pInfo->name_id = 0;
|
|
pInfo->local_flag = 0;
|
|
m_CategoryInfos.push_back( pInfo );
|
|
// #2
|
|
pInfo = new CategoryInfo;
|
|
pInfo->category_id = 0;
|
|
pInfo->sub_category_id = 0;
|
|
pInfo->name_id = 0;
|
|
pInfo->local_flag = 0;
|
|
m_CategoryInfos.push_back( pInfo );
|
|
// #3
|
|
pInfo = new CategoryInfo;
|
|
pInfo->category_id = 0;
|
|
pInfo->sub_category_id = 1;
|
|
pInfo->name_id = 0;
|
|
pInfo->local_flag = 0;
|
|
m_CategoryInfos.push_back( pInfo );
|
|
// #4
|
|
pInfo = new CategoryInfo;
|
|
pInfo->category_id = 1;
|
|
pInfo->sub_category_id = -1;
|
|
pInfo->name_id = 0;
|
|
pInfo->local_flag = 1;
|
|
m_CategoryInfos.push_back( pInfo );
|
|
}
|
|
|
|
category_info_container_t m_CategoryInfos;
|
|
};
|
|
|
|
AuctionCategoryResourceDB& GetAuctionCategoryResourceDB();
|
|
|
|
}*/
|
|
// } 3.1.5 검색 카테고리 수정.sonador
|
|
|
|
} // namespace auction
|
|
|
|
/// auction window main frame ----------------------------------------------------------------------
|
|
|
|
class SUIAuctionWnd : public SUIWnd
|
|
{
|
|
public:
|
|
|
|
enum CATEGORY { SEARCH, REGISTER, TENDER, DEPOSIT, MAX };
|
|
enum OFFSET { CATEGORY_X = 6, CATEGORY_Y = 57 };
|
|
|
|
SUIAuctionWnd( SGameManager* pGameManager, SUIDisplayInfo* pDisplayInfo )
|
|
: SUIWnd ( pGameManager )
|
|
, m_pDisplayInfo ( pDisplayInfo )
|
|
, m_NoticeBox ( 5000 )
|
|
, m_LazyMsgProc ( pGameManager, m_NoticeBox )
|
|
, m_pCtrlCategoryTab( 0 )
|
|
, m_pCtrlNoticeBox ( 0 )
|
|
{
|
|
}
|
|
~SUIAuctionWnd()
|
|
{
|
|
}
|
|
|
|
virtual void Process( DWORD dwTime );
|
|
virtual bool InitControls( KPoint kPos );
|
|
virtual bool InitData( bool bReload = false );
|
|
virtual void* Perform( KID id, KArg& msg );
|
|
virtual void PumpUpMessage( LPCTSTR lpszControlID, DWORD nMessage, DWORD lparam, DWORD wparam );
|
|
virtual void ProcMsgAtStatic( SGameMessage* pMsg );
|
|
virtual void OnNotifyUIWindowOpen( bool bOpen, bool bLimitWnd = true );
|
|
virtual void CheckManager();
|
|
|
|
// 2010.08.12 - prodongi
|
|
bool isSearchEditFocus() const;
|
|
|
|
private:
|
|
|
|
void _Refresh();
|
|
void _UpdateHoldMoney();
|
|
void _UpdateNoticeMessage( const char* msg );
|
|
|
|
void _SelectCategory( CATEGORY index );
|
|
|
|
SUIDisplayInfo* m_pDisplayInfo;
|
|
auction::NoticeBox m_NoticeBox;
|
|
auction::LazyMsgProc m_LazyMsgProc;
|
|
|
|
// controls
|
|
|
|
KUISimpleTabControl* m_pCtrlCategoryTab;
|
|
KUIControlStatic* m_pCtrlMoneyStatic;
|
|
KUIControlStatic* m_pCtrlNoticeBox;
|
|
|
|
auction::CategoryInterface* m_arCategoryWnd[ CATEGORY::MAX ];
|
|
};
|
|
|
|
/// search products category window ----------------------------------------------------------------
|
|
|
|
class SUIAuctionSearchWnd : public auction::CategoryInterface
|
|
{
|
|
public:
|
|
|
|
enum {
|
|
TREE_MAX = 20,
|
|
LIST_MAX = 8,
|
|
LIST_OFFSET = 37,
|
|
};
|
|
|
|
enum COLUMN {
|
|
ITEM,
|
|
SELLER,
|
|
LIMITTIME,
|
|
TENDER,
|
|
PURCHASE,
|
|
RANK,
|
|
MAX,
|
|
};
|
|
|
|
SUIAuctionSearchWnd( SGameManager* pGameManager, SUIDisplayInfo* pDisplayInfo, auction::NoticeBox& TipMgr, auction::LazyMsgProc& LazyMsgPoster )
|
|
: CategoryInterface ( pGameManager )
|
|
, m_pDisplayInfo ( pDisplayInfo )
|
|
, m_NoticeBox ( TipMgr )
|
|
, m_LazyMsgPoster ( LazyMsgPoster )
|
|
, m_pSearchEdit ( 0 )
|
|
, m_pTreeControl ( 0 )
|
|
, m_ItemList ( this, "item_list", LIST_MAX, LIST_OFFSET )
|
|
, m_SelectedItem ( this, "item_selected" , 1 )
|
|
, m_pCtrlCurrentPage( 0 )
|
|
, m_pCtrlEndPage ( 0 )
|
|
, m_pTenderButton ( 0 )
|
|
, m_pPurchaseButton ( 0 )
|
|
, m_pEditBid ( 0 )
|
|
, m_nSavedSortingState( COLUMN::ITEM )
|
|
, m_bMaintainListState( false )
|
|
{
|
|
::memset( m_bSortButtonState, 0, sizeof( m_bSortButtonState ) );
|
|
}
|
|
// 2010.04.22 auction::search::deco_list_item_l 메모리 해제 때문에 cpp로 뺐습니다. - prodongi
|
|
~SUIAuctionSearchWnd();
|
|
// {
|
|
// }
|
|
|
|
virtual void Process( DWORD dwTime );
|
|
virtual bool InitControls( KPoint kPos );
|
|
virtual bool InitData( bool bReload = false );
|
|
virtual void* Perform( KID id, KArg& msg );
|
|
virtual void PumpUpMessage( LPCTSTR lpszControlID, DWORD nMessage, DWORD lparam, DWORD wparam );
|
|
virtual void ProcMsgAtStatic( SGameMessage* pMsg );
|
|
virtual void OnNotifyUIWindowOpen( bool bOpen, bool bLimitWnd = true );
|
|
virtual DWORD OnMouseMessage( DWORD dwMessage, int x, int y );
|
|
void RefreshCategory();
|
|
// 2010.08.12 - prodongi
|
|
bool isSearchEditFocus() const { return m_pSearchEdit->HasFocus(); }
|
|
void enterSearch();
|
|
|
|
private:
|
|
|
|
struct ItemCategoryInfo
|
|
{
|
|
ItemCategoryInfo() : name( "" ), categoryID( -1 ), subCategoryID( -1 )
|
|
{
|
|
}
|
|
ItemCategoryInfo( const char* lpszName, int nGroupID = -1, int nClassID = - 1 ) : name( lpszName ), categoryID( nGroupID ), subCategoryID( nClassID )
|
|
{
|
|
}
|
|
ItemCategoryInfo( const ItemCategoryInfo& rhs ) : name( rhs.name ), categoryID( rhs.categoryID ), subCategoryID( rhs.subCategoryID )
|
|
{
|
|
}
|
|
ItemCategoryInfo& operator = ( const ItemCategoryInfo& rhs )
|
|
{
|
|
if( this == &rhs )
|
|
return *this;
|
|
name = rhs.name;
|
|
categoryID = rhs.categoryID;
|
|
subCategoryID = rhs.subCategoryID;
|
|
return *this;
|
|
}
|
|
bool operator == ( const ItemCategoryInfo& rhs ) const
|
|
{
|
|
return ( categoryID == rhs.categoryID && subCategoryID == rhs.subCategoryID ) ? true : false;
|
|
}
|
|
bool operator != ( const ItemCategoryInfo& rhs ) const
|
|
{
|
|
return !operator == ( rhs );
|
|
}
|
|
std::string name;
|
|
int categoryID;
|
|
int subCategoryID;
|
|
};
|
|
typedef sui::proxy_tree< ItemCategoryInfo > search_tree_t;
|
|
typedef sui::proxy_list item_list_t;
|
|
|
|
struct ItemImporter {
|
|
typedef TS_SC_AUCTION_SEARCH::SEARCHED_AUCTION_INFO item_t;
|
|
ItemImporter ( SUIAuctionSearchWnd* wnd, item_list_t& list ) : m_searchwnd( wnd ), m_target_list( list ) {}
|
|
void operator()( item_t& item );
|
|
item_list_t& m_target_list;
|
|
SUIAuctionSearchWnd* m_searchwnd;
|
|
};
|
|
|
|
void _PrepareControls();
|
|
void _RefreshTree();
|
|
void _RefreshKeyword();
|
|
void _UpdatePage( int nCurrent = 1, int nTotal = 1 );
|
|
void _UpdateCurrentCategory( const ItemCategoryInfo& info = ItemCategoryInfo() );
|
|
void _UpdateBidablePrice( money_t nPrice = money_t( 0 ) );
|
|
void _RequestItemList( int nCategoryID = 0, int nSubCategoryID = 0, int nPage = 1 );
|
|
void _RequestBid();
|
|
void _RequestInstantPurchase();
|
|
void _GetTemporaryListData();
|
|
void _GetTreeItemCaption( const search_tree_t::node& node, std::string& caption );
|
|
void _SortItemListByColumn( COLUMN column, bool maintain = false );
|
|
// 2010.08.25 - prodongi
|
|
int GetCheckBoxValue( const char * pControlName );
|
|
|
|
SUIDisplayInfo* m_pDisplayInfo;
|
|
auction::NoticeBox& m_NoticeBox;
|
|
auction::LazyMsgProc& m_LazyMsgPoster;
|
|
|
|
KUIControlEdit* m_pSearchEdit;
|
|
KUIControlEdit* m_pEditBid;
|
|
KUIControIStringList* m_pTreeControl;
|
|
KUIControlStatic* m_pCtrlCurrentPage;
|
|
KUIControlStatic* m_pCtrlEndPage;
|
|
KUIControlButton* m_pTenderButton;
|
|
KUIControlButton* m_pPurchaseButton;
|
|
bool m_bSortButtonState[ COLUMN::MAX ];
|
|
|
|
search_tree_t m_SearchTree;
|
|
item_list_t m_ItemList;
|
|
item_list_t m_SelectedItem;
|
|
ItemCategoryInfo m_CurrentCategory;
|
|
sui::Page m_Page;
|
|
COLUMN m_nSavedSortingState;
|
|
bool m_bMaintainListState;
|
|
// 2010.08.25 - prodongi
|
|
bool m_checkEnableEquipItemShow;
|
|
};
|
|
|
|
/// register products window -----------------------------------------------------------------------
|
|
|
|
class SUIAuctionRegisterWnd : public auction::CategoryInterface
|
|
{
|
|
public:
|
|
|
|
enum {
|
|
LIST_MAX = 9,
|
|
LIST_OFFSET = 37,
|
|
};
|
|
|
|
enum COLUMN {
|
|
ITEM,
|
|
STATE,
|
|
LIMITTIME,
|
|
TENDER,
|
|
PURCHASE,
|
|
RANK,
|
|
MAX,
|
|
};
|
|
|
|
SUIAuctionRegisterWnd( SGameManager* pGameManager, SUIDisplayInfo* pDisplayInfo, auction::NoticeBox& TipMgr, auction::LazyMsgProc& LazyMsgPoster )
|
|
: CategoryInterface ( pGameManager )
|
|
, m_pDisplayInfo ( pDisplayInfo )
|
|
, m_NoticeBox ( TipMgr )
|
|
, m_LazyMsgPoster ( LazyMsgPoster )
|
|
, m_hRegisterItemCandidate ( 0 )
|
|
, m_nCurrentDuration ( auction::rule::DUR_SHORT )
|
|
, m_pCtrlCurrentPage ( 0 )
|
|
, m_pCtrlEndPage ( 0 )
|
|
, m_pCtrlRegisterSlotFrame ( 0 )
|
|
, m_ItemList ( this, "item_list", LIST_MAX, LIST_OFFSET )
|
|
, m_SelectedItem ( this, "item_selected" , 1 )
|
|
, m_pEditBasePrice ( 0 )
|
|
, m_pEditPurchasePrice ( 0 )
|
|
, m_pStaticGuarantee ( 0 )
|
|
, m_pBtnRegister ( 0 )
|
|
, m_nSavedSortingState ( COLUMN::ITEM )
|
|
, m_bMaintainListState ( false )
|
|
{
|
|
::memset( m_bSortButtonState, 0, sizeof( m_bSortButtonState ) );
|
|
::memset( m_pCheckAvailableTime, 0, sizeof( m_pCheckAvailableTime ) );
|
|
}
|
|
~SUIAuctionRegisterWnd();
|
|
|
|
virtual bool InitControls( KPoint kPos );
|
|
virtual bool InitData( bool bReload = false );
|
|
virtual void* Perform( KID id, KArg& msg );
|
|
virtual void PumpUpMessage( LPCTSTR lpszControlID, DWORD nMessage, DWORD lparam, DWORD wparam );
|
|
virtual void ProcMsgAtStatic( SGameMessage* pMsg );
|
|
virtual void OnNotifyUIWindowOpen( bool bOpen, bool bLimitWnd = true );
|
|
virtual DWORD OnMouseMessage( DWORD dwMessage, int x, int y );
|
|
void RefreshCategory();
|
|
|
|
private:
|
|
|
|
struct CachedPrice
|
|
{
|
|
struct Key
|
|
{
|
|
Key() : nItemCode( 0 ), nItemCount( 0 ) {}
|
|
Key( int nCode, count_t nCount ) : nItemCode( nCode ), nItemCount( nCount ) {}
|
|
bool operator < ( const Key& rhs ) const
|
|
{
|
|
if( nItemCode < rhs.nItemCode )
|
|
return true;
|
|
if( nItemCode == rhs.nItemCode && nItemCount < rhs.nItemCount )
|
|
return true;
|
|
return false;
|
|
}
|
|
int nItemCode;
|
|
count_t nItemCount;
|
|
};
|
|
CachedPrice() : nBase( 0 ), nPurchase( 0 ) {}
|
|
CachedPrice( money_t base, money_t purchase ) : nBase( base ), nPurchase( purchase ) {}
|
|
money_t nBase;
|
|
money_t nPurchase;
|
|
};
|
|
|
|
typedef sui::proxy_list item_list_t;
|
|
typedef std::map< CachedPrice::Key, CachedPrice > price_cache_t;
|
|
|
|
struct ItemImporter {
|
|
typedef TS_SC_AUCTION_SELLING_LIST::REGISTERED_AUCTION_INFO item_t;
|
|
ItemImporter( item_list_t& list ) : m_target_list( list ) {}
|
|
void operator()( item_t& item );
|
|
item_list_t& m_target_list;
|
|
};
|
|
|
|
void _GetTemporaryListData();
|
|
void _SortItemListByColumn( COLUMN id, bool maintain = false );
|
|
void _RequestSellingList( int nPage = 1 );
|
|
void _RequestItemRegistration();
|
|
void _RegisterItem();
|
|
void _RequestItemDeregistration();
|
|
void _DeregisterItem();
|
|
void _RequestOpenInventory();
|
|
void _AcceptDrag( SInventorySlot* pSlot, const char* lpszDragSound );
|
|
|
|
void _PrepareControls();
|
|
void _UpdatePage( int nCurrent = 1, int nTotal = 1 );
|
|
void _UpdateRegisterSlot( SInventorySlot* pSlot = 0, count_t nCount = count_t( 0 ) );
|
|
void _UpdateRegisterPrice( SInventorySlot* pSlot = 0, count_t nCount = count_t( 0 ) );
|
|
void _UpdateRegisterDuration( auction::rule::DURATION dur );
|
|
void _UpdateRegisterButton();
|
|
void _UpdateBasePrice( money_t nPrice );
|
|
void _UpdatePurchasePrice( money_t nPrice );
|
|
|
|
bool _IsRegisterableItem( AR_HANDLE hItem ) const;
|
|
bool _IsWearableItem( int nItemCode ) const;
|
|
bool _IsCreatureCard( int nItemCode ) const;
|
|
bool _IsExistInInventory( int nItemCode ) const;
|
|
void _NormalizePrice();
|
|
TS_CS_AUCTION_REGISTER::AUCTION_DURATION_TYPE _GetDurationType( auction::rule::DURATION dur );
|
|
|
|
// rules...
|
|
money_t _GetMarketPrice( int nItemCode,int nLevel ) const;
|
|
|
|
SUIDisplayInfo* m_pDisplayInfo;
|
|
auction::NoticeBox& m_NoticeBox;
|
|
auction::LazyMsgProc& m_LazyMsgPoster;
|
|
AR_HANDLE m_hRegisterItemCandidate;
|
|
auction::rule::DURATION m_nCurrentDuration;
|
|
|
|
bool m_bSortButtonState[ COLUMN::MAX ];
|
|
KUIControlStatic* m_pCtrlCurrentPage;
|
|
KUIControlStatic* m_pCtrlEndPage;
|
|
KUIControlStatic* m_pCtrlRegisterSlotFrame;
|
|
sui::kui_updatable_window_array m_RegisterSlot;
|
|
KUIControlCheck* m_pCheckAvailableTime[ auction::rule::DUR_MAX ];
|
|
KUIControlEdit* m_pEditBasePrice;
|
|
KUIControlEdit* m_pEditPurchasePrice;
|
|
KUIControlStatic* m_pStaticGuarantee;
|
|
KUIControlButton* m_pBtnRegister;
|
|
|
|
item_list_t m_ItemList;
|
|
item_list_t m_SelectedItem;
|
|
price_cache_t m_PriceCache;
|
|
sui::Page m_Page;
|
|
COLUMN m_nSavedSortingState;
|
|
bool m_bMaintainListState;
|
|
};
|
|
|
|
/// tender window ----------------------------------------------------------------------------------
|
|
|
|
class SUIAuctionTenderWnd : public auction::CategoryInterface
|
|
{
|
|
public:
|
|
|
|
enum {
|
|
LIST_MAX = 9,
|
|
LIST_OFFSET = 37,
|
|
};
|
|
|
|
enum COLUMN {
|
|
ITEM,
|
|
LIMITTIME,
|
|
TENDER,
|
|
STATE,
|
|
PURCHASE,
|
|
MAX,
|
|
};
|
|
|
|
SUIAuctionTenderWnd( SGameManager* pGameManager, SUIDisplayInfo* pDisplayInfo, auction::NoticeBox& TipMgr, auction::LazyMsgProc& LazyMsgPoster )
|
|
: CategoryInterface ( pGameManager )
|
|
, m_pDisplayInfo ( pDisplayInfo )
|
|
, m_NoticeBox ( TipMgr )
|
|
, m_LazyMsgPoster ( LazyMsgPoster )
|
|
, m_pCtrlCurrentPage( 0 )
|
|
, m_pCtrlEndPage ( 0 )
|
|
, m_pEditBid ( 0 )
|
|
, m_pRetenderButton ( 0 )
|
|
, m_pPurchaseButton ( 0 )
|
|
, m_ItemList ( this, "item_list", LIST_MAX, LIST_OFFSET )
|
|
, m_SelectedItem ( this, "item_selected" , 1 )
|
|
, m_nSavedSortingState( COLUMN::ITEM )
|
|
, m_bMaintainListState( false )
|
|
{
|
|
::memset( m_bSortButtonState, 0, sizeof( m_bSortButtonState ) );
|
|
}
|
|
// 2010.04.22 auction::search::deco_list_item_l 메모리 해제 때문에 cpp로 뺐습니다. - prodongi
|
|
~SUIAuctionTenderWnd();
|
|
// {
|
|
// }
|
|
|
|
virtual bool InitControls( KPoint kPos );
|
|
virtual bool InitData( bool bReload = false );
|
|
virtual void* Perform( KID id, KArg& msg );
|
|
virtual void PumpUpMessage( LPCTSTR lpszControlID, DWORD nMessage, DWORD lparam, DWORD wparam );
|
|
virtual void ProcMsgAtStatic( SGameMessage* pMsg );
|
|
virtual void OnNotifyUIWindowOpen( bool bOpen, bool bLimitWnd = true );
|
|
virtual DWORD OnMouseMessage( DWORD dwMessage, int x, int y );
|
|
void RefreshCategory();
|
|
|
|
private:
|
|
|
|
typedef sui::proxy_list item_list_t;
|
|
|
|
struct ItemImporter {
|
|
typedef TS_SC_AUCTION_BIDDED_LIST::BIDDED_AUCTION_LIST item_t;
|
|
ItemImporter ( item_list_t& list ) : m_target_list( list ) {}
|
|
void operator()( item_t& item );
|
|
item_list_t& m_target_list;
|
|
};
|
|
|
|
void _UpdatePage( int nCurrent = 1, int nTotal = 1 );
|
|
void _UpdateBidablePrice( money_t nPrice = money_t( 0 ) );
|
|
void _GetTemporaryListData();
|
|
void _RequestBiddedList( int nPage = 1 );
|
|
void _RequestBid();
|
|
void _RequestInstantPurchase();
|
|
void _SortItemListByColumn( COLUMN id, bool maintain = false );
|
|
|
|
SUIDisplayInfo* m_pDisplayInfo;
|
|
auction::NoticeBox& m_NoticeBox;
|
|
auction::LazyMsgProc& m_LazyMsgPoster;
|
|
|
|
bool m_bSortButtonState[ COLUMN::MAX ];
|
|
KUIControlStatic* m_pCtrlCurrentPage;
|
|
KUIControlStatic* m_pCtrlEndPage;
|
|
KUIControlEdit* m_pEditBid;
|
|
KUIControlButton* m_pRetenderButton;
|
|
KUIControlButton* m_pPurchaseButton;
|
|
|
|
item_list_t m_ItemList;
|
|
item_list_t m_SelectedItem;
|
|
sui::Page m_Page;
|
|
COLUMN m_nSavedSortingState;
|
|
bool m_bMaintainListState;
|
|
};
|
|
|
|
/// diposit window ---------------------------------------------------------------------------------
|
|
|
|
class SUIAuctionDepositWnd : public auction::CategoryInterface
|
|
{
|
|
public:
|
|
|
|
enum {
|
|
LIST_MAX = 8,
|
|
LIST_OFFSET = 41,
|
|
};
|
|
|
|
enum COLUMN {
|
|
ITEM,
|
|
STORABLETIME,
|
|
STATE,
|
|
MAX,
|
|
};
|
|
|
|
SUIAuctionDepositWnd( SGameManager* pGameManager, SUIDisplayInfo* pDisplayInfo, auction::NoticeBox& TipMgr, auction::LazyMsgProc& LazyMsgPoster )
|
|
: CategoryInterface ( pGameManager )
|
|
, m_pDisplayInfo ( pDisplayInfo )
|
|
, m_NoticeBox ( TipMgr )
|
|
, m_LazyMsgPoster ( LazyMsgPoster )
|
|
, m_pCtrlCurrentPage( 0 )
|
|
, m_pCtrlEndPage ( 0 )
|
|
, m_ItemList ( this, "item_list", LIST_MAX, LIST_OFFSET )
|
|
, m_SelectedItem ( this, "item_selected" , 1 )
|
|
, m_nSavedSortingState( COLUMN::STORABLETIME )
|
|
, m_bMaintainListState( false )
|
|
{
|
|
::memset( m_bSortButtonState, 0, sizeof( m_bSortButtonState ) );
|
|
}
|
|
// 2010.04.22 auction::search::deco_list_item_l 메모리 해제 때문에 cpp로 뺐습니다. - prodongi
|
|
~SUIAuctionDepositWnd();
|
|
// {
|
|
// }
|
|
|
|
virtual bool InitControls( KPoint kPos );
|
|
virtual bool InitData( bool bReload = false );
|
|
virtual void* Perform( KID id, KArg& msg );
|
|
virtual void PumpUpMessage( LPCTSTR lpszControlID, DWORD nMessage, DWORD lparam, DWORD wparam );
|
|
virtual void ProcMsgAtStatic( SGameMessage* pMsg );
|
|
virtual void OnNotifyUIWindowOpen( bool bOpen, bool bLimitWnd = true );
|
|
virtual DWORD OnMouseMessage( DWORD dwMessage, int x, int y );
|
|
void RefreshCategory();
|
|
|
|
private:
|
|
|
|
typedef sui::proxy_list item_list_t;
|
|
|
|
struct ItemImporter {
|
|
typedef TS_SC_ITEM_KEEPING_LIST::TS_ITEM_KEEPING_INFO item_t;
|
|
ItemImporter ( item_list_t& list ) : m_target_list( list ) {}
|
|
void operator()( item_t& item );
|
|
item_list_t& m_target_list;
|
|
};
|
|
|
|
void _UpdatePage( int nCurrent = 1, int nTotal = 1 );
|
|
void _RequestKeepingList( int nPage = 1 );
|
|
void _RequestDrawingItem( int nKeepingID );
|
|
void _GetTemporaryListData();
|
|
void _SortItemListByColumn( COLUMN id, bool maintain = false );
|
|
|
|
SUIDisplayInfo* m_pDisplayInfo;
|
|
auction::NoticeBox& m_NoticeBox;
|
|
auction::LazyMsgProc& m_LazyMsgPoster;
|
|
|
|
bool m_bSortButtonState[ COLUMN::MAX ];
|
|
KUIControlStatic* m_pCtrlCurrentPage;
|
|
KUIControlStatic* m_pCtrlEndPage;
|
|
|
|
item_list_t m_ItemList;
|
|
item_list_t m_SelectedItem;
|
|
sui::Page m_Page;
|
|
bool m_bSelectable;
|
|
COLUMN m_nSavedSortingState;
|
|
bool m_bMaintainListState;
|
|
}; |