Introduce QtFrontend with renderer, input handler, and theming support.
- Added `QtFrontend`, `QtRenderer`, and `QtInputHandler` for Qt-based UI rendering and input handling. - Implemented support for theming, font customization, and palette overrides in GUITheme. - Renamed and refactored ImGui-specific components (e.g., `GUIRenderer` -> `ImGuiRenderer`). - Added cross-frontend integration for commands and visual font picker.
This commit is contained in:
538
QtInputHandler.cc
Normal file
538
QtInputHandler.cc
Normal file
@@ -0,0 +1,538 @@
|
||||
// Refactor: route all key processing through command subsystem, mirroring ImGuiInputHandler
|
||||
|
||||
#include "QtInputHandler.h"
|
||||
|
||||
#include <QKeyEvent>
|
||||
|
||||
#include <ncurses.h>
|
||||
|
||||
#include "Editor.h"
|
||||
#include "KKeymap.h"
|
||||
|
||||
// Temporary verbose logging to debug macOS Qt key translation issues
|
||||
// Default to off; enable by defining QT_IH_DEBUG=1 at compile time when needed.
|
||||
#ifndef QT_IH_DEBUG
|
||||
#define QT_IH_DEBUG 0
|
||||
#endif
|
||||
|
||||
#if QT_IH_DEBUG
|
||||
#include <cstdio>
|
||||
static const char *
|
||||
mods_str(Qt::KeyboardModifiers m)
|
||||
{
|
||||
static thread_local char buf[64];
|
||||
buf[0] = '\0';
|
||||
bool first = true;
|
||||
auto add = [&](const char *s) {
|
||||
if (!first)
|
||||
std::snprintf(buf + std::strlen(buf), sizeof(buf) - std::strlen(buf), "|");
|
||||
std::snprintf(buf + std::strlen(buf), sizeof(buf) - std::strlen(buf), "%s", s);
|
||||
first = false;
|
||||
};
|
||||
if (m & Qt::ShiftModifier)
|
||||
add("Shift");
|
||||
if (m & Qt::ControlModifier)
|
||||
add("Ctrl");
|
||||
if (m & Qt::AltModifier)
|
||||
add("Alt");
|
||||
if (m & Qt::MetaModifier)
|
||||
add("Meta");
|
||||
if (first)
|
||||
std::snprintf(buf, sizeof(buf), "none");
|
||||
return buf;
|
||||
}
|
||||
#define LOGF(...) std::fprintf(stderr, __VA_ARGS__)
|
||||
#else
|
||||
#define LOGF(...) ((void)0)
|
||||
#endif
|
||||
|
||||
static bool
|
||||
IsPrintableQt(const QKeyEvent &e)
|
||||
{
|
||||
// Printable if it yields non-empty text and no Ctrl/Meta modifier
|
||||
if (e.modifiers() & (Qt::ControlModifier | Qt::MetaModifier))
|
||||
return false;
|
||||
const QString t = e.text();
|
||||
return !t.isEmpty() && !t.at(0).isNull();
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
ToAsciiKey(const QKeyEvent &e)
|
||||
{
|
||||
const QString t = e.text();
|
||||
if (!t.isEmpty()) {
|
||||
const QChar c = t.at(0);
|
||||
if (!c.isNull())
|
||||
return KLowerAscii(c.unicode());
|
||||
}
|
||||
// When modifiers (like Control) are held, Qt::text() can be empty on macOS.
|
||||
// Fall back to mapping common virtual keys to ASCII.
|
||||
switch (e.key()) {
|
||||
case Qt::Key_A:
|
||||
return 'a';
|
||||
case Qt::Key_B:
|
||||
return 'b';
|
||||
case Qt::Key_C:
|
||||
return 'c';
|
||||
case Qt::Key_D:
|
||||
return 'd';
|
||||
case Qt::Key_E:
|
||||
return 'e';
|
||||
case Qt::Key_F:
|
||||
return 'f';
|
||||
case Qt::Key_G:
|
||||
return 'g';
|
||||
case Qt::Key_H:
|
||||
return 'h';
|
||||
case Qt::Key_I:
|
||||
return 'i';
|
||||
case Qt::Key_J:
|
||||
return 'j';
|
||||
case Qt::Key_K:
|
||||
return 'k';
|
||||
case Qt::Key_L:
|
||||
return 'l';
|
||||
case Qt::Key_M:
|
||||
return 'm';
|
||||
case Qt::Key_N:
|
||||
return 'n';
|
||||
case Qt::Key_O:
|
||||
return 'o';
|
||||
case Qt::Key_P:
|
||||
return 'p';
|
||||
case Qt::Key_Q:
|
||||
return 'q';
|
||||
case Qt::Key_R:
|
||||
return 'r';
|
||||
case Qt::Key_S:
|
||||
return 's';
|
||||
case Qt::Key_T:
|
||||
return 't';
|
||||
case Qt::Key_U:
|
||||
return 'u';
|
||||
case Qt::Key_V:
|
||||
return 'v';
|
||||
case Qt::Key_W:
|
||||
return 'w';
|
||||
case Qt::Key_X:
|
||||
return 'x';
|
||||
case Qt::Key_Y:
|
||||
return 'y';
|
||||
case Qt::Key_Z:
|
||||
return 'z';
|
||||
case Qt::Key_0:
|
||||
return '0';
|
||||
case Qt::Key_1:
|
||||
return '1';
|
||||
case Qt::Key_2:
|
||||
return '2';
|
||||
case Qt::Key_3:
|
||||
return '3';
|
||||
case Qt::Key_4:
|
||||
return '4';
|
||||
case Qt::Key_5:
|
||||
return '5';
|
||||
case Qt::Key_6:
|
||||
return '6';
|
||||
case Qt::Key_7:
|
||||
return '7';
|
||||
case Qt::Key_8:
|
||||
return '8';
|
||||
case Qt::Key_9:
|
||||
return '9';
|
||||
case Qt::Key_Comma:
|
||||
return ',';
|
||||
case Qt::Key_Period:
|
||||
return '.';
|
||||
case Qt::Key_Semicolon:
|
||||
return ';';
|
||||
case Qt::Key_Apostrophe:
|
||||
return '\'';
|
||||
case Qt::Key_Minus:
|
||||
return '-';
|
||||
case Qt::Key_Equal:
|
||||
return '=';
|
||||
case Qt::Key_Slash:
|
||||
return '/';
|
||||
case Qt::Key_Backslash:
|
||||
return '\\';
|
||||
case Qt::Key_BracketLeft:
|
||||
return '[';
|
||||
case Qt::Key_BracketRight:
|
||||
return ']';
|
||||
case Qt::Key_QuoteLeft:
|
||||
return '`';
|
||||
case Qt::Key_Space:
|
||||
return ' ';
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
// Case-preserving ASCII derivation for k-prefix handling where we need to
|
||||
// distinguish between 'C' and 'c'. Falls back to virtual-key mapping if
|
||||
// event text is unavailable (common when Control/Meta held on macOS).
|
||||
static int
|
||||
ToAsciiKeyPreserveCase(const QKeyEvent &e)
|
||||
{
|
||||
const QString t = e.text();
|
||||
if (!t.isEmpty()) {
|
||||
const QChar c = t.at(0);
|
||||
if (!c.isNull())
|
||||
return c.unicode();
|
||||
}
|
||||
// Fall back to virtual key mapping (letters as uppercase A..Z)
|
||||
switch (e.key()) {
|
||||
case Qt::Key_A:
|
||||
return 'A';
|
||||
case Qt::Key_B:
|
||||
return 'B';
|
||||
case Qt::Key_C:
|
||||
return 'C';
|
||||
case Qt::Key_D:
|
||||
return 'D';
|
||||
case Qt::Key_E:
|
||||
return 'E';
|
||||
case Qt::Key_F:
|
||||
return 'F';
|
||||
case Qt::Key_G:
|
||||
return 'G';
|
||||
case Qt::Key_H:
|
||||
return 'H';
|
||||
case Qt::Key_I:
|
||||
return 'I';
|
||||
case Qt::Key_J:
|
||||
return 'J';
|
||||
case Qt::Key_K:
|
||||
return 'K';
|
||||
case Qt::Key_L:
|
||||
return 'L';
|
||||
case Qt::Key_M:
|
||||
return 'M';
|
||||
case Qt::Key_N:
|
||||
return 'N';
|
||||
case Qt::Key_O:
|
||||
return 'O';
|
||||
case Qt::Key_P:
|
||||
return 'P';
|
||||
case Qt::Key_Q:
|
||||
return 'Q';
|
||||
case Qt::Key_R:
|
||||
return 'R';
|
||||
case Qt::Key_S:
|
||||
return 'S';
|
||||
case Qt::Key_T:
|
||||
return 'T';
|
||||
case Qt::Key_U:
|
||||
return 'U';
|
||||
case Qt::Key_V:
|
||||
return 'V';
|
||||
case Qt::Key_W:
|
||||
return 'W';
|
||||
case Qt::Key_X:
|
||||
return 'X';
|
||||
case Qt::Key_Y:
|
||||
return 'Y';
|
||||
case Qt::Key_Z:
|
||||
return 'Z';
|
||||
case Qt::Key_Comma:
|
||||
return ',';
|
||||
case Qt::Key_Period:
|
||||
return '.';
|
||||
case Qt::Key_Semicolon:
|
||||
return ';';
|
||||
case Qt::Key_Apostrophe:
|
||||
return '\'';
|
||||
case Qt::Key_Minus:
|
||||
return '-';
|
||||
case Qt::Key_Equal:
|
||||
return '=';
|
||||
case Qt::Key_Slash:
|
||||
return '/';
|
||||
case Qt::Key_Backslash:
|
||||
return '\\';
|
||||
case Qt::Key_BracketLeft:
|
||||
return '[';
|
||||
case Qt::Key_BracketRight:
|
||||
return ']';
|
||||
case Qt::Key_QuoteLeft:
|
||||
return '`';
|
||||
case Qt::Key_Space:
|
||||
return ' ';
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
QtInputHandler::ProcessKeyEvent(const QKeyEvent &e)
|
||||
{
|
||||
const Qt::KeyboardModifiers mods = e.modifiers();
|
||||
LOGF("[QtIH] keyPress key=0x%X mods=%s text='%s' k_prefix=%d k_ctrl_pending=%d esc_meta=%d\n",
|
||||
e.key(), mods_str(mods), e.text().toUtf8().constData(), (int)k_prefix_, (int)k_ctrl_pending_,
|
||||
(int)esc_meta_);
|
||||
|
||||
// Control-chord detection: only treat the physical Control key as control-like.
|
||||
// Do NOT include Meta (Command) here so that ⌘-letter shortcuts do not fall into
|
||||
// the Ctrl map (prevents ⌘-T being mistaken for C-t).
|
||||
const bool ctrl_like = (mods & Qt::ControlModifier);
|
||||
|
||||
// 1) Universal argument digits (when active), consume digits without enqueuing commands
|
||||
if (ed_ &&ed_
|
||||
|
||||
->
|
||||
UArg() != 0
|
||||
)
|
||||
{
|
||||
if (!(mods & (Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier))) {
|
||||
if (e.key() >= Qt::Key_0 && e.key() <= Qt::Key_9) {
|
||||
int d = e.key() - Qt::Key_0;
|
||||
ed_->UArgDigit(d);
|
||||
// request status refresh
|
||||
std::lock_guard<std::mutex> lk(mu_);
|
||||
q_.push(MappedInput{true, CommandId::UArgStatus, std::string(), 0});
|
||||
LOGF("[QtIH] UArg digit %d -> enqueue UArgStatus\n", d);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 2) Enter k-prefix on C-k
|
||||
if (ctrl_like && (e.key() == Qt::Key_K)) {
|
||||
k_prefix_ = true;
|
||||
k_ctrl_pending_ = false;
|
||||
LOGF("[QtIH] Enter KPrefix\n");
|
||||
std::lock_guard<std::mutex> lk(mu_);
|
||||
q_.push(MappedInput{true, CommandId::KPrefix, std::string(), 0});
|
||||
return true;
|
||||
}
|
||||
|
||||
// 3) If currently in k-prefix, resolve next key via KLookupKCommand
|
||||
if (k_prefix_) {
|
||||
// ESC/meta prefix should not interfere with k-suffix resolution
|
||||
esc_meta_ = false;
|
||||
// Support literal 'C' (uppercase) or '^' to indicate the next key is Ctrl-qualified.
|
||||
// Use case-preserving derivation so that 'c' (lowercase) can still be a valid suffix
|
||||
// like C-k c (BufferClose).
|
||||
int ascii_raw = ToAsciiKeyPreserveCase(e);
|
||||
if (ascii_raw == 'C' || ascii_raw == '^') {
|
||||
k_ctrl_pending_ = true;
|
||||
if (ed_)
|
||||
ed_->SetStatus("C-k C _");
|
||||
LOGF("[QtIH] KPrefix: set k_ctrl_pending via '%c'\n", (ascii_raw == 'C') ? 'C' : '^');
|
||||
return true; // consume, wait for next key
|
||||
}
|
||||
int ascii_key = (ascii_raw != 0) ? ascii_raw : ToAsciiKey(e);
|
||||
int lower = KLowerAscii(ascii_key);
|
||||
// Only pass a control suffix for specific supported keys (d/x/q),
|
||||
// matching ImGui behavior so that holding Ctrl during the suffix
|
||||
// doesn't break other mappings like C-k c (BufferClose).
|
||||
bool ctrl_suffix_supported = (lower == 'd' || lower == 'x' || lower == 'q');
|
||||
bool pass_ctrl = (ctrl_like || k_ctrl_pending_) && ctrl_suffix_supported;
|
||||
k_ctrl_pending_ = false; // consume pending qualifier on any suffix
|
||||
LOGF("[QtIH] KPrefix: ascii_key=%d lower=%d pass_ctrl=%d\n", ascii_key, lower, (int)pass_ctrl);
|
||||
if (ascii_key != 0) {
|
||||
CommandId id;
|
||||
if (KLookupKCommand(ascii_key, pass_ctrl, id)) {
|
||||
LOGF("[QtIH] KPrefix: mapped to command id=%d\n", (int)id);
|
||||
std::lock_guard<std::mutex> lk(mu_);
|
||||
q_.push(MappedInput{true, id, std::string(), 0});
|
||||
} else {
|
||||
// Unknown k-command: notify
|
||||
std::string a;
|
||||
a.push_back(static_cast<char>(ascii_key));
|
||||
LOGF("[QtIH] KPrefix: unknown command for '%c'\n", (char)ascii_key);
|
||||
std::lock_guard<std::mutex> lk(mu_);
|
||||
q_.push(MappedInput{true, CommandId::UnknownKCommand, a, 0});
|
||||
}
|
||||
k_prefix_ = false;
|
||||
return true;
|
||||
}
|
||||
// If not resolvable, consume and exit k-prefix
|
||||
k_prefix_ = false;
|
||||
LOGF("[QtIH] KPrefix: unresolved key; exiting prefix\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
// 3.5) GUI shortcut: Command/Meta + T opens the visual font picker (Qt only).
|
||||
// Require Meta present and Control NOT present so Ctrl-T never triggers this.
|
||||
if ((mods & Qt::MetaModifier) && !(mods & Qt::ControlModifier) && e.key() == Qt::Key_T) {
|
||||
LOGF("[QtIH] Meta/Super-T -> VisualFontPickerToggle\n");
|
||||
std::lock_guard<std::mutex> lk(mu_);
|
||||
q_.push(MappedInput{true, CommandId::VisualFontPickerToggle, std::string(), 0});
|
||||
return true;
|
||||
}
|
||||
|
||||
// 4) ESC as Meta prefix (set state). Alt/Meta chord handled below directly.
|
||||
if (e.key() == Qt::Key_Escape) {
|
||||
esc_meta_ = true;
|
||||
LOGF("[QtIH] ESC: set esc_meta\n");
|
||||
return true; // consumed
|
||||
}
|
||||
|
||||
// 5) Alt/Meta bindings (ESC f/b equivalent). Handle either Alt/Meta or pending esc_meta_
|
||||
// ESC/meta chords: on macOS, do NOT treat Meta as ESC; only Alt (Option) should trigger.
|
||||
#if defined(__APPLE__)
|
||||
if (esc_meta_ || (mods & Qt::AltModifier)) {
|
||||
|
||||
|
||||
#else
|
||||
if (esc_meta_ || (mods & (Qt::AltModifier | Qt::MetaModifier))) {
|
||||
#endif
|
||||
int ascii_key = 0;
|
||||
if (e.key() == Qt::Key_Backspace) {
|
||||
ascii_key = KEY_BACKSPACE;
|
||||
} else if (e.key() >= Qt::Key_A && e.key() <= Qt::Key_Z) {
|
||||
ascii_key = 'a' + (e.key() - Qt::Key_A);
|
||||
} else if (e.key() == Qt::Key_Comma) {
|
||||
ascii_key = '<';
|
||||
} else if (e.key() == Qt::Key_Period) {
|
||||
ascii_key = '>';
|
||||
}
|
||||
// If still unknown, try deriving from text (covers digits, punctuation, locale)
|
||||
if (ascii_key == 0) {
|
||||
ascii_key = ToAsciiKey(e);
|
||||
}
|
||||
esc_meta_ = false; // one-shot regardless
|
||||
if (ascii_key != 0) {
|
||||
ascii_key = KLowerAscii(ascii_key);
|
||||
CommandId id;
|
||||
if (KLookupEscCommand(ascii_key, id)) {
|
||||
LOGF("[QtIH] ESC/Meta: mapped '%d' -> id=%d\n", ascii_key, (int)id);
|
||||
std::lock_guard<std::mutex> lk(mu_);
|
||||
q_.push(MappedInput{true, id, std::string(), 0});
|
||||
return true;
|
||||
} else {
|
||||
// Report invalid ESC sequence just like ImGui path
|
||||
LOGF("[QtIH] ESC/Meta: unknown command for ascii=%d\n", ascii_key);
|
||||
std::lock_guard<std::mutex> lk(mu_);
|
||||
q_.push(MappedInput{true, CommandId::UnknownEscCommand, std::string(), 0});
|
||||
return true;
|
||||
}
|
||||
}
|
||||
// Nothing derivable: consume (ESC prefix cleared) and do not insert text
|
||||
return true;
|
||||
}
|
||||
|
||||
// 6) Control-chord direct mappings (e.g., C-n/C-p/C-f/C-b...)
|
||||
if (ctrl_like) {
|
||||
// Universal argument handling: C-u starts collection; C-g cancels
|
||||
if (e.key() == Qt::Key_U) {
|
||||
if (ed_)
|
||||
ed_->UArgStart();
|
||||
LOGF("[QtIH] Ctrl-chord: start universal argument\n");
|
||||
return true;
|
||||
}
|
||||
if (e.key() == Qt::Key_G) {
|
||||
if (ed_)
|
||||
ed_->UArgClear();
|
||||
k_ctrl_pending_ = false;
|
||||
k_prefix_ = false;
|
||||
LOGF("[QtIH] Ctrl-chord: cancel universal argument and k-prefix via C-g\n");
|
||||
// Fall through to map C-g to Refresh via ctrl map
|
||||
}
|
||||
if (e.key() >= Qt::Key_A && e.key() <= Qt::Key_Z) {
|
||||
int ascii_key = 'a' + (e.key() - Qt::Key_A);
|
||||
CommandId id;
|
||||
if (KLookupCtrlCommand(ascii_key, id)) {
|
||||
LOGF("[QtIH] Ctrl-chord: 'C-%c' -> id=%d\n", (char)ascii_key, (int)id);
|
||||
std::lock_guard<std::mutex> lk(mu_);
|
||||
q_.push(MappedInput{true, id, std::string(), 0});
|
||||
return true;
|
||||
}
|
||||
}
|
||||
// If no mapping, continue to allow other keys below
|
||||
}
|
||||
|
||||
// 7) Special navigation/edit keys (match ImGui behavior)
|
||||
{
|
||||
CommandId id;
|
||||
bool has = false;
|
||||
switch (e.key()) {
|
||||
case Qt::Key_Return:
|
||||
case Qt::Key_Enter:
|
||||
id = CommandId::Newline;
|
||||
has = true;
|
||||
break;
|
||||
case Qt::Key_Backspace:
|
||||
id = CommandId::Backspace;
|
||||
has = true;
|
||||
break;
|
||||
case Qt::Key_Delete:
|
||||
id = CommandId::DeleteChar;
|
||||
has = true;
|
||||
break;
|
||||
case Qt::Key_Left:
|
||||
id = CommandId::MoveLeft;
|
||||
has = true;
|
||||
break;
|
||||
case Qt::Key_Right:
|
||||
id = CommandId::MoveRight;
|
||||
has = true;
|
||||
break;
|
||||
case Qt::Key_Up:
|
||||
id = CommandId::MoveUp;
|
||||
has = true;
|
||||
break;
|
||||
case Qt::Key_Down:
|
||||
id = CommandId::MoveDown;
|
||||
has = true;
|
||||
break;
|
||||
case Qt::Key_Home:
|
||||
id = CommandId::MoveHome;
|
||||
has = true;
|
||||
break;
|
||||
case Qt::Key_End:
|
||||
id = CommandId::MoveEnd;
|
||||
has = true;
|
||||
break;
|
||||
case Qt::Key_PageUp:
|
||||
id = CommandId::PageUp;
|
||||
has = true;
|
||||
break;
|
||||
case Qt::Key_PageDown:
|
||||
id = CommandId::PageDown;
|
||||
has = true;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if (has) {
|
||||
LOGF("[QtIH] Special key -> id=%d\n", (int)id);
|
||||
std::lock_guard<std::mutex> lk(mu_);
|
||||
q_.push(MappedInput{true, id, std::string(), 0});
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// 8) Insert printable text
|
||||
if (IsPrintableQt(e)) {
|
||||
std::string s = e.text().toStdString();
|
||||
if (!s.empty()) {
|
||||
LOGF("[QtIH] InsertText '%s'\n", s.c_str());
|
||||
std::lock_guard<std::mutex> lk(mu_);
|
||||
q_.push(MappedInput{true, CommandId::InsertText, s, 0});
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
LOGF("[QtIH] Unhandled key\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
QtInputHandler::Poll(MappedInput &out)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mu_);
|
||||
if (q_.empty())
|
||||
return false;
|
||||
out = q_.front();
|
||||
q_.pop();
|
||||
return true;
|
||||
}
|
||||
Reference in New Issue
Block a user