thunderbrewhq/thunderbrew
1
0
Fork 0
mirror of https://github.com/thunderbrewhq/thunderbrew synced 2025-12-12 03:02:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

chore(ui): clean up function declarations

Browse source
This commit is contained in:
fallenoak 2023-01-04 17:25:03 -06:00 • committed by GitHub
parent f24fbf26c6
commit d61f0faef1
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
38 changed files with 471 additions and 471 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/ui/CBackdropGenerator.hpp
View file

@ -40,10 +40,10 @@ class CBackdropGenerator {
// Member functions // Member functions
CBackdropGenerator(); CBackdropGenerator();
void Generate(const CRect*); void Generate(const CRect* rect);
void LoadXML(XMLNode*, CStatus*); void LoadXML(XMLNode* node, CStatus* status);
void SetBorderVertexColor(const CImVector&); void SetBorderVertexColor(const CImVector& borderColor);
void SetOutput(CSimpleFrame*); void SetOutput(CSimpleFrame* frame);
}; };
#endif #endif

12
src/ui/CFramePoint.hpp
View file

@ -20,13 +20,13 @@ class CFramePoint {
uint32_t m_flags : 24; uint32_t m_flags : 24;
// Member functions // Member functions
CFramePoint(CLayoutFrame*, FRAMEPOINT, float, float); CFramePoint(CLayoutFrame* relative, FRAMEPOINT framePoint, float offsetX, float offsetY);
CLayoutFrame* GetRelative(); CLayoutFrame* GetRelative();
int32_t GetRelativeRect(CRect&); int32_t GetRelativeRect(CRect& rect);
void MarkUnused(void); void MarkUnused();
void SetRelative(CLayoutFrame*, FRAMEPOINT, float, float); void SetRelative(CLayoutFrame* relative, FRAMEPOINT relativePoint, float offsetX, float offsetY);
float X(float); float X(float scale);
float Y(float); float Y(float scale);
}; };
#endif #endif

18
src/ui/CFrameStrata.hpp
View file

@ -18,9 +18,9 @@ class CFrameStrataNode {
STORM_EXPLICIT_LIST(CRenderBatch, renderLink) renderList; STORM_EXPLICIT_LIST(CRenderBatch, renderLink) renderList;
// Member functions // Member functions
int32_t BuildBatches(void); int32_t BuildBatches();
void OnLayerUpdate(float); void OnLayerUpdate(float elapsedSec);
bool RemoveFrame(CSimpleFrame*); bool RemoveFrame(CSimpleFrame* frame);
}; };
class CFrameStrata { class CFrameStrata {
@ -33,12 +33,12 @@ class CFrameStrata {
// Member functions // Member functions
void AddFrame(CSimpleFrame*); void AddFrame(CSimpleFrame*);
int32_t BuildBatches(int32_t); int32_t BuildBatches(int32_t a2);
void CheckOcclusion(void); void CheckOcclusion();
int32_t FrameOccluded(CSimpleFrame*); int32_t FrameOccluded(CSimpleFrame* frame);
void OnLayerUpdate(float); void OnLayerUpdate(float elapsedSec);
void RemoveFrame(CSimpleFrame*); void RemoveFrame(CSimpleFrame* frame);
void RenderBatches(void); void RenderBatches();
}; };
#endif #endif

2
src/ui/CLayoutFrame.cpp
View file

@ -190,7 +190,7 @@ int32_t CLayoutFrame::CalculateRect(CRect* rect) {
return 1; return 1;
} }
bool CLayoutFrame::CanBeAnchorFor(CLayoutFrame*) { bool CLayoutFrame::CanBeAnchorFor(CLayoutFrame* frame) {
// TODO // TODO
return true; return true;

84
src/ui/CLayoutFrame.hpp
View file

@ -20,7 +20,7 @@ class CLayoutFrame {
}; };
// Static functions // Static functions
static void ResizePending(void); static void ResizePending();
// Member variables // Member variables
TSLink<CLayoutFrame> resizeLink; TSLink<CLayoutFrame> resizeLink;
@ -44,51 +44,51 @@ class CLayoutFrame {
// Virtual member functions // Virtual member functions
virtual ~CLayoutFrame(); virtual ~CLayoutFrame();
virtual CLayoutFrame* GetLayoutParent(void); virtual CLayoutFrame* GetLayoutParent();
virtual bool SetLayoutScale(float, bool); virtual bool SetLayoutScale(float scale, bool force);
virtual void SetWidth(float); virtual void SetWidth(float width);
virtual void SetHeight(float); virtual void SetHeight(float height);
virtual float GetWidth(void); virtual float GetWidth();
virtual float GetHeight(void); virtual float GetHeight();
virtual void GetClampRectInsets(float&, float&, float&, float&); virtual void GetClampRectInsets(float& a1, float& a2, float& a3, float& a4);
virtual int32_t IsAttachmentOrigin(void); virtual int32_t IsAttachmentOrigin();
virtual CLayoutFrame* GetLayoutFrameByName(const char*); virtual CLayoutFrame* GetLayoutFrameByName(const char* name);
virtual int32_t IsObjectLoaded(void); virtual int32_t IsObjectLoaded();
virtual void OnFrameSizeChanged(const CRect&); virtual void OnFrameSizeChanged(const CRect& rect);
// Member functions // Member functions
CLayoutFrame(); CLayoutFrame();
void AddToResizeList(void); void AddToResizeList();
float Bottom(void); float Bottom();
int32_t CalculateRect(CRect*); int32_t CalculateRect(CRect* rect);
bool CanBeAnchorFor(CLayoutFrame*); bool CanBeAnchorFor(CLayoutFrame* frame);
float CenterX(void); float CenterX();
float CenterY(void); float CenterY();
void ClearAllPoints(void); void ClearAllPoints();
void DestroyLayout(); void DestroyLayout();
void FreePoints(void); void FreePoints();
void GetFirstPointX(const FRAMEPOINT* const, int32_t, float&); void GetFirstPointX(const FRAMEPOINT* const pointarray, int32_t elements, float& x);
void GetFirstPointY(const FRAMEPOINT* const, int32_t, float&); void GetFirstPointY(const FRAMEPOINT* const pointarray, int32_t elements, float& y);
int32_t GetRect(CRect*); int32_t GetRect(CRect* rect);
int32_t IsResizeDependency(CLayoutFrame*); int32_t IsResizeDependency(CLayoutFrame* dependentFrame);
uint32_t IsResizePending(void); uint32_t IsResizePending();
float Left(void); float Left();
void LoadXML(XMLNode*, CStatus*); void LoadXML(XMLNode* node, CStatus* status);
int32_t OnFrameResize(void); int32_t OnFrameResize();
void OnProtectedAttach(CLayoutFrame*); void OnProtectedAttach(CLayoutFrame* frame);
int32_t PtInFrameRect(const C2Vector&); int32_t PtInFrameRect(const C2Vector& pt);
void RegisterResize(CLayoutFrame*, uint32_t); void RegisterResize(CLayoutFrame* frame, uint32_t dep);
void Resize(int32_t); void Resize(int32_t force);
float Right(void); float Right();
void SetAllPoints(CLayoutFrame*, int32_t); void SetAllPoints(CLayoutFrame* relative, int32_t doResize);
void SetDeferredResize(int32_t); void SetDeferredResize(int32_t enable);
void SetPoint(FRAMEPOINT, CLayoutFrame*, FRAMEPOINT, float, float, int32_t); void SetPoint(FRAMEPOINT point, CLayoutFrame* relative, FRAMEPOINT relativePoint, float offsetX, float offsetY, int32_t doResize);
void SetProtectFlag(uint32_t); void SetProtectFlag(uint32_t flag);
int32_t Sub488DB0(const FRAMEPOINT* const, int32_t, float&); int32_t Sub488DB0(const FRAMEPOINT* const pointarray, int32_t elements, float& x);
int32_t Sub488E40(const FRAMEPOINT* const, int32_t, float&); int32_t Sub488E40(const FRAMEPOINT* const pointarray, int32_t elements, float& y);
float Top(void); float Top();
void UnflattenFrame(CLayoutFrame*); void UnflattenFrame(CLayoutFrame* frame);
void UnregisterResize(CLayoutFrame*, uint32_t); void UnregisterResize(CLayoutFrame* frame, uint32_t dep);
}; };
namespace LayoutFrame { namespace LayoutFrame {

14
src/ui/CRenderBatch.hpp
View file

@ -39,7 +39,7 @@ class CSimpleBatchedMesh {
C2Vector atlasOffset; C2Vector atlasOffset;
// Member functions // Member functions
EGxBlend GetAlphaMode(void); EGxBlend GetAlphaMode();
}; };
class CRenderBatch { class CRenderBatch {
@ -52,12 +52,12 @@ class CRenderBatch {
TSLink<CRenderBatch> renderLink; TSLink<CRenderBatch> renderLink;
// Member functions // Member functions
void Clear(void); void Clear();
void Finish(void); void Finish();
void Queue(CTexture*, EGxBlend, int32_t, const C3Vector*, const C2Vector*, int32_t, const CImVector*, int32_t, const uint16_t*, CGxShader*); void Queue(CTexture* texture, EGxBlend alphaMode, int32_t posCount, const C3Vector* position, const C2Vector* texCoord, int32_t colorCount, const CImVector* color, int32_t idx, const uint16_t* indices, CGxShader* shader);
void QueueCallback(void (*)(void*), void*); void QueueCallback(void (*callback)(void*), void* param);
void QueueFontString(CSimpleFontString*); void QueueFontString(CSimpleFontString* string);
void QueueTexture(CSimpleTexture*); void QueueTexture(CSimpleTexture* texture);
}; };
#endif #endif

22
src/ui/CScriptObject.hpp
View file

@ -15,24 +15,24 @@ class CScriptObject : public FrameScript_Object {
static const char* s_objectTypeName; static const char* s_objectTypeName;
// Static functions // Static functions
static void RegisterScriptMethods(lua_State*); static void RegisterScriptMethods(lua_State* L);
static CScriptObject* GetScriptObjectByName(const char*, int32_t); static CScriptObject* GetScriptObjectByName(const char* name, int32_t type);
// Member variables // Member variables
RCString m_name; RCString m_name;
// Virtual member functions // Virtual member functions
virtual ~CScriptObject(void); virtual ~CScriptObject();
virtual char* GetName(void); virtual char* GetName();
virtual bool IsA(int32_t); virtual bool IsA(int32_t type);
virtual CScriptObject* GetScriptObjectParent(void) = 0; virtual CScriptObject* GetScriptObjectParent() = 0;
virtual bool IsA(const char*); virtual bool IsA(const char* typeName);
virtual const char* GetObjectTypeName(void); virtual const char* GetObjectTypeName();
// Member functions // Member functions
void CreateName(const char*, char*, uint32_t); void CreateName(const char* source, char* dest, uint32_t destsize);
void PreLoadXML(XMLNode*, CStatus*); void PreLoadXML(XMLNode* node, CStatus* status);
void SetName(const char*); void SetName(const char* name);
}; };
#endif #endif

38
src/ui/CScriptRegion.hpp
View file

@ -17,36 +17,36 @@ class CScriptRegion : public CScriptObject, public CLayoutFrame {
static const char* s_objectTypeName; static const char* s_objectTypeName;
// Static functions // Static functions
static void RegisterScriptMethods(lua_State*); static void RegisterScriptMethods(lua_State* L);
static int32_t GetObjectType(void); static int32_t GetObjectType();
// Member variables // Member variables
CSimpleFrame* m_parent = NULL; // TODO verify type CSimpleFrame* m_parent = NULL; // TODO verify type
// Virtual member functions // Virtual member functions
virtual bool IsA(int32_t); virtual bool IsA(int32_t type);
virtual CScriptObject* GetScriptObjectParent(void); virtual CScriptObject* GetScriptObjectParent();
virtual bool IsA(const char*); virtual bool IsA(const char* typeName);
virtual const char* GetObjectTypeName(void); virtual const char* GetObjectTypeName();
virtual bool IsDragging(void); virtual bool IsDragging();
virtual void PreOnAnimUpdate(void) {}; virtual void PreOnAnimUpdate() {};
virtual void OnLayerUpdate(float); virtual void OnLayerUpdate(float elapsedSec);
virtual void NotifyAnimBegin(CSimpleAnimGroup*); virtual void NotifyAnimBegin(CSimpleAnimGroup* animGroup);
virtual void NotifyAnimEnd(CSimpleAnimGroup*); virtual void NotifyAnimEnd(CSimpleAnimGroup* animGroup);
virtual void StopAnimating(void); virtual void StopAnimating();
virtual void AnimActivated(CSimpleAnimGroup*, int32_t, int32_t) {}; virtual void AnimActivated(CSimpleAnimGroup* animGroup, int32_t, int32_t) {};
virtual void AnimDeactivated(CSimpleAnimGroup*, int32_t, int32_t) {}; virtual void AnimDeactivated(CSimpleAnimGroup* animGroup, int32_t, int32_t) {};
virtual void AddAnimTranslation(CScriptRegion*, const C2Vector&) {}; virtual void AddAnimTranslation(CScriptRegion*, const C2Vector&) {};
virtual void AddAnimRotation(CScriptRegion*, FRAMEPOINT, const C2Vector&, float) {}; virtual void AddAnimRotation(CScriptRegion*, FRAMEPOINT, const C2Vector&, float) {};
virtual void AddAnimScale(CScriptRegion*, FRAMEPOINT, const C2Vector&, const C2Vector&) {}; virtual void AddAnimScale(CScriptRegion*, FRAMEPOINT, const C2Vector&, const C2Vector&) {};
virtual void AddAnimAlpha(CScriptRegion*, int16_t) {}; virtual void AddAnimAlpha(CScriptRegion*, int16_t) {};
virtual void LoadXML(XMLNode*, CStatus*); virtual void LoadXML(XMLNode* node, CStatus* status);
virtual CLayoutFrame* GetLayoutParent(void); virtual CLayoutFrame* GetLayoutParent();
virtual CLayoutFrame* GetLayoutFrameByName(const char*); virtual CLayoutFrame* GetLayoutFrameByName(const char* name);
// Member functions // Member functions
void LoadXML_Animations(XMLNode*, CStatus*); void LoadXML_Animations(XMLNode* node, CStatus* status);
bool ProtectedFunctionsAllowed(void); bool ProtectedFunctionsAllowed();
}; };
#endif #endif

50
src/ui/CSimpleButton.hpp
View file

@ -22,9 +22,9 @@ class CSimpleButton : public CSimpleFrame {
static int32_t s_objectType; static int32_t s_objectType;
// Static functions // Static functions
static void CreateScriptMetaTable(void); static void CreateScriptMetaTable();
static int32_t GetObjectType(void); static int32_t GetObjectType();
static void RegisterScriptMethods(lua_State*); static void RegisterScriptMethods(lua_State* L);
// Member variables // Member variables
uint32_t m_doubleClickTime = 0; uint32_t m_doubleClickTime = 0;
@ -45,33 +45,33 @@ class CSimpleButton : public CSimpleFrame {
ScriptIx m_onDoubleClick; ScriptIx m_onDoubleClick;
// Virtual member functions // Virtual member functions
virtual ScriptIx* GetScriptByName(const char*, ScriptData&); virtual ScriptIx* GetScriptByName(const char* name, ScriptData& data);
virtual bool IsA(int32_t); virtual bool IsA(int32_t type);
virtual int32_t GetScriptMetaTable(void); virtual int32_t GetScriptMetaTable();
virtual void LoadXML(XMLNode*, CStatus*); virtual void LoadXML(XMLNode* node, CStatus* status);
virtual void OnLayerHide(void); virtual void OnLayerHide();
virtual void OnLayerCursorEnter(int32_t); virtual void OnLayerCursorEnter(int32_t a2);
virtual void OnLayerCursorExit(int32_t, int32_t); virtual void OnLayerCursorExit(int32_t a2, int32_t a3);
virtual int32_t OnLayerMouseDown(const CMouseEvent&, const char*); virtual int32_t OnLayerMouseDown(const CMouseEvent& evt, const char* btn);
virtual int32_t OnLayerMouseUp(const CMouseEvent&, const char*); virtual int32_t OnLayerMouseUp(const CMouseEvent& evt, const char* btn);
virtual void LockHighlight(int32_t); virtual void LockHighlight(int32_t lock);
virtual void Enable(int32_t); virtual void Enable(int32_t enabled);
virtual void OnClick(const char*, int32_t); virtual void OnClick(const char* btn, int32_t a3);
virtual void OnDoubleClick(const char*); virtual void OnDoubleClick(const char* btn);
virtual void SetButtonState(CSimpleButtonState, int32_t); virtual void SetButtonState(CSimpleButtonState state, int32_t stateLocked);
// Member functions // Member functions
CSimpleButton(CSimpleFrame*); CSimpleButton(CSimpleFrame* parent);
void RunOnClickScript(const char*, int32_t); void RunOnClickScript(const char* btn, int32_t down);
void SetClickAction(uint64_t action); void SetClickAction(uint64_t action);
void SetFontString(CSimpleFontString*); void SetFontString(CSimpleFontString* text);
void SetHighlight(CSimpleTexture*, EGxBlend); void SetHighlight(CSimpleTexture* texture, EGxBlend blend);
int32_t SetHighlight(const char* texFile, EGxBlend blendMode); int32_t SetHighlight(const char* texFile, EGxBlend blendMode);
void SetPressedOffset(C2Vector&); void SetPressedOffset(C2Vector& offset);
void SetStateTexture(CSimpleButtonState, CSimpleTexture*); void SetStateTexture(CSimpleButtonState state, CSimpleTexture* texture);
int32_t SetStateTexture(CSimpleButtonState state, const char* texFile); int32_t SetStateTexture(CSimpleButtonState state, const char* texFile);
void SetText(const char*); void SetText(const char* string);
void UpdateTextState(CSimpleButtonState); void UpdateTextState(CSimpleButtonState state);
}; };
#endif #endif

12
src/ui/CSimpleCheckbox.hpp
View file

@ -10,18 +10,18 @@ class CSimpleCheckbox : public CSimpleButton {
static int32_t s_objectType; static int32_t s_objectType;
// Static functions // Static functions
static void CreateScriptMetaTable(void); static void CreateScriptMetaTable();
static int32_t GetObjectType(void); static int32_t GetObjectType();
static void RegisterScriptMethods(lua_State*); static void RegisterScriptMethods(lua_State* L);
// Member variables // Member variables
// Virtual member functions // Virtual member functions
virtual bool IsA(int32_t); virtual bool IsA(int32_t type);
virtual int32_t GetScriptMetaTable(void); virtual int32_t GetScriptMetaTable();
// Member functions // Member functions
CSimpleCheckbox(CSimpleFrame*); CSimpleCheckbox(CSimpleFrame* parent);
}; };
#endif #endif

4
src/ui/CSimpleEditBox.cpp
View file

@ -749,14 +749,14 @@ void CSimpleEditBox::MoveForward(int32_t highlight) {
} }
} }
void CSimpleEditBox::OnEnterPressed(void) { void CSimpleEditBox::OnEnterPressed() {
this->RunOnEnterPressedScript(); this->RunOnEnterPressedScript();
// TODO // TODO
// - invoke action // - invoke action
} }
void CSimpleEditBox::OnEscapePressed(void) { void CSimpleEditBox::OnEscapePressed() {
// TODO // TODO
} }

84
src/ui/CSimpleEditBox.hpp
View file

@ -15,10 +15,10 @@ class CSimpleEditBox : public CSimpleFrame, CSimpleFontedFrame {
static int32_t s_objectType; static int32_t s_objectType;
// Static functions // Static functions
static void CreateScriptMetaTable(void); static void CreateScriptMetaTable();
static int32_t GetObjectType(void); static int32_t GetObjectType();
static void RegisterScriptMethods(lua_State*); static void RegisterScriptMethods(lua_State* L);
static void SetKeyboardFocus(CSimpleEditBox*); static void SetKeyboardFocus(CSimpleEditBox* editBox);
// Member variables // Member variables
int32_t m_autoFocus : 1; int32_t m_autoFocus : 1;
@ -63,52 +63,52 @@ class CSimpleEditBox : public CSimpleFrame, CSimpleFontedFrame {
ScriptIx m_onCharComposition; ScriptIx m_onCharComposition;
// Virtual member functions // Virtual member functions
virtual ScriptIx* GetScriptByName(const char*, ScriptData&); virtual ScriptIx* GetScriptByName(const char* name, ScriptData& data);
virtual bool IsA(int32_t); virtual bool IsA(int32_t type);
virtual int32_t GetScriptMetaTable(void); virtual int32_t GetScriptMetaTable();
virtual void LoadXML(XMLNode*, CStatus*); virtual void LoadXML(XMLNode* node, CStatus* status);
virtual void OnLayerUpdate(float); virtual void OnLayerUpdate(float elapsedSec);
virtual void OnFrameSizeChanged(float, float); virtual void OnFrameSizeChanged(float width, float height);
virtual int32_t OnLayerChar(const CCharEvent&); virtual int32_t OnLayerChar(const CCharEvent& evt);
virtual int32_t OnLayerKeyDown(const CKeyEvent&); virtual int32_t OnLayerKeyDown(const CKeyEvent& evt);
virtual int32_t OnLayerMouseDown(const CMouseEvent&, const char*); virtual int32_t OnLayerMouseDown(const CMouseEvent& evt, const char* btn);
virtual int32_t OnLayerMouseUp(const CMouseEvent&, const char*); virtual int32_t OnLayerMouseUp(const CMouseEvent& evt, const char* btn);
virtual void FontUpdated(CSimpleFontedFrameFont*, int32_t); virtual void FontUpdated(CSimpleFontedFrameFont* font, int32_t a3);
// Member functions // Member functions
CSimpleEditBox(CSimpleFrame*); CSimpleEditBox(CSimpleFrame* parent);
int32_t ConvertCoordinateToIndex(float, float, int32_t&); int32_t ConvertCoordinateToIndex(float a2, float a3, int32_t& a4);
void DeleteBackward(int32_t a2); void DeleteBackward(int32_t a2);
void DeleteForward(int32_t a2); void DeleteForward(int32_t a2);
void DeleteHighlight(int32_t); void DeleteHighlight(int32_t a2);
void DeleteSubstring(int32_t left, int32_t right, int32_t a4); void DeleteSubstring(int32_t left, int32_t right, int32_t a4);
int32_t GetNumToLen(int32_t, int32_t, bool); int32_t GetNumToLen(int32_t offset, int32_t amount, bool a4);
void GrowText(int32_t); void GrowText(int32_t size);
void Insert(uint32_t); void Insert(uint32_t chr);
void Insert(const char*, const char*, int32_t, int32_t, int32_t); void Insert(const char* a2, const char* a3, int32_t a4, int32_t a5, int32_t a6);
int32_t IsCurrentFocus(void); int32_t IsCurrentFocus();
void Move(int32_t distance, int32_t highlight); void Move(int32_t distance, int32_t highlight);
void MoveBackward(int32_t highlight); void MoveBackward(int32_t highlight);
void MoveForward(int32_t highlight); void MoveForward(int32_t highlight);
void OnEnterPressed(void); void OnEnterPressed();
void OnEscapePressed(void); void OnEscapePressed();
void OnTextChanged(void); void OnTextChanged();
int32_t PrevCharOffset(int32_t); int32_t PrevCharOffset(int32_t offset);
void RunOnCursorChangedScript(float, float, float, float); void RunOnCursorChangedScript(float x, float y, float w, float h);
void RunOnEditFocusGainedScript(void); void RunOnEditFocusGainedScript();
void RunOnEditFocusLostScript(void); void RunOnEditFocusLostScript();
void RunOnEnterPressedScript(void); void RunOnEnterPressedScript();
void RunOnTextChangedScript(int32_t); void RunOnTextChangedScript(int32_t changed);
void SetCursorPosition(int32_t); void SetCursorPosition(int32_t position);
void SetHistoryLines(int32_t); void SetHistoryLines(int32_t a2);
void SetMultiLine(int32_t); void SetMultiLine(int32_t enabled);
void StartHighlight(void); void StartHighlight();
void UpdateDirtyBits(void); void UpdateDirtyBits();
void UpdateSizes(void); void UpdateSizes();
void UpdateTextInfo(void); void UpdateTextInfo();
void UpdateVisibleCursor(void); void UpdateVisibleCursor();
void UpdateVisibleHighlight(void); void UpdateVisibleHighlight();
void UpdateVisibleText(void); void UpdateVisibleText();
}; };
#endif #endif

18
src/ui/CSimpleFont.hpp
View file

@ -29,10 +29,10 @@ class CSimpleFont : public FrameScript_Object, public CSimpleFontable {
static int32_t s_objectType; static int32_t s_objectType;
// Static functions // Static functions
static void CreateScriptMetaTable(void); static void CreateScriptMetaTable();
static CSimpleFont* GetFont(const char*, int32_t); static CSimpleFont* GetFont(const char* name, int32_t a2);
static int32_t GetObjectType(); static int32_t GetObjectType();
static void RegisterScriptMethods(lua_State*); static void RegisterScriptMethods(lua_State* L);
// Member variables // Member variables
CSimpleFontStringAttributes m_attributes; CSimpleFontStringAttributes m_attributes;
@ -40,15 +40,15 @@ class CSimpleFont : public FrameScript_Object, public CSimpleFontable {
STORM_EXPLICIT_LIST(CSimpleFontable, m_fontableLink) m_fontableList; STORM_EXPLICIT_LIST(CSimpleFontable, m_fontableLink) m_fontableList;
// Virtual member functions // Virtual member functions
virtual char* GetName(void); virtual char* GetName();
virtual int32_t GetScriptMetaTable(void); virtual int32_t GetScriptMetaTable();
virtual bool IsA(int32_t); virtual bool IsA(int32_t type);
virtual void FontObjectUpdated(CSimpleFontStringAttributes&); virtual void FontObjectUpdated(CSimpleFontStringAttributes& attributes);
// Member functions // Member functions
CSimpleFont(); CSimpleFont();
void LoadXML(XMLNode*, CStatus*); void LoadXML(XMLNode* node, CStatus* status);
void UpdateObjects(void); void UpdateObjects();
}; };
#endif #endif

82
src/ui/CSimpleFontString.hpp
View file

@ -16,9 +16,9 @@ class CSimpleFontString : public CSimpleRegion, public CSimpleFontable {
static int32_t s_objectType; static int32_t s_objectType;
// Static functions // Static functions
static void CreateScriptMetaTable(void); static void CreateScriptMetaTable();
static int32_t GetObjectType(void); static int32_t GetObjectType();
static void RegisterScriptMethods(lua_State*); static void RegisterScriptMethods(lua_State* L);
// Member variables // Member variables
HTEXTFONT m_font = nullptr; HTEXTFONT m_font = nullptr;
@ -42,48 +42,48 @@ class CSimpleFontString : public CSimpleRegion, public CSimpleFontable {
// Virtual member functions // Virtual member functions
virtual ~CSimpleFontString(); virtual ~CSimpleFontString();
virtual bool IsA(int32_t); virtual bool IsA(int32_t type);
virtual int32_t GetScriptMetaTable(void); virtual int32_t GetScriptMetaTable();
virtual void LoadXML(XMLNode*, CStatus*); virtual void LoadXML(XMLNode* node, CStatus* status);
virtual void OnColorChanged(bool); virtual void OnColorChanged(bool a2);
virtual void OnScreenSizeChanged(); virtual void OnScreenSizeChanged();
virtual void Draw(CRenderBatch*); virtual void Draw(CRenderBatch* batch);
virtual float GetWidth(void); virtual float GetWidth();
virtual float GetHeight(void); virtual float GetHeight();
virtual void OnFrameSizeChanged(const CRect&); virtual void OnFrameSizeChanged(const CRect& rect);
virtual void FontObjectUpdated(CSimpleFontStringAttributes&); virtual void FontObjectUpdated(CSimpleFontStringAttributes& attributes);
// Member functions // Member functions
CSimpleFontString(CSimpleFrame*, uint32_t, int32_t); CSimpleFontString(CSimpleFrame* frame, uint32_t drawlayer, int32_t show);
void AddShadow(const CImVector&, const C2Vector&); void AddShadow(const CImVector& shadowColor, const C2Vector& shadowOffset);
void ClearString(void); void ClearString();
void DrawEmbeddedTextures(CRenderBatch*); void DrawEmbeddedTextures(CRenderBatch* batch);
void FreeEmbeddedTextures(void); void FreeEmbeddedTextures();
const char* GetDisplayText(float, float); const char* GetDisplayText(float width, float height);
uint32_t GetFontFlags(void); uint32_t GetFontFlags();
float GetFontHeight(bool); float GetFontHeight(bool a2);
const char* GetFontName(void); const char* GetFontName();
uint32_t GetNumCharsWithinWidth(const char*, uint32_t, float); uint32_t GetNumCharsWithinWidth(const char* text, uint32_t textBytes, float maxWidth);
float GetStringHeight(void); float GetStringHeight();
float GetStringWidth(void); float GetStringWidth();
const char* GetText(void); const char* GetText();
float GetTextWidth(const char*, uint32_t); float GetTextWidth(const char* text, uint32_t textBytes);
void PostLoadXML(XMLNode*, CStatus*); void PostLoadXML(XMLNode* node, CStatus* status);
void RefreshEmbeddedTextures(void); void RefreshEmbeddedTextures();
void RemoveShadow(void); void RemoveShadow();
int32_t SetFont(const char*, float, uint32_t, bool); int32_t SetFont(const char* fontName, float fontHeight, uint32_t fontFlags, bool force);
void SetIndentedWordWrap(bool); void SetIndentedWordWrap(bool a2);
void SetJustificationOffset(float, float); void SetJustificationOffset(float x, float y);
void SetJustifyV(uint8_t); void SetJustifyV(uint8_t justify);
void SetJustifyH(uint8_t); void SetJustifyH(uint8_t justify);
void SetNonSpaceWrap(int32_t); void SetNonSpaceWrap(int32_t a2);
void SetNonWordWrap(int32_t); void SetNonWordWrap(int32_t a2);
void SetSpacing(float); void SetSpacing(float spacing);
void SetStyleFlags(uint32_t); void SetStyleFlags(uint32_t styleFlags);
void SetText(const char*, int32_t); void SetText(const char* text, int32_t a3);
void SetTextLength(uint32_t); void SetTextLength(uint32_t a2);
int32_t Sub482AC0(); int32_t Sub482AC0();
void UpdateString(void); void UpdateString();
}; };
#endif #endif

22
src/ui/CSimpleFontStringAttributes.hpp
View file

@ -21,17 +21,17 @@ class CSimpleFontStringAttributes {
C2Vector m_shadowOffset; C2Vector m_shadowOffset;
// Member functions // Member functions
void SetColor(const CImVector&); void SetColor(const CImVector& color);
int32_t SetFont(const char*, float, uint32_t); int32_t SetFont(const char* fontName, float fontHeight, uint32_t fontFlags);
void SetIndented(bool); void SetIndented(bool indented);
void SetJustifyV(uint8_t); void SetJustifyV(uint8_t justify);
void SetJustifyH(uint8_t); void SetJustifyH(uint8_t justify);
void SetNonSpaceWrap(bool); void SetNonSpaceWrap(bool wrap);
void SetShadow(const CImVector&, const C2Vector&); void SetShadow(const CImVector& shadowColor, const C2Vector& shadowOffset);
void SetSpacing(float); void SetSpacing(float spacing);
void SetStyleFlags(uint32_t); void SetStyleFlags(uint32_t styleFlags);
void Update(CSimpleFontString*, uint32_t); void Update(CSimpleFontString* fontString, uint32_t flags);
void Update(CSimpleFontStringAttributes&, uint32_t); void Update(CSimpleFontStringAttributes& attributes, uint32_t flags);
}; };
#endif #endif

6
src/ui/CSimpleFontable.hpp
View file

@ -16,11 +16,11 @@ class CSimpleFontable {
// Virtual member functions // Virtual member functions
virtual ~CSimpleFontable(); virtual ~CSimpleFontable();
virtual void FontObjectUpdated(CSimpleFontStringAttributes&) = 0; virtual void FontObjectUpdated(CSimpleFontStringAttributes& attributes) = 0;
// Member functions // Member functions
CSimpleFont* GetFontObject(void); CSimpleFont* GetFontObject();
void SetFontObject(CSimpleFont*); void SetFontObject(CSimpleFont* fontObject);
}; };
#endif #endif

2
src/ui/CSimpleFrame.cpp
View file

@ -1542,7 +1542,7 @@ int32_t CSimpleFrame::TestHitRect(const C2Vector& pt) {
return rect.IsPointInside(pt); return rect.IsPointInside(pt);
} }
void CSimpleFrame::UpdateDepth(bool a1) { void CSimpleFrame::UpdateDepth(bool a2) {
// TODO // TODO
} }

142
src/ui/CSimpleFrame.hpp
View file

@ -23,9 +23,9 @@ class CSimpleFrame : public CScriptRegion {
static int32_t s_objectType; static int32_t s_objectType;
// Static functions // Static functions
static void CreateScriptMetaTable(void); static void CreateScriptMetaTable();
static int32_t GetObjectType(void); static int32_t GetObjectType();
static void RegisterScriptMethods(lua_State*); static void RegisterScriptMethods(lua_State* L);
// Member variables // Member variables
CSimpleTop* m_top = NULL; CSimpleTop* m_top = NULL;
@ -82,81 +82,81 @@ class CSimpleFrame : public CScriptRegion {
// Virtual member functions // Virtual member functions
virtual ~CSimpleFrame(); virtual ~CSimpleFrame();
virtual ScriptIx* GetScriptByName(const char*, ScriptData&); virtual ScriptIx* GetScriptByName(const char* name, ScriptData& data);
virtual bool IsA(int32_t); virtual bool IsA(int32_t type);
virtual int32_t GetScriptMetaTable(void); virtual int32_t GetScriptMetaTable();
virtual void LoadXML(XMLNode*, CStatus*); virtual void LoadXML(XMLNode* node, CStatus* status);
virtual void PreOnAnimUpdate(void); virtual void PreOnAnimUpdate();
virtual void OnLayerShow(void); virtual void OnLayerShow();
virtual void OnLayerHide(void); virtual void OnLayerHide();
virtual void OnLayerUpdate(float); virtual void OnLayerUpdate(float elapsedSec);
virtual int32_t OnLayerTrackUpdate(const CMouseEvent&); virtual int32_t OnLayerTrackUpdate(const CMouseEvent& evt);
virtual void OnFrameRender(void); virtual void OnFrameRender();
virtual void OnFrameRender(CRenderBatch*, uint32_t); virtual void OnFrameRender(CRenderBatch* batch, uint32_t layer);
virtual void OnScreenSizeChanged(); virtual void OnScreenSizeChanged();
virtual void OnFrameSizeChanged(float, float); virtual void OnFrameSizeChanged(float width, float height);
virtual void OnLayerCursorEnter(int32_t); virtual void OnLayerCursorEnter(int32_t a2);
virtual void OnLayerCursorExit(int32_t, int32_t); virtual void OnLayerCursorExit(int32_t a2, int32_t a3);
virtual int32_t OnLayerChar(const CCharEvent&); virtual int32_t OnLayerChar(const CCharEvent& evt);
virtual int32_t OnLayerKeyDown(const CKeyEvent&); virtual int32_t OnLayerKeyDown(const CKeyEvent& evt);
virtual int32_t OnLayerKeyUp(const CKeyEvent&); virtual int32_t OnLayerKeyUp(const CKeyEvent& evt);
virtual int32_t OnLayerMouseDown(const CMouseEvent&, const char*); virtual int32_t OnLayerMouseDown(const CMouseEvent& evt, const char* btn);
virtual int32_t OnLayerMouseUp(const CMouseEvent&, const char*); virtual int32_t OnLayerMouseUp(const CMouseEvent& evt, const char* btn);
virtual void PostLoadXML(XMLNode*, CStatus*); virtual void PostLoadXML(XMLNode* node, CStatus* status);
virtual void UnregisterRegion(CSimpleRegion*); virtual void UnregisterRegion(CSimpleRegion* region);
virtual int32_t GetBoundsRect(CRect& bounds); virtual int32_t GetBoundsRect(CRect& bounds);
virtual void PreLoadXML(XMLNode*, CStatus*); virtual void PreLoadXML(XMLNode* node, CStatus* status);
virtual void LockHighlight(int32_t); virtual void LockHighlight(int32_t lock);
virtual int32_t HideThis(void); virtual int32_t HideThis();
virtual int32_t ShowThis(void); virtual int32_t ShowThis();
virtual bool UpdateScale(bool); virtual bool UpdateScale(bool a2);
virtual void UpdateDepth(bool); virtual void UpdateDepth(bool a2);
virtual void ParentFrame(CSimpleFrame*); virtual void ParentFrame(CSimpleFrame* frame);
virtual void OnFrameSizeChanged(const CRect&); virtual void OnFrameSizeChanged(const CRect& rect);
// Member functions // Member functions
CSimpleFrame(CSimpleFrame*); CSimpleFrame(CSimpleFrame* parent);
void AddFrameRegion(CSimpleRegion*, uint32_t); void AddFrameRegion(CSimpleRegion* region, uint32_t drawlayer);
void DisableDrawLayer(uint32_t); void DisableDrawLayer(uint32_t drawlayer);
void EnableDrawLayer(uint32_t); void EnableDrawLayer(uint32_t drawlayer);
void EnableEvent(CSimpleEventType, int32_t); void EnableEvent(CSimpleEventType eventType, int32_t priority);
int32_t GetHitRect(CRect& rect); int32_t GetHitRect(CRect& rect);
void Hide(void); void Hide();
void LoadXML_Attributes(XMLNode*, CStatus*); void LoadXML_Attributes(XMLNode* node, CStatus* status);
void LoadXML_Backdrop(XMLNode*, CStatus*); void LoadXML_Backdrop(XMLNode* node, CStatus* status);
void LoadXML_Layers(XMLNode*, CStatus*); void LoadXML_Layers(XMLNode* node, CStatus* status);
void LoadXML_Scripts(XMLNode*, CStatus*); void LoadXML_Scripts(XMLNode* node, CStatus* status);
void NotifyDrawLayerChanged(uint32_t); void NotifyDrawLayerChanged(uint32_t drawlayer);
void NotifyScrollParent(void); void NotifyScrollParent();
void PostLoadXML_Frames(XMLNode*, CStatus*); void PostLoadXML_Frames(XMLNode* node, CStatus* status);
void Raise(void); void Raise();
void RegisterForEvents(int32_t); void RegisterForEvents(int32_t a2);
void RegisterRegion(CSimpleRegion*); void RegisterRegion(CSimpleRegion* region);
void RemoveFrameRegion(CSimpleRegion*, uint32_t); void RemoveFrameRegion(CSimpleRegion* region, uint32_t drawlayer);
void RunOnCharScript(const char*); void RunOnCharScript(const char* chr);
void RunOnEnterScript(int32_t); void RunOnEnterScript(int32_t a2);
void RunOnHideScript(void); void RunOnHideScript();
void RunOnKeyDownScript(const char*); void RunOnKeyDownScript(const char* key);
void RunOnKeyUpScript(const char*); void RunOnKeyUpScript(const char* key);
void RunOnLeaveScript(int32_t); void RunOnLeaveScript(int32_t a2);
void RunOnLoadScript(void); void RunOnLoadScript();
void RunOnMouseDownScript(const char*); void RunOnMouseDownScript(const char* btn);
void RunOnMouseUpScript(const char*); void RunOnMouseUpScript(const char* btn);
void RunOnShowScript(void); void RunOnShowScript();
void RunOnSizeChangedScript(float, float); void RunOnSizeChangedScript(float width, float height);
void RunOnUpdateScript(float); void RunOnUpdateScript(float elapsedSec);
void SetBackdrop(CBackdropGenerator*); void SetBackdrop(CBackdropGenerator* backdrop);
void SetBeingScrolled(int32_t, int32_t); void SetBeingScrolled(int32_t a2, int32_t a3);
void SetFrameAlpha(uint8_t alpha); void SetFrameAlpha(uint8_t alpha);
void SetFrameFlag(int32_t, int32_t); void SetFrameFlag(int32_t flag, int32_t on);
void SetFrameLevel(int32_t, int32_t); void SetFrameLevel(int32_t level, int32_t shiftChildren);
bool SetFrameScale(float scale, bool a3); bool SetFrameScale(float scale, bool a3);
void SetFrameStrata(FRAME_STRATA); void SetFrameStrata(FRAME_STRATA strata);
void SetHitRect(void); void SetHitRect();
void SetParent(CSimpleFrame*); void SetParent(CSimpleFrame* parent);
void Show(void); void Show();
int32_t TestHitRect(const C2Vector&); int32_t TestHitRect(const C2Vector& pt);
void UnregisterForEvents(int32_t); void UnregisterForEvents(int32_t a2);
}; };
#endif #endif

10
src/ui/CSimpleHTML.hpp
View file

@ -22,9 +22,9 @@ class CSimpleHTML : public CSimpleHyperlinkedFrame, CSimpleFontedFrame {
static int32_t s_objectType; static int32_t s_objectType;
// Static functions // Static functions
static void CreateScriptMetaTable(void); static void CreateScriptMetaTable();
static int32_t GetObjectType(void); static int32_t GetObjectType();
static void RegisterScriptMethods(lua_State*); static void RegisterScriptMethods(lua_State* L);
// Member variables // Member variables
STORM_LIST(CONTENTNODE) m_content; STORM_LIST(CONTENTNODE) m_content;
@ -34,12 +34,12 @@ class CSimpleHTML : public CSimpleHyperlinkedFrame, CSimpleFontedFrame {
// Virtual member functions // Virtual member functions
virtual bool IsA(int32_t type); virtual bool IsA(int32_t type);
virtual int32_t GetScriptMetaTable(void); virtual int32_t GetScriptMetaTable();
virtual void LoadXML(XMLNode* node, CStatus* status); virtual void LoadXML(XMLNode* node, CStatus* status);
virtual void FontUpdated(CSimpleFontedFrameFont* font, int32_t a3); virtual void FontUpdated(CSimpleFontedFrameFont* font, int32_t a3);
// Member functions // Member functions
CSimpleHTML(CSimpleFrame*); CSimpleHTML(CSimpleFrame* parent);
void AddText(const char* text, HTML_TEXT_TYPE type, uint32_t justify); void AddText(const char* text, HTML_TEXT_TYPE type, uint32_t justify);
void ClearContent(); void ClearContent();
void ParseBODY(XMLNode* node, CStatus* status); void ParseBODY(XMLNode* node, CStatus* status);

2
src/ui/CSimpleHyperlinkedFrame.hpp
View file

@ -6,7 +6,7 @@
class CSimpleHyperlinkedFrame : public CSimpleFrame { class CSimpleHyperlinkedFrame : public CSimpleFrame {
public: public:
// Member functions // Member functions
CSimpleHyperlinkedFrame(CSimpleFrame*); CSimpleHyperlinkedFrame(CSimpleFrame* parent);
}; };
#endif #endif

28
src/ui/CSimpleModel.hpp
View file

@ -17,11 +17,11 @@ class CSimpleModel : public CSimpleFrame {
static int32_t s_objectType; static int32_t s_objectType;
// Static functions // Static functions
static void CreateScriptMetaTable(void); static void CreateScriptMetaTable();
static int32_t GetObjectType(void); static int32_t GetObjectType();
static void LightingCallback(CM2Model* model, CM2Lighting* lighting, void* userArg); static void LightingCallback(CM2Model* model, CM2Lighting* lighting, void* userArg);
static void ModelLoaded(CM2Model* model, void* arg); static void ModelLoaded(CM2Model* model, void* arg);
static void RegisterScriptMethods(lua_State*); static void RegisterScriptMethods(lua_State* L);
static void RenderModel(void* arg); static void RenderModel(void* arg);
// Member variables // Member variables
@ -45,25 +45,25 @@ class CSimpleModel : public CSimpleFrame {
// Virtual member functions // Virtual member functions
virtual ScriptIx* GetScriptByName(const char* name, ScriptData& data); virtual ScriptIx* GetScriptByName(const char* name, ScriptData& data);
virtual bool IsA(int32_t type); virtual bool IsA(int32_t type);
virtual int32_t GetScriptMetaTable(void); virtual int32_t GetScriptMetaTable();
virtual void LoadXML(XMLNode*, CStatus*); virtual void LoadXML(XMLNode* node, CStatus* status);
virtual void OnLayerUpdate(float elapsedSec); virtual void OnLayerUpdate(float elapsedSec);
virtual void OnFrameRender(CRenderBatch*, uint32_t); virtual void OnFrameRender(CRenderBatch*, uint32_t);
virtual void UpdateModel(void); virtual void UpdateModel();
virtual void OnModelLoaded(CM2Model* model); virtual void OnModelLoaded(CM2Model* model);
// Member functions // Member functions
CSimpleModel(CSimpleFrame*); CSimpleModel(CSimpleFrame* parent);
CM2Scene* GetScene(void); CM2Scene* GetScene();
void SetCamera(HCAMERA camera); void SetCamera(HCAMERA camera);
void SetCameraByID(uint32_t id); void SetCameraByID(uint32_t id);
void SetCameraByIndex(uint32_t index); void SetCameraByIndex(uint32_t index);
void SetFogColor(CImVector&); void SetFogColor(CImVector& fogColor);
void SetFogFar(float); void SetFogFar(float fogFar);
void SetFogNear(float); void SetFogNear(float fogNear);
void SetModel(const char*); void SetModel(const char* sourcefile);
void SetModel(CM2Model*); void SetModel(CM2Model* model);
void SetScale(float); void SetScale(float scale);
void SetSequence(uint32_t sequence); void SetSequence(uint32_t sequence);
int32_t SetSequenceTime(uint32_t sequence, int32_t time); int32_t SetSequenceTime(uint32_t sequence, int32_t time);
}; };

14
src/ui/CSimpleModelFFX.hpp
View file

@ -11,17 +11,17 @@ class CSimpleModelFFX : public CSimpleModel {
static int32_t s_metatable; static int32_t s_metatable;
// Static functions // Static functions
static CSimpleFrame* Create(CSimpleFrame*); static CSimpleFrame* Create(CSimpleFrame* parent);
static void CreateScriptMetaTable(void); static void CreateScriptMetaTable();
static void RegisterScriptMethods(lua_State*); static void RegisterScriptMethods(lua_State* L);
static void Render(void*); static void Render(void* arg);
// Virtual member functions // Virtual member functions
virtual int32_t GetScriptMetaTable(void); virtual int32_t GetScriptMetaTable();
virtual void OnFrameRender(CRenderBatch*, uint32_t); virtual void OnFrameRender(CRenderBatch* batch, uint32_t layer);
// Member functions // Member functions
CSimpleModelFFX(CSimpleFrame*); CSimpleModelFFX(CSimpleFrame* parent);
}; };
#endif #endif

20
src/ui/CSimpleRegion.hpp
View file

@ -22,21 +22,21 @@ class CSimpleRegion : public CScriptRegion {
// Virtual member functions // Virtual member functions
virtual ~CSimpleRegion(); virtual ~CSimpleRegion();
virtual void OnColorChanged(bool); virtual void OnColorChanged(bool a2);
virtual void OnScreenSizeChanged() {}; virtual void OnScreenSizeChanged() {};
virtual void Draw(CRenderBatch*) = 0; virtual void Draw(CRenderBatch* batch) = 0;
// Member functions // Member functions
CSimpleRegion(CSimpleFrame*, uint32_t, int32_t); CSimpleRegion(CSimpleFrame* frame, uint32_t drawlayer, int32_t show);
void GetVertexColor(CImVector& color) const; void GetVertexColor(CImVector& color) const;
void Hide(void); void Hide();
void HideThis(void); void HideThis();
bool IsShown(); bool IsShown();
void OnRegionChanged(void); void OnRegionChanged();
void SetVertexColor(const CImVector&); void SetVertexColor(const CImVector& color);
void SetFrame(CSimpleFrame*, uint32_t, int32_t); void SetFrame(CSimpleFrame* frame, uint32_t drawlayer, int32_t show);
void Show(void); void Show();
void ShowThis(void); void ShowThis();
}; };
#endif #endif

4
src/ui/CSimpleRender.hpp
View file

@ -10,8 +10,8 @@ class CSimpleRender {
static CGxShader* s_vertexShader[]; static CGxShader* s_vertexShader[];
// Static functions // Static functions
static void DrawBatch(CRenderBatch*); static void DrawBatch(CRenderBatch* batch);
static void Init(void); static void Init();
}; };
#endif #endif

18
src/ui/CSimpleScrollFrame.hpp
View file

@ -14,9 +14,9 @@ class CSimpleScrollFrame : public CSimpleFrame {
static int32_t s_objectType; static int32_t s_objectType;
// Static functions // Static functions
static void CreateScriptMetaTable(void); static void CreateScriptMetaTable();
static int32_t GetObjectType(void); static int32_t GetObjectType();
static void RegisterScriptMethods(lua_State*); static void RegisterScriptMethods(lua_State* L);
static void RenderScrollChild(void* param); static void RenderScrollChild(void* param);
// Member variables // Member variables
@ -29,20 +29,20 @@ class CSimpleScrollFrame : public CSimpleFrame {
ScriptIx m_onScrollRangeChanged; ScriptIx m_onScrollRangeChanged;
// Virtual member functions // Virtual member functions
virtual ScriptIx* GetScriptByName(const char*, ScriptData&); virtual ScriptIx* GetScriptByName(const char* name, ScriptData& data);
virtual bool IsA(int32_t); virtual bool IsA(int32_t type);
virtual int32_t GetScriptMetaTable(void); virtual int32_t GetScriptMetaTable();
virtual void LoadXML(XMLNode*, CStatus*); virtual void LoadXML(XMLNode* node, CStatus* status);
virtual int32_t GetBoundsRect(CRect& bounds); virtual int32_t GetBoundsRect(CRect& bounds);
virtual void OnLayerUpdate(float elapsedSec); virtual void OnLayerUpdate(float elapsedSec);
virtual void OnFrameRender(CRenderBatch* batch, uint32_t layer); virtual void OnFrameRender(CRenderBatch* batch, uint32_t layer);
virtual void OnFrameSizeChanged(float w, float h); virtual void OnFrameSizeChanged(float w, float h);
// Member functions // Member functions
CSimpleScrollFrame(CSimpleFrame*); CSimpleScrollFrame(CSimpleFrame* parent);
void RunOnScrollRangeChangedScript(); void RunOnScrollRangeChangedScript();
void RunOnVerticalScrollScript(); void RunOnVerticalScrollScript();
void SetScrollChild(CSimpleFrame*); void SetScrollChild(CSimpleFrame* frame);
void SetVerticalScroll(float offset); void SetVerticalScroll(float offset);
void UpdateScrollChild(); void UpdateScrollChild();
void UpdateScrollChildRect(float w, float h); void UpdateScrollChildRect(float w, float h);

12
src/ui/CSimpleSlider.hpp
View file

@ -10,9 +10,9 @@ class CSimpleSlider : public CSimpleFrame {
static int32_t s_objectType; static int32_t s_objectType;
// Static functions // Static functions
static void CreateScriptMetaTable(void); static void CreateScriptMetaTable();
static int32_t GetObjectType(void); static int32_t GetObjectType();
static void RegisterScriptMethods(lua_State*); static void RegisterScriptMethods(lua_State* L);
// Member variables // Member variables
int32_t m_changed : 1; int32_t m_changed : 1;
@ -27,9 +27,9 @@ class CSimpleSlider : public CSimpleFrame {
ScriptIx m_onMinMaxChanged; ScriptIx m_onMinMaxChanged;
// Virtual member functions // Virtual member functions
virtual ScriptIx* GetScriptByName(const char*, ScriptData&); virtual ScriptIx* GetScriptByName(const char* name, ScriptData& data);
virtual bool IsA(int32_t); virtual bool IsA(int32_t type);
virtual int32_t GetScriptMetaTable(void); virtual int32_t GetScriptMetaTable();
// Member functions // Member functions
CSimpleSlider(CSimpleFrame* parent) CSimpleSlider(CSimpleFrame* parent)

40
src/ui/CSimpleTexture.hpp
View file

@ -21,11 +21,11 @@ class CSimpleTexture : public CSimpleRegion {
static EGxTexFilter s_textureFilterMode; static EGxTexFilter s_textureFilterMode;
// Static functions // Static functions
static void CreateScriptMetaTable(void); static void CreateScriptMetaTable();
static CGxShader* GetImageModePixelShader(TextureImageMode); static CGxShader* GetImageModePixelShader(TextureImageMode mode);
static int32_t GetObjectType(void); static int32_t GetObjectType();
static void Init(void); static void Init();
static void RegisterScriptMethods(lua_State*); static void RegisterScriptMethods(lua_State* L);
// Member variables // Member variables
HTEXTURE m_texture = nullptr; HTEXTURE m_texture = nullptr;
@ -40,25 +40,25 @@ class CSimpleTexture : public CSimpleRegion {
// Virtual member functions // Virtual member functions
virtual ~CSimpleTexture(); virtual ~CSimpleTexture();
virtual int32_t GetScriptMetaTable(void); virtual int32_t GetScriptMetaTable();
virtual bool IsA(int32_t); virtual bool IsA(int32_t type);
virtual void LoadXML(XMLNode*, CStatus*); virtual void LoadXML(XMLNode* node, CStatus* status);
virtual float GetWidth(void); virtual float GetWidth();
virtual float GetHeight(void); virtual float GetHeight();
virtual void Draw(CRenderBatch*); virtual void Draw(CRenderBatch* batch);
virtual void OnFrameSizeChanged(const CRect&); virtual void OnFrameSizeChanged(const CRect& rect);
// Member functions // Member functions
CSimpleTexture(CSimpleFrame*, uint32_t, int32_t); CSimpleTexture(CSimpleFrame* frame, uint32_t drawlayer, int32_t show);
void GetTexCoord(C2Vector*); void GetTexCoord(C2Vector* texCoord);
void PostLoadXML(XMLNode*, CStatus*); void PostLoadXML(XMLNode* node, CStatus* status);
void SetAlpha(float alpha); void SetAlpha(float alpha);
void SetBlendMode(EGxBlend); void SetBlendMode(EGxBlend blend);
void SetPosition(const CRect&, C3Vector*); void SetPosition(const CRect& rect, C3Vector* position);
void SetTexCoord(const CRect& texRect); void SetTexCoord(const CRect& texRect);
void SetTexCoord(const C2Vector*); void SetTexCoord(const C2Vector* texCoord);
int32_t SetTexture(const char*, bool, bool, EGxTexFilter, TextureImageMode); int32_t SetTexture(const char* fileName, bool wrapU, bool wrapV, EGxTexFilter filter, TextureImageMode mode);
int32_t SetTexture(const CImVector&); int32_t SetTexture(const CImVector& color);
}; };
#endif #endif

10
src/ui/CSimpleTop.cpp
View file

@ -71,12 +71,12 @@ int32_t CSimpleTop::OnDisplaySizeChanged(const EVENT_DATA_SIZE* pSizeData, void*
return 1; return 1;
} }
int32_t CSimpleTop::OnFocusChanged(const void*, void*) { int32_t CSimpleTop::OnFocusChanged(const void* a1, void* a2) {
// TODO // TODO
return 0; return 0;
} }
int32_t CSimpleTop::OnIme(const void*, void*) { int32_t CSimpleTop::OnIme(const void* a1, void* a2) {
// TODO // TODO
return 0; return 0;
} }
@ -123,7 +123,7 @@ int32_t CSimpleTop::OnKeyDown(const EVENT_DATA_KEY* pKeyData, void* param) {
return eaten == 0; return eaten == 0;
} }
int32_t CSimpleTop::OnKeyDownRepeat(const void*, void*) { int32_t CSimpleTop::OnKeyDownRepeat(const void* a1, void* a2) {
// TODO // TODO
return 0; return 0;
} }
@ -282,7 +282,7 @@ int32_t CSimpleTop::OnMouseMove(const EVENT_DATA_MOUSE* pMouseData, void* param)
return nextFocus == nullptr; return nextFocus == nullptr;
} }
int32_t CSimpleTop::OnMouseMoveRelative(const EVENT_DATA_MOUSE*, void*) { int32_t CSimpleTop::OnMouseMoveRelative(const EVENT_DATA_MOUSE* pMouseData, void* param) {
// TODO // TODO
return 0; return 0;
} }
@ -325,7 +325,7 @@ int32_t CSimpleTop::OnMouseUp(const EVENT_DATA_MOUSE* pMouseData, void* param) {
return 0; return 0;
} }
int32_t CSimpleTop::OnMouseWheel(const EVENT_DATA_MOUSE*, void*) { int32_t CSimpleTop::OnMouseWheel(const EVENT_DATA_MOUSE* pMouseData, void* param) {
// TODO // TODO
return 0; return 0;
} }

58
src/ui/CSimpleTop.hpp
View file

@ -31,19 +31,19 @@ class CSimpleTop : public CLayoutFrame {
static uint32_t m_eventTime; static uint32_t m_eventTime;
// Static functions // Static functions
static int32_t OnChar(const EVENT_DATA_CHAR*, void*); static int32_t OnChar(const EVENT_DATA_CHAR* pCharData, void* param);
static int32_t OnDisplaySizeChanged(const EVENT_DATA_SIZE*, void*); static int32_t OnDisplaySizeChanged(const EVENT_DATA_SIZE* pSizeData, void* param);
static int32_t OnFocusChanged(const void*, void*); static int32_t OnFocusChanged(const void* a1, void* a2);
static int32_t OnIme(const void*, void*); static int32_t OnIme(const void* a1, void* a2);
static int32_t OnKeyDown(const EVENT_DATA_KEY*, void*); static int32_t OnKeyDown(const EVENT_DATA_KEY* pKeyData, void* param);
static int32_t OnKeyDownRepeat(const void*, void*); static int32_t OnKeyDownRepeat(const void* a1, void* a2);
static int32_t OnKeyUp(const EVENT_DATA_KEY*, void*); static int32_t OnKeyUp(const EVENT_DATA_KEY* pKeyData, void* param);
static int32_t OnMouseDown(const EVENT_DATA_MOUSE*, void*); static int32_t OnMouseDown(const EVENT_DATA_MOUSE* pMouseData, void* param);
static int32_t OnMouseMove(const EVENT_DATA_MOUSE*, void*); static int32_t OnMouseMove(const EVENT_DATA_MOUSE* pMouseData, void* param);
static int32_t OnMouseMoveRelative(const EVENT_DATA_MOUSE*, void*); static int32_t OnMouseMoveRelative(const EVENT_DATA_MOUSE* pMouseData, void* param);
static int32_t OnMouseUp(const EVENT_DATA_MOUSE*, void*); static int32_t OnMouseUp(const EVENT_DATA_MOUSE* pMouseData, void* param);
static int32_t OnMouseWheel(const EVENT_DATA_MOUSE*, void*); static int32_t OnMouseWheel(const EVENT_DATA_MOUSE* pMouseData, void* param);
static float RoundToPixelHeight(float); static float RoundToPixelHeight(float ddcHeight);
// Member variables // Member variables
HLAYER m_screenLayer; HLAYER m_screenLayer;
@ -63,22 +63,22 @@ class CSimpleTop : public CLayoutFrame {
// Member functions // Member functions
CSimpleTop(); CSimpleTop();
void CompressStrata(int32_t); void CompressStrata(int32_t strata);
void EnableEvents(void); void EnableEvents();
void HideFrame(CSimpleFrame*, int32_t); void HideFrame(CSimpleFrame* frame, int32_t a4);
void MoveOrResizeFrame(const CMouseEvent&); void MoveOrResizeFrame(const CMouseEvent& evt);
void NotifyFrameLayerChanged(CSimpleFrame*, uint32_t); void NotifyFrameLayerChanged(CSimpleFrame* frame, uint32_t layer);
void NotifyFrameMovedOrResized(CSimpleFrame*); void NotifyFrameMovedOrResized(CSimpleFrame* frame);
void OnLayerUpdate(float); void OnLayerUpdate(float elapsedSec);
void OnLayerRender(void); void OnLayerRender();
int32_t RaiseFrame(CSimpleFrame*, int32_t); int32_t RaiseFrame(CSimpleFrame* frame, int32_t checkOcclusion);
void RegisterForEvent(CSimpleFrame*, CSimpleEventType, int32_t, uint32_t); void RegisterForEvent(CSimpleFrame* frame, CSimpleEventType event, int32_t a4, uint32_t priority);
void RegisterFrame(CSimpleFrame*); void RegisterFrame(CSimpleFrame* frame);
void ShowFrame(CSimpleFrame*, int32_t); void ShowFrame(CSimpleFrame* frame, int32_t a3);
int32_t StartMoveOrResizeFrame(const CMouseEvent&, MOVERESIZE_REASON, int32_t); int32_t StartMoveOrResizeFrame(const CMouseEvent& start, MOVERESIZE_REASON reason, int32_t resize);
int32_t StartMoveOrResizeFrame(CSimpleFrame*, MOVERESIZE_REASON, float, float, int32_t); int32_t StartMoveOrResizeFrame(CSimpleFrame* frame, MOVERESIZE_REASON reason, float startx, float starty, int32_t a6);
int32_t StartMoveOrResizeFrame(CSimpleFrame*, MOVERESIZE_REASON, float, float, FRAMEPOINT); int32_t StartMoveOrResizeFrame(CSimpleFrame* frame, MOVERESIZE_REASON reason, float startx, float starty, FRAMEPOINT a6);
void UnregisterForEvent(CSimpleFrame*, CSimpleEventType, int32_t); void UnregisterForEvent(CSimpleFrame* frame, CSimpleEventType event, int32_t a4);
}; };
#endif #endif

44
src/ui/FrameScript.hpp
View file

@ -37,7 +37,7 @@ class FrameScript_EventObject : public TSHashObject<FrameScript_EventObject, HAS
// Member functions // Member functions
FrameScript_EventObject() : TSHashObject<FrameScript_EventObject, HASHKEY_STRI>() {}; FrameScript_EventObject() : TSHashObject<FrameScript_EventObject, HASHKEY_STRI>() {};
const char* GetName(void); const char* GetName();
}; };
extern const char* g_glueScriptEvents[41]; extern const char* g_glueScriptEvents[41];
@ -60,48 +60,48 @@ namespace FrameScript {
extern TSHashTable<FrameScript_EventObject, HASHKEY_STRI> s_scriptEventsHash; extern TSHashTable<FrameScript_EventObject, HASHKEY_STRI> s_scriptEventsHash;
} }
int32_t FrameScript_CompileFunction(const char*, const char*, const char*, CStatus*); int32_t FrameScript_CompileFunction(const char* name, const char* wrapper, const char* body, CStatus* status);
void FrameScript_CreateEvents(const char*[], uint32_t); void FrameScript_CreateEvents(const char* names[], uint32_t count);
void FrameScript_Destroy(void); void FrameScript_Destroy();
void FrameScript_Execute(const char*, const char*, const char*); void FrameScript_Execute(const char* source, const char* filename, const char* a3);
void FrameScript_Execute(int32_t, FrameScript_Object*, int32_t, const char*, FrameScript_EventObject*); void FrameScript_Execute(int32_t function, FrameScript_Object* objectThis, int32_t argCount, const char* a4, FrameScript_EventObject* event);
int32_t FrameScript_ExecuteBuffer(const char*, size_t, const char*, CStatus*, const char*); int32_t FrameScript_ExecuteBuffer(const char* buffer, size_t bufferBytes, const char* bufferName, CStatus* status, const char* a5);
int32_t FrameScript_ExecuteFile(const char*, const char*, MD5_CTX*, CStatus*); int32_t FrameScript_ExecuteFile(const char* filePath, const char* a2, MD5_CTX* md5, CStatus* status);
void FrameScript_Flush(void); void FrameScript_Flush();
void FrameScript_GetColor(lua_State* L, int32_t idx, CImVector& color); void FrameScript_GetColor(lua_State* L, int32_t idx, CImVector& color);
lua_State* FrameScript_GetContext(void); lua_State* FrameScript_GetContext();
const char* FrameScript_GetCurrentObject(lua_State*, int32_t); const char* FrameScript_GetCurrentObject(lua_State* L, int32_t a2);
char const* FrameScript_GetText(const char*, int32_t, FRAMESCRIPT_GENDER); char const* FrameScript_GetText(const char* a1, int32_t count, FRAMESCRIPT_GENDER gender);
int32_t FrameScript_GetVariable(const char*, const char**); int32_t FrameScript_GetVariable(const char* a1, const char** a2);
int32_t FrameScript_HandleError(lua_State*); int32_t FrameScript_HandleError(lua_State* L);
int32_t FrameScript_Initialize(int32_t); int32_t FrameScript_Initialize(int32_t a1);
void FrameScript_RegisterFunction(const char*, int32_t (*)(lua_State*)); void FrameScript_RegisterFunction(const char* name, int32_t (*function)(lua_State*));
void FrameScript_RegisterScriptEvent(FrameScript_Object*, FrameScript_EventObject*); void FrameScript_RegisterScriptEvent(FrameScript_Object* object, FrameScript_EventObject* event);
void FrameScript_SetPluralRule(PLURAL_RULE); void FrameScript_SetPluralRule(PLURAL_RULE rule);
void FrameScript_SignalEvent(uint32_t, const char*, ...); void FrameScript_SignalEvent(uint32_t index, const char* format, ...);
void FrameScript_UnregisterScriptEvent(FrameScript_Object*, FrameScript_EventObject*); void FrameScript_UnregisterScriptEvent(FrameScript_Object* object, FrameScript_EventObject* event);
void GlueScriptEventsInitialize(void); void GlueScriptEventsInitialize();
void ScriptEventsInitialize(void); void ScriptEventsInitialize();
#endif #endif

22
src/ui/FrameXML.hpp
View file

@ -30,26 +30,26 @@ namespace FrameXML {
extern TSHashTable<HashedNode, HASHKEY_STRI> s_nodeHash; extern TSHashTable<HashedNode, HASHKEY_STRI> s_nodeHash;
} }
XMLNode* FrameXML_AcquireHashNode(const char*, const char*&, bool&); XMLNode* FrameXML_AcquireHashNode(const char* name, const char*& tainted, bool& locked);
int32_t FrameXML_CheckSignature(const char*, const char*, const unsigned char*, unsigned char*); int32_t FrameXML_CheckSignature(const char* tocPath, const char* a2, const unsigned char* key, unsigned char* digest);
CSimpleFrame* FrameXML_CreateFrame(XMLNode*, CSimpleFrame*, CStatus*); CSimpleFrame* FrameXML_CreateFrame(XMLNode* node, CSimpleFrame* parent, CStatus* status);
int32_t FrameXML_CreateFrames(const char*, const char*, MD5_CTX*, CStatus*); int32_t FrameXML_CreateFrames(const char* tocPath, const char* a2, MD5_CTX* md5, CStatus* status);
void FrameXML_FreeHashNodes(void); void FrameXML_FreeHashNodes();
XMLTree* FrameXML_LoadXML(const char*, MD5_CTX*, CStatus*); XMLTree* FrameXML_LoadXML(const char* filePath, MD5_CTX* md5, CStatus* status);
int32_t FrameXML_ProcessFile(const char*, const char*, MD5_CTX*, CStatus*); int32_t FrameXML_ProcessFile(const char* filePath, const char* a2, MD5_CTX* md5, CStatus* status);
void FrameXML_RegisterDefault(void); void FrameXML_RegisterDefault();
int32_t FrameXML_RegisterFactory(const char*, CSimpleFrame* (*)(CSimpleFrame*), bool); int32_t FrameXML_RegisterFactory(const char* type, CSimpleFrame* (*factory)(CSimpleFrame*), bool);
void FrameXML_ReleaseHashNode(const char*); void FrameXML_ReleaseHashNode(const char* name);
void FrameXML_StoreHashNode(XMLNode*, const char*, const char*, CStatus*); void FrameXML_StoreHashNode(XMLNode* node, const char* name, const char* a3, CStatus* status);
#endif #endif

2
src/ui/Interface.cpp
View file

@ -1,5 +1,5 @@
#include "ui/Interface.hpp" #include "ui/Interface.hpp"
void DeleteInterfaceFiles(void) { void DeleteInterfaceFiles() {
// TODO // TODO
} }

2
src/ui/Interface.hpp
View file

@ -1,6 +1,6 @@
#ifndef UI_INTERFACE_HPP #ifndef UI_INTERFACE_HPP
#define UI_INTERFACE_HPP #define UI_INTERFACE_HPP
void DeleteInterfaceFiles(void); void DeleteInterfaceFiles();
#endif #endif

12
src/ui/LoadXML.hpp
View file

@ -10,16 +10,16 @@ class CStatus;
class XMLNode; class XMLNode;
class CImVector; class CImVector;
int32_t LoadXML_Color(XMLNode*, CImVector&); int32_t LoadXML_Color(XMLNode* node, CImVector& color);
int32_t LoadXML_Dimensions(XMLNode*, float&, float&, CStatus*); int32_t LoadXML_Dimensions(XMLNode* node, float& x, float& y, CStatus* status);
int32_t LoadXML_Insets(XMLNode*, float&, float&, float&, float&, CStatus*); int32_t LoadXML_Insets(XMLNode* node, float& left, float& right, float& top, float& bottom, CStatus* status);
CSimpleFontString* LoadXML_String(XMLNode*, CSimpleFrame*, CStatus*); CSimpleFontString* LoadXML_String(XMLNode* node, CSimpleFrame* frame, CStatus* status);
CSimpleTexture* LoadXML_Texture(XMLNode*, CSimpleFrame*, CStatus*); CSimpleTexture* LoadXML_Texture(XMLNode* node, CSimpleFrame* frame, CStatus* status);
int32_t LoadXML_Value(XMLNode*, float&, CStatus*); int32_t LoadXML_Value(XMLNode* node, float& value, CStatus* status);
#endif #endif

4
src/ui/LuaMemory.hpp
View file

@ -3,7 +3,7 @@
#include <cstdlib> #include <cstdlib>
void* luaM_initPool(void); void* luaM_initPool();
void* luaM_reallocPool(void*, void*, size_t, size_t); void* luaM_reallocPool(void* ud, void* ptr, size_t osize, size_t nsize);
#endif #endif

10
src/ui/ScriptFunctions.hpp
View file

@ -22,11 +22,11 @@ namespace FrameScript {
// Utility // Utility
void CharacterCreateRegisterScriptFunctions(void); void CharacterCreateRegisterScriptFunctions();
void CharSelectRegisterScriptFunctions(void); void CharSelectRegisterScriptFunctions();
void GlueScriptEventsRegisterFunctions(void); void GlueScriptEventsRegisterFunctions();
void RegisterSimpleFrameScriptMethods(void); void RegisterSimpleFrameScriptMethods();
void SystemRegisterFunctions(void); void SystemRegisterFunctions();
// Shared // Shared
int32_t Script_GetAccountExpansionLevel(lua_State*); int32_t Script_GetAccountExpansionLevel(lua_State*);

8
src/ui/Util.hpp
View file

@ -5,12 +5,12 @@
#include "ui/Types.hpp" #include "ui/Types.hpp"
#include <cstdint> #include <cstdint>
const char* LanguageProcess(const char*); const char* LanguageProcess(const char* string);
int32_t StringToBlendMode(const char*, EGxBlend&); int32_t StringToBlendMode(const char* string, EGxBlend& blend);
int32_t StringToFramePoint(const char*, FRAMEPOINT&); int32_t StringToFramePoint(const char* string, FRAMEPOINT& point);
int32_t StringToFrameStrata(const char*, FRAME_STRATA&); int32_t StringToFrameStrata(const char* string, FRAME_STRATA& strata);
#endif #endif