From 2778643f4fb43f2e25da56fc2acb63c8b65a7c8b Mon Sep 17 00:00:00 2001 From: Brues <5278969+brues-code@users.noreply.github.com> Date: Mon, 31 Aug 2026 10:38:35 -0500 Subject: [PATCH] feat(editbox): GetUTF8CursorPosition, ClearHighlightText, HasFocus, HasText MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Round out the EditBox method backports alongside Set/GetCursorPosition, all reusing state the engine already maintains: - GetUTF8CursorPosition — caret as a character index (vs GetCursorPosition's byte offset), via the engine's own byte->char counter FUN_0077bc80. - ClearHighlightText — drop the selection but keep the caret (collapse selStart/selEnd onto the cursor + highlight-dirty bit). Vanilla can only clear a selection with HighlightText(0,0), which yanks it to offset 0. - HasFocus — pointer identity against VAR_FOCUSED_EDITBOX (the global the engine's SetFocus writes / ClearFocus clears). - HasText — text byte length (+0x338) is non-zero. Registered on the EditBox method registry, so only EditBox frames dispatch them. New offsets: OFF_EDITBOX_TEXT_LENGTH, FUN_EDITBOX_COUNT_CHARS. The module now covers cursor / selection / focus / text-state, so it moves from editbox/Cursor.cpp to editbox/Methods.cpp (namespace EditBox::Methods). Documented in docs/API.md and the README under the Frame widget section. Verified in-game: SetText+SetFocus reports HasFocus/HasText true and both cursor getters 5; an empty box reports both predicates false. --- README.md | 2 +- docs/API.md | 25 +++++++ src/Offsets.h | 14 +++- src/editbox/Cursor.cpp | 92 ------------------------ src/editbox/Methods.cpp | 156 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 193 insertions(+), 96 deletions(-) delete mode 100644 src/editbox/Cursor.cpp create mode 100644 src/editbox/Methods.cpp diff --git a/README.md b/README.md index 97e40e07..17d38b7e 100644 --- a/README.md +++ b/README.md @@ -67,7 +67,7 @@ reference in **[docs/API.md](docs/API.md)**. | [Expansion](docs/API.md#expansion) | `ClassicExpansionAtLeast`, `ClassicExpansionAtMost`, `GetClassicExpansionLevel` | | [Faction](docs/API.md#faction) | `C_Reputation.GetFactionDataByIndex`, `C_Reputation.GetFactionStandings`, `C_Reputation.GetLastStandingChange`, `C_Reputation.GetWatchedFactionData`, `C_Reputation.SetWatchedFactionByID`, `GetFactionIDByIndex`, `GetFactionInfoByID`, `GetFactionParentID` | | [Focus](docs/API.md#focus) | `ClearFocus`, `FocusUnit` | -| [Frame](docs/API.md#frame) | `region:SetPoint("point")` (one-arg form), `region:SetSize`, `region:GetSize`, `region:IsMouseOver`, `region:GetRect`, `region:IsDragging`, `GetMouseFoci`, `frame:SetShown`, `fontstring:GetStringHeight`, `fontstring:GetUnboundedStringWidth`, `fontstring:GetWrappedWidth`, `fontstring:GetNumLines`, `fontstring:GetLineHeight`, `fontstring:IsTruncated`, `fontstring:SetMaxLines`, `fontstring:GetMaxLines`, `fontstring:SetFormattedText`, `texture:SetRotation`, `texture:GetRotation`, `texture:SetVertexOffset`, `texture:GetVertexOffset`, `texture:SetColorTexture`, `texture:SetMask`, `frame:CreateMaskTexture`, `texture:AddMaskTexture`, `texture:RemoveMaskTexture`, `texture:GetNumMaskTextures`, `texture:GetMaskTexture`, `fontstring:SetRotation`, `fontstring:GetRotation`, `frame:SetResizeBounds`, `frame:HookScript`, `frame:IsEventRegistered`, `frame:GetEffectiveAlpha`, `frame:SetAttribute`, `frame:SetAttributeNoHandler`, `frame:ClearAttribute`, `frame:GetAttribute`, `OnAttributeChanged` (script), `SetModernScriptArgs`, `GetModernScriptArgs`, `PreClick` (script), `PostClick` (script), `GetClickFrame` | +| [Frame](docs/API.md#frame) | `region:SetPoint("point")` (one-arg form), `region:SetSize`, `region:GetSize`, `region:IsMouseOver`, `region:GetRect`, `region:IsDragging`, `GetMouseFoci`, `frame:SetShown`, `fontstring:GetStringHeight`, `fontstring:GetUnboundedStringWidth`, `fontstring:GetWrappedWidth`, `fontstring:GetNumLines`, `fontstring:GetLineHeight`, `fontstring:IsTruncated`, `fontstring:SetMaxLines`, `fontstring:GetMaxLines`, `fontstring:SetFormattedText`, `texture:SetRotation`, `texture:GetRotation`, `texture:SetVertexOffset`, `texture:GetVertexOffset`, `texture:SetColorTexture`, `texture:SetMask`, `frame:CreateMaskTexture`, `texture:AddMaskTexture`, `texture:RemoveMaskTexture`, `texture:GetNumMaskTextures`, `texture:GetMaskTexture`, `fontstring:SetRotation`, `fontstring:GetRotation`, `editBox:SetCursorPosition`, `editBox:GetCursorPosition`, `editBox:GetUTF8CursorPosition`, `editBox:ClearHighlightText`, `editBox:HasFocus`, `editBox:HasText`, `frame:SetResizeBounds`, `frame:HookScript`, `frame:IsEventRegistered`, `frame:GetEffectiveAlpha`, `frame:SetAttribute`, `frame:SetAttributeNoHandler`, `frame:ClearAttribute`, `frame:GetAttribute`, `OnAttributeChanged` (script), `SetModernScriptArgs`, `GetModernScriptArgs`, `PreClick` (script), `PostClick` (script), `GetClickFrame` | | [FriendList](docs/API.md#friendlist) | `C_FriendList.GetFriendInfo`, `C_FriendList.GetFriendInfoByIndex`, `C_FriendList.GetNumFriends`, `C_FriendList.GetNumOnlineFriends`, `C_FriendList.GetNumWhoResults`, `C_FriendList.GetWhoInfo`, `C_FriendList.IsFriend`, `C_FriendList.IsIgnored`, `C_FriendList.IsIgnoredByGuid`, `C_FriendList.IsWhoQueryPending`, `C_FriendList.SendWhoQueryByName`, `C_FriendList.SetFriendNotes`, `C_FriendList.SetFriendNotesByIndex` | | [GameObject](docs/API.md#gameobject) | `C_GameObjectInfo.GetGameObjectInfoByID`, `C_GameObjectInfo.RequestLoadGameObjectByID`, `ClosestGameObjectPosition` | | [Glue](docs/API.md#glue) | `C_Glue.IsOnGlueScreen` | diff --git a/docs/API.md b/docs/API.md index 9b0d18ee..315b677e 100644 --- a/docs/API.md +++ b/docs/API.md @@ -196,6 +196,10 @@ build instructions. - [`fontstring:SetRotation(angle [, cx, cy])`](#fontstringsetrotationangle--cx-cy) - [`editBox:SetCursorPosition(position)`](#editboxsetcursorpositionposition) - [`editBox:GetCursorPosition()`](#editboxgetcursorposition) + - [`editBox:GetUTF8CursorPosition()`](#editboxgetutf8cursorposition) + - [`editBox:ClearHighlightText()`](#editboxclearhighlighttext) + - [`editBox:HasFocus()`](#editboxhasfocus) + - [`editBox:HasText()`](#editboxhastext) - [`frame:SetResizeBounds(minWidth, minHeight [, maxWidth, maxHeight])`](#framesetresizeboundsminwidth-minheight--maxwidth-maxheight) - [`frame:HookScript(scriptType, handler)`](#framehookscriptscripttype-handler) - [`frame:IsEventRegistered(event)`](#frameiseventregisteredevent) @@ -4657,6 +4661,27 @@ box:SetCursorPosition(5) -- cursor after "hello" print(box:GetCursorPosition()) -- 5 ``` +### `editBox:GetUTF8CursorPosition()` + +Returns the cursor position as a character count, not a byte count. For text +with only ASCII characters this equals `GetCursorPosition`. For text with +multibyte characters it counts characters, so the two values differ. + +### `editBox:ClearHighlightText()` + +Clears the selected text. The cursor stays where it is. Vanilla can clear a +selection only with `HighlightText(0, 0)`, which moves the selection to the +start. This method leaves the cursor in place. + +### `editBox:HasFocus()` + +Returns `true` if this edit box has keyboard focus. Vanilla has `SetFocus` +and `ClearFocus` but no way to read the focus state. + +### `editBox:HasText()` + +Returns `true` if the edit box holds any text. + ### `frame:SetResizeBounds(minWidth, minHeight [, maxWidth, maxHeight])` The modern rename of vanilla's `SetMinResize` / `SetMaxResize` pair. diff --git a/src/Offsets.h b/src/Offsets.h index 335d2775..13e23233 100644 --- a/src/Offsets.h +++ b/src/Offsets.h @@ -1903,8 +1903,8 @@ enum Offsets { VAR_FONTSTRING_METHOD_REGISTRY = 0x00CF5400, // EditBox — 48 methods (table 0x0087BB68), ctx per // docs/BlizzardScriptAPI.md. Backs `EditBox:SetCursorPosition` / - // `GetCursorPosition` (`EditBox::Cursor`), the modern cursor methods - // vanilla's EditBox lacks. + // `GetCursorPosition` (`EditBox::Methods`), the modern cursor / focus / + // text-state methods vanilla's EditBox lacks. VAR_EDITBOX_METHOD_REGISTRY = 0x00CF5378, // Model frame — backs `Model:SetDisplayInfo(creatureDisplayID)` @@ -7579,7 +7579,7 @@ enum Offsets { // *(this+0xF0) via SStrDup. OFF_EDITBOX_TEXT_FONTSTRING = 0x328, // CSimpleFontString* — the display text object - // CSimpleEditBox cursor / selection internals (backs EditBox::Cursor's + // CSimpleEditBox cursor / selection internals (backs EditBox::Methods' // SetCursorPosition / GetCursorPosition). Verified from the engine's own // HighlightText (FUN_00798870 → FUN_0077cca0) and Insert (FUN_00798400 → // FUN_0077bee0) paths: @@ -7591,6 +7591,7 @@ enum Offsets { // byte-based EditBox cursor (GetCursorPosition returns bytes; for // ASCII text byte == character). OFF_EDITBOX_FLAGS = 0x31c, + OFF_EDITBOX_TEXT_LENGTH = 0x338, // current text length in bytes OFF_EDITBOX_CURSOR_BYTE = 0x36c, // `void __thiscall(editbox, byteOffset)` — sets the cursor to a byte // offset, clamping to [0, textByteLen] and OR-ing the +0x31c cursor-dirty @@ -7601,6 +7602,13 @@ enum Offsets { // (selStart = selEnd = +0x36c). The engine's own "clear selection to the // caret" helper (FUN_0077ccf0), used before extending a shift-selection. FUN_EDITBOX_COLLAPSE_SELECTION = 0x0077ccf0, + // `int __thiscall(editbox, startByteIndex, byteCount)` — counts CHARACTERS + // (UTF-8 codepoints) in a byte range, walking the per-byte char-class table + // at +0x330 (a byte begins a codepoint when its class is 2/3/6). So + // `COUNT_CHARS(eb, 0, cursorByteOffset)` is the cursor's character index — + // backs GetUTF8CursorPosition. Verified from the arrow-key mover + // FUN_0077cb20's own `FUN_0077bc80(this, byteOff, cursorByte - byteOff)`. + FUN_EDITBOX_COUNT_CHARS = 0x0077bc80, // --- FontString measure internals (GetStringWidth icon fix + GetStringHeight) --- // CSimpleFontString::GetStringWidthInternal — `float(__fastcall)(fs /*ecx*/)`, diff --git a/src/editbox/Cursor.cpp b/src/editbox/Cursor.cpp deleted file mode 100644 index b3880df8..00000000 --- a/src/editbox/Cursor.cpp +++ /dev/null @@ -1,92 +0,0 @@ -// This file is part of ClassicAPI. -// -// ClassicAPI is free software: you can redistribute it and/or modify it under the terms -// of the GNU General Public License as published by the Free Software Foundation, either -// version 3 of the License, or (at your option) any later version. -// -// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY -// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR -// PURPOSE. See the GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License along with -// ClassicAPI. If not, see . - -// EditBox cursor methods — `editBox:SetCursorPosition(position)` and -// `editBox:GetCursorPosition()`, the modern widget methods vanilla's EditBox -// lacks (its 48-method registry has HighlightText / Insert / SetText but no -// cursor accessor). Modern addons that place the caret after programmatically -// setting text (autocomplete, chat helpers) call SetCursorPosition and error -// on 1.12 without it. -// -// Both are registered on the EditBox method registry, so — like every other -// per-type frame method — only EditBox frames dispatch to them; a Button or -// Frame calling `:SetCursorPosition()` still gets "method not found", so the -// resolved `this` is always a real CSimpleEditBox. -// -// The engine already stores and manipulates the caret; we just expose it. The -// cursor is a BYTE offset into the UTF-8 text buffer (field +0x36c), which is -// exactly what modern WoW's byte-based EditBox cursor uses — for ASCII text a -// byte offset equals a character index, so callers passing `#text` land at the -// end either way. Set path: the engine's own `FUN_EDITBOX_SET_CURSOR_BYTE` -// (clamp + set + cursor-dirty) then `FUN_EDITBOX_COLLAPSE_SELECTION` (clear any -// selection onto the caret), then flag the selection dirty so a prior highlight -// repaints away. - -#include "Game.h" -#include "Offsets.h" - -#include - -namespace EditBox::Cursor { - -namespace { - -using SetCursorByte_t = void(__thiscall *)(void *editbox, int byteOffset); -using CollapseSelection_t = void(__thiscall *)(void *editbox); - -int __fastcall Script_SetCursorPosition(void *L) { - void *eb = Game::Lua::ResolveObject(L, 1); - if (eb == nullptr || !Game::Lua::IsNumber(L, 2)) { - Game::Lua::Error(L, "Usage: EditBox:SetCursorPosition(position)"); - return 0; - } - const int pos = static_cast(Game::Lua::ToNumber(L, 2)); - reinterpret_cast( - Offsets::FUN_EDITBOX_SET_CURSOR_BYTE)(eb, pos); - reinterpret_cast( - Offsets::FUN_EDITBOX_COLLAPSE_SELECTION)(eb); - // COLLAPSE_SELECTION moves selStart/selEnd but doesn't flag them; set the - // selection-dirty bit (2) so any highlight from before is cleared on the - // next paint. SET_CURSOR_BYTE already set the cursor-dirty bit (4). - Game::Ref(eb, Offsets::OFF_EDITBOX_FLAGS) |= 2; - return 0; -} - -int __fastcall Script_GetCursorPosition(void *L) { - void *eb = Game::Lua::ResolveObject(L, 1); - if (eb == nullptr) { - Game::Lua::Error(L, "Usage: EditBox:GetCursorPosition()"); - return 0; - } - Game::Lua::PushNumber(L, static_cast( - Game::Read(eb, Offsets::OFF_EDITBOX_CURSOR_BYTE))); - return 1; -} - -const Game::Lua::FrameMethodEntry g_methods[] = { - {"SetCursorPosition", &Script_SetCursorPosition}, - {"GetCursorPosition", &Script_GetCursorPosition}, -}; - -void RegisterLuaFunctions() { - Game::Lua::RegisterFrameMethods( - reinterpret_cast(Offsets::VAR_EDITBOX_METHOD_REGISTRY), - g_methods, - static_cast(sizeof(g_methods) / sizeof(g_methods[0]))); -} - -const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions}; - -} // namespace - -} // namespace EditBox::Cursor diff --git a/src/editbox/Methods.cpp b/src/editbox/Methods.cpp new file mode 100644 index 00000000..0983a7f1 --- /dev/null +++ b/src/editbox/Methods.cpp @@ -0,0 +1,156 @@ +// This file is part of ClassicAPI. +// +// ClassicAPI is free software: you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software Foundation, either +// version 3 of the License, or (at your option) any later version. +// +// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +// PURPOSE. See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along with +// ClassicAPI. If not, see . + +// Modern EditBox method backports — cursor, selection, focus and text-state +// accessors that vanilla's 48-method EditBox registry lacks but modern addons +// call unconditionally (the caret bug that motivated this: TwitchEmotes' +// autocomplete calls SetCursorPosition after replacing the text). +// +// SetCursorPosition / GetCursorPosition — caret as a byte offset +// GetUTF8CursorPosition — caret as a character index +// ClearHighlightText — drop the selection, keep the caret +// HasFocus — does this box own keyboard focus +// HasText — is the box non-empty +// +// The engine already stores and manipulates all of this; we just expose it. +// Every method is registered on the EditBox method registry, so — like any +// per-type frame method — only EditBox frames dispatch to them (a Button or +// Frame still gets "method not found"), so the resolved `this` is always a +// real CSimpleEditBox. +// +// The caret is a BYTE offset into the UTF-8 text buffer (field +0x36c), which +// is exactly what modern WoW's byte-based EditBox cursor uses — for ASCII text +// a byte offset equals a character index, so callers passing `#text` land at +// the end either way. + +#include "Game.h" +#include "Offsets.h" + +#include + +namespace EditBox::Methods { + +namespace { + +using SetCursorByte_t = void(__thiscall *)(void *editbox, int byteOffset); +using CollapseSelection_t = void(__thiscall *)(void *editbox); +using CountChars_t = int(__thiscall *)(void *editbox, int startByte, int byteCount); + +int __fastcall Script_SetCursorPosition(void *L) { + void *eb = Game::Lua::ResolveObject(L, 1); + if (eb == nullptr || !Game::Lua::IsNumber(L, 2)) { + Game::Lua::Error(L, "Usage: EditBox:SetCursorPosition(position)"); + return 0; + } + const int pos = static_cast(Game::Lua::ToNumber(L, 2)); + reinterpret_cast( + Offsets::FUN_EDITBOX_SET_CURSOR_BYTE)(eb, pos); + reinterpret_cast( + Offsets::FUN_EDITBOX_COLLAPSE_SELECTION)(eb); + // COLLAPSE_SELECTION moves selStart/selEnd but doesn't flag them; set the + // selection-dirty bit (2) so any highlight from before is cleared on the + // next paint. SET_CURSOR_BYTE already set the cursor-dirty bit (4). + Game::Ref(eb, Offsets::OFF_EDITBOX_FLAGS) |= 2; + return 0; +} + +int __fastcall Script_GetCursorPosition(void *L) { + void *eb = Game::Lua::ResolveObject(L, 1); + if (eb == nullptr) { + Game::Lua::Error(L, "Usage: EditBox:GetCursorPosition()"); + return 0; + } + Game::Lua::PushNumber(L, static_cast( + Game::Read(eb, Offsets::OFF_EDITBOX_CURSOR_BYTE))); + return 1; +} + +// The caret as a 0-based CHARACTER index (UTF-8 codepoints before the caret), +// vs GetCursorPosition's byte offset. Equal for ASCII; differs once the text +// holds multibyte characters. +int __fastcall Script_GetUTF8CursorPosition(void *L) { + void *eb = Game::Lua::ResolveObject(L, 1); + if (eb == nullptr) { + Game::Lua::Error(L, "Usage: EditBox:GetUTF8CursorPosition()"); + return 0; + } + const int cursorByte = Game::Read(eb, Offsets::OFF_EDITBOX_CURSOR_BYTE); + const int chars = reinterpret_cast( + Offsets::FUN_EDITBOX_COUNT_CHARS)(eb, 0, cursorByte); + Game::Lua::PushNumber(L, static_cast(chars)); + return 1; +} + +// Drop the current selection without moving the caret. Collapsing selection to +// the caret (selStart = selEnd = cursor) is exactly what the engine's own +// helper does; vanilla can only clear a selection via HighlightText(0, 0), +// which yanks it to offset 0 instead of leaving the caret in place. +int __fastcall Script_ClearHighlightText(void *L) { + void *eb = Game::Lua::ResolveObject(L, 1); + if (eb == nullptr) { + Game::Lua::Error(L, "Usage: EditBox:ClearHighlightText()"); + return 0; + } + reinterpret_cast( + Offsets::FUN_EDITBOX_COLLAPSE_SELECTION)(eb); + Game::Ref(eb, Offsets::OFF_EDITBOX_FLAGS) |= 2; + return 0; +} + +// True when this edit box currently owns keyboard focus. The engine tracks the +// focused box in one global (written by SetFocus / cleared by ClearFocus), so +// focus is just pointer identity against it. +int __fastcall Script_HasFocus(void *L) { + void *eb = Game::Lua::ResolveObject(L, 1); + if (eb == nullptr) { + Game::Lua::PushBool(L, false); + return 1; + } + Game::Lua::PushBool(L, + eb == Game::Read(Offsets::VAR_FOCUSED_EDITBOX)); + return 1; +} + +// True when the box holds any text (its byte length is non-zero). +int __fastcall Script_HasText(void *L) { + void *eb = Game::Lua::ResolveObject(L, 1); + if (eb == nullptr) { + Game::Lua::PushBool(L, false); + return 1; + } + Game::Lua::PushBool(L, + Game::Read(eb, Offsets::OFF_EDITBOX_TEXT_LENGTH) > 0); + return 1; +} + +const Game::Lua::FrameMethodEntry g_methods[] = { + {"SetCursorPosition", &Script_SetCursorPosition}, + {"GetCursorPosition", &Script_GetCursorPosition}, + {"GetUTF8CursorPosition", &Script_GetUTF8CursorPosition}, + {"ClearHighlightText", &Script_ClearHighlightText}, + {"HasFocus", &Script_HasFocus}, + {"HasText", &Script_HasText}, +}; + +void RegisterLuaFunctions() { + Game::Lua::RegisterFrameMethods( + reinterpret_cast(Offsets::VAR_EDITBOX_METHOD_REGISTRY), + g_methods, + static_cast(sizeof(g_methods) / sizeof(g_methods[0]))); +} + +const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions}; + +} // namespace + +} // namespace EditBox::Methods