clank/rodecomp
1
0
Fork 0
Code Issues Wiki Activity
rodecomp/Source/UI/Edit/UIEditVariants.cpp
ragnarok-clanker a12ca0d9c6 Decompile fn_10753 (UIEditCtrl3::PaintText) 
Batch #9895 by codeplay: 0 byte-identical, 1 confirmed by peer review.

- fn_10753 UIEditCtrl3::PaintText: logic confirmed by peer review

Peer-reviewed-by: ragnarok-clanker, Yommy, unna
Accepted without human review: peers confirmed the logic ("same" ahead by at least 3, with 70% of the votes).
2026-11-02 07:07:56 +00:00

1187 lines
36 KiB
C++
Raw Blame History

#include "Client/Input/InputCharset.h"
#include "Client/Input/Language.h"
#include "Contents/SkinMgr.h"
#include "Render/Text/FontCache.h"
#include "Render/Text/TextContext.h"
#include "Resource/Bitmap/BitmapResource.h"
#include "Resource/ResourceMgr.h"
#include "Resource/SkinPalette.h"
#include "Resource/TextureNames.h"
#include "UI/Buttons/UIButton.h"
#include "UI/Buttons/UIItemTagButton.h"
#include "UI/Window/InputFocus.h"
#include "UI/Window/UIWindowMgr.h"
#include "UI/Chat/ChatSuggestions.h"
#include "UI/Edit/UIEditCtrl.h"
#include "UI/Lists/UIScrollBar.h"
#include "Network/TextEncoding.h"
#include "Utility/Text/FormatString.h"
#include "Utility/Text/StringUtil.h"
#include <cstring>
#include <windows.h>
#include <timeapi.h>
// OFFSET: 0x0084F250
// FUNCTION: fn_10657
UIEditCtrl2::UIEditCtrl2(UIWindowContext& windows, UIEditContext& edit) : UIEditCtrl(windows, edit) {
}
// OFFSET: 0x008515E0
// OFFSET: 0x00852700
// FUNCTION: fn_10692
UIEditCtrl2::~UIEditCtrl2() = default;
// OFFSET: 0x00863BF0
// FUNCTION: fn_10911
int UIEditCtrl2::SendMsg(UIWindow* sender, int message, std::intptr_t a, std::intptr_t b, std::intptr_t c, std::intptr_t d) {
if (message != 0) {
this->UIEditCtrl::SendMsg(sender, message, a, b, c, d);
} else {
InputFocus& focus = this->m_edit->focus;
if (focus.IsLast(focus.window)) {
focus.First();
} else {
focus.Next();
}
this->UIWindow::SendMsg(sender, message, a, b, c, d);
}
return 0;
}
// OFFSET: 0x00863C70
// FUNCTION: fn_10912
int UIEditCtrl3::SendMsg(UIWindow* sender, int message, std::intptr_t a, std::intptr_t b, std::intptr_t c, std::intptr_t d) {
using NextCharHandler = const char*(__thiscall*)(InputCharset*, const char*, int);
CLanguage& input = this->m_edit->input;
unsigned char* const scrolling = reinterpret_cast<unsigned char*>(&this->unknown_015C);
unsigned char* const lineMove = reinterpret_cast<unsigned char*>(&this->unknown_0184);
if (message == 0) {
if (lineMove[1] == 0 || (static_cast<unsigned short>(GetKeyState(VK_SHIFT)) >> 8) != 0 || lineMove[1] == 0) {
char newline[] = "\r\n";
input.Insert(newline);
return 0;
}
this->UIWindow::SendMsg(sender, 0, a, b, c, d);
return 0;
}
if (message == 7 || message == 9 || message == 10) {
const int previous = this->unknown_0158;
const int visible = this->geometry.height / this->unknown_0138;
scrolling[0] = 1;
if (message == 9) {
this->unknown_0158 = previous - visible + 1;
} else if (message == 10) {
this->unknown_0158 = previous - 1 + visible;
} else {
this->unknown_0158 = previous + a;
}
if (this->unknown_0158 < 0) {
this->unknown_0158 = 0;
}
const int last = this->unknown_013C - this->geometry.height / this->unknown_0138;
if (this->unknown_0158 > last) {
this->unknown_0158 = last;
}
static_cast<UIScrollBar*>(this->unknown_0130)->SetPosition(this->unknown_0158);
this->unknown_0130->Invalidate();
this->Invalidate();
if (this->parent) {
this->parent->Invalidate();
}
return this->unknown_0158 - previous;
}
if (message == 18) {
lineMove[0] = 0;
const unsigned count = this->unknown_0168.size();
if (count < 2 && (count != 1 || !this->unknown_0174[0])) {
return 0;
}
input.Selection(this->anchor, this->cursor);
if (this->unknown_0150 < 1 || this->unknown_0154 != this->cursor || scrolling[1] != 0) {
const char* current = this->unknown_0160;
this->unknown_015E = 0;
int bytes = 0;
int width = 0;
const char* const end = current + std::strlen(current);
int column = 0;
if (this->unknown_0144 != 0) {
while (current < end) {
const int previousBytes = bytes;
const int previousWidth = width;
const char* const start = current;
current = reinterpret_cast<NextCharHandler>((*reinterpret_cast<void***>(g_serverLanguage))[5])(g_serverLanguage, start, static_cast<int>(end - start));
const int length = static_cast<int>(current - start);
const TextLocale locale = {};
width += this->TextWidth(g_fontCache, locale, start, length, 0, 12, 0, 0);
bytes += length;
if (length == 1 && *start == '\n') {
column = bytes - 1;
break;
}
column = bytes;
if (width > this->unknown_014C) {
if (width - this->unknown_014C > this->unknown_014C - previousWidth) {
column = previousBytes;
}
break;
}
}
}
this->unknown_0150 = static_cast<int>(std::strlen(this->unknown_0160)) + this->unknown_0144 - column;
}
input.RetreatCursor(this->unknown_0150);
scrolling[1] = 1;
lineMove[0] = 1;
} else if (message == 19) {
lineMove[0] = 0;
const unsigned count = this->unknown_0168.size();
if ((count < 2 || count - 1 <= static_cast<unsigned>(this->textY)) && (count != 1 || !this->unknown_0174[0] || this->unknown_0148 < 1)) {
return 0;
}
input.Selection(this->anchor, this->cursor);
if (this->unknown_0150 < 1 || this->unknown_0154 != this->cursor || this->unknown_015E != 0) {
scrolling[1] = 0;
int bytes = 0;
int width = 0;
int column = 0;
const unsigned lines = this->unknown_0168.size();
if (lines >= 2 && lines - 1 > static_cast<unsigned>(this->textY)) {
const char* current = this->unknown_0164;
const char* const end = current + std::strlen(current);
while (current < end) {
const int previousBytes = bytes;
const int previousWidth = width;
const char* const start = current;
current = reinterpret_cast<NextCharHandler>((*reinterpret_cast<void***>(g_serverLanguage))[5])(g_serverLanguage, start, static_cast<int>(end - start));
const int length = static_cast<int>(current - start);
const TextLocale locale = {};
width += this->TextWidth(g_fontCache, locale, start, length, 0, 12, 0, 0);
bytes += length;
if (length == 1 && *start == '\n') {
column = bytes - 1;
break;
}
column = bytes;
if (width > this->unknown_014C) {
if (width - this->unknown_014C > this->unknown_014C - previousWidth) {
column = previousBytes;
}
break;
}
}
}
this->unknown_0150 = this->unknown_0148 + column;
}
input.AdvanceCursor(this->unknown_0150);
this->unknown_015E = 1;
} else if (message == 256) {
scrolling[0] = 0;
this->HandleInputMessage(a, b);
return 3;
} else {
this->UIEditCtrl::SendMsg(sender, message, a, b, c, d);
return 0;
}
input.Selection(this->anchor, this->cursor);
this->unknown_0154 = this->cursor;
return 0;
}
// OFFSET: 0x0085E420
// FUNCTION: fn_10829
void UIEditCtrl3::HandleInputMessage(unsigned key, std::intptr_t data) {
CLanguage& input = this->m_edit->input;
const bool password = this->m_edit->password != 0;
UIWindow* const chatWindow = g_chatSuggestions ? g_chatSuggestions->window : nullptr;
this->unknown_0150 = 0;
this->unknown_0154 = 0;
switch (key) {
case VK_BACK:
if (this->unknown_0168.size() != 0) {
input.Selection(this->anchor, this->cursor);
int length = 0;
for (int line = 0; line < this->textY; ++line) {
length += static_cast<int>(std::strlen(this->unknown_0168[line].c_str()));
}
if (length == this->cursor && this->unknown_0174[this->textY - 1]) {
input.Character(VK_BACK, data, g_textCodePage);
}
}
break;
case VK_END:
if (this->unknown_0168.size() != 0) {
input.Selection(this->anchor, this->cursor);
int offset = this->cursor;
for (int line = 0; line < this->textY; ++line) {
offset -= static_cast<int>(std::strlen(this->unknown_0168[line].c_str()));
}
const int length = static_cast<int>(std::strlen(this->unknown_0168[this->textY].c_str()));
input.AdvanceCursor(this->unknown_0174[this->textY] ? length - offset - 2 : length - offset);
input.Selection(this->anchor, this->cursor);
}
reinterpret_cast<unsigned char*>(&this->unknown_0184)[0] = 1;
return;
case VK_HOME:
if (this->unknown_0168.size() != 0) {
input.Selection(this->anchor, this->cursor);
int offset = this->cursor;
for (int line = 0; line < this->textY; ++line) {
offset -= static_cast<int>(std::strlen(this->unknown_0168[line].c_str()));
}
input.RetreatCursor(offset);
input.Selection(this->anchor, this->cursor);
}
break;
case VK_LEFT:
if (this->textY > 0) {
input.Selection(this->anchor, this->cursor);
int length = 0;
for (int line = 0; line < this->textY; ++line) {
length += static_cast<int>(std::strlen(this->unknown_0168[line].c_str()));
}
if (length == this->cursor && this->unknown_0174[this->textY - 1]) {
input.KeyDown(key, data, g_textCodePage, password, g_windowMgr.window_4F1FC, this->m_edit->windows, chatWindow);
}
}
input.KeyDown(key, data, g_textCodePage, password, g_windowMgr.window_4F1FC, this->m_edit->windows, chatWindow);
break;
case VK_RIGHT:
input.Selection(this->anchor, this->cursor);
if (static_cast<unsigned>(this->textY) < this->unknown_0168.size()) {
int length = 0;
for (int line = 0; line <= this->textY; ++line) {
length += static_cast<int>(std::strlen(this->unknown_0168[line].c_str()));
}
if (length - 2 == this->cursor && this->unknown_0174[this->textY]) {
input.KeyDown(key, data, g_textCodePage, password, g_windowMgr.window_4F1FC, this->m_edit->windows, chatWindow);
input.KeyDown(key, data, g_textCodePage, password, g_windowMgr.window_4F1FC, this->m_edit->windows, chatWindow);
return;
}
}
input.KeyDown(key, data, g_textCodePage, password, g_windowMgr.window_4F1FC, this->m_edit->windows, chatWindow);
break;
case VK_INSERT:
case VK_DELETE:
case 'A':
case 'C':
case 'V':
case 'X':
input.KeyDown(key, data, g_textCodePage, password, g_windowMgr.window_4F1FC, this->m_edit->windows, chatWindow);
break;
}
}
// OFFSET: 0x0084F570
// FUNCTION: fn_10659
UIEditCtrl3::UIEditCtrl3(UIWindowContext& windows, UIEditContext& edit) : UIEditCtrl2(windows, edit) {
this->unknown_0130 = 0;
this->unknown_0134 = 0;
this->unknown_0138 = 14;
this->unknown_013C = 0;
this->unknown_0140 = 0;
this->unknown_0144 = 0;
this->unknown_0148 = 0;
this->unknown_014C = 0;
this->unknown_0150 = 0;
this->unknown_0154 = 0;
this->unknown_0158 = 0;
this->unknown_015C = 0;
this->unknown_015E = 0;
this->unknown_0184 = 0;
this->unknown_0160 = 0;
this->unknown_0164 = 0;
}
// OFFSET: 0x0084F2B0
// FUNCTION: fn_10658
UIEditCtrl3::UIEditCtrl3(const UIEditCtrl3& other) : UIEditCtrl2(other) {
this->unknown_0130 = 0;
this->UIEditCtrl3::Slot15(other.geometry.width, other.geometry.height);
this->unknown_0134 = other.unknown_0134;
this->unknown_0138 = other.unknown_0138;
this->unknown_013C = other.unknown_013C;
this->unknown_0140 = other.unknown_0140;
this->unknown_0144 = other.unknown_0144;
this->unknown_0148 = other.unknown_0148;
this->unknown_014C = other.unknown_014C;
this->unknown_0150 = other.unknown_0150;
this->unknown_0154 = other.unknown_0154;
this->unknown_0158 = other.unknown_0158;
this->unknown_015C = other.unknown_015C;
this->unknown_015E = other.unknown_015E;
this->unknown_0184 = other.unknown_0184;
char* first = other.unknown_0160;
if (first != this->unknown_0160) {
if (IsNullOrEmpty(first)) {
this->unknown_0160 = 0;
} else {
const std::size_t length = std::strlen(first) + 1;
this->unknown_0160 = new char[length];
strcpy_s(this->unknown_0160, length, first);
}
}
char* second = other.unknown_0164;
if (second != this->unknown_0164) {
if (IsNullOrEmpty(second)) {
this->unknown_0164 = 0;
} else {
const std::size_t length = std::strlen(second) + 1;
this->unknown_0164 = new char[length];
strcpy_s(this->unknown_0164, length, second);
}
}
}
// OFFSET: 0x00851630
// OFFSET: 0x00852770
// FUNCTION: fn_10693
// FUNCTION: fn_10715
UIEditCtrl3::~UIEditCtrl3() {
this->ClearLineState();
this->pendingText.clear();
}
// OFFSET: 0x0085AC40
// FUNCTION: fn_10786
void UIEditCtrl3::Slot15(int width, int height) {
auto* scrollBar = new UIScrollBar(*this->m_context);
this->unknown_0130 = scrollBar;
scrollBar->Configure(width - 10, 0, 1, height);
this->AddChild(scrollBar);
}
// OFFSET: 0x00863280
// FUNCTION: fn_10906
void UIEditCtrl3::Resize(int width, int height) {
this->UIWindow::Resize(width, height);
this->unknown_0130->Move(this->geometry.width - 10, 0);
this->unknown_0130->Resize(this->unknown_0130->geometry.width, height);
using ResizeHandler = void(__thiscall*)(UIEditCtrl3*);
reinterpret_cast<ResizeHandler>((*reinterpret_cast<void***>(this))[58])(this);
}
// OFFSET: 0x00865220
// FUNCTION: fn_10922
int UIWhisperEditCtrl::SendMsg(UIWindow* sender, int message, std::intptr_t a, std::intptr_t b, std::intptr_t c, std::intptr_t d) {
if (message == 18) {
if (!this->history.empty()) {
if (this->historyIndex != 0) {
--this->historyIndex;
}
this->SetText(this->history[this->historyIndex].c_str());
this->Slot23();
}
} else if (message == 19) {
if (!this->history.empty() && static_cast<std::size_t>(this->historyIndex) < this->history.size()) {
++this->historyIndex;
this->SetText(this->historyIndex == static_cast<int>(this->history.size()) ? "" : this->history[this->historyIndex].c_str());
this->Slot23();
}
} else {
return this->UIEditCtrl::SendMsg(sender, message, a, b, c, d);
}
return 0;
}
// OFFSET: 0x00867FC0
// OFFSET: 0x00853760
// FUNCTION: fn_10741
void UIEditCtrl_OldList::RecallHistory(int step) {
if (this->historyIndex == -1) {
return;
}
this->historyIndex += step;
if (this->historyIndex < 0) {
this->historyIndex = static_cast<int>(this->history.size()) - 1;
}
if (static_cast<std::size_t>(this->historyIndex) >= this->history.size()) {
this->historyIndex = 0;
}
this->SetText(this->history[this->historyIndex].c_str());
this->Slot23();
this->Invalidate();
}
// OFFSET: 0x008551B0
// FUNCTION: fn_10753
void UIEditCtrl3::PaintText() {
FontCache& fonts = this->m_edit->buttons.fonts;
const TextLocale& locale = this->m_edit->buttons.locale;
int x = 3;
if (this->invalidatesParent == 0 && this->firstVisible != 0) {
x = 3 - this->TextWidth(fonts, locale, this->text.c_str(), this->firstVisible, 0, 12, 0, 0);
}
std::string display;
std::uint32_t color = this->textColor;
if (g_windowMgr.GetHoverWindow() == this) {
this->Synchronize();
}
const char* prefix = g_serverLanguage->Prefix(false);
display = prefix + this->text;
int width = this->geometry.width - 6;
if (this->unknown_0134 != 0) {
width += 3 - this->unknown_0130->geometry.width;
}
std::vector<std::string>& lines = this->unknown_0168;
std::vector<bool>& breaks = this->unknown_0174;
lines.clear();
breaks.clear();
this->WrapTextWithBreaks(display.c_str(), &lines, &breaks, width);
this->WrapLines(lines);
for (std::size_t index = 0; index < lines.size() - breaks.size(); ++index) {
breaks.push_back(false);
}
this->unknown_013C = static_cast<int>(lines.size());
if (reinterpret_cast<const unsigned char*>(&this->unknown_0184)[1] != 0) {
this->unknown_013C = static_cast<int>(lines.size()) + 1;
}
if (lines.size() == 0) {
this->DrawBlinkingCaret(color);
return;
}
const int rows = this->geometry.height / this->unknown_0138;
const int first = this->unknown_0158;
int last = rows + first;
if (lines.size() < static_cast<unsigned>(last)) {
last = static_cast<int>(lines.size());
}
int offset = 0;
for (int line = 0; line < first; ++line) {
offset += static_cast<int>(std::strlen(lines[line].c_str()));
}
for (int line = first; line < last; ++line) {
const int y = (line - first) * this->unknown_0138;
offset += static_cast<int>(std::strlen(lines[line].c_str()));
if (g_windowMgr.GetHoverWindow() == this && this->m_edit->input.cursor - this->m_edit->input.anchor != 0) {
const int selectionBegin = this->cursor < this->anchor ? this->cursor : this->anchor;
const int selectionEnd = this->anchor < this->cursor ? this->cursor : this->anchor;
int startX = 0;
int endX = 0;
if (selectionBegin < offset) {
int begin = selectionBegin + static_cast<int>(std::strlen(lines[line].c_str())) - offset;
if (begin < 0) {
begin = 0;
}
startX = begin != 0 ? this->TextWidth(fonts, locale, lines[line].c_str(), begin, 0, 12, 0, 0) : 0;
int length = static_cast<int>(std::strlen(lines[line].c_str()));
if (breaks[line]) {
length -= 2;
}
endX = this->TextWidth(fonts, locale, lines[line].c_str(), length, 0, 12, 0, 0);
}
if (selectionEnd <= offset) {
int end = selectionEnd + static_cast<int>(std::strlen(lines[line].c_str())) - offset;
if (end < 0) {
end = 0;
}
int length = end;
if (static_cast<int>(std::strlen(lines[line].c_str())) == end && breaks[line]) {
length = end - 2;
}
endX = length != 0 ? this->TextWidth(fonts, locale, lines[line].c_str(), length, 0, 12, 0, 0) : 0;
}
int left = x + startX;
int span = endX - startX;
if (left < 3) {
span += left - 3;
left = 3;
}
const int windowWidth = this->geometry.width;
if (left < windowWidth && span > 0) {
unsigned red, green, blue;
SkinPaletteChannels(ResourceMgr::Instance(), 6, 2, red, green, blue);
this->FillRegion(left, y, left + span <= windowWidth ? span : windowWidth - left, 14, RGB(red, green, blue));
}
}
int tagOffset = 0;
if (this->geometry.id == 0x1F8 || this->geometry.id == 0x1EB) {
tagOffset = 1;
}
if (this->pendingText.size() < static_cast<unsigned>(line + 1)) {
this->pendingText.push_back(lines[line]);
} else if (&this->pendingText[line] != &lines[line]) {
this->pendingText[line] = lines[line];
}
this->PlaceLinks(lines[line], y, line, first, last);
const std::size_t length = std::strlen(lines[line].c_str());
char* buffer = new char[length + 1];
std::strcpy(buffer, lines[line].c_str());
buffer[length] = '\0';
if (buffer[length - 2] == '\r') {
buffer[length - 2] = '\0';
}
this->DrawTextAt(fonts, locale, x, tagOffset + y, buffer, 0, 0, 12, color, 0, 0);
for (std::vector<UIItemTagButton*>& entry : this->entries) {
for (std::size_t index = 0; index < entry.size(); ++index) {
UIItemTagButton* button = entry[index];
const int buttonLine = button->line;
if (buttonLine < first || last - 1 < buttonLine) {
button->Move(-100, -100);
} else if (line == buttonLine) {
button->Move(button->column + x - 1, y);
}
}
}
if (buffer) {
delete[] buffer;
}
}
const int prefixLength = static_cast<int>(std::strlen(prefix));
int column = prefixLength + this->cursor;
int reading = prefixLength + (this->anchor < this->cursor ? this->cursor : this->anchor) + this->m_edit->candidateCursor;
int remaining = column;
for (std::size_t index = 0; index < lines.size(); ++index) {
remaining -= static_cast<int>(std::strlen(lines[index].c_str()));
this->textY = static_cast<int>(index);
if (remaining < 0 || (static_cast<unsigned char>(this->unknown_0184) != 0 && remaining == 0)) {
break;
}
}
if (g_windowMgr.GetHoverWindow() == this) {
int caretLine = this->textY;
if (this->unknown_0140 != static_cast<int>(std::strlen(lines[caretLine].c_str()))) {
reinterpret_cast<unsigned char*>(&this->unknown_015C)[0] = 0;
this->unknown_0140 = static_cast<int>(std::strlen(lines[caretLine].c_str()));
}
int before = 0;
for (int index = 0; index < caretLine; ++index) {
before += static_cast<int>(std::strlen(lines[index].c_str()));
}
int wrapped = 0;
if (column - before >= 0) {
column -= before;
}
if (static_cast<int>(std::strlen(lines[caretLine].c_str())) == column && breaks[caretLine]) {
wrapped = 1;
column = 0;
}
if (this->unknown_0148 != static_cast<int>(std::strlen(lines[caretLine].c_str())) - column) {
this->unknown_0148 = static_cast<int>(std::strlen(lines[caretLine].c_str())) - column;
}
if (this->unknown_0144 != column) {
this->unknown_0144 = column;
}
int caretX = 0;
if (column != 0) {
caretX = this->TextWidth(fonts, locale, lines[caretLine].c_str(), column, 0, 12, 0, 0);
caretLine = this->textY;
}
if (reading - before >= 0) {
reading -= before;
}
int readingLength = reading;
if (static_cast<int>(std::strlen(lines[caretLine].c_str())) == reading && breaks[caretLine]) {
readingLength = reading - 2;
}
const int readingX = readingLength != 0 ? this->TextWidth(fonts, locale, lines[caretLine].c_str(), readingLength, 0, 12, 0, 0) : 0;
if (this->m_edit->candidateCursor != 0) {
int gap = readingX - caretX;
if (gap < 2) {
gap = 2;
}
caretX += gap + 2;
this->unknown_0144 += 2;
this->MoveCandidateWindow(caretX);
this->MoveReadingWindow(readingX);
}
if (this->unknown_014C != caretX) {
this->unknown_014C = caretX;
}
if ((timeGetTime() / 500 & 1) == 0 && (!g_windowMgr.IsHoverOnWindow01C8Button() || g_inputSuggestionsEnabled)) {
this->DrawTextAt(fonts, locale, x - 2 + caretX, (wrapped + this->textY - first) * this->unknown_0138, "|", 0, 0, 12, color, 0, 0);
const unsigned char* scroll = reinterpret_cast<const unsigned char*>(&this->unknown_015C);
if (scroll[0] == 0) {
if (scroll[1] == 0) {
if (this->unknown_015E == 0) {
const int top = rows < this->unknown_013C ? wrapped + (this->unknown_013C - rows) : this->textY;
this->unknown_0158 = top;
if (reinterpret_cast<const unsigned char*>(&this->unknown_0184)[1] != 0 && top > 0) {
this->unknown_0158 = top - 1;
}
} else {
const int current = this->textY;
if (this->unknown_0158 - 1 + rows < current) {
if (current < rows) {
this->unknown_0158 = 0;
} else {
this->unknown_0158 = current - rows + 1;
}
}
}
} else {
const int current = this->textY;
if (current - wrapped < this->unknown_0158) {
if (current < this->unknown_013C - rows) {
this->unknown_0158 = wrapped + current;
} else {
this->unknown_0158 = this->unknown_013C - rows;
}
}
}
}
}
if (wrapped != 0) {
++this->textY;
}
}
std::size_t count = lines.size();
if (count < 2 || this->textY < 1) {
if ((count == 1 || (count > 1 && this->textY == 0)) && breaks[0]) {
if (this->unknown_0160) {
delete[] this->unknown_0160;
this->unknown_0160 = nullptr;
}
this->unknown_0160 = new char[std::strlen(lines[0].c_str()) + 1];
std::strcpy(this->unknown_0160, lines[0].c_str());
}
} else {
const std::string& previous = lines[this->textY - 1];
if (this->unknown_0160) {
delete[] this->unknown_0160;
this->unknown_0160 = nullptr;
}
this->unknown_0160 = new char[std::strlen(previous.c_str()) + 1];
std::strcpy(this->unknown_0160, lines[this->textY - 1].c_str());
}
count = lines.size();
if (count < 2 || count - 1 <= static_cast<unsigned>(this->textY)) {
if (count == 1 && breaks[0]) {
if (this->unknown_0164) {
delete[] this->unknown_0164;
this->unknown_0164 = nullptr;
}
this->unknown_0164 = new char[std::strlen(lines[0].c_str()) + 1];
std::strcpy(this->unknown_0164, lines[0].c_str());
}
} else {
const std::string& next = lines[this->textY + 1];
if (this->unknown_0164) {
delete[] this->unknown_0164;
this->unknown_0164 = nullptr;
}
this->unknown_0164 = new char[std::strlen(next.c_str()) + 1];
std::strcpy(this->unknown_0164, lines[this->textY + 1].c_str());
}
this->UpdateScrollBar();
}
// OFFSET: 0x00853810
// FUNCTION: fn_10742
int UIEditCtrl::MeasureText(const std::string& text, const int& bytes) {
const TextLocale locale = {};
return this->TextWidth(g_fontCache, locale, text.c_str(), bytes, 0, 12, 0, 0);
}
// OFFSET: 0x0084F7B0
// FUNCTION: fn_10660
UIEditCtrl4::UIEditCtrl4(UIWindowContext& windows, UIEditContext& edit) : UIEditCtrl(windows, edit), placeholderColor(0xFFFFFFFFu), placeholderEnabled(0) {
}
// OFFSET: 0x00852870
UIEditCtrl4::~UIEditCtrl4() = default;
// OFFSET: 0x0085AA40
// FUNCTION: fn_10782
void UIEditCtrl4::Slot23() {
this->text.clear();
this->m_edit->input.ResetInput();
this->m_edit->input.ResetInput();
this->m_edit->input.Insert(this->text.c_str());
this->m_edit->password = this->mask != 0;
this->SelectAll();
}
// OFFSET: 0x008563D0
// FUNCTION: fn_10754
void UIEditCtrl4::PaintText() {
this->PaintTextWithPolicy(true, &this->placeholder, this->placeholderColor, this->placeholderEnabled == 1);
}
// OFFSET: 0x00869800
// FUNCTION: fn_10972
void UIEditCtrl4::SetPlaceholderEnabled(bool enabled) {
this->placeholderEnabled = enabled;
}
// OFFSET: 0x00867960
// FUNCTION: fn_10943
void UIEditCtrl4::SetPlaceholder(const char* value) {
this->placeholder.assign(value, std::strlen(value));
this->Trim();
if (this->m_edit->focus.window == this) {
this->m_edit->input.ResetInput();
this->m_edit->input.ResetInput();
this->m_edit->input.Insert(this->placeholder.c_str());
}
this->SelectAll();
if (this->parent) {
this->parent->Invalidate();
}
}
// OFFSET: 0x008679F0
// FUNCTION: fn_10944
void UIEditCtrl4::SetPlaceholderColor(std::uint32_t color) {
this->placeholderColor = color;
}
// OFFSET: 0x0084F7B0
// FUNCTION: fn_10661
UIEditCtrl5::UIEditCtrl5(UIWindowContext& windows, UIEditContext& edit) : UIEditCtrl4(windows, edit) {
}
// OFFSET: 0x008528F0
UIEditCtrl5::~UIEditCtrl5() = default;
// OFFSET: 0x00864140
// FUNCTION: fn_10913
int UIEditCtrl5::SendMsg(UIWindow* sender, int message, std::intptr_t a, std::intptr_t b, std::intptr_t c, std::intptr_t d) {
if (message != 0) {
this->UIEditCtrl::SendMsg(sender, message, a, b, c, d);
} else {
InputFocus& focus = this->m_edit->focus;
if (focus.IsLast(focus.window)) {
focus.First();
} else {
focus.Next();
}
this->UIWindow::SendMsg(sender, message, a, b, c, d);
}
return 0;
}
// OFFSET: 0x0085CBF0
// FUNCTION: fn_10806
void UIEditCtrl3::Paint() {
const bool selected = g_skinInfo.Selected();
const SkinPaletteCell cell = {1, 2};
const std::uint32_t color = SkinPaletteColor(ResourceMgr::Instance(), cell, selected);
this->red = color & 0xFF;
this->blue = (color >> 16) & 0xFF;
this->green = (color & 0xFFFF) >> 8;
this->Invalidate();
this->ClearSurface(static_cast<unsigned char>(this->red) | (static_cast<unsigned char>(this->green) << 8) | (static_cast<unsigned char>(this->blue) << 16));
this->PaintText();
if (this->parent) {
this->parent->Invalidate();
}
}
// OFFSET: 0x0085FF60
// FUNCTION: fn_10892
void UIEditCtrl3::Slot35(int value) {
if (this->unknown_0134 == 0) {
return;
}
if (value < 0) {
this->SendMsg(this->unknown_0130, 7, 3, 0, 0, 0);
} else {
this->SendMsg(this->unknown_0130, 7, -3, 0, 0, 0);
}
}
// OFFSET: 0x00868300
// FUNCTION: fn_10958
void UIEditCtrl3::Trim() {
const int limit = this->maximum - this->unknown_00F0;
const auto length = this->text.size();
if (static_cast<int>(length) <= limit) {
return;
}
const char* next = CharNextExA(static_cast<WORD>(g_textCodePage), this->text.c_str(), 0);
while (length - std::strlen(next) <= static_cast<unsigned>(limit)) {
next = CharNextExA(static_cast<WORD>(g_textCodePage), next, 0);
}
const char* previous = CharPrevExA(static_cast<WORD>(g_textCodePage), this->text.c_str(), next, 0);
this->text.resize(length - std::strlen(previous));
this->m_edit->input.ResetInput();
this->m_edit->input.ResetInput();
this->m_edit->input.Insert(this->text.c_str());
while (this->text.size() < static_cast<unsigned>(limit)) {
this->text += " ";
}
}
// OFFSET: 0x0085BB60
// FUNCTION: fn_10796
void UIBitmapEditCtrl::Paint() {
this->ClearSurface(0xFFFFFFFF);
CBitmapRes* bitmap = static_cast<CBitmapRes*>(ResourceMgr::Instance().Load(Resolve(this->bitmapName.c_str())));
this->DrawBitmap(0, 0, bitmap ? &bitmap->image : nullptr, false);
this->textY = 3;
this->PaintText();
}
// OFFSET: 0x00865590
// FUNCTION: fn_10927
void UIBitmapEditCtrl::SetBitmapName(const char* name) {
this->bitmapName.assign(name, std::strlen(name));
CBitmapRes* bitmap = static_cast<CBitmapRes*>(ResourceMgr::Instance().Load(Resolve(this->bitmapName.c_str())));
this->geometry.width = bitmap->image.width;
this->geometry.height = bitmap->image.height;
}
// OFFSET: 0x0084EE90
// FUNCTION: fn_10654
UIChatEditCtrl::UIChatEditCtrl(UIWindowContext& windows, UIEditContext& edit) : UIEditCtrl(windows, edit), unknown_0140(0), historyLimit(30) {
this->history.reserve(this->historyLimit);
this->unknown_0144 = 0;
}
// OFFSET: 0x0085EB50
// FUNCTION: fn_10840
void UIChatEditCtrl::Slot25(int x, int y) {
if (this->disabled == 0) {
this->m_edit->focus.Set(this);
}
this->parent->Slot25(x + this->geometry.x, y + this->geometry.y);
}
// OFFSET: 0x00863640
// FUNCTION: fn_10909
int UIChatEditCtrl::SendMsg(UIWindow* sender, int message, std::intptr_t a, std::intptr_t b, std::intptr_t c, std::intptr_t d) {
if (message == 18) {
if (this->history.size() != 0) {
if (this->unknown_0140 == this->history.size()) {
this->pending = this->Text();
}
if (this->unknown_0140 != 0) {
--this->unknown_0140;
}
this->SetText(this->history[this->unknown_0140].c_str());
this->Slot23();
}
} else if (message == 19) {
if (this->history.size() != 0 && this->unknown_0140 < this->history.size()) {
++this->unknown_0140;
this->SetText(this->unknown_0140 == this->history.size() ? this->pending.c_str() : this->history[this->unknown_0140].c_str());
this->Slot23();
}
} else {
return UIEditCtrl::SendMsg(sender, message, a, b, c, d);
}
return 0;
}
// OFFSET: 0x0085CDE0
// FUNCTION: fn_10808
void UIEditCtrl_OldList::Paint() {
this->ClearSurface(0xFFFF00FF);
if (!this->bitmapName.empty()) {
CBitmapRes* bitmap = static_cast<CBitmapRes*>(ResourceMgr::Instance().Load(Resolve(this->bitmapName.c_str())));
this->DrawBitmap(0, 0, bitmap ? &bitmap->image : nullptr, false);
}
this->PaintText();
}
// OFFSET: 0x0085FFC0
// FUNCTION: fn_10894
void UIEditCtrl_OldList::Slot35(int value) {
if (value < 0) {
this->SendMsg(nullptr, 19, 0, 0, 0, 0);
} else {
this->SendMsg(nullptr, 18, 0, 0, 0, 0);
}
}
// OFFSET: 0x0085E3D0
// FUNCTION: fn_10827
void UIEditCtrlVarId::Slot24(int) {
this->Synchronize();
this->Invalidate();
this->SendMsg(this, 0, 0, 0, 0, 0);
}
// OFFSET: 0x0085FFA0
// FUNCTION: fn_10893
void UIEditCtrlVarId::Slot35(int value) {
if (this->parent) {
this->parent->Slot35(value);
}
}
// OFFSET: 0x00864CE0
// FUNCTION: fn_10915
int UIEditCtrlVarId::SendMsg(UIWindow* sender, int message, std::intptr_t argument1, std::intptr_t argument2, std::intptr_t argument3, std::intptr_t argument4) {
if (message != 0) {
return UIEditCtrl::SendMsg(sender, message, argument1, argument2, argument3, argument4);
}
if (this->parent) {
this->parent->SendMsg(this, 6, this->geometry.id, 0, 0, 0);
}
return 0;
}
// OFFSET: 0x00868160
// FUNCTION: fn_10953
void UIEditCtrlVarId::SetText(const char* value) {
this->UIEditCtrl::SetText(value);
this->Invalidate();
}
// OFFSET: 0x0085AB10
// FUNCTION: fn_10784
void UIWhisperEditCtrl::Slot23() {
this->m_edit->input.ResetInput();
this->m_edit->input.ResetInput();
this->m_edit->input.Insert(this->text.c_str());
this->m_edit->password = this->mask != 0;
this->SelectAll();
this->SelectAll();
}
// OFFSET: 0x00868230
// FUNCTION: fn_10956
void UIWhisperEditCtrl::SetText(const char* value) {
this->UIEditCtrl::SetText(value);
if (std::strlen(value) == 0) {
this->historyIndex = static_cast<int>(this->history.size());
}
}
// OFFSET: 0x00864D20
// FUNCTION: fn_10916
int UIEditCtrl_OldList::SendMsg(UIWindow* sender, int message, std::intptr_t argument1, std::intptr_t argument2, std::intptr_t argument3, std::intptr_t argument4) {
switch (message) {
case 18:
this->RecallHistory(-1);
return 0;
case 19:
this->RecallHistory(1);
return 0;
default:
return UIEditCtrl::SendMsg(sender, message, argument1, argument2, argument3, argument4);
}
}
// OFFSET: 0x00886F90
// FUNCTION: fn_11330
void UIShowAndEditTimeCtrl::Slot15(int, int) {
for (int i = 0; i < 2; ++i) {
UIEditCtrlVarId*& field = this->fields[i];
field = new UIEditCtrlVarId(*this->m_context, *this->m_edit);
field->SetSize(20, 18);
field->Background(232, 232, 232);
field->Border(192, 192, 192);
field->flat = 0;
field->maximum = 2;
field->Move(i * 38, 0);
field->SetText("0");
field->SetId(184);
this->AddChild(field);
}
}
// OFFSET: 0x008996B0
// FUNCTION: fn_11556
int UIShowAndEditTimeCtrl::SendMsg(UIWindow* sender, int message, std::intptr_t argument1, std::intptr_t argument2, std::intptr_t argument3, std::intptr_t argument4) {
if (message == 6 && argument1 == 184) {
for (UIEditCtrlVarId* field : this->fields) {
if (sender == field) {
int value = std::atoi(field->Text());
if (value > 60) {
value = 60;
}
const std::string text = FormatOwnedString("%d", value);
field->SetText(text.c_str());
}
}
}
return 0;
}
// OFFSET: 0x00853F20
// FUNCTION: fn_10745
void UIEditCtrl3::ClearLineState() {
while (!this->unknown_0168.empty()) {
this->unknown_0168.erase(this->unknown_0168.begin());
}
this->unknown_0168.clear();
for (std::vector<bool>::iterator it = this->unknown_0174.begin(); it != this->unknown_0174.end();) {
it = this->unknown_0174.erase(it);
}
this->unknown_0174.clear();
if (this->unknown_0160) {
delete[] this->unknown_0160;
this->unknown_0160 = nullptr;
}
if (this->unknown_0164) {
delete[] this->unknown_0164;
this->unknown_0164 = nullptr;
}
}
// OFFSET: 0x0086E7D0
// FUNCTION: fn_11077
UIShowAndEditTimeCtrl::UIShowAndEditTimeCtrl(UIWindowContext& windows) : UIWindow(windows, 0) {
this->unknown_0084 = 0;
this->unknown_0088 = 0;
}
#include "UI/Edit/UIItemTagCtrl.h"
// OFFSET: 0x0085C4F0
// FUNCTION: fn_10801
void UIChatEditCtrl::Paint() {
const auto component = [&](int value) { return static_cast<unsigned char>(this->disabled != 0 && value > 30 ? value - 30 : value); };
const unsigned color = component(this->red) | (component(this->green) << 8) | (component(this->blue) << 16);
this->textY = 0;
if (this->flat == 0) {
RECT rectangle{0, 0, this->geometry.width, this->geometry.height};
const unsigned border = static_cast<unsigned char>(this->borderRed) | (static_cast<unsigned char>(this->borderGreen) << 8) |
(static_cast<unsigned char>(this->borderBlue) << 16);
this->FillSurface(border, &rectangle);
SetRect(&rectangle, 1, 1, this->geometry.width - 1, this->geometry.height - 1);
this->FillSurface(color, &rectangle);
} else {
this->ClearSurface(color);
}
this->textY = this->topPadding + 2;
this->PaintText();
UIItemTagOnChat* tag = this->unknown_0144;
if (tag != nullptr) {
tag->SetTaggedText(this->text, this->geometry.width);
tag = this->unknown_0144;
tag->sub_8962C0();
tag = this->unknown_0144;
const int span = static_cast<int>(tag->unknown_0140.size() - tag->taggedText.size());
this->unknown_00F0 = span > 0 ? span : 0;
if (tag->unknown_011C == 0) {
delete tag;
this->unknown_0144 = nullptr;
}
}
}
// OFFSET: 0x00867FC0
// FUNCTION: fn_10951
void UIEditCtrl3::SetText(const char* value) {
this->text.assign(value, std::strlen(value));
this->Trim();
if (g_windowMgr.GetHoverWindow() == this) {
this->m_edit->input.ResetInput();
this->m_edit->input.ResetInput();
this->m_edit->input.Insert(this->text.c_str());
}
this->SelectAll();
if (this->text.find("<ITEML>") != std::string::npos || this->text.find("</ITEML>") != std::string::npos) {
this->sub_869810(this->text.c_str());
}
if (this->parent != nullptr) {
this->parent->Invalidate();
}
}
Reference in a new issue View git blame Copy permalink