diff --git a/src/ui/CBackdropGenerator.hpp b/src/ui/CBackdropGenerator.hpp
index b120929..06f248e 100644
--- a/src/ui/CBackdropGenerator.hpp
+++ b/src/ui/CBackdropGenerator.hpp
@@ -40,10 +40,10 @@ class CBackdropGenerator {
 
         // Member functions
         CBackdropGenerator();
-        void Generate(const CRect*);
-        void LoadXML(XMLNode*, CStatus*);
-        void SetBorderVertexColor(const CImVector&);
-        void SetOutput(CSimpleFrame*);
+        void Generate(const CRect* rect);
+        void LoadXML(XMLNode* node, CStatus* status);
+        void SetBorderVertexColor(const CImVector& borderColor);
+        void SetOutput(CSimpleFrame* frame);
 };
 
 #endif
diff --git a/src/ui/CFramePoint.hpp b/src/ui/CFramePoint.hpp
index cccb3b4..a075175 100644
--- a/src/ui/CFramePoint.hpp
+++ b/src/ui/CFramePoint.hpp
@@ -20,13 +20,13 @@ class CFramePoint {
         uint32_t m_flags : 24;
 
         // Member functions
-        CFramePoint(CLayoutFrame*, FRAMEPOINT, float, float);
+        CFramePoint(CLayoutFrame* relative, FRAMEPOINT framePoint, float offsetX, float offsetY);
         CLayoutFrame* GetRelative();
-        int32_t GetRelativeRect(CRect&);
-        void MarkUnused(void);
-        void SetRelative(CLayoutFrame*, FRAMEPOINT, float, float);
-        float X(float);
-        float Y(float);
+        int32_t GetRelativeRect(CRect& rect);
+        void MarkUnused();
+        void SetRelative(CLayoutFrame* relative, FRAMEPOINT relativePoint, float offsetX, float offsetY);
+        float X(float scale);
+        float Y(float scale);
 };
 
 #endif
diff --git a/src/ui/CFrameStrata.hpp b/src/ui/CFrameStrata.hpp
index e2a0caa..649b22a 100644
--- a/src/ui/CFrameStrata.hpp
+++ b/src/ui/CFrameStrata.hpp
@@ -18,9 +18,9 @@ class CFrameStrataNode {
         STORM_EXPLICIT_LIST(CRenderBatch, renderLink) renderList;
 
         // Member functions
-        int32_t BuildBatches(void);
-        void OnLayerUpdate(float);
-        bool RemoveFrame(CSimpleFrame*);
+        int32_t BuildBatches();
+        void OnLayerUpdate(float elapsedSec);
+        bool RemoveFrame(CSimpleFrame* frame);
 };
 
 class CFrameStrata {
@@ -33,12 +33,12 @@ class CFrameStrata {
 
         // Member functions
         void AddFrame(CSimpleFrame*);
-        int32_t BuildBatches(int32_t);
-        void CheckOcclusion(void);
-        int32_t FrameOccluded(CSimpleFrame*);
-        void OnLayerUpdate(float);
-        void RemoveFrame(CSimpleFrame*);
-        void RenderBatches(void);
+        int32_t BuildBatches(int32_t a2);
+        void CheckOcclusion();
+        int32_t FrameOccluded(CSimpleFrame* frame);
+        void OnLayerUpdate(float elapsedSec);
+        void RemoveFrame(CSimpleFrame* frame);
+        void RenderBatches();
 };
 
 #endif
diff --git a/src/ui/CLayoutFrame.cpp b/src/ui/CLayoutFrame.cpp
index cfe6792..9074488 100644
--- a/src/ui/CLayoutFrame.cpp
+++ b/src/ui/CLayoutFrame.cpp
@@ -190,7 +190,7 @@ int32_t CLayoutFrame::CalculateRect(CRect* rect) {
     return 1;
 }
 
-bool CLayoutFrame::CanBeAnchorFor(CLayoutFrame*) {
+bool CLayoutFrame::CanBeAnchorFor(CLayoutFrame* frame) {
     // TODO
 
     return true;
diff --git a/src/ui/CLayoutFrame.hpp b/src/ui/CLayoutFrame.hpp
index 36f8f7c..19fe973 100644
--- a/src/ui/CLayoutFrame.hpp
+++ b/src/ui/CLayoutFrame.hpp
@@ -20,7 +20,7 @@ class CLayoutFrame {
         };
 
         // Static functions
-        static void ResizePending(void);
+        static void ResizePending();
 
         // Member variables
         TSLink<CLayoutFrame> resizeLink;
@@ -44,51 +44,51 @@ class CLayoutFrame {
 
         // Virtual member functions
         virtual ~CLayoutFrame();
-        virtual CLayoutFrame* GetLayoutParent(void);
-        virtual bool SetLayoutScale(float, bool);
-        virtual void SetWidth(float);
-        virtual void SetHeight(float);
-        virtual float GetWidth(void);
-        virtual float GetHeight(void);
-        virtual void GetClampRectInsets(float&, float&, float&, float&);
-        virtual int32_t IsAttachmentOrigin(void);
-        virtual CLayoutFrame* GetLayoutFrameByName(const char*);
-        virtual int32_t IsObjectLoaded(void);
-        virtual void OnFrameSizeChanged(const CRect&);
+        virtual CLayoutFrame* GetLayoutParent();
+        virtual bool SetLayoutScale(float scale, bool force);
+        virtual void SetWidth(float width);
+        virtual void SetHeight(float height);
+        virtual float GetWidth();
+        virtual float GetHeight();
+        virtual void GetClampRectInsets(float& a1, float& a2, float& a3, float& a4);
+        virtual int32_t IsAttachmentOrigin();
+        virtual CLayoutFrame* GetLayoutFrameByName(const char* name);
+        virtual int32_t IsObjectLoaded();
+        virtual void OnFrameSizeChanged(const CRect& rect);
 
         // Member functions
         CLayoutFrame();
-        void AddToResizeList(void);
-        float Bottom(void);
-        int32_t CalculateRect(CRect*);
-        bool CanBeAnchorFor(CLayoutFrame*);
-        float CenterX(void);
-        float CenterY(void);
-        void ClearAllPoints(void);
+        void AddToResizeList();
+        float Bottom();
+        int32_t CalculateRect(CRect* rect);
+        bool CanBeAnchorFor(CLayoutFrame* frame);
+        float CenterX();
+        float CenterY();
+        void ClearAllPoints();
         void DestroyLayout();
-        void FreePoints(void);
-        void GetFirstPointX(const FRAMEPOINT* const, int32_t, float&);
-        void GetFirstPointY(const FRAMEPOINT* const, int32_t, float&);
-        int32_t GetRect(CRect*);
-        int32_t IsResizeDependency(CLayoutFrame*);
-        uint32_t IsResizePending(void);
-        float Left(void);
-        void LoadXML(XMLNode*, CStatus*);
-        int32_t OnFrameResize(void);
-        void OnProtectedAttach(CLayoutFrame*);
-        int32_t PtInFrameRect(const C2Vector&);
-        void RegisterResize(CLayoutFrame*, uint32_t);
-        void Resize(int32_t);
-        float Right(void);
-        void SetAllPoints(CLayoutFrame*, int32_t);
-        void SetDeferredResize(int32_t);
-        void SetPoint(FRAMEPOINT, CLayoutFrame*, FRAMEPOINT, float, float, int32_t);
-        void SetProtectFlag(uint32_t);
-        int32_t Sub488DB0(const FRAMEPOINT* const, int32_t, float&);
-        int32_t Sub488E40(const FRAMEPOINT* const, int32_t, float&);
-        float Top(void);
-        void UnflattenFrame(CLayoutFrame*);
-        void UnregisterResize(CLayoutFrame*, uint32_t);
+        void FreePoints();
+        void GetFirstPointX(const FRAMEPOINT* const pointarray, int32_t elements, float& x);
+        void GetFirstPointY(const FRAMEPOINT* const pointarray, int32_t elements, float& y);
+        int32_t GetRect(CRect* rect);
+        int32_t IsResizeDependency(CLayoutFrame* dependentFrame);
+        uint32_t IsResizePending();
+        float Left();
+        void LoadXML(XMLNode* node, CStatus* status);
+        int32_t OnFrameResize();
+        void OnProtectedAttach(CLayoutFrame* frame);
+        int32_t PtInFrameRect(const C2Vector& pt);
+        void RegisterResize(CLayoutFrame* frame, uint32_t dep);
+        void Resize(int32_t force);
+        float Right();
+        void SetAllPoints(CLayoutFrame* relative, int32_t doResize);
+        void SetDeferredResize(int32_t enable);
+        void SetPoint(FRAMEPOINT point, CLayoutFrame* relative, FRAMEPOINT relativePoint, float offsetX, float offsetY, int32_t doResize);
+        void SetProtectFlag(uint32_t flag);
+        int32_t Sub488DB0(const FRAMEPOINT* const pointarray, int32_t elements, float& x);
+        int32_t Sub488E40(const FRAMEPOINT* const pointarray, int32_t elements, float& y);
+        float Top();
+        void UnflattenFrame(CLayoutFrame* frame);
+        void UnregisterResize(CLayoutFrame* frame, uint32_t dep);
 };
 
 namespace LayoutFrame {
diff --git a/src/ui/CRenderBatch.hpp b/src/ui/CRenderBatch.hpp
index ee6ebea..a2a1ca5 100644
--- a/src/ui/CRenderBatch.hpp
+++ b/src/ui/CRenderBatch.hpp
@@ -39,7 +39,7 @@ class CSimpleBatchedMesh {
         C2Vector atlasOffset;
 
         // Member functions
-        EGxBlend GetAlphaMode(void);
+        EGxBlend GetAlphaMode();
 };
 
 class CRenderBatch {
@@ -52,12 +52,12 @@ class CRenderBatch {
         TSLink<CRenderBatch> renderLink;
 
         // Member functions
-        void Clear(void);
-        void Finish(void);
-        void Queue(CTexture*, EGxBlend, int32_t, const C3Vector*, const C2Vector*, int32_t, const CImVector*, int32_t, const uint16_t*, CGxShader*);
-        void QueueCallback(void (*)(void*), void*);
-        void QueueFontString(CSimpleFontString*);
-        void QueueTexture(CSimpleTexture*);
+        void Clear();
+        void Finish();
+        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 (*callback)(void*), void* param);
+        void QueueFontString(CSimpleFontString* string);
+        void QueueTexture(CSimpleTexture* texture);
 };
 
 #endif
diff --git a/src/ui/CScriptObject.hpp b/src/ui/CScriptObject.hpp
index 018a9e9..be2a64a 100644
--- a/src/ui/CScriptObject.hpp
+++ b/src/ui/CScriptObject.hpp
@@ -15,24 +15,24 @@ class CScriptObject : public FrameScript_Object {
         static const char* s_objectTypeName;
 
         // Static functions
-        static void RegisterScriptMethods(lua_State*);
-        static CScriptObject* GetScriptObjectByName(const char*, int32_t);
+        static void RegisterScriptMethods(lua_State* L);
+        static CScriptObject* GetScriptObjectByName(const char* name, int32_t type);
 
         // Member variables
         RCString m_name;
 
         // Virtual member functions
-        virtual ~CScriptObject(void);
-        virtual char* GetName(void);
-        virtual bool IsA(int32_t);
-        virtual CScriptObject* GetScriptObjectParent(void) = 0;
-        virtual bool IsA(const char*);
-        virtual const char* GetObjectTypeName(void);
+        virtual ~CScriptObject();
+        virtual char* GetName();
+        virtual bool IsA(int32_t type);
+        virtual CScriptObject* GetScriptObjectParent() = 0;
+        virtual bool IsA(const char* typeName);
+        virtual const char* GetObjectTypeName();
 
         // Member functions
-        void CreateName(const char*, char*, uint32_t);
-        void PreLoadXML(XMLNode*, CStatus*);
-        void SetName(const char*);
+        void CreateName(const char* source, char* dest, uint32_t destsize);
+        void PreLoadXML(XMLNode* node, CStatus* status);
+        void SetName(const char* name);
 };
 
 #endif
diff --git a/src/ui/CScriptRegion.hpp b/src/ui/CScriptRegion.hpp
index ff75ee9..6c34039 100644
--- a/src/ui/CScriptRegion.hpp
+++ b/src/ui/CScriptRegion.hpp
@@ -17,36 +17,36 @@ class CScriptRegion : public CScriptObject, public CLayoutFrame {
         static const char* s_objectTypeName;
 
         // Static functions
-        static void RegisterScriptMethods(lua_State*);
-        static int32_t GetObjectType(void);
+        static void RegisterScriptMethods(lua_State* L);
+        static int32_t GetObjectType();
 
         // Member variables
         CSimpleFrame* m_parent = NULL; // TODO verify type
 
         // Virtual member functions
-        virtual bool IsA(int32_t);
-        virtual CScriptObject* GetScriptObjectParent(void);
-        virtual bool IsA(const char*);
-        virtual const char* GetObjectTypeName(void);
-        virtual bool IsDragging(void);
-        virtual void PreOnAnimUpdate(void) {};
-        virtual void OnLayerUpdate(float);
-        virtual void NotifyAnimBegin(CSimpleAnimGroup*);
-        virtual void NotifyAnimEnd(CSimpleAnimGroup*);
-        virtual void StopAnimating(void);
-        virtual void AnimActivated(CSimpleAnimGroup*, int32_t, int32_t) {};
-        virtual void AnimDeactivated(CSimpleAnimGroup*, int32_t, int32_t) {};
+        virtual bool IsA(int32_t type);
+        virtual CScriptObject* GetScriptObjectParent();
+        virtual bool IsA(const char* typeName);
+        virtual const char* GetObjectTypeName();
+        virtual bool IsDragging();
+        virtual void PreOnAnimUpdate() {};
+        virtual void OnLayerUpdate(float elapsedSec);
+        virtual void NotifyAnimBegin(CSimpleAnimGroup* animGroup);
+        virtual void NotifyAnimEnd(CSimpleAnimGroup* animGroup);
+        virtual void StopAnimating();
+        virtual void AnimActivated(CSimpleAnimGroup* animGroup, int32_t, int32_t) {};
+        virtual void AnimDeactivated(CSimpleAnimGroup* animGroup, int32_t, int32_t) {};
         virtual void AddAnimTranslation(CScriptRegion*, const C2Vector&) {};
         virtual void AddAnimRotation(CScriptRegion*, FRAMEPOINT, const C2Vector&, float) {};
         virtual void AddAnimScale(CScriptRegion*, FRAMEPOINT, const C2Vector&, const C2Vector&) {};
         virtual void AddAnimAlpha(CScriptRegion*, int16_t) {};
-        virtual void LoadXML(XMLNode*, CStatus*);
-        virtual CLayoutFrame* GetLayoutParent(void);
-        virtual CLayoutFrame* GetLayoutFrameByName(const char*);
+        virtual void LoadXML(XMLNode* node, CStatus* status);
+        virtual CLayoutFrame* GetLayoutParent();
+        virtual CLayoutFrame* GetLayoutFrameByName(const char* name);
 
         // Member functions
-        void LoadXML_Animations(XMLNode*, CStatus*);
-        bool ProtectedFunctionsAllowed(void);
+        void LoadXML_Animations(XMLNode* node, CStatus* status);
+        bool ProtectedFunctionsAllowed();
 };
 
 #endif
diff --git a/src/ui/CSimpleButton.hpp b/src/ui/CSimpleButton.hpp
index 083c80e..aace692 100644
--- a/src/ui/CSimpleButton.hpp
+++ b/src/ui/CSimpleButton.hpp
@@ -22,9 +22,9 @@ class CSimpleButton : public CSimpleFrame {
         static int32_t s_objectType;
 
         // Static functions
-        static void CreateScriptMetaTable(void);
-        static int32_t GetObjectType(void);
-        static void RegisterScriptMethods(lua_State*);
+        static void CreateScriptMetaTable();
+        static int32_t GetObjectType();
+        static void RegisterScriptMethods(lua_State* L);
 
         // Member variables
         uint32_t m_doubleClickTime = 0;
@@ -45,33 +45,33 @@ class CSimpleButton : public CSimpleFrame {
         ScriptIx m_onDoubleClick;
 
         // Virtual member functions
-        virtual ScriptIx* GetScriptByName(const char*, ScriptData&);
-        virtual bool IsA(int32_t);
-        virtual int32_t GetScriptMetaTable(void);
-        virtual void LoadXML(XMLNode*, CStatus*);
-        virtual void OnLayerHide(void);
-        virtual void OnLayerCursorEnter(int32_t);
-        virtual void OnLayerCursorExit(int32_t, int32_t);
-        virtual int32_t OnLayerMouseDown(const CMouseEvent&, const char*);
-        virtual int32_t OnLayerMouseUp(const CMouseEvent&, const char*);
-        virtual void LockHighlight(int32_t);
-        virtual void Enable(int32_t);
-        virtual void OnClick(const char*, int32_t);
-        virtual void OnDoubleClick(const char*);
-        virtual void SetButtonState(CSimpleButtonState, int32_t);
+        virtual ScriptIx* GetScriptByName(const char* name, ScriptData& data);
+        virtual bool IsA(int32_t type);
+        virtual int32_t GetScriptMetaTable();
+        virtual void LoadXML(XMLNode* node, CStatus* status);
+        virtual void OnLayerHide();
+        virtual void OnLayerCursorEnter(int32_t a2);
+        virtual void OnLayerCursorExit(int32_t a2, int32_t a3);
+        virtual int32_t OnLayerMouseDown(const CMouseEvent& evt, const char* btn);
+        virtual int32_t OnLayerMouseUp(const CMouseEvent& evt, const char* btn);
+        virtual void LockHighlight(int32_t lock);
+        virtual void Enable(int32_t enabled);
+        virtual void OnClick(const char* btn, int32_t a3);
+        virtual void OnDoubleClick(const char* btn);
+        virtual void SetButtonState(CSimpleButtonState state, int32_t stateLocked);
 
         // Member functions
-        CSimpleButton(CSimpleFrame*);
-        void RunOnClickScript(const char*, int32_t);
+        CSimpleButton(CSimpleFrame* parent);
+        void RunOnClickScript(const char* btn, int32_t down);
         void SetClickAction(uint64_t action);
-        void SetFontString(CSimpleFontString*);
-        void SetHighlight(CSimpleTexture*, EGxBlend);
+        void SetFontString(CSimpleFontString* text);
+        void SetHighlight(CSimpleTexture* texture, EGxBlend blend);
         int32_t SetHighlight(const char* texFile, EGxBlend blendMode);
-        void SetPressedOffset(C2Vector&);
-        void SetStateTexture(CSimpleButtonState, CSimpleTexture*);
+        void SetPressedOffset(C2Vector& offset);
+        void SetStateTexture(CSimpleButtonState state, CSimpleTexture* texture);
         int32_t SetStateTexture(CSimpleButtonState state, const char* texFile);
-        void SetText(const char*);
-        void UpdateTextState(CSimpleButtonState);
+        void SetText(const char* string);
+        void UpdateTextState(CSimpleButtonState state);
 };
 
 #endif
diff --git a/src/ui/CSimpleCheckbox.hpp b/src/ui/CSimpleCheckbox.hpp
index 866a21e..3435844 100644
--- a/src/ui/CSimpleCheckbox.hpp
+++ b/src/ui/CSimpleCheckbox.hpp
@@ -10,18 +10,18 @@ class CSimpleCheckbox : public CSimpleButton {
         static int32_t s_objectType;
 
         // Static functions
-        static void CreateScriptMetaTable(void);
-        static int32_t GetObjectType(void);
-        static void RegisterScriptMethods(lua_State*);
+        static void CreateScriptMetaTable();
+        static int32_t GetObjectType();
+        static void RegisterScriptMethods(lua_State* L);
 
         // Member variables
 
         // Virtual member functions
-        virtual bool IsA(int32_t);
-        virtual int32_t GetScriptMetaTable(void);
+        virtual bool IsA(int32_t type);
+        virtual int32_t GetScriptMetaTable();
 
         // Member functions
-        CSimpleCheckbox(CSimpleFrame*);
+        CSimpleCheckbox(CSimpleFrame* parent);
 };
 
 #endif
diff --git a/src/ui/CSimpleEditBox.cpp b/src/ui/CSimpleEditBox.cpp
index fe5bb6b..028f037 100644
--- a/src/ui/CSimpleEditBox.cpp
+++ b/src/ui/CSimpleEditBox.cpp
@@ -749,14 +749,14 @@ void CSimpleEditBox::MoveForward(int32_t highlight) {
     }
 }
 
-void CSimpleEditBox::OnEnterPressed(void) {
+void CSimpleEditBox::OnEnterPressed() {
     this->RunOnEnterPressedScript();
 
     // TODO
     // - invoke action
 }
 
-void CSimpleEditBox::OnEscapePressed(void) {
+void CSimpleEditBox::OnEscapePressed() {
     // TODO
 }
 
diff --git a/src/ui/CSimpleEditBox.hpp b/src/ui/CSimpleEditBox.hpp
index bd890c0..5fb7e26 100644
--- a/src/ui/CSimpleEditBox.hpp
+++ b/src/ui/CSimpleEditBox.hpp
@@ -15,10 +15,10 @@ class CSimpleEditBox : public CSimpleFrame, CSimpleFontedFrame {
         static int32_t s_objectType;
 
         // Static functions
-        static void CreateScriptMetaTable(void);
-        static int32_t GetObjectType(void);
-        static void RegisterScriptMethods(lua_State*);
-        static void SetKeyboardFocus(CSimpleEditBox*);
+        static void CreateScriptMetaTable();
+        static int32_t GetObjectType();
+        static void RegisterScriptMethods(lua_State* L);
+        static void SetKeyboardFocus(CSimpleEditBox* editBox);
 
         // Member variables
         int32_t m_autoFocus : 1;
@@ -63,52 +63,52 @@ class CSimpleEditBox : public CSimpleFrame, CSimpleFontedFrame {
         ScriptIx m_onCharComposition;
 
         // Virtual member functions
-        virtual ScriptIx* GetScriptByName(const char*, ScriptData&);
-        virtual bool IsA(int32_t);
-        virtual int32_t GetScriptMetaTable(void);
-        virtual void LoadXML(XMLNode*, CStatus*);
-        virtual void OnLayerUpdate(float);
-        virtual void OnFrameSizeChanged(float, float);
-        virtual int32_t OnLayerChar(const CCharEvent&);
-        virtual int32_t OnLayerKeyDown(const CKeyEvent&);
-        virtual int32_t OnLayerMouseDown(const CMouseEvent&, const char*);
-        virtual int32_t OnLayerMouseUp(const CMouseEvent&, const char*);
-        virtual void FontUpdated(CSimpleFontedFrameFont*, int32_t);
+        virtual ScriptIx* GetScriptByName(const char* name, ScriptData& data);
+        virtual bool IsA(int32_t type);
+        virtual int32_t GetScriptMetaTable();
+        virtual void LoadXML(XMLNode* node, CStatus* status);
+        virtual void OnLayerUpdate(float elapsedSec);
+        virtual void OnFrameSizeChanged(float width, float height);
+        virtual int32_t OnLayerChar(const CCharEvent& evt);
+        virtual int32_t OnLayerKeyDown(const CKeyEvent& evt);
+        virtual int32_t OnLayerMouseDown(const CMouseEvent& evt, const char* btn);
+        virtual int32_t OnLayerMouseUp(const CMouseEvent& evt, const char* btn);
+        virtual void FontUpdated(CSimpleFontedFrameFont* font, int32_t a3);
 
         // Member functions
-        CSimpleEditBox(CSimpleFrame*);
-        int32_t ConvertCoordinateToIndex(float, float, int32_t&);
+        CSimpleEditBox(CSimpleFrame* parent);
+        int32_t ConvertCoordinateToIndex(float a2, float a3, int32_t& a4);
         void DeleteBackward(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);
-        int32_t GetNumToLen(int32_t, int32_t, bool);
-        void GrowText(int32_t);
-        void Insert(uint32_t);
-        void Insert(const char*, const char*, int32_t, int32_t, int32_t);
-        int32_t IsCurrentFocus(void);
+        int32_t GetNumToLen(int32_t offset, int32_t amount, bool a4);
+        void GrowText(int32_t size);
+        void Insert(uint32_t chr);
+        void Insert(const char* a2, const char* a3, int32_t a4, int32_t a5, int32_t a6);
+        int32_t IsCurrentFocus();
         void Move(int32_t distance, int32_t highlight);
         void MoveBackward(int32_t highlight);
         void MoveForward(int32_t highlight);
-        void OnEnterPressed(void);
-        void OnEscapePressed(void);
-        void OnTextChanged(void);
-        int32_t PrevCharOffset(int32_t);
-        void RunOnCursorChangedScript(float, float, float, float);
-        void RunOnEditFocusGainedScript(void);
-        void RunOnEditFocusLostScript(void);
-        void RunOnEnterPressedScript(void);
-        void RunOnTextChangedScript(int32_t);
-        void SetCursorPosition(int32_t);
-        void SetHistoryLines(int32_t);
-        void SetMultiLine(int32_t);
-        void StartHighlight(void);
-        void UpdateDirtyBits(void);
-        void UpdateSizes(void);
-        void UpdateTextInfo(void);
-        void UpdateVisibleCursor(void);
-        void UpdateVisibleHighlight(void);
-        void UpdateVisibleText(void);
+        void OnEnterPressed();
+        void OnEscapePressed();
+        void OnTextChanged();
+        int32_t PrevCharOffset(int32_t offset);
+        void RunOnCursorChangedScript(float x, float y, float w, float h);
+        void RunOnEditFocusGainedScript();
+        void RunOnEditFocusLostScript();
+        void RunOnEnterPressedScript();
+        void RunOnTextChangedScript(int32_t changed);
+        void SetCursorPosition(int32_t position);
+        void SetHistoryLines(int32_t a2);
+        void SetMultiLine(int32_t enabled);
+        void StartHighlight();
+        void UpdateDirtyBits();
+        void UpdateSizes();
+        void UpdateTextInfo();
+        void UpdateVisibleCursor();
+        void UpdateVisibleHighlight();
+        void UpdateVisibleText();
 };
 
 #endif
diff --git a/src/ui/CSimpleFont.hpp b/src/ui/CSimpleFont.hpp
index e2bcbc1..d51a90c 100644
--- a/src/ui/CSimpleFont.hpp
+++ b/src/ui/CSimpleFont.hpp
@@ -29,10 +29,10 @@ class CSimpleFont : public FrameScript_Object, public CSimpleFontable {
         static int32_t s_objectType;
 
         // Static functions
-        static void CreateScriptMetaTable(void);
-        static CSimpleFont* GetFont(const char*, int32_t);
+        static void CreateScriptMetaTable();
+        static CSimpleFont* GetFont(const char* name, int32_t a2);
         static int32_t GetObjectType();
-        static void RegisterScriptMethods(lua_State*);
+        static void RegisterScriptMethods(lua_State* L);
 
         // Member variables
         CSimpleFontStringAttributes m_attributes;
@@ -40,15 +40,15 @@ class CSimpleFont : public FrameScript_Object, public CSimpleFontable {
         STORM_EXPLICIT_LIST(CSimpleFontable, m_fontableLink) m_fontableList;
 
         // Virtual member functions
-        virtual char* GetName(void);
-        virtual int32_t GetScriptMetaTable(void);
-        virtual bool IsA(int32_t);
-        virtual void FontObjectUpdated(CSimpleFontStringAttributes&);
+        virtual char* GetName();
+        virtual int32_t GetScriptMetaTable();
+        virtual bool IsA(int32_t type);
+        virtual void FontObjectUpdated(CSimpleFontStringAttributes& attributes);
 
         // Member functions
         CSimpleFont();
-        void LoadXML(XMLNode*, CStatus*);
-        void UpdateObjects(void);
+        void LoadXML(XMLNode* node, CStatus* status);
+        void UpdateObjects();
 };
 
 #endif
diff --git a/src/ui/CSimpleFontString.hpp b/src/ui/CSimpleFontString.hpp
index 8847a7a..a8a538d 100644
--- a/src/ui/CSimpleFontString.hpp
+++ b/src/ui/CSimpleFontString.hpp
@@ -16,9 +16,9 @@ class CSimpleFontString : public CSimpleRegion, public CSimpleFontable {
         static int32_t s_objectType;
 
         // Static functions
-        static void CreateScriptMetaTable(void);
-        static int32_t GetObjectType(void);
-        static void RegisterScriptMethods(lua_State*);
+        static void CreateScriptMetaTable();
+        static int32_t GetObjectType();
+        static void RegisterScriptMethods(lua_State* L);
 
         // Member variables
         HTEXTFONT m_font = nullptr;
@@ -42,48 +42,48 @@ class CSimpleFontString : public CSimpleRegion, public CSimpleFontable {
 
         // Virtual member functions
         virtual ~CSimpleFontString();
-        virtual bool IsA(int32_t);
-        virtual int32_t GetScriptMetaTable(void);
-        virtual void LoadXML(XMLNode*, CStatus*);
-        virtual void OnColorChanged(bool);
+        virtual bool IsA(int32_t type);
+        virtual int32_t GetScriptMetaTable();
+        virtual void LoadXML(XMLNode* node, CStatus* status);
+        virtual void OnColorChanged(bool a2);
         virtual void OnScreenSizeChanged();
-        virtual void Draw(CRenderBatch*);
-        virtual float GetWidth(void);
-        virtual float GetHeight(void);
-        virtual void OnFrameSizeChanged(const CRect&);
-        virtual void FontObjectUpdated(CSimpleFontStringAttributes&);
+        virtual void Draw(CRenderBatch* batch);
+        virtual float GetWidth();
+        virtual float GetHeight();
+        virtual void OnFrameSizeChanged(const CRect& rect);
+        virtual void FontObjectUpdated(CSimpleFontStringAttributes& attributes);
 
         // Member functions
-        CSimpleFontString(CSimpleFrame*, uint32_t, int32_t);
-        void AddShadow(const CImVector&, const C2Vector&);
-        void ClearString(void);
-        void DrawEmbeddedTextures(CRenderBatch*);
-        void FreeEmbeddedTextures(void);
-        const char* GetDisplayText(float, float);
-        uint32_t GetFontFlags(void);
-        float GetFontHeight(bool);
-        const char* GetFontName(void);
-        uint32_t GetNumCharsWithinWidth(const char*, uint32_t, float);
-        float GetStringHeight(void);
-        float GetStringWidth(void);
-        const char* GetText(void);
-        float GetTextWidth(const char*, uint32_t);
-        void PostLoadXML(XMLNode*, CStatus*);
-        void RefreshEmbeddedTextures(void);
-        void RemoveShadow(void);
-        int32_t SetFont(const char*, float, uint32_t, bool);
-        void SetIndentedWordWrap(bool);
-        void SetJustificationOffset(float, float);
-        void SetJustifyV(uint8_t);
-        void SetJustifyH(uint8_t);
-        void SetNonSpaceWrap(int32_t);
-        void SetNonWordWrap(int32_t);
-        void SetSpacing(float);
-        void SetStyleFlags(uint32_t);
-        void SetText(const char*, int32_t);
-        void SetTextLength(uint32_t);
+        CSimpleFontString(CSimpleFrame* frame, uint32_t drawlayer, int32_t show);
+        void AddShadow(const CImVector& shadowColor, const C2Vector& shadowOffset);
+        void ClearString();
+        void DrawEmbeddedTextures(CRenderBatch* batch);
+        void FreeEmbeddedTextures();
+        const char* GetDisplayText(float width, float height);
+        uint32_t GetFontFlags();
+        float GetFontHeight(bool a2);
+        const char* GetFontName();
+        uint32_t GetNumCharsWithinWidth(const char* text, uint32_t textBytes, float maxWidth);
+        float GetStringHeight();
+        float GetStringWidth();
+        const char* GetText();
+        float GetTextWidth(const char* text, uint32_t textBytes);
+        void PostLoadXML(XMLNode* node, CStatus* status);
+        void RefreshEmbeddedTextures();
+        void RemoveShadow();
+        int32_t SetFont(const char* fontName, float fontHeight, uint32_t fontFlags, bool force);
+        void SetIndentedWordWrap(bool a2);
+        void SetJustificationOffset(float x, float y);
+        void SetJustifyV(uint8_t justify);
+        void SetJustifyH(uint8_t justify);
+        void SetNonSpaceWrap(int32_t a2);
+        void SetNonWordWrap(int32_t a2);
+        void SetSpacing(float spacing);
+        void SetStyleFlags(uint32_t styleFlags);
+        void SetText(const char* text, int32_t a3);
+        void SetTextLength(uint32_t a2);
         int32_t Sub482AC0();
-        void UpdateString(void);
+        void UpdateString();
 };
 
 #endif
diff --git a/src/ui/CSimpleFontStringAttributes.hpp b/src/ui/CSimpleFontStringAttributes.hpp
index 1e8365a..7d1c7b1 100644
--- a/src/ui/CSimpleFontStringAttributes.hpp
+++ b/src/ui/CSimpleFontStringAttributes.hpp
@@ -21,17 +21,17 @@ class CSimpleFontStringAttributes {
         C2Vector m_shadowOffset;
 
         // Member functions
-        void SetColor(const CImVector&);
-        int32_t SetFont(const char*, float, uint32_t);
-        void SetIndented(bool);
-        void SetJustifyV(uint8_t);
-        void SetJustifyH(uint8_t);
-        void SetNonSpaceWrap(bool);
-        void SetShadow(const CImVector&, const C2Vector&);
-        void SetSpacing(float);
-        void SetStyleFlags(uint32_t);
-        void Update(CSimpleFontString*, uint32_t);
-        void Update(CSimpleFontStringAttributes&, uint32_t);
+        void SetColor(const CImVector& color);
+        int32_t SetFont(const char* fontName, float fontHeight, uint32_t fontFlags);
+        void SetIndented(bool indented);
+        void SetJustifyV(uint8_t justify);
+        void SetJustifyH(uint8_t justify);
+        void SetNonSpaceWrap(bool wrap);
+        void SetShadow(const CImVector& shadowColor, const C2Vector& shadowOffset);
+        void SetSpacing(float spacing);
+        void SetStyleFlags(uint32_t styleFlags);
+        void Update(CSimpleFontString* fontString, uint32_t flags);
+        void Update(CSimpleFontStringAttributes& attributes, uint32_t flags);
 };
 
 #endif
diff --git a/src/ui/CSimpleFontable.hpp b/src/ui/CSimpleFontable.hpp
index b081fe8..9740d31 100644
--- a/src/ui/CSimpleFontable.hpp
+++ b/src/ui/CSimpleFontable.hpp
@@ -16,11 +16,11 @@ class CSimpleFontable {
 
         // Virtual member functions
         virtual ~CSimpleFontable();
-        virtual void FontObjectUpdated(CSimpleFontStringAttributes&) = 0;
+        virtual void FontObjectUpdated(CSimpleFontStringAttributes& attributes) = 0;
 
         // Member functions
-        CSimpleFont* GetFontObject(void);
-        void SetFontObject(CSimpleFont*);
+        CSimpleFont* GetFontObject();
+        void SetFontObject(CSimpleFont* fontObject);
 };
 
 #endif
diff --git a/src/ui/CSimpleFrame.cpp b/src/ui/CSimpleFrame.cpp
index 2173950..05199ed 100644
--- a/src/ui/CSimpleFrame.cpp
+++ b/src/ui/CSimpleFrame.cpp
@@ -1542,7 +1542,7 @@ int32_t CSimpleFrame::TestHitRect(const C2Vector& pt) {
     return rect.IsPointInside(pt);
 }
 
-void CSimpleFrame::UpdateDepth(bool a1) {
+void CSimpleFrame::UpdateDepth(bool a2) {
     // TODO
 }
 
diff --git a/src/ui/CSimpleFrame.hpp b/src/ui/CSimpleFrame.hpp
index d7df261..597b1f2 100644
--- a/src/ui/CSimpleFrame.hpp
+++ b/src/ui/CSimpleFrame.hpp
@@ -23,9 +23,9 @@ class CSimpleFrame : public CScriptRegion {
         static int32_t s_objectType;
 
         // Static functions
-        static void CreateScriptMetaTable(void);
-        static int32_t GetObjectType(void);
-        static void RegisterScriptMethods(lua_State*);
+        static void CreateScriptMetaTable();
+        static int32_t GetObjectType();
+        static void RegisterScriptMethods(lua_State* L);
 
         // Member variables
         CSimpleTop* m_top = NULL;
@@ -82,81 +82,81 @@ class CSimpleFrame : public CScriptRegion {
 
         // Virtual member functions
         virtual ~CSimpleFrame();
-        virtual ScriptIx* GetScriptByName(const char*, ScriptData&);
-        virtual bool IsA(int32_t);
-        virtual int32_t GetScriptMetaTable(void);
-        virtual void LoadXML(XMLNode*, CStatus*);
-        virtual void PreOnAnimUpdate(void);
-        virtual void OnLayerShow(void);
-        virtual void OnLayerHide(void);
-        virtual void OnLayerUpdate(float);
-        virtual int32_t OnLayerTrackUpdate(const CMouseEvent&);
-        virtual void OnFrameRender(void);
-        virtual void OnFrameRender(CRenderBatch*, uint32_t);
+        virtual ScriptIx* GetScriptByName(const char* name, ScriptData& data);
+        virtual bool IsA(int32_t type);
+        virtual int32_t GetScriptMetaTable();
+        virtual void LoadXML(XMLNode* node, CStatus* status);
+        virtual void PreOnAnimUpdate();
+        virtual void OnLayerShow();
+        virtual void OnLayerHide();
+        virtual void OnLayerUpdate(float elapsedSec);
+        virtual int32_t OnLayerTrackUpdate(const CMouseEvent& evt);
+        virtual void OnFrameRender();
+        virtual void OnFrameRender(CRenderBatch* batch, uint32_t layer);
         virtual void OnScreenSizeChanged();
-        virtual void OnFrameSizeChanged(float, float);
-        virtual void OnLayerCursorEnter(int32_t);
-        virtual void OnLayerCursorExit(int32_t, int32_t);
-        virtual int32_t OnLayerChar(const CCharEvent&);
-        virtual int32_t OnLayerKeyDown(const CKeyEvent&);
-        virtual int32_t OnLayerKeyUp(const CKeyEvent&);
-        virtual int32_t OnLayerMouseDown(const CMouseEvent&, const char*);
-        virtual int32_t OnLayerMouseUp(const CMouseEvent&, const char*);
-        virtual void PostLoadXML(XMLNode*, CStatus*);
-        virtual void UnregisterRegion(CSimpleRegion*);
+        virtual void OnFrameSizeChanged(float width, float height);
+        virtual void OnLayerCursorEnter(int32_t a2);
+        virtual void OnLayerCursorExit(int32_t a2, int32_t a3);
+        virtual int32_t OnLayerChar(const CCharEvent& evt);
+        virtual int32_t OnLayerKeyDown(const CKeyEvent& evt);
+        virtual int32_t OnLayerKeyUp(const CKeyEvent& evt);
+        virtual int32_t OnLayerMouseDown(const CMouseEvent& evt, const char* btn);
+        virtual int32_t OnLayerMouseUp(const CMouseEvent& evt, const char* btn);
+        virtual void PostLoadXML(XMLNode* node, CStatus* status);
+        virtual void UnregisterRegion(CSimpleRegion* region);
         virtual int32_t GetBoundsRect(CRect& bounds);
-        virtual void PreLoadXML(XMLNode*, CStatus*);
-        virtual void LockHighlight(int32_t);
-        virtual int32_t HideThis(void);
-        virtual int32_t ShowThis(void);
-        virtual bool UpdateScale(bool);
-        virtual void UpdateDepth(bool);
-        virtual void ParentFrame(CSimpleFrame*);
-        virtual void OnFrameSizeChanged(const CRect&);
+        virtual void PreLoadXML(XMLNode* node, CStatus* status);
+        virtual void LockHighlight(int32_t lock);
+        virtual int32_t HideThis();
+        virtual int32_t ShowThis();
+        virtual bool UpdateScale(bool a2);
+        virtual void UpdateDepth(bool a2);
+        virtual void ParentFrame(CSimpleFrame* frame);
+        virtual void OnFrameSizeChanged(const CRect& rect);
 
         // Member functions
-        CSimpleFrame(CSimpleFrame*);
-        void AddFrameRegion(CSimpleRegion*, uint32_t);
-        void DisableDrawLayer(uint32_t);
-        void EnableDrawLayer(uint32_t);
-        void EnableEvent(CSimpleEventType, int32_t);
+        CSimpleFrame(CSimpleFrame* parent);
+        void AddFrameRegion(CSimpleRegion* region, uint32_t drawlayer);
+        void DisableDrawLayer(uint32_t drawlayer);
+        void EnableDrawLayer(uint32_t drawlayer);
+        void EnableEvent(CSimpleEventType eventType, int32_t priority);
         int32_t GetHitRect(CRect& rect);
-        void Hide(void);
-        void LoadXML_Attributes(XMLNode*, CStatus*);
-        void LoadXML_Backdrop(XMLNode*, CStatus*);
-        void LoadXML_Layers(XMLNode*, CStatus*);
-        void LoadXML_Scripts(XMLNode*, CStatus*);
-        void NotifyDrawLayerChanged(uint32_t);
-        void NotifyScrollParent(void);
-        void PostLoadXML_Frames(XMLNode*, CStatus*);
-        void Raise(void);
-        void RegisterForEvents(int32_t);
-        void RegisterRegion(CSimpleRegion*);
-        void RemoveFrameRegion(CSimpleRegion*, uint32_t);
-        void RunOnCharScript(const char*);
-        void RunOnEnterScript(int32_t);
-        void RunOnHideScript(void);
-        void RunOnKeyDownScript(const char*);
-        void RunOnKeyUpScript(const char*);
-        void RunOnLeaveScript(int32_t);
-        void RunOnLoadScript(void);
-        void RunOnMouseDownScript(const char*);
-        void RunOnMouseUpScript(const char*);
-        void RunOnShowScript(void);
-        void RunOnSizeChangedScript(float, float);
-        void RunOnUpdateScript(float);
-        void SetBackdrop(CBackdropGenerator*);
-        void SetBeingScrolled(int32_t, int32_t);
+        void Hide();
+        void LoadXML_Attributes(XMLNode* node, CStatus* status);
+        void LoadXML_Backdrop(XMLNode* node, CStatus* status);
+        void LoadXML_Layers(XMLNode* node, CStatus* status);
+        void LoadXML_Scripts(XMLNode* node, CStatus* status);
+        void NotifyDrawLayerChanged(uint32_t drawlayer);
+        void NotifyScrollParent();
+        void PostLoadXML_Frames(XMLNode* node, CStatus* status);
+        void Raise();
+        void RegisterForEvents(int32_t a2);
+        void RegisterRegion(CSimpleRegion* region);
+        void RemoveFrameRegion(CSimpleRegion* region, uint32_t drawlayer);
+        void RunOnCharScript(const char* chr);
+        void RunOnEnterScript(int32_t a2);
+        void RunOnHideScript();
+        void RunOnKeyDownScript(const char* key);
+        void RunOnKeyUpScript(const char* key);
+        void RunOnLeaveScript(int32_t a2);
+        void RunOnLoadScript();
+        void RunOnMouseDownScript(const char* btn);
+        void RunOnMouseUpScript(const char* btn);
+        void RunOnShowScript();
+        void RunOnSizeChangedScript(float width, float height);
+        void RunOnUpdateScript(float elapsedSec);
+        void SetBackdrop(CBackdropGenerator* backdrop);
+        void SetBeingScrolled(int32_t a2, int32_t a3);
         void SetFrameAlpha(uint8_t alpha);
-        void SetFrameFlag(int32_t, int32_t);
-        void SetFrameLevel(int32_t, int32_t);
+        void SetFrameFlag(int32_t flag, int32_t on);
+        void SetFrameLevel(int32_t level, int32_t shiftChildren);
         bool SetFrameScale(float scale, bool a3);
-        void SetFrameStrata(FRAME_STRATA);
-        void SetHitRect(void);
-        void SetParent(CSimpleFrame*);
-        void Show(void);
-        int32_t TestHitRect(const C2Vector&);
-        void UnregisterForEvents(int32_t);
+        void SetFrameStrata(FRAME_STRATA strata);
+        void SetHitRect();
+        void SetParent(CSimpleFrame* parent);
+        void Show();
+        int32_t TestHitRect(const C2Vector& pt);
+        void UnregisterForEvents(int32_t a2);
 };
 
 #endif
diff --git a/src/ui/CSimpleHTML.hpp b/src/ui/CSimpleHTML.hpp
index 44cda1a..b83a56f 100644
--- a/src/ui/CSimpleHTML.hpp
+++ b/src/ui/CSimpleHTML.hpp
@@ -22,9 +22,9 @@ class CSimpleHTML : public CSimpleHyperlinkedFrame, CSimpleFontedFrame {
         static int32_t s_objectType;
 
         // Static functions
-        static void CreateScriptMetaTable(void);
-        static int32_t GetObjectType(void);
-        static void RegisterScriptMethods(lua_State*);
+        static void CreateScriptMetaTable();
+        static int32_t GetObjectType();
+        static void RegisterScriptMethods(lua_State* L);
 
         // Member variables
         STORM_LIST(CONTENTNODE) m_content;
@@ -34,12 +34,12 @@ class CSimpleHTML : public CSimpleHyperlinkedFrame, CSimpleFontedFrame {
 
         // Virtual member functions
         virtual bool IsA(int32_t type);
-        virtual int32_t GetScriptMetaTable(void);
+        virtual int32_t GetScriptMetaTable();
         virtual void LoadXML(XMLNode* node, CStatus* status);
         virtual void FontUpdated(CSimpleFontedFrameFont* font, int32_t a3);
 
         // Member functions
-        CSimpleHTML(CSimpleFrame*);
+        CSimpleHTML(CSimpleFrame* parent);
         void AddText(const char* text, HTML_TEXT_TYPE type, uint32_t justify);
         void ClearContent();
         void ParseBODY(XMLNode* node, CStatus* status);
diff --git a/src/ui/CSimpleHyperlinkedFrame.hpp b/src/ui/CSimpleHyperlinkedFrame.hpp
index 6467b27..0c8aa10 100644
--- a/src/ui/CSimpleHyperlinkedFrame.hpp
+++ b/src/ui/CSimpleHyperlinkedFrame.hpp
@@ -6,7 +6,7 @@
 class CSimpleHyperlinkedFrame : public CSimpleFrame {
     public:
         // Member functions
-        CSimpleHyperlinkedFrame(CSimpleFrame*);
+        CSimpleHyperlinkedFrame(CSimpleFrame* parent);
 };
 
 #endif
diff --git a/src/ui/CSimpleModel.hpp b/src/ui/CSimpleModel.hpp
index 5876e2e..7f1959b 100644
--- a/src/ui/CSimpleModel.hpp
+++ b/src/ui/CSimpleModel.hpp
@@ -17,11 +17,11 @@ class CSimpleModel : public CSimpleFrame {
         static int32_t s_objectType;
 
         // Static functions
-        static void CreateScriptMetaTable(void);
-        static int32_t GetObjectType(void);
+        static void CreateScriptMetaTable();
+        static int32_t GetObjectType();
         static void LightingCallback(CM2Model* model, CM2Lighting* lighting, void* userArg);
         static void ModelLoaded(CM2Model* model, void* arg);
-        static void RegisterScriptMethods(lua_State*);
+        static void RegisterScriptMethods(lua_State* L);
         static void RenderModel(void* arg);
 
         // Member variables
@@ -45,25 +45,25 @@ class CSimpleModel : public CSimpleFrame {
         // Virtual member functions
         virtual ScriptIx* GetScriptByName(const char* name, ScriptData& data);
         virtual bool IsA(int32_t type);
-        virtual int32_t GetScriptMetaTable(void);
-        virtual void LoadXML(XMLNode*, CStatus*);
+        virtual int32_t GetScriptMetaTable();
+        virtual void LoadXML(XMLNode* node, CStatus* status);
         virtual void OnLayerUpdate(float elapsedSec);
         virtual void OnFrameRender(CRenderBatch*, uint32_t);
-        virtual void UpdateModel(void);
+        virtual void UpdateModel();
         virtual void OnModelLoaded(CM2Model* model);
 
         // Member functions
-        CSimpleModel(CSimpleFrame*);
-        CM2Scene* GetScene(void);
+        CSimpleModel(CSimpleFrame* parent);
+        CM2Scene* GetScene();
         void SetCamera(HCAMERA camera);
         void SetCameraByID(uint32_t id);
         void SetCameraByIndex(uint32_t index);
-        void SetFogColor(CImVector&);
-        void SetFogFar(float);
-        void SetFogNear(float);
-        void SetModel(const char*);
-        void SetModel(CM2Model*);
-        void SetScale(float);
+        void SetFogColor(CImVector& fogColor);
+        void SetFogFar(float fogFar);
+        void SetFogNear(float fogNear);
+        void SetModel(const char* sourcefile);
+        void SetModel(CM2Model* model);
+        void SetScale(float scale);
         void SetSequence(uint32_t sequence);
         int32_t SetSequenceTime(uint32_t sequence, int32_t time);
 };
diff --git a/src/ui/CSimpleModelFFX.hpp b/src/ui/CSimpleModelFFX.hpp
index 5503cf7..1a4a3fd 100644
--- a/src/ui/CSimpleModelFFX.hpp
+++ b/src/ui/CSimpleModelFFX.hpp
@@ -11,17 +11,17 @@ class CSimpleModelFFX : public CSimpleModel {
         static int32_t s_metatable;
 
         // Static functions
-        static CSimpleFrame* Create(CSimpleFrame*);
-        static void CreateScriptMetaTable(void);
-        static void RegisterScriptMethods(lua_State*);
-        static void Render(void*);
+        static CSimpleFrame* Create(CSimpleFrame* parent);
+        static void CreateScriptMetaTable();
+        static void RegisterScriptMethods(lua_State* L);
+        static void Render(void* arg);
 
         // Virtual member functions
-        virtual int32_t GetScriptMetaTable(void);
-        virtual void OnFrameRender(CRenderBatch*, uint32_t);
+        virtual int32_t GetScriptMetaTable();
+        virtual void OnFrameRender(CRenderBatch* batch, uint32_t layer);
 
         // Member functions
-        CSimpleModelFFX(CSimpleFrame*);
+        CSimpleModelFFX(CSimpleFrame* parent);
 };
 
 #endif
diff --git a/src/ui/CSimpleRegion.hpp b/src/ui/CSimpleRegion.hpp
index 2ed96b2..ae77d88 100644
--- a/src/ui/CSimpleRegion.hpp
+++ b/src/ui/CSimpleRegion.hpp
@@ -22,21 +22,21 @@ class CSimpleRegion : public CScriptRegion {
 
         // Virtual member functions
         virtual ~CSimpleRegion();
-        virtual void OnColorChanged(bool);
+        virtual void OnColorChanged(bool a2);
         virtual void OnScreenSizeChanged() {};
-        virtual void Draw(CRenderBatch*) = 0;
+        virtual void Draw(CRenderBatch* batch) = 0;
 
         // Member functions
-        CSimpleRegion(CSimpleFrame*, uint32_t, int32_t);
+        CSimpleRegion(CSimpleFrame* frame, uint32_t drawlayer, int32_t show);
         void GetVertexColor(CImVector& color) const;
-        void Hide(void);
-        void HideThis(void);
+        void Hide();
+        void HideThis();
         bool IsShown();
-        void OnRegionChanged(void);
-        void SetVertexColor(const CImVector&);
-        void SetFrame(CSimpleFrame*, uint32_t, int32_t);
-        void Show(void);
-        void ShowThis(void);
+        void OnRegionChanged();
+        void SetVertexColor(const CImVector& color);
+        void SetFrame(CSimpleFrame* frame, uint32_t drawlayer, int32_t show);
+        void Show();
+        void ShowThis();
 };
 
 #endif
diff --git a/src/ui/CSimpleRender.hpp b/src/ui/CSimpleRender.hpp
index 63c9899..b3a7357 100644
--- a/src/ui/CSimpleRender.hpp
+++ b/src/ui/CSimpleRender.hpp
@@ -10,8 +10,8 @@ class CSimpleRender {
         static CGxShader* s_vertexShader[];
 
         // Static functions
-        static void DrawBatch(CRenderBatch*);
-        static void Init(void);
+        static void DrawBatch(CRenderBatch* batch);
+        static void Init();
 };
 
 #endif
diff --git a/src/ui/CSimpleScrollFrame.hpp b/src/ui/CSimpleScrollFrame.hpp
index a4da539..e726749 100644
--- a/src/ui/CSimpleScrollFrame.hpp
+++ b/src/ui/CSimpleScrollFrame.hpp
@@ -14,9 +14,9 @@ class CSimpleScrollFrame : public CSimpleFrame {
         static int32_t s_objectType;
 
         // Static functions
-        static void CreateScriptMetaTable(void);
-        static int32_t GetObjectType(void);
-        static void RegisterScriptMethods(lua_State*);
+        static void CreateScriptMetaTable();
+        static int32_t GetObjectType();
+        static void RegisterScriptMethods(lua_State* L);
         static void RenderScrollChild(void* param);
 
         // Member variables
@@ -29,20 +29,20 @@ class CSimpleScrollFrame : public CSimpleFrame {
         ScriptIx m_onScrollRangeChanged;
 
         // Virtual member functions
-        virtual ScriptIx* GetScriptByName(const char*, ScriptData&);
-        virtual bool IsA(int32_t);
-        virtual int32_t GetScriptMetaTable(void);
-        virtual void LoadXML(XMLNode*, CStatus*);
+        virtual ScriptIx* GetScriptByName(const char* name, ScriptData& data);
+        virtual bool IsA(int32_t type);
+        virtual int32_t GetScriptMetaTable();
+        virtual void LoadXML(XMLNode* node, CStatus* status);
         virtual int32_t GetBoundsRect(CRect& bounds);
         virtual void OnLayerUpdate(float elapsedSec);
         virtual void OnFrameRender(CRenderBatch* batch, uint32_t layer);
         virtual void OnFrameSizeChanged(float w, float h);
 
         // Member functions
-        CSimpleScrollFrame(CSimpleFrame*);
+        CSimpleScrollFrame(CSimpleFrame* parent);
         void RunOnScrollRangeChangedScript();
         void RunOnVerticalScrollScript();
-        void SetScrollChild(CSimpleFrame*);
+        void SetScrollChild(CSimpleFrame* frame);
         void SetVerticalScroll(float offset);
         void UpdateScrollChild();
         void UpdateScrollChildRect(float w, float h);
diff --git a/src/ui/CSimpleSlider.hpp b/src/ui/CSimpleSlider.hpp
index 1c2b0b4..e1d62ed 100644
--- a/src/ui/CSimpleSlider.hpp
+++ b/src/ui/CSimpleSlider.hpp
@@ -10,9 +10,9 @@ class CSimpleSlider : public CSimpleFrame {
         static int32_t s_objectType;
 
         // Static functions
-        static void CreateScriptMetaTable(void);
-        static int32_t GetObjectType(void);
-        static void RegisterScriptMethods(lua_State*);
+        static void CreateScriptMetaTable();
+        static int32_t GetObjectType();
+        static void RegisterScriptMethods(lua_State* L);
 
         // Member variables
         int32_t m_changed : 1;
@@ -27,9 +27,9 @@ class CSimpleSlider : public CSimpleFrame {
         ScriptIx m_onMinMaxChanged;
 
         // Virtual member functions
-        virtual ScriptIx* GetScriptByName(const char*, ScriptData&);
-        virtual bool IsA(int32_t);
-        virtual int32_t GetScriptMetaTable(void);
+        virtual ScriptIx* GetScriptByName(const char* name, ScriptData& data);
+        virtual bool IsA(int32_t type);
+        virtual int32_t GetScriptMetaTable();
 
         // Member functions
         CSimpleSlider(CSimpleFrame* parent)
diff --git a/src/ui/CSimpleTexture.hpp b/src/ui/CSimpleTexture.hpp
index e21fcc1..dbdff84 100644
--- a/src/ui/CSimpleTexture.hpp
+++ b/src/ui/CSimpleTexture.hpp
@@ -21,11 +21,11 @@ class CSimpleTexture : public CSimpleRegion {
         static EGxTexFilter s_textureFilterMode;
 
         // Static functions
-        static void CreateScriptMetaTable(void);
-        static CGxShader* GetImageModePixelShader(TextureImageMode);
-        static int32_t GetObjectType(void);
-        static void Init(void);
-        static void RegisterScriptMethods(lua_State*);
+        static void CreateScriptMetaTable();
+        static CGxShader* GetImageModePixelShader(TextureImageMode mode);
+        static int32_t GetObjectType();
+        static void Init();
+        static void RegisterScriptMethods(lua_State* L);
 
         // Member variables
         HTEXTURE m_texture = nullptr;
@@ -40,25 +40,25 @@ class CSimpleTexture : public CSimpleRegion {
 
         // Virtual member functions
         virtual ~CSimpleTexture();
-        virtual int32_t GetScriptMetaTable(void);
-        virtual bool IsA(int32_t);
-        virtual void LoadXML(XMLNode*, CStatus*);
-        virtual float GetWidth(void);
-        virtual float GetHeight(void);
-        virtual void Draw(CRenderBatch*);
-        virtual void OnFrameSizeChanged(const CRect&);
+        virtual int32_t GetScriptMetaTable();
+        virtual bool IsA(int32_t type);
+        virtual void LoadXML(XMLNode* node, CStatus* status);
+        virtual float GetWidth();
+        virtual float GetHeight();
+        virtual void Draw(CRenderBatch* batch);
+        virtual void OnFrameSizeChanged(const CRect& rect);
 
         // Member functions
-        CSimpleTexture(CSimpleFrame*, uint32_t, int32_t);
-        void GetTexCoord(C2Vector*);
-        void PostLoadXML(XMLNode*, CStatus*);
+        CSimpleTexture(CSimpleFrame* frame, uint32_t drawlayer, int32_t show);
+        void GetTexCoord(C2Vector* texCoord);
+        void PostLoadXML(XMLNode* node, CStatus* status);
         void SetAlpha(float alpha);
-        void SetBlendMode(EGxBlend);
-        void SetPosition(const CRect&, C3Vector*);
+        void SetBlendMode(EGxBlend blend);
+        void SetPosition(const CRect& rect, C3Vector* position);
         void SetTexCoord(const CRect& texRect);
-        void SetTexCoord(const C2Vector*);
-        int32_t SetTexture(const char*, bool, bool, EGxTexFilter, TextureImageMode);
-        int32_t SetTexture(const CImVector&);
+        void SetTexCoord(const C2Vector* texCoord);
+        int32_t SetTexture(const char* fileName, bool wrapU, bool wrapV, EGxTexFilter filter, TextureImageMode mode);
+        int32_t SetTexture(const CImVector& color);
 };
 
 #endif
diff --git a/src/ui/CSimpleTop.cpp b/src/ui/CSimpleTop.cpp
index dd6c2c6..2fdfc52 100644
--- a/src/ui/CSimpleTop.cpp
+++ b/src/ui/CSimpleTop.cpp
@@ -71,12 +71,12 @@ int32_t CSimpleTop::OnDisplaySizeChanged(const EVENT_DATA_SIZE* pSizeData, void*
     return 1;
 }
 
-int32_t CSimpleTop::OnFocusChanged(const void*, void*) {
+int32_t CSimpleTop::OnFocusChanged(const void* a1, void* a2) {
     // TODO
     return 0;
 }
 
-int32_t CSimpleTop::OnIme(const void*, void*) {
+int32_t CSimpleTop::OnIme(const void* a1, void* a2) {
     // TODO
     return 0;
 }
@@ -123,7 +123,7 @@ int32_t CSimpleTop::OnKeyDown(const EVENT_DATA_KEY* pKeyData, void* param) {
     return eaten == 0;
 }
 
-int32_t CSimpleTop::OnKeyDownRepeat(const void*, void*) {
+int32_t CSimpleTop::OnKeyDownRepeat(const void* a1, void* a2) {
     // TODO
     return 0;
 }
@@ -282,7 +282,7 @@ int32_t CSimpleTop::OnMouseMove(const EVENT_DATA_MOUSE* pMouseData, void* param)
     return nextFocus == nullptr;
 }
 
-int32_t CSimpleTop::OnMouseMoveRelative(const EVENT_DATA_MOUSE*, void*) {
+int32_t CSimpleTop::OnMouseMoveRelative(const EVENT_DATA_MOUSE* pMouseData, void* param) {
     // TODO
     return 0;
 }
@@ -325,7 +325,7 @@ int32_t CSimpleTop::OnMouseUp(const EVENT_DATA_MOUSE* pMouseData, void* param) {
     return 0;
 }
 
-int32_t CSimpleTop::OnMouseWheel(const EVENT_DATA_MOUSE*, void*) {
+int32_t CSimpleTop::OnMouseWheel(const EVENT_DATA_MOUSE* pMouseData, void* param) {
     // TODO
     return 0;
 }
diff --git a/src/ui/CSimpleTop.hpp b/src/ui/CSimpleTop.hpp
index feb07fa..e1f5610 100644
--- a/src/ui/CSimpleTop.hpp
+++ b/src/ui/CSimpleTop.hpp
@@ -31,19 +31,19 @@ class CSimpleTop : public CLayoutFrame {
         static uint32_t m_eventTime;
 
         // Static functions
-        static int32_t OnChar(const EVENT_DATA_CHAR*, void*);
-        static int32_t OnDisplaySizeChanged(const EVENT_DATA_SIZE*, void*);
-        static int32_t OnFocusChanged(const void*, void*);
-        static int32_t OnIme(const void*, void*);
-        static int32_t OnKeyDown(const EVENT_DATA_KEY*, void*);
-        static int32_t OnKeyDownRepeat(const void*, void*);
-        static int32_t OnKeyUp(const EVENT_DATA_KEY*, void*);
-        static int32_t OnMouseDown(const EVENT_DATA_MOUSE*, void*);
-        static int32_t OnMouseMove(const EVENT_DATA_MOUSE*, void*);
-        static int32_t OnMouseMoveRelative(const EVENT_DATA_MOUSE*, void*);
-        static int32_t OnMouseUp(const EVENT_DATA_MOUSE*, void*);
-        static int32_t OnMouseWheel(const EVENT_DATA_MOUSE*, void*);
-        static float RoundToPixelHeight(float);
+        static int32_t OnChar(const EVENT_DATA_CHAR* pCharData, void* param);
+        static int32_t OnDisplaySizeChanged(const EVENT_DATA_SIZE* pSizeData, void* param);
+        static int32_t OnFocusChanged(const void* a1, void* a2);
+        static int32_t OnIme(const void* a1, void* a2);
+        static int32_t OnKeyDown(const EVENT_DATA_KEY* pKeyData, void* param);
+        static int32_t OnKeyDownRepeat(const void* a1, void* a2);
+        static int32_t OnKeyUp(const EVENT_DATA_KEY* pKeyData, void* param);
+        static int32_t OnMouseDown(const EVENT_DATA_MOUSE* pMouseData, void* param);
+        static int32_t OnMouseMove(const EVENT_DATA_MOUSE* pMouseData, void* param);
+        static int32_t OnMouseMoveRelative(const EVENT_DATA_MOUSE* pMouseData, void* param);
+        static int32_t OnMouseUp(const EVENT_DATA_MOUSE* pMouseData, void* param);
+        static int32_t OnMouseWheel(const EVENT_DATA_MOUSE* pMouseData, void* param);
+        static float RoundToPixelHeight(float ddcHeight);
 
         // Member variables
         HLAYER m_screenLayer;
@@ -63,22 +63,22 @@ class CSimpleTop : public CLayoutFrame {
 
         // Member functions
         CSimpleTop();
-        void CompressStrata(int32_t);
-        void EnableEvents(void);
-        void HideFrame(CSimpleFrame*, int32_t);
-        void MoveOrResizeFrame(const CMouseEvent&);
-        void NotifyFrameLayerChanged(CSimpleFrame*, uint32_t);
-        void NotifyFrameMovedOrResized(CSimpleFrame*);
-        void OnLayerUpdate(float);
-        void OnLayerRender(void);
-        int32_t RaiseFrame(CSimpleFrame*, int32_t);
-        void RegisterForEvent(CSimpleFrame*, CSimpleEventType, int32_t, uint32_t);
-        void RegisterFrame(CSimpleFrame*);
-        void ShowFrame(CSimpleFrame*, int32_t);
-        int32_t StartMoveOrResizeFrame(const CMouseEvent&, MOVERESIZE_REASON, int32_t);
-        int32_t StartMoveOrResizeFrame(CSimpleFrame*, MOVERESIZE_REASON, float, float, int32_t);
-        int32_t StartMoveOrResizeFrame(CSimpleFrame*, MOVERESIZE_REASON, float, float, FRAMEPOINT);
-        void UnregisterForEvent(CSimpleFrame*, CSimpleEventType, int32_t);
+        void CompressStrata(int32_t strata);
+        void EnableEvents();
+        void HideFrame(CSimpleFrame* frame, int32_t a4);
+        void MoveOrResizeFrame(const CMouseEvent& evt);
+        void NotifyFrameLayerChanged(CSimpleFrame* frame, uint32_t layer);
+        void NotifyFrameMovedOrResized(CSimpleFrame* frame);
+        void OnLayerUpdate(float elapsedSec);
+        void OnLayerRender();
+        int32_t RaiseFrame(CSimpleFrame* frame, int32_t checkOcclusion);
+        void RegisterForEvent(CSimpleFrame* frame, CSimpleEventType event, int32_t a4, uint32_t priority);
+        void RegisterFrame(CSimpleFrame* frame);
+        void ShowFrame(CSimpleFrame* frame, int32_t a3);
+        int32_t StartMoveOrResizeFrame(const CMouseEvent& start, MOVERESIZE_REASON reason, int32_t resize);
+        int32_t StartMoveOrResizeFrame(CSimpleFrame* frame, MOVERESIZE_REASON reason, float startx, float starty, int32_t a6);
+        int32_t StartMoveOrResizeFrame(CSimpleFrame* frame, MOVERESIZE_REASON reason, float startx, float starty, FRAMEPOINT a6);
+        void UnregisterForEvent(CSimpleFrame* frame, CSimpleEventType event, int32_t a4);
 };
 
 #endif
diff --git a/src/ui/FrameScript.hpp b/src/ui/FrameScript.hpp
index 3a9896f..debf40f 100644
--- a/src/ui/FrameScript.hpp
+++ b/src/ui/FrameScript.hpp
@@ -37,7 +37,7 @@ class FrameScript_EventObject : public TSHashObject<FrameScript_EventObject, HAS
 
         // Member functions
         FrameScript_EventObject() : TSHashObject<FrameScript_EventObject, HASHKEY_STRI>() {};
-        const char* GetName(void);
+        const char* GetName();
 };
 
 extern const char* g_glueScriptEvents[41];
@@ -60,48 +60,48 @@ namespace FrameScript {
     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);
 
-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
diff --git a/src/ui/FrameXML.hpp b/src/ui/FrameXML.hpp
index 99f9c44..f03546e 100644
--- a/src/ui/FrameXML.hpp
+++ b/src/ui/FrameXML.hpp
@@ -30,26 +30,26 @@ namespace FrameXML {
     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
diff --git a/src/ui/Interface.cpp b/src/ui/Interface.cpp
index 9e48f98..44e07b0 100644
--- a/src/ui/Interface.cpp
+++ b/src/ui/Interface.cpp
@@ -1,5 +1,5 @@
 #include "ui/Interface.hpp"
 
-void DeleteInterfaceFiles(void) {
+void DeleteInterfaceFiles() {
     // TODO
 }
diff --git a/src/ui/Interface.hpp b/src/ui/Interface.hpp
index 60c669d..0cc1998 100644
--- a/src/ui/Interface.hpp
+++ b/src/ui/Interface.hpp
@@ -1,6 +1,6 @@
 #ifndef UI_INTERFACE_HPP
 #define UI_INTERFACE_HPP
 
-void DeleteInterfaceFiles(void);
+void DeleteInterfaceFiles();
 
 #endif
diff --git a/src/ui/LoadXML.hpp b/src/ui/LoadXML.hpp
index eb8bea3..307fbb8 100644
--- a/src/ui/LoadXML.hpp
+++ b/src/ui/LoadXML.hpp
@@ -10,16 +10,16 @@ class CStatus;
 class XMLNode;
 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
diff --git a/src/ui/LuaMemory.cpp b/src/ui/LuaMemory.cpp
index 5f930a0..8644a9c 100644
--- a/src/ui/LuaMemory.cpp
+++ b/src/ui/LuaMemory.cpp
@@ -38,7 +38,7 @@ void* luaM_initPool() {
     return pools;
 }
 
-void* luaM_reallocPool(void* ud, void *ptr, size_t osize, size_t nsize) {
+void* luaM_reallocPool(void* ud, void* ptr, size_t osize, size_t nsize) {
     void* result; // eax
     signed int v5; // esi
     signed int v6; // edx
diff --git a/src/ui/LuaMemory.hpp b/src/ui/LuaMemory.hpp
index c9051f3..0f9cd96 100644
--- a/src/ui/LuaMemory.hpp
+++ b/src/ui/LuaMemory.hpp
@@ -3,7 +3,7 @@
 
 #include <cstdlib>
 
-void* luaM_initPool(void);
-void* luaM_reallocPool(void*, void*, size_t, size_t);
+void* luaM_initPool();
+void* luaM_reallocPool(void* ud, void* ptr, size_t osize, size_t nsize);
 
 #endif
diff --git a/src/ui/ScriptFunctions.hpp b/src/ui/ScriptFunctions.hpp
index 5745f98..2cbb5ba 100644
--- a/src/ui/ScriptFunctions.hpp
+++ b/src/ui/ScriptFunctions.hpp
@@ -22,11 +22,11 @@ namespace FrameScript {
 
 // Utility
 
-void CharacterCreateRegisterScriptFunctions(void);
-void CharSelectRegisterScriptFunctions(void);
-void GlueScriptEventsRegisterFunctions(void);
-void RegisterSimpleFrameScriptMethods(void);
-void SystemRegisterFunctions(void);
+void CharacterCreateRegisterScriptFunctions();
+void CharSelectRegisterScriptFunctions();
+void GlueScriptEventsRegisterFunctions();
+void RegisterSimpleFrameScriptMethods();
+void SystemRegisterFunctions();
 
 // Shared
 int32_t Script_GetAccountExpansionLevel(lua_State*);
diff --git a/src/ui/Util.hpp b/src/ui/Util.hpp
index 61fb4d3..c7f813b 100644
--- a/src/ui/Util.hpp
+++ b/src/ui/Util.hpp
@@ -5,12 +5,12 @@
 #include "ui/Types.hpp"
 #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