- gr2: BitKnit2 decompression, 64-bit LE files, compressed curves - net: remaining GamePhase handlers, generated GC packet table - python: event/chat/chr/minimap/guild/quest/messenger/shop-search and other native modules ported against the AVA2 Windows client - render: D3D8 fixed-function lighting in Gr2ModelRenderer, terrain without baked shade; cape/NPC equipment attachment - tests + audits updated; docs/PORT-PLAN.md and WINDOWS-PARITY.md Batch 4 (render pipeline: background.*, app.RenderGame/UpdateGame, camera bindings, main.cpp fake-content removal) is still in progress. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
709 lines
26 KiB
C++
709 lines
26 KiB
C++
#pragma once
|
|
|
|
#include "shared/common/Win32Types.h"
|
|
#include "shared/common/EterBaseUtils.h"
|
|
#include "shared/common/PythonUtils.h"
|
|
#include <string>
|
|
#include <vector>
|
|
#include <list>
|
|
#include <map>
|
|
#include <algorithm>
|
|
|
|
#include "src/eter_image/GrpImageInstance.h"
|
|
#include "src/eter_image/GrpExpandedImageInstance.h"
|
|
#include "src/eter_image/GrpMarkInstance.h"
|
|
#include "src/eter_resource/ResourceManager.h"
|
|
|
|
namespace UI
|
|
{
|
|
|
|
class CGraphicTextInstance {
|
|
public:
|
|
enum {
|
|
HORIZONTAL_ALIGN_LEFT = 0x01,
|
|
HORIZONTAL_ALIGN_CENTER = 0x02,
|
|
HORIZONTAL_ALIGN_RIGHT = 0x03,
|
|
VERTICAL_ALIGN_TOP = 0x10,
|
|
VERTICAL_ALIGN_CENTER = 0x20,
|
|
VERTICAL_ALIGN_BOTTOM = 0x30
|
|
};
|
|
CGraphicTextInstance() = default;
|
|
~CGraphicTextInstance() = default;
|
|
void SetText(const char* text) { if (text) m_text = text; }
|
|
const char* GetText() const { return m_text.c_str(); }
|
|
void SetValue(const char* text) { SetText(text); }
|
|
void SetValueString(const std::string& text) { m_text = text; }
|
|
void SetHorizonalAlign(int align) { m_hAlign = align; }
|
|
int GetHorizontalAlign() const { return m_hAlign; }
|
|
// EterLib CGraphicTextInstance::SetColor(r, g, b): alpha 1.
|
|
void SetColor(float r, float g, float b) {
|
|
auto c = [](float v) { return DWORD(std::clamp(v, 0.0f, 1.0f) * 255.0f + 0.5f); };
|
|
m_color = 0xff000000 | (c(r) << 16) | (c(g) << 8) | c(b);
|
|
}
|
|
// EterLib CGraphicTextInstance::SetColor(const D3DXCOLOR&) / SetColor(DWORD): alpha kept.
|
|
void SetColor(const D3DXCOLOR& color) { m_color = DWORD(color); }
|
|
DWORD GetColor() const { return m_color; }
|
|
// EterLib CGraphicTextInstance::Destroy: back to an empty, left-aligned instance.
|
|
void Destroy() { *this = CGraphicTextInstance(); }
|
|
void SetVerticalAlign(int align) { m_vAlign = align; }
|
|
void SetMax(int max) { m_max = max; }
|
|
void SetFontName(const char* name) { if (name) m_font = name; }
|
|
void SetFontColor(DWORD color) { m_color = color; }
|
|
void SetLimitWidth(float w) { m_limitWidth = w; }
|
|
void SetSecret(BOOL b) { m_secret = b; }
|
|
void SetOutline(BOOL b) { m_outline = b; }
|
|
void SetFeather(BOOL b) { m_feather = b; }
|
|
void SetMultiLine(BOOL b) { m_multiLine = b; }
|
|
void SetLineHeight(int h) { m_lineHeight = h; }
|
|
int GetLineHeight() const { return m_lineHeight; }
|
|
int GetTextLineCount() const { return 1; }
|
|
void DisableEnterToken() {}
|
|
void ShowCursor() { m_showCursor = true; }
|
|
void HideCursor() { m_showCursor = false; }
|
|
int GetCursorPosition() const { return (int)m_text.length(); }
|
|
void GetTextSize(int* w, int* h) {
|
|
if (w) *w = (int)m_text.length() * 6;
|
|
if (h) *h = 12;
|
|
}
|
|
void SetPosition(float fx, float fy) { m_v2Position.x = fx; m_v2Position.y = fy; }
|
|
D3DXVECTOR2 GetPosition() const { return m_v2Position; }
|
|
void Update() {}
|
|
void Render();
|
|
// Render(RECT* pClipRect): the clip rectangle is not applied by this text stand-in.
|
|
void Render(const RECT*) { Render(); }
|
|
static const char* Hyperlink_GetText(const std::string&, int, int*) { return ""; }
|
|
private:
|
|
D3DXVECTOR2 m_v2Position = D3DXVECTOR2(0.0f, 0.0f);
|
|
std::string m_text;
|
|
std::string m_font;
|
|
DWORD m_color = 0xffffffff;
|
|
int m_hAlign = HORIZONTAL_ALIGN_LEFT;
|
|
int m_vAlign = VERTICAL_ALIGN_TOP;
|
|
int m_max = 0;
|
|
int m_lineHeight = 12;
|
|
float m_limitWidth = 0.0f;
|
|
BOOL m_secret = FALSE;
|
|
BOOL m_outline = FALSE;
|
|
BOOL m_feather = FALSE;
|
|
BOOL m_multiLine = FALSE;
|
|
bool m_showCursor = false;
|
|
};
|
|
|
|
class CWindow
|
|
{
|
|
public:
|
|
typedef std::list<CWindow *> TWindowContainer;
|
|
|
|
static DWORD Type();
|
|
BOOL IsType(DWORD dwType);
|
|
|
|
enum EHorizontalAlign
|
|
{
|
|
HORIZONTAL_ALIGN_LEFT = 0,
|
|
HORIZONTAL_ALIGN_CENTER = 1,
|
|
HORIZONTAL_ALIGN_RIGHT = 2,
|
|
};
|
|
|
|
enum EVerticalAlign
|
|
{
|
|
VERTICAL_ALIGN_TOP = 0,
|
|
VERTICAL_ALIGN_CENTER = 1,
|
|
VERTICAL_ALIGN_BOTTOM = 2,
|
|
};
|
|
|
|
enum EFlags
|
|
{
|
|
FLAG_MOVABLE = (1 << 0),
|
|
FLAG_LIMIT = (1 << 1),
|
|
FLAG_SNAP = (1 << 2),
|
|
FLAG_DRAGABLE = (1 << 3),
|
|
FLAG_ATTACH = (1 << 4),
|
|
FLAG_RESTRICT_X = (1 << 5),
|
|
FLAG_RESTRICT_Y = (1 << 6),
|
|
FLAG_NOT_CAPTURE = (1 << 7),
|
|
FLAG_FLOAT = (1 << 8),
|
|
FLAG_NOT_PICK = (1 << 9),
|
|
FLAG_IGNORE_SIZE = (1 << 10),
|
|
FLAG_RTL = (1 << 11),
|
|
};
|
|
|
|
public:
|
|
CWindow(PyObject * ppyObject);
|
|
virtual ~CWindow();
|
|
|
|
void AddChild(CWindow * pWin);
|
|
void Clear();
|
|
void DestroyHandle();
|
|
void Update();
|
|
void Render();
|
|
|
|
void SetName(const char * c_szName);
|
|
const char * GetName() { return m_strName.c_str(); }
|
|
void SetSize(long width, long height);
|
|
long GetWidth() { return m_lWidth; }
|
|
long GetHeight() { return m_lHeight; }
|
|
|
|
void SetHorizontalAlign(DWORD dwAlign);
|
|
void SetVerticalAlign(DWORD dwAlign);
|
|
void SetPosition(long x, long y);
|
|
void GetPosition(long * plx, long * ply);
|
|
long GetPositionX( void ) const { return m_x; }
|
|
long GetPositionY( void ) const { return m_y; }
|
|
RECT & GetRect() { return m_rect; }
|
|
void GetLocalPosition(long & rlx, long & rly);
|
|
void GetMouseLocalPosition(long & rlx, long & rly);
|
|
long UpdateRect();
|
|
|
|
RECT & GetLimitBias() { return m_limitBiasRect; }
|
|
void SetLimitBias(long l, long r, long t, long b) { m_limitBiasRect.left = l; m_limitBiasRect.right = r; m_limitBiasRect.top = t; m_limitBiasRect.bottom = b; }
|
|
|
|
void Show();
|
|
void Hide();
|
|
bool IsShow() { return m_bShow; }
|
|
bool IsRendering();
|
|
|
|
bool HasParent() { return m_pParent ? true : false; }
|
|
bool HasChild() { return !m_pChildList.empty(); }
|
|
int GetChildCount() { return (int)m_pChildList.size(); }
|
|
|
|
CWindow * GetRoot();
|
|
CWindow * GetParent();
|
|
bool IsChild(CWindow * pWin);
|
|
void DeleteChild(CWindow * pWin);
|
|
void SetTop(CWindow * pWin);
|
|
|
|
bool IsIn(long x, long y);
|
|
bool IsIn();
|
|
CWindow * PickWindow(long x, long y);
|
|
CWindow * PickTopWindow(long x, long y);
|
|
|
|
void __RemoveReserveChildren();
|
|
|
|
void AddFlag(DWORD flag) { SET_BIT(m_dwFlag, flag); }
|
|
void RemoveFlag(DWORD flag) { REMOVE_BIT(m_dwFlag, flag); }
|
|
bool IsFlag(DWORD flag) { return (m_dwFlag & flag) ? true : false; }
|
|
|
|
virtual void OnRender();
|
|
virtual void OnUpdate();
|
|
virtual void OnChangePosition(){}
|
|
|
|
virtual void OnSetFocus();
|
|
virtual void OnKillFocus();
|
|
|
|
virtual void OnMouseDrag(long lx, long ly);
|
|
virtual void OnMouseOverIn();
|
|
virtual void OnMouseOverOut();
|
|
virtual void OnMouseOver();
|
|
virtual void OnDrop();
|
|
virtual void OnTop();
|
|
virtual void OnIMEUpdate();
|
|
|
|
virtual void OnMoveWindow(long x, long y);
|
|
|
|
BOOL RunIMETabEvent();
|
|
BOOL RunIMEReturnEvent();
|
|
BOOL RunIMEKeyDownEvent(int ikey);
|
|
|
|
CWindow * RunKeyDownEvent(int ikey);
|
|
BOOL RunKeyUpEvent(int ikey);
|
|
BOOL RunPressEscapeKeyEvent();
|
|
BOOL RunPressExitKeyEvent();
|
|
|
|
virtual BOOL OnIMETabEvent();
|
|
virtual BOOL OnIMEReturnEvent();
|
|
virtual BOOL OnIMEKeyDownEvent(int ikey);
|
|
|
|
virtual BOOL OnIMEChangeCodePage();
|
|
virtual BOOL OnIMEOpenCandidateListEvent();
|
|
virtual BOOL OnIMECloseCandidateListEvent();
|
|
virtual BOOL OnIMEOpenReadingWndEvent();
|
|
virtual BOOL OnIMECloseReadingWndEvent();
|
|
|
|
virtual BOOL OnMouseLeftButtonDown();
|
|
virtual BOOL OnMouseLeftButtonUp();
|
|
virtual BOOL OnMouseLeftButtonDoubleClick();
|
|
virtual BOOL OnMouseRightButtonDown();
|
|
virtual BOOL OnMouseRightButtonUp();
|
|
virtual BOOL OnMouseRightButtonDoubleClick();
|
|
virtual BOOL OnMouseMiddleButtonDown();
|
|
virtual BOOL OnMouseMiddleButtonUp();
|
|
virtual BOOL OnMouseWheelScroll(short wDelta);
|
|
virtual void SetScrollable() { m_bIsScrollable = true; }
|
|
virtual BOOL OnMouseWheel(int nLen);
|
|
virtual BOOL RunMouseWheelEvent(long nLen);
|
|
|
|
virtual BOOL OnKeyDown(int ikey);
|
|
virtual BOOL OnKeyUp(int ikey);
|
|
virtual BOOL OnPressEscapeKey();
|
|
virtual BOOL OnPressExitKey();
|
|
|
|
virtual void SetColor(DWORD dwColor){}
|
|
virtual BOOL OnIsType(DWORD dwType);
|
|
|
|
virtual BOOL IsWindow() { return TRUE; }
|
|
|
|
protected:
|
|
std::string m_strName;
|
|
EHorizontalAlign m_HorizontalAlign;
|
|
EVerticalAlign m_VerticalAlign;
|
|
long m_x, m_y;
|
|
long m_lWidth, m_lHeight;
|
|
RECT m_rect;
|
|
RECT m_limitBiasRect;
|
|
bool m_bMovable;
|
|
bool m_bShow;
|
|
DWORD m_dwFlag;
|
|
PyObject * m_poHandler;
|
|
CWindow * m_pParent;
|
|
TWindowContainer m_pChildList;
|
|
BOOL m_isUpdatingChildren;
|
|
TWindowContainer m_pReserveChildList;
|
|
bool m_bIsScrollable = false;
|
|
};
|
|
|
|
class CLayer : public CWindow
|
|
{
|
|
public:
|
|
CLayer(PyObject * ppyObject) : CWindow(ppyObject) {}
|
|
virtual ~CLayer() {}
|
|
BOOL IsWindow() override { return FALSE; }
|
|
};
|
|
|
|
class CBox : public CWindow
|
|
{
|
|
public:
|
|
CBox(PyObject * ppyObject) : CWindow(ppyObject), m_dwColor(0) {}
|
|
virtual ~CBox() {}
|
|
void SetColor(DWORD dwColor) override { m_dwColor = dwColor; }
|
|
protected:
|
|
void OnRender() override;
|
|
DWORD m_dwColor;
|
|
};
|
|
|
|
class CBar : public CWindow
|
|
{
|
|
public:
|
|
CBar(PyObject * ppyObject) : CWindow(ppyObject), m_dwColor(0) {}
|
|
virtual ~CBar() {}
|
|
void SetColor(DWORD dwColor) override { m_dwColor = dwColor; }
|
|
protected:
|
|
void OnRender() override;
|
|
DWORD m_dwColor;
|
|
};
|
|
|
|
class CLine : public CWindow
|
|
{
|
|
public:
|
|
CLine(PyObject * ppyObject) : CWindow(ppyObject), m_dwColor(0) {}
|
|
virtual ~CLine() {}
|
|
void SetColor(DWORD dwColor) override { m_dwColor = dwColor; }
|
|
protected:
|
|
void OnRender() override;
|
|
DWORD m_dwColor;
|
|
};
|
|
|
|
class CBar3D : public CWindow
|
|
{
|
|
public:
|
|
static DWORD Type();
|
|
CBar3D(PyObject * ppyObject) : CWindow(ppyObject), m_dwLeftColor(0), m_dwRightColor(0), m_dwCenterColor(0) {}
|
|
virtual ~CBar3D() {}
|
|
void SetColor(DWORD l, DWORD r, DWORD c) { m_dwLeftColor = l; m_dwRightColor = r; m_dwCenterColor = c; }
|
|
protected:
|
|
void OnRender() override;
|
|
BOOL OnIsType(DWORD dwType) override;
|
|
DWORD m_dwLeftColor, m_dwRightColor, m_dwCenterColor;
|
|
};
|
|
|
|
class CTextLine : public CWindow
|
|
{
|
|
public:
|
|
static DWORD Type();
|
|
CTextLine(PyObject * ppyObject);
|
|
virtual ~CTextLine();
|
|
void SetMax(int iMax) { m_TextInstance.SetMax(iMax); }
|
|
void SetHorizontalAlign(int iType) { m_TextInstance.SetHorizonalAlign(iType); }
|
|
void SetVerticalAlign(int iType) { m_TextInstance.SetVerticalAlign(iType); }
|
|
void SetSecret(BOOL bFlag) { m_TextInstance.SetSecret(bFlag); }
|
|
void SetOutline(BOOL bFlag) { m_TextInstance.SetOutline(bFlag); }
|
|
void SetFeather(BOOL bFlag) { m_TextInstance.SetFeather(bFlag); }
|
|
void SetMultiLine(BOOL bFlag) { m_TextInstance.SetMultiLine(bFlag); }
|
|
void SetFontName(const char * c_szFontName) { m_TextInstance.SetFontName(c_szFontName); }
|
|
void SetFontColor(DWORD dwColor) { m_TextInstance.SetFontColor(dwColor); }
|
|
void SetLimitWidth(float fWidth) { m_TextInstance.SetLimitWidth(fWidth); }
|
|
void ShowCursor() { m_TextInstance.ShowCursor(); }
|
|
void HideCursor() { m_TextInstance.HideCursor(); }
|
|
int GetCursorPosition() { return m_TextInstance.GetCursorPosition(); }
|
|
void SetText(const char * c_szText);
|
|
const char * GetText() { return m_TextInstance.GetText(); }
|
|
void GetTextSize(int* pnWidth, int* pnHeight) { m_TextInstance.GetTextSize(pnWidth, pnHeight); }
|
|
int GetTextLineCount() { return m_TextInstance.GetTextLineCount(); }
|
|
void DisableEnterToken() { m_TextInstance.DisableEnterToken(); }
|
|
void SetLineHeight(int iHeight) { m_TextInstance.SetLineHeight(iHeight); }
|
|
int GetLineHeight() { return m_TextInstance.GetLineHeight(); }
|
|
protected:
|
|
void OnRender() override;
|
|
void OnChangePosition() override;
|
|
BOOL OnIsType(DWORD dwType) override;
|
|
CGraphicTextInstance m_TextInstance;
|
|
};
|
|
|
|
class CNumberLine : public CWindow
|
|
{
|
|
public:
|
|
static DWORD Type();
|
|
CNumberLine(PyObject * ppyObject) : CWindow(ppyObject), m_iHorizontalAlign(0), m_dwWidthSummary(0) {}
|
|
CNumberLine(CWindow * pParent) : CWindow(nullptr), m_iHorizontalAlign(0), m_dwWidthSummary(0) { m_pParent = pParent; }
|
|
virtual ~CNumberLine() {}
|
|
void SetPath(const char * c_szPath) { if (c_szPath) m_strPath = c_szPath; }
|
|
void SetHorizontalAlign(int iType) { m_iHorizontalAlign = iType; }
|
|
void SetNumber(const char * c_szNumber) { if (c_szNumber) m_strNumber = c_szNumber; }
|
|
protected:
|
|
BOOL OnIsType(DWORD dwType) override;
|
|
std::string m_strPath, m_strNumber;
|
|
int m_iHorizontalAlign;
|
|
DWORD m_dwWidthSummary;
|
|
};
|
|
|
|
class CImageBox : public CWindow
|
|
{
|
|
public:
|
|
static DWORD Type();
|
|
CImageBox(PyObject * ppyObject);
|
|
virtual ~CImageBox();
|
|
|
|
void LeftRightReverse();
|
|
BOOL LoadImage(CGraphicImageInstance* imageInstance);
|
|
BOOL LoadImage(const char * c_szFileName);
|
|
void SetDiffuseColor(float fr, float fg, float fb, float fa);
|
|
|
|
void Clear();
|
|
int GetWidth();
|
|
int GetHeight();
|
|
void SetScale(float sx, float sy);
|
|
void SetCoolTime(float fCoolTime) { m_fCoolTime = fCoolTime; }
|
|
void SetCoolTimeStart(float fCoolTimeStart) { m_fCoolTimeStart = fCoolTimeStart; }
|
|
|
|
protected:
|
|
virtual void OnCreateInstance();
|
|
virtual void OnDestroyInstance();
|
|
|
|
void OnUpdate() override;
|
|
void OnRender() override;
|
|
void OnChangePosition() override;
|
|
|
|
BOOL OnIsType(DWORD dwType) override;
|
|
|
|
protected:
|
|
CGraphicImageInstance * m_pImageInstance;
|
|
float m_fCoolTime;
|
|
float m_fCoolTimeStart;
|
|
};
|
|
|
|
class CMarkBox : public CWindow
|
|
{
|
|
public:
|
|
static DWORD Type();
|
|
CMarkBox(PyObject * ppyObject);
|
|
virtual ~CMarkBox();
|
|
|
|
void LoadImage(const char * c_szFilename);
|
|
void SetDiffuseColor(float fr, float fg, float fb, float fa);
|
|
void SetIndex(UINT uIndex);
|
|
void SetScale(FLOAT fScale);
|
|
|
|
protected:
|
|
virtual void OnCreateInstance();
|
|
virtual void OnDestroyInstance();
|
|
|
|
void OnUpdate() override;
|
|
void OnRender() override;
|
|
void OnChangePosition() override;
|
|
|
|
BOOL OnIsType(DWORD dwType) override;
|
|
|
|
protected:
|
|
CGraphicMarkInstance * m_pMarkInstance;
|
|
};
|
|
|
|
class CExpandedImageBox : public CImageBox
|
|
{
|
|
public:
|
|
static DWORD Type();
|
|
CExpandedImageBox(PyObject * ppyObject);
|
|
virtual ~CExpandedImageBox();
|
|
|
|
void SetScale(float fx, float fy);
|
|
void SetOrigin(float fx, float fy);
|
|
void SetRotation(float fRotation);
|
|
void SetRenderingRect(float fLeft, float fTop, float fRight, float fBottom);
|
|
void SetRenderingMode(int iMode);
|
|
void SetImageClipRect(float fLeft, float fTop, float fRight, float fBottom, bool bIsVertical = false) {}
|
|
|
|
protected:
|
|
void OnCreateInstance() override;
|
|
void OnDestroyInstance() override;
|
|
|
|
void OnUpdate() override;
|
|
void OnRender() override;
|
|
|
|
BOOL OnIsType(DWORD dwType) override;
|
|
};
|
|
|
|
class CAniImageBox : public CWindow
|
|
{
|
|
public:
|
|
static DWORD Type();
|
|
CAniImageBox(PyObject * ppyObject);
|
|
virtual ~CAniImageBox();
|
|
|
|
void SetDelay(int iDelay);
|
|
void AppendImage(const char * c_szFileName, float r = 1.0, float g = 1.0, float b = 1.0, float a = 1.0);
|
|
void SetRenderingRect(float fLeft, float fTop, float fRight, float fBottom);
|
|
void SetRenderingMode(int iMode);
|
|
void AppendImageScale(const char * c_szFileName, float scale_x, float scale_y);
|
|
void ResetFrame();
|
|
void SetRotation(float fRotation);
|
|
void SetMoveStatus(bool bFlag);
|
|
void SetMoveSpeed(float speed);
|
|
void SetMovePos(float directionX, float directionY);
|
|
float GetRotation();
|
|
|
|
protected:
|
|
void OnUpdate() override;
|
|
void OnRender() override;
|
|
void OnChangePosition() override;
|
|
virtual void OnEndFrame();
|
|
|
|
BOOL OnIsType(DWORD dwType) override;
|
|
|
|
protected:
|
|
BYTE m_bycurDelay;
|
|
BYTE m_byDelay;
|
|
BYTE m_bycurIndex;
|
|
std::vector<CGraphicExpandedImageInstance*> m_ImageVector;
|
|
};
|
|
|
|
class CButton : public CWindow
|
|
{
|
|
public:
|
|
static DWORD Type();
|
|
CButton(PyObject * ppyObject);
|
|
virtual ~CButton();
|
|
|
|
void LeftRightReverse();
|
|
|
|
BOOL SetUpVisual(const char * c_szFileName);
|
|
BOOL SetOverVisual(const char * c_szFileName);
|
|
BOOL SetDownVisual(const char * c_szFileName);
|
|
BOOL SetDisableVisual(const char * c_szFileName);
|
|
void SetRenderingRect(float fLeft, float fTop, float fRight, float fBottom) {}
|
|
|
|
const char * GetUpVisualFileName();
|
|
const char * GetOverVisualFileName();
|
|
const char * GetDownVisualFileName();
|
|
|
|
void FlashEx() { m_isFlashEx = TRUE; }
|
|
void Flash(bool bFlash = true) { m_isFlash = bFlash; }
|
|
void Enable() { m_bEnable = TRUE; }
|
|
void Disable() { m_bEnable = FALSE; }
|
|
|
|
void SetUp();
|
|
void Up();
|
|
void Over();
|
|
void Down();
|
|
|
|
BOOL IsDisable() { return !m_bEnable; }
|
|
BOOL IsPressed() { return m_isPressed; }
|
|
|
|
protected:
|
|
void OnUpdate() override;
|
|
void OnRender() override;
|
|
void OnChangePosition() override;
|
|
|
|
BOOL OnMouseLeftButtonDown() override;
|
|
BOOL OnMouseLeftButtonUp() override;
|
|
void OnMouseOverIn() override;
|
|
void OnMouseOverOut() override;
|
|
|
|
BOOL IsEnable() { return m_bEnable; }
|
|
void SetCurrentVisual(CGraphicImageInstance* pVisual);
|
|
|
|
BOOL OnIsType(DWORD dwType) override;
|
|
|
|
protected:
|
|
BOOL m_bEnable;
|
|
BOOL m_isPressed;
|
|
BOOL m_isFlashEx;
|
|
BOOL m_isFlash;
|
|
CGraphicImageInstance* m_pcurVisual;
|
|
CGraphicImageInstance m_upVisual;
|
|
CGraphicImageInstance m_overVisual;
|
|
CGraphicImageInstance m_downVisual;
|
|
CGraphicImageInstance m_disableVisual;
|
|
};
|
|
|
|
class CRadioButton : public CButton
|
|
{
|
|
public:
|
|
static DWORD Type();
|
|
CRadioButton(PyObject* ppyObject) : CButton(ppyObject) {}
|
|
virtual ~CRadioButton() {}
|
|
protected:
|
|
BOOL OnIsType(DWORD dwType) override;
|
|
};
|
|
|
|
class CToggleButton : public CButton
|
|
{
|
|
public:
|
|
static DWORD Type();
|
|
CToggleButton(PyObject* ppyObject) : CButton(ppyObject) {}
|
|
virtual ~CToggleButton() {}
|
|
protected:
|
|
BOOL OnIsType(DWORD dwType) override;
|
|
};
|
|
|
|
class CDragButton : public CButton
|
|
{
|
|
public:
|
|
static DWORD Type();
|
|
CDragButton(PyObject * ppyObject) : CButton(ppyObject) { memset(&m_restrictArea, 0, sizeof(m_restrictArea)); }
|
|
virtual ~CDragButton() {}
|
|
void SetRestrictMovementArea(int ix, int iy, int iwidth, int iheight) {
|
|
m_restrictArea.left = ix; m_restrictArea.top = iy;
|
|
m_restrictArea.right = ix + iwidth; m_restrictArea.bottom = iy + iheight;
|
|
}
|
|
protected:
|
|
BOOL OnIsType(DWORD dwType) override;
|
|
RECT m_restrictArea;
|
|
};
|
|
|
|
class CUiRenderTarget : public CWindow
|
|
{
|
|
public:
|
|
static DWORD Type();
|
|
CUiRenderTarget(PyObject* ppyObject) : CWindow(ppyObject), m_dwIndex(0) {}
|
|
virtual ~CUiRenderTarget() {}
|
|
bool SetRenderTarget(int index) { m_dwIndex = (DWORD)index; return true; }
|
|
void SetRenderingRect(float fLeft, float fTop, float fRight, float fBottom) {}
|
|
protected:
|
|
void OnRender() override;
|
|
BOOL OnIsType(DWORD dwType) override;
|
|
DWORD m_dwIndex;
|
|
};
|
|
|
|
class CSlotWindow : public CWindow
|
|
{
|
|
public:
|
|
struct SSlot
|
|
{
|
|
DWORD dwIndex = 0;
|
|
int ixPosition = 0;
|
|
int iyPosition = 0;
|
|
int ixCellSize = 32;
|
|
int iyCellSize = 32;
|
|
BYTE byWidth = 1;
|
|
BYTE byHeight = 1;
|
|
bool bRenderBaseSlotImage = true;
|
|
bool isItem = false;
|
|
DWORD dwItemIndex = 0;
|
|
CGraphicImageInstance* pInstance = nullptr;
|
|
CGraphicImageInstance* pCoverInstance = nullptr;
|
|
DWORD dwItemCount = 0;
|
|
DWORD dwGrade = 0;
|
|
bool bActive = false;
|
|
bool bLocked = false;
|
|
float fCoolTime = 0.0f;
|
|
float fStartCoolTime = 0.0f;
|
|
};
|
|
|
|
static DWORD Type();
|
|
CSlotWindow(PyObject * ppyObject);
|
|
virtual ~CSlotWindow();
|
|
void Destroy();
|
|
void SetSlotID(DWORD dwIndex, DWORD dwID) {}
|
|
void SetSlotType(DWORD dwType) { m_dwSlotType = dwType; }
|
|
void SetSlotStyle(DWORD dwStyle) { m_dwSlotStyle = dwStyle; }
|
|
void AppendSlot(DWORD dwIndex, int ix, int iy, int iw, int ih);
|
|
void SetCoverButton(DWORD dwIndex, const char* c_szUpImageName, const char* c_szOverImageName, const char* c_szDownImageName, const char* c_szDisableImageName, BOOL bLeftButtonEnable, BOOL bRightButtonEnable);
|
|
void SetSlotBaseImage(const char* szFileName, float fr = 1.0f, float fg = 1.0f, float fb = 1.0f, float fa = 1.0f);
|
|
void AppendSlotButton(const char*, const char*, const char*) {}
|
|
void AppendRequirementSignImage(const char*) {}
|
|
void SetSlotBaseImageScale(const char*, float, float, float, float, float, float) {}
|
|
void SetSlotScale(DWORD dwIndex, DWORD dwItemIndex, BYTE byWidth, BYTE byHeight, CGraphicImage* pImage, float sx, float sy, const D3DXCOLOR& diffuseColor);
|
|
void EnableCoverButton(DWORD) {}
|
|
void DisableCoverButton(DWORD) {}
|
|
void SetAlwaysRenderCoverButton(DWORD, bool = false) {}
|
|
void ShowSlotBaseImage(DWORD dwIndex);
|
|
void HideSlotBaseImage(DWORD dwIndex);
|
|
BOOL IsDisableCoverButton(DWORD) { return FALSE; }
|
|
BOOL HasSlot(DWORD dwIndex);
|
|
void ClearAllSlot();
|
|
void ClearSlot(DWORD dwIndex);
|
|
void SetSlot(DWORD dwIndex, DWORD dwItemIndex, BYTE byWidth, BYTE byHeight, CGraphicImage* pImage, const D3DXCOLOR& diffuseColor);
|
|
void SetCardSlot(DWORD dwIndex, DWORD, BYTE, BYTE, const char*, DWORD) { if (!HasSlot(dwIndex)) AppendSlot(dwIndex, 0, 0, 32, 32); }
|
|
void SetSlotCount(DWORD dwIndex, DWORD dwCount);
|
|
void SetSlotCountNew(DWORD dwIndex, DWORD dwGrade, DWORD dwCount);
|
|
void SetSlotCoolTime(DWORD dwIndex, float fCoolTime, float fElapsedTime = 0.0f);
|
|
bool IsSlotCoolTime(DWORD dwIndex);
|
|
float GetSlotCoolTime(DWORD dwIndex);
|
|
float GetSlotRemainingCoolTime(DWORD dwIndex);
|
|
void StoreSlotCoolTime(DWORD, DWORD, float, float = 0.0f) {}
|
|
void RestoreSlotCoolTime(DWORD) {}
|
|
void ActivateSlot(DWORD dwIndex);
|
|
void DeactivateSlot(DWORD dwIndex);
|
|
void RefreshSlot() {}
|
|
DWORD GetSlotCount() { return (DWORD)m_slotMap.size(); }
|
|
void LockSlot(DWORD dwIndex);
|
|
void UnlockSlot(DWORD dwIndex);
|
|
BOOL IsLockSlot(DWORD dwIndex);
|
|
void SetCantUseSlot(DWORD) {}
|
|
void SetUseSlot(DWORD) {}
|
|
BOOL IsCantUseSlot(DWORD) { return FALSE; }
|
|
void EnableSlot(DWORD) {}
|
|
void DisableSlot(DWORD) {}
|
|
BOOL IsEnableSlot(DWORD) { return TRUE; }
|
|
void SetCanMouseEventSlot(DWORD) {}
|
|
void SetCantMouseEventSlot(DWORD) {}
|
|
void SetUsableSlotOnTopWnd(DWORD) {}
|
|
void SetUnusableSlotOnTopWnd(DWORD) {}
|
|
void ClearSelected() { m_selected.clear(); }
|
|
void SelectSlot(DWORD dwIndex) { m_selected.push_back(dwIndex); }
|
|
BOOL isSelectedSlot(DWORD dwIndex) {
|
|
return std::find(m_selected.begin(), m_selected.end(), dwIndex) != m_selected.end();
|
|
}
|
|
DWORD GetSelectedSlotCount() { return (DWORD)m_selected.size(); }
|
|
DWORD GetSelectedSlotNumber(DWORD dwIndex) {
|
|
return (dwIndex < m_selected.size()) ? m_selected[dwIndex] : 0;
|
|
}
|
|
void ShowSlotButton(DWORD) {}
|
|
void HideAllSlotButton() {}
|
|
void ShowRequirementSign(DWORD) {}
|
|
void HideRequirementSign(DWORD) {}
|
|
void SetUseMode(BOOL) {}
|
|
void SetUsableItem(BOOL) {}
|
|
void ActivateEffect(DWORD, float, float, float, float) {}
|
|
void DeactivateEffect(DWORD) {}
|
|
protected:
|
|
void OnRender() override;
|
|
BOOL OnIsType(DWORD dwType) override;
|
|
DWORD m_dwSlotType;
|
|
DWORD m_dwSlotStyle;
|
|
std::vector<DWORD> m_slots;
|
|
std::vector<DWORD> m_selected;
|
|
std::map<DWORD, SSlot> m_slotMap;
|
|
CGraphicImageInstance* m_pBaseImageInstance;
|
|
};
|
|
|
|
class CGridSlotWindow : public CSlotWindow
|
|
{
|
|
public:
|
|
static DWORD Type();
|
|
CGridSlotWindow(PyObject * ppyObject) : CSlotWindow(ppyObject) {}
|
|
virtual ~CGridSlotWindow() {}
|
|
void ArrangeGridSlot(DWORD dwStartIndex, DWORD dwxCount, DWORD dwyCount, int ixSlotSize, int iySlotSize, int ixTemporarySize, int iyTemporarySize);
|
|
protected:
|
|
BOOL OnIsType(DWORD dwType) override;
|
|
};
|
|
}
|