Files
SatyandClaude Opus 5.5 34770ee7ab Frame: port Engine/Frame (waves 1-4), 1667 of 1669 functions
Core (CSimpleFrame + Lua, CSimpleTop/CFrameStrata/CSimpleRender/
CRenderBatch, CSimpleRegion/CBackdropGenerator/CScriptRegion), animation,
text (FontString/Font/Fontable), texture and model, buttons, EditBox,
MessageFrame/MessageScrollFrame, MovieFrame/ColorSelect/StatusBar,
Slider/ScrollFrame/HTML/HyperlinkedFrame, all Lua method tables and
RegisterScriptMethods. Layouts, vtables and sizes rebuilt from the
12340 ctors, vtables and allocator initializers; CScriptObject vtable
slots 5/6 fixed; CSimpleFontedFrame is a real secondary base. Lua error
paths return after luaL_error as in 12340 (209 sites; 5 fall through).
Binary quirks kept and documented in docs/.

Supporting additions: Event key/char/ime/focus/size event headers,
Scrn/Scrn.h (ScrnLayerCreate), DivxDecoder import declarations,
C2Vector/CRect helpers, CM2Light dtor, OsInputEnableSecureMode, stpl.h
instance addresses, FrameXML LoadXML_AnimGroup/Create_SimpleMovieFrame.
Engine->WoW includes where 12340 calls directly: CSimpleModelFFX,
StringToMouseButton, GetDeclinedWord, EmblemTextureUpdate.

Also drops stale VERIFY stamps found invalid by the harness recheck.

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
2026-09-27 15:32:18 +02:00

659 lines
20 KiB
C++

#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <new>
#include <typeinfo>
#include "Engine/Source/FrameXML/FrameXML.h"
#include "Engine/Source/BlizzardCore/SFile2-Core.h"
#include "Engine/Source/Frame/CLayoutFrame.h"
#include "Engine/Source/Frame/CSimpleButton.h"
#include "Engine/Source/Frame/CSimpleCheckbox.h"
#include "Engine/Source/Frame/CSimpleColorSelect.h"
#include "Engine/Source/Frame/CSimpleEditBox.h"
#include "Engine/Source/Frame/CSimpleFont.h"
#include "Engine/Source/Frame/CSimpleFrame.h"
#include "Engine/Source/Frame/CSimpleHTML.h"
#include "Engine/Source/Frame/CSimpleMessageFrame.h"
#include "Engine/Source/Frame/CSimpleMessageScrollFrame.h"
#include "Engine/Source/Frame/CSimpleModel.h"
#include "Engine/Source/Frame/CSimpleMovieFrame.h"
#include "Engine/Source/Frame/CSimpleScrollFrame.h"
#include "Engine/Source/Frame/CSimpleSlider.h"
#include "Engine/Source/Frame/CSimpleStatusBar.h"
#include "Engine/Source/FrameScript/FrameScript.h"
#include "Engine/Source/FrameXML/XMLTree.h"
#include "Engine/Source/Storm/H/storm.h"
#include "Engine/Source/Storm/Source/MD5.h"
#include "Engine/Source/lua-5.1/src/lua.h"
// STATIC: 0x00AF5718
static CFrameXMLStatus s_frameXMLStatus;
// STATIC: 0x00D3F6AC
static uint32_t s_progressTotal;
// STATIC: 0x00D3F6B0
static uint32_t s_progressFiles;
// STATIC: 0x00D3F6B4
static void* s_progressParam;
// STATIC: 0x00D3F6B8
static void (*s_progressCallback)(float progress, void* param);
// STATIC: 0x00D3F6BC
static int32_t s_debugLevel;
// STATIC: 0x00D3F6C0
static TSHashTable<HashedNode, HASHKEY_STRI> s_virtualNodes;
// STATIC: 0x00D3F6E8
static TSHashTable<FrameFactoryNode, HASHKEY_STRI> s_factories;
// VERIFY: 3a773c6f auto
// OFFSET: 0x00812530
XMLTree* FrameXML_LoadXML(const char* filename, MD5_CTX* md5, CStatus* status) {
void* data;
uint32_t size;
if (!SFile::ReadFile(nullptr, filename, &data, &size, 0, 1, nullptr)) {
status->Add(STATUS_ERROR, "Couldn't open %s", filename);
return nullptr;
}
MD5Update(md5, static_cast<const uint8_t*>(data), size);
XMLTree* tree = XMLTree_Load(static_cast<const char*>(data), size);
if (!tree) {
status->Add(STATUS_ERROR, "Couldn't parse XML in %s", filename);
}
SFile::Unload(data);
return tree;
}
// VERIFY: c503afd8 auto
// OFFSET: 0x008125C0
void FrameXML_SetDebugLevel(int32_t level) {
s_debugLevel = level;
}
// VERIFY: b84c8d55 auto
// OFFSET: 0x008125D0
int32_t FrameXML_GetDebugLevel() {
return s_debugLevel;
}
// VERIFY: 4231d5bb auto
// OFFSET: 0x008125E0
int32_t FrameXML_GuessNumFiles(const char* toc) {
int32_t count = 0;
const char* current = toc;
while (*current) {
while (*current == '\r' || *current == '\n') {
current++;
}
char c = *current;
if (!c) {
break;
}
if (c != '#') {
count++;
}
while (c != '\r' && c != '\n') {
c = *++current;
if (!c) {
return count;
}
}
}
return count;
}
// VERIFY: c88573f9 auto
// OFFSET: 0x00812630
CSimpleFrame* Create_SimpleCheckButton(CSimpleFrame* parent) {
void* data = CSimpleCheckbox::s_allocator.GetData(0, typeid(CSimpleCheckbox).raw_name(), SLOG_OBJECT);
return data ? new (data) CSimpleCheckbox(parent) : nullptr;
}
// VERIFY: e0d76346 auto
// OFFSET: 0x00812660
CSimpleFrame* Create_SimpleEditBox(CSimpleFrame* parent) {
void* data = CSimpleEditBox::s_allocator.GetData(0, typeid(CSimpleEditBox).raw_name(), SLOG_OBJECT);
return data ? new (data) CSimpleEditBox(parent) : nullptr;
}
// VERIFY: 2aa2d739 auto
// OFFSET: 0x00812690
CSimpleFrame* Create_SimpleMessageFrame(CSimpleFrame* parent) {
void* data = CSimpleMessageFrame::s_allocator.GetData(0, typeid(CSimpleMessageFrame).raw_name(), SLOG_OBJECT);
return data ? new (data) CSimpleMessageFrame(parent) : nullptr;
}
// VERIFY: 9ec2bd5d auto
// OFFSET: 0x008126C0
CSimpleFrame* Create_SimpleModel(CSimpleFrame* parent) {
void* data = CSimpleModel::s_allocator.GetData(0, typeid(CSimpleModel).raw_name(), SLOG_OBJECT);
return data ? new (data) CSimpleModel(parent) : nullptr;
}
// VERIFY: d93ae8f1 auto
// OFFSET: 0x008126F0
CSimpleFrame* Create_SimpleScrollFrame(CSimpleFrame* parent) {
void* data = CSimpleScrollFrame::s_allocator.GetData(0, typeid(CSimpleScrollFrame).raw_name(), SLOG_OBJECT);
return data ? new (data) CSimpleScrollFrame(parent) : nullptr;
}
// VERIFY: 2ba95665 auto
// OFFSET: 0x00812720
CSimpleFrame* Create_SimpleScrollingMessageFrame(CSimpleFrame* parent) {
void* data = CSimpleMessageScrollFrame::s_allocator.GetData(0, typeid(CSimpleMessageScrollFrame).raw_name(), SLOG_OBJECT);
return data ? new (data) CSimpleMessageScrollFrame(parent, 8) : nullptr;
}
// VERIFY: 1a3fde32 auto
// OFFSET: 0x00812750
CSimpleFrame* Create_SimpleSlider(CSimpleFrame* parent) {
void* data = CSimpleSlider::s_allocator.GetData(0, typeid(CSimpleSlider).raw_name(), SLOG_OBJECT);
return data ? new (data) CSimpleSlider(parent) : nullptr;
}
// VERIFY: 4bbcca61 auto
// OFFSET: 0x00812780
CSimpleFrame* Create_SimpleHTML(CSimpleFrame* parent) {
void* data = CSimpleHTML::s_allocator.GetData(0, typeid(CSimpleHTML).raw_name(), SLOG_OBJECT);
return data ? new (data) CSimpleHTML(parent) : nullptr;
}
// VERIFY: 7fb244de auto
// OFFSET: 0x008127B0
CSimpleFrame* Create_SimpleStatusBar(CSimpleFrame* parent) {
void* data = CSimpleStatusBar::s_allocator.GetData(0, typeid(CSimpleStatusBar).raw_name(), SLOG_OBJECT);
return data ? new (data) CSimpleStatusBar(parent) : nullptr;
}
// VERIFY: dd0cf87c auto
// OFFSET: 0x008127E0
CSimpleFrame* Create_SimpleColorSelect(CSimpleFrame* parent) {
void* data = CSimpleColorSelect::s_allocator.GetData(0, typeid(CSimpleColorSelect).raw_name(), SLOG_OBJECT);
return data ? new (data) CSimpleColorSelect(parent) : nullptr;
}
// VERIFY: b85fa974 auto
// OFFSET: 0x00812810
CSimpleFrame* Create_SimpleMovieFrame(CSimpleFrame* parent) {
void* data = CSimpleMovieFrame::s_allocator.GetData(0, typeid(CSimpleMovieFrame).raw_name(), SLOG_OBJECT);
return data ? new (data) CSimpleMovieFrame(parent) : nullptr;
}
// VERIFY: 1562cfb0 auto
// OFFSET: 0x00812840
void FrameXML_RegisterLoadProgressCallback(void (*callback)(float progress, void* param), void* param, uint32_t total) {
s_progressCallback = callback;
s_progressParam = param;
s_progressFiles = 0;
s_progressTotal = total;
}
// VERIFY: 36e2fb88 auto
// OFFSET: 0x00812870
CSimpleFrame* Create_SimpleButton(CSimpleFrame* parent) {
void* data = CSimpleButton::s_allocator.GetData(0, typeid(CSimpleButton).raw_name(), SLOG_OBJECT);
return data ? new (data) CSimpleButton(parent) : nullptr;
}
// VERIFY: 8993fe13 auto
// OFFSET: 0x008128A0
CSimpleFrame* Create_SimpleFrame(CSimpleFrame* parent) {
void* data = CSimpleFrame::s_allocator.GetData(0, typeid(CSimpleFrame).raw_name(), SLOG_OBJECT);
return data ? new (data) CSimpleFrame(parent) : nullptr;
}
// VERIFY: f5a4d98a auto
// OFFSET: 0x00812B90
void FrameXML_FreeHashNodes() {
s_virtualNodes.InternalClear(0);
}
// VERIFY: b51e4fcc auto
// OFFSET: 0x00812BA0
void FrameXML_ClearFactories() {
s_factories.InternalClear(0);
XMLTree_Cleanup();
}
// VERIFY: d21a2d6d manual
// OFFSET: 0x00812CE0
XMLNode* FrameXML_AcquireHashNode(const char* name, const char*& taint, bool& locked) {
HashedNode* hashed = s_virtualNodes.Ptr(name);
if (!hashed) {
return nullptr;
}
locked = hashed->m_locked;
taint = hashed->m_taint;
hashed->m_locked = true;
return hashed->m_node;
}
// VERIFY: e53052f6 auto
// OFFSET: 0x00812D20
void FrameXML_ReleaseHashNode(const char* name) {
s_virtualNodes.Ptr(name)->m_locked = false;
}
// VERIFY: 743ec1d8 auto
// OFFSET: 0x00812F60
void CFrameXMLStatus::Add(STATUS_TYPE severity, const char* format, ...) {
char buffer[512];
va_list args;
va_start(args, format);
SStrVPrintf(buffer, sizeof(buffer), format, args);
va_end(args);
DebugLog(buffer);
}
// VERIFY: e9a4b97a manual
// OFFSET: 0x00812FA0
CSimpleFrame* FrameXML_CreateFrame(XMLNode* node, CSimpleFrame* parent, CStatus* status) {
if (s_debugLevel > 0) {
const char* frameName = node->GetAttributeByName("name");
if (frameName && *frameName) {
status->Add(STATUS_INFO, "-- Creating %s named %s", node->m_name.m_str, frameName);
} else {
status->Add(STATUS_INFO, "-- Creating unnamed %s", node->m_name.m_str);
}
}
FrameFactoryNode* factory = s_factories.Ptr(node->m_name.m_str);
if (!factory) {
status->Add(STATUS_WARNING, "Unknown frame type: %s", node->m_name.m_str);
return nullptr;
}
const char* parentName = node->GetAttributeByName("parent");
if (!parentName) {
XMLNode* current = node;
do {
const char* inherits = current->GetAttributeByName("inherits");
if (!inherits || !*inherits) {
break;
}
char inheritName[1024];
do {
SStrTokenize(&inherits, inheritName, sizeof(inheritName), " ,", nullptr);
if (!inheritName[0]) {
break;
}
HashedNode* hashed = s_virtualNodes.Ptr(inheritName);
if (hashed) {
current = hashed->m_node;
bool locked = hashed->m_locked;
hashed->m_locked = true;
if (current && !locked) {
parentName = current->GetAttributeByName("parent");
s_virtualNodes.Ptr(inheritName)->m_locked = false;
}
} else {
current = nullptr;
}
} while (inheritName[0]);
if (parentName) {
break;
}
} while (current);
}
if (parentName && *parentName) {
if (!CSimpleFrame::s_objectType) {
CSimpleFrame::s_objectType = ++FrameScript_Object::s_objectTypes;
}
parent = static_cast<CSimpleFrame*>(CScriptObject::GetScriptObjectByName(parentName, CSimpleFrame::s_objectType));
if (!parent) {
status->Add(STATUS_WARNING, "Couldn't find frame parent: %s", parentName);
}
}
CSimpleFrame* frame = factory->m_factory(parent);
if (!frame) {
status->Add(STATUS_WARNING, "Unable to create frame type: %s", node->m_name.m_str);
return nullptr;
}
if (factory->m_unique) {
s_factories.Delete(factory);
}
frame->PreLoadXML(node, status);
frame->LoadXML(node, status);
frame->PostLoadXML(node, status);
return frame;
}
// VERIFY: 50a4650d manual
// OFFSET: 0x00813BE0
void FrameXML_StoreHashNode(XMLNode* node, const char* name, const char* taint, CStatus* status) {
HashedNode* hashed = s_virtualNodes.Ptr(name);
if (hashed) {
if (!hashed->m_taint || taint) {
status->Add(STATUS_WARNING, "Virtual object named %s already exists", name);
return;
}
if (hashed->m_node) {
delete hashed->m_node;
}
} else {
hashed = s_virtualNodes.New(name, 0, 0);
}
hashed->m_node = node;
hashed->m_taint = taint;
node->Detach();
if (s_debugLevel > 0) {
status->Add(STATUS_INFO, "-- Added virtual frame %s", name);
}
}
// VERIFY: 56caf1af manual
// OFFSET: 0x00813D20
int32_t FrameXML_RegisterFactory(const char* name, CSimpleFrame* (*factory)(CSimpleFrame* parent), bool unique) {
if (s_factories.Ptr(name)) {
return 0;
}
FrameFactoryNode* node = s_factories.New(name, 0, 0);
node->m_factory = factory;
node->m_unique = unique;
return 1;
}
// VERIFY: 99b277ec auto
// OFFSET: 0x00813DF0
int32_t FrameXML_RegisterDefault() {
FrameXML_RegisterFactory("Button", Create_SimpleButton, false);
FrameXML_RegisterFactory("CheckButton", Create_SimpleCheckButton, false);
FrameXML_RegisterFactory("EditBox", Create_SimpleEditBox, false);
FrameXML_RegisterFactory("Frame", Create_SimpleFrame, false);
FrameXML_RegisterFactory("MessageFrame", Create_SimpleMessageFrame, false);
FrameXML_RegisterFactory("Model", Create_SimpleModel, false);
FrameXML_RegisterFactory("ScrollFrame", Create_SimpleScrollFrame, false);
FrameXML_RegisterFactory("ScrollingMessageFrame", Create_SimpleScrollingMessageFrame, false);
FrameXML_RegisterFactory("Slider", Create_SimpleSlider, false);
FrameXML_RegisterFactory("SimpleHTML", Create_SimpleHTML, false);
FrameXML_RegisterFactory("StatusBar", Create_SimpleStatusBar, false);
FrameXML_RegisterFactory("ColorSelect", Create_SimpleColorSelect, false);
FrameXML_RegisterFactory("MovieFrame", Create_SimpleMovieFrame, false);
return 1;
}
// VERIFY: 0ad0cd1b manual
// OFFSET: 0x00813EE0
int32_t FrameXML_ProcessFile(const char* filename, const char* wrapper, MD5_CTX* md5, CStatus* status) {
char cleanPath[260];
if (SStrStr(filename, "..")) {
SStrCopy(cleanPath, filename, sizeof(cleanPath));
for (char* dots = SStrStr(cleanPath, ".."); dots; dots = SStrStr(cleanPath, "..")) {
char before = dots[-1];
if (before != '\\' && before != '/') {
break;
}
char after = dots[2];
if (after != '\\' && after != '/') {
break;
}
char* dir = dots - 2;
while (dir >= cleanPath && *dir != '\\' && *dir != '/') {
dir--;
}
SStrCopy(dir + 1, dots + 3, STORM_MAX_STR);
}
filename = cleanPath;
}
const char* extension = SStrChrR(const_cast<char*>(filename), '.');
if (extension && !SStrCmpI(extension, ".lua", STORM_MAX_STR)) {
return FrameScript_ExecuteFile(filename, wrapper, md5, status);
}
XMLTree* tree = FrameXML_LoadXML(filename, md5, status);
if (!tree) {
return 0;
}
CStatus fileStatus;
XMLNode* child = XMLTree_GetRoot(tree)->m_child;
if (child) {
XMLNode* next;
do {
next = child->m_next;
if (!SStrCmpI(child->m_name.m_str, "Include", STORM_MAX_STR)) {
const char* file = child->GetAttributeByName("file");
if (file) {
char includePath[260];
const char* slash = SStrChrR(const_cast<char*>(filename), '\\');
if (slash) {
size_t length = slash - filename + 1;
if (length < sizeof(includePath)) {
SStrCopy(includePath, filename, sizeof(includePath));
includePath[length] = '\0';
SStrPack(includePath, file, sizeof(includePath));
}
} else {
SStrCopy(includePath, file, sizeof(includePath));
}
FrameXML_ProcessFile(includePath, wrapper, md5, &fileStatus);
} else {
fileStatus.Add(STATUS_ERROR, "Element 'Include' without file attribute");
}
} else if (!SStrCmpI(child->m_name.m_str, "Script", STORM_MAX_STR)) {
const char* file = child->GetAttributeByName("file");
if (file) {
char scriptPath[260];
const char* slash = SStrChrR(const_cast<char*>(filename), '\\');
if (slash) {
size_t length = slash - filename + 1;
if (length < sizeof(scriptPath)) {
SStrCopy(scriptPath, filename, sizeof(scriptPath));
scriptPath[length] = '\0';
SStrPack(scriptPath, file, sizeof(scriptPath));
}
} else {
SStrCopy(scriptPath, file, sizeof(scriptPath));
}
FrameScript_ExecuteFile(scriptPath, wrapper, md5, &fileStatus);
}
const char* body = child->m_body;
if (body && *body) {
char scriptName[271];
SStrPrintf(scriptName, sizeof(scriptName), "%s:<Scripts>", filename);
FrameScript_Execute(body, scriptName, lua_tainted);
}
} else if (!SStrCmpI(child->m_name.m_str, "Font", STORM_MAX_STR)) {
const char* fontName = child->GetAttributeByName("name");
if (fontName && *fontName) {
CSimpleFont* font = CSimpleFont::GetFont(fontName, 1);
font->LoadXML(child, status);
} else {
fileStatus.Add(STATUS_WARNING, "Unnamed font node at top level");
}
} else {
const char* isVirtual = child->GetAttributeByName("virtual");
if (isVirtual && !SStrCmpI(isVirtual, "true", STORM_MAX_STR)) {
const char* virtualName = child->GetAttributeByName("name");
if (virtualName && *virtualName) {
FrameXML_StoreHashNode(child, virtualName, lua_tainted, &fileStatus);
} else {
fileStatus.Add(STATUS_WARNING, "Unnamed virtual node at top level");
}
} else {
FrameXML_CreateFrame(child, nullptr, &fileStatus);
CLayoutFrame::ResizePending();
}
}
child = next;
} while (next);
}
XMLTree_Free(tree);
if (s_debugLevel > 0 || fileStatus.m_highestSeverity > STATUS_INFO) {
fileStatus.Prepend(STATUS_INFO, "++ Loading file %s", filename);
}
status->Add(fileStatus);
return 1;
}
// VERIFY: a8106274 manual
// OFFSET: 0x00814340
int32_t FrameXML_CreateFrames(const char* tocFile, const char* wrapper, MD5_CTX* md5, CStatus* status) {
if (!status) {
status = &s_frameXMLStatus;
}
char tocPath[260];
memset(tocPath, 0, sizeof(tocPath));
const char* slash = SStrChrR(const_cast<char*>(tocFile), '\\');
if (slash) {
size_t length = slash - tocFile + 1;
if (length < sizeof(tocPath) - 1) {
SStrCopy(tocPath, tocFile, length + 1);
tocPath[length] = '\0';
}
}
void* data;
uint32_t size;
if (!SFile::ReadFile(nullptr, tocFile, &data, &size, 1, 1, nullptr)) {
status->Add(STATUS_ERROR, "Couldn't open %s", tocFile);
return 0;
}
MD5Update(md5, static_cast<const uint8_t*>(data), size);
const char* text = static_cast<const char*>(data);
if (static_cast<uint8_t>(text[0]) == 0xEF && static_cast<uint8_t>(text[1]) == 0xBB && static_cast<uint8_t>(text[2]) == 0xBF) {
text += 3;
}
CStatus tocStatus;
char line[1024];
do {
SStrTokenize(&text, line, sizeof(line), "\r\n", nullptr);
if (!line[0]) {
break;
}
if (line[0] != '#') {
char path[260];
SStrCopy(path, tocPath, sizeof(path));
SStrPack(path, line, sizeof(path));
size_t length = SStrLen(path);
char* end = &path[length];
if (path[length - 1] == ' ') {
do {
if (end <= path) {
break;
}
end--;
} while (end[-1] == ' ');
}
*end = '\0';
FrameXML_ProcessFile(path, wrapper, md5, &tocStatus);
if (s_progressCallback && s_progressFiles < s_progressTotal) {
s_progressFiles++;
s_progressCallback(static_cast<float>(s_progressFiles) / static_cast<float>(s_progressTotal), s_progressParam);
}
}
} while (line[0]);
XMLTree_Cleanup();
SFile::Unload(data);
if (s_debugLevel > 0 || tocStatus.m_highestSeverity > STATUS_INFO) {
tocStatus.Prepend(STATUS_INFO, "** Loading table of contents %s", tocFile);
}
status->Add(tocStatus);
return 1;
}