daniel
f7ec6c69d3
Bump the selected character's name (16->19) and metadata (14->15) sizes, and lay them out as a two-line block vertically centered on the preview glyph box instead of top-aligned. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
616 lines
22 KiB
C++
616 lines
22 KiB
C++
/*
|
|
* main.cpp
|
|
* MontaukOS Character Map - standalone Window Server app
|
|
*
|
|
* Browse curated sets of characters, click (or use the keyboard) to select,
|
|
* and copy to the system clipboard for pasting into other apps.
|
|
*
|
|
* Character model: MontaukOS's GUI text stack is single-byte (Windows-1252,
|
|
* with the 0x80-0x9F block mapped to typographic punctuation in
|
|
* gui::decode_single_byte_codepoint). The glyph cache only holds codepoints
|
|
* 0-255, so that byte range is exactly the set of glyphs the system font can
|
|
* render. We therefore present that set and copy the *raw byte* to the
|
|
* clipboard: it renders identically here and in every other Montauk app
|
|
* (copying multi-byte UTF-8 would render as mojibake in the single-byte stack).
|
|
*
|
|
* Copyright (c) 2026 Daniel Hammer
|
|
*/
|
|
|
|
#include <cstdint>
|
|
#include <montauk/syscall.h>
|
|
#include <montauk/string.h>
|
|
#include <gui/gui.hpp>
|
|
#include <gui/canvas.hpp>
|
|
#include <gui/font.hpp>
|
|
#include <gui/clipboard.hpp>
|
|
#include <gui/standalone.hpp>
|
|
#include <gui/truetype.hpp>
|
|
#include <gui/mtk/theme.hpp>
|
|
#include <gui/mtk/widgets.hpp>
|
|
|
|
extern "C" {
|
|
#include <stdio.h>
|
|
}
|
|
|
|
using namespace gui;
|
|
|
|
// ==== Character data ====
|
|
|
|
struct Glyph {
|
|
uint8_t byte; // Windows-1252 byte value (what gets copied / rendered)
|
|
const char* name; // human-readable description
|
|
};
|
|
|
|
struct CharSet {
|
|
const char* label;
|
|
const Glyph* glyphs;
|
|
int count;
|
|
};
|
|
|
|
// Accented Latin letters and ligatures (things you can't easily type).
|
|
static const Glyph LATIN[] = {
|
|
{0xC0, "Latin Capital Letter A With Grave"},
|
|
{0xC1, "Latin Capital Letter A With Acute"},
|
|
{0xC2, "Latin Capital Letter A With Circumflex"},
|
|
{0xC3, "Latin Capital Letter A With Tilde"},
|
|
{0xC4, "Latin Capital Letter A With Diaeresis"},
|
|
{0xC5, "Latin Capital Letter A With Ring Above"},
|
|
{0xC6, "Latin Capital Letter AE"},
|
|
{0xC7, "Latin Capital Letter C With Cedilla"},
|
|
{0xC8, "Latin Capital Letter E With Grave"},
|
|
{0xC9, "Latin Capital Letter E With Acute"},
|
|
{0xCA, "Latin Capital Letter E With Circumflex"},
|
|
{0xCB, "Latin Capital Letter E With Diaeresis"},
|
|
{0xCC, "Latin Capital Letter I With Grave"},
|
|
{0xCD, "Latin Capital Letter I With Acute"},
|
|
{0xCE, "Latin Capital Letter I With Circumflex"},
|
|
{0xCF, "Latin Capital Letter I With Diaeresis"},
|
|
{0xD0, "Latin Capital Letter Eth"},
|
|
{0xD1, "Latin Capital Letter N With Tilde"},
|
|
{0xD2, "Latin Capital Letter O With Grave"},
|
|
{0xD3, "Latin Capital Letter O With Acute"},
|
|
{0xD4, "Latin Capital Letter O With Circumflex"},
|
|
{0xD5, "Latin Capital Letter O With Tilde"},
|
|
{0xD6, "Latin Capital Letter O With Diaeresis"},
|
|
{0xD8, "Latin Capital Letter O With Stroke"},
|
|
{0xD9, "Latin Capital Letter U With Grave"},
|
|
{0xDA, "Latin Capital Letter U With Acute"},
|
|
{0xDB, "Latin Capital Letter U With Circumflex"},
|
|
{0xDC, "Latin Capital Letter U With Diaeresis"},
|
|
{0xDD, "Latin Capital Letter Y With Acute"},
|
|
{0xDE, "Latin Capital Letter Thorn"},
|
|
{0x8A, "Latin Capital Letter S With Caron"},
|
|
{0x8C, "Latin Capital Ligature OE"},
|
|
{0x8E, "Latin Capital Letter Z With Caron"},
|
|
{0x9F, "Latin Capital Letter Y With Diaeresis"},
|
|
{0xDF, "Latin Small Letter Sharp S"},
|
|
{0xE0, "Latin Small Letter A With Grave"},
|
|
{0xE1, "Latin Small Letter A With Acute"},
|
|
{0xE2, "Latin Small Letter A With Circumflex"},
|
|
{0xE3, "Latin Small Letter A With Tilde"},
|
|
{0xE4, "Latin Small Letter A With Diaeresis"},
|
|
{0xE5, "Latin Small Letter A With Ring Above"},
|
|
{0xE6, "Latin Small Letter AE"},
|
|
{0xE7, "Latin Small Letter C With Cedilla"},
|
|
{0xE8, "Latin Small Letter E With Grave"},
|
|
{0xE9, "Latin Small Letter E With Acute"},
|
|
{0xEA, "Latin Small Letter E With Circumflex"},
|
|
{0xEB, "Latin Small Letter E With Diaeresis"},
|
|
{0xEC, "Latin Small Letter I With Grave"},
|
|
{0xED, "Latin Small Letter I With Acute"},
|
|
{0xEE, "Latin Small Letter I With Circumflex"},
|
|
{0xEF, "Latin Small Letter I With Diaeresis"},
|
|
{0xF0, "Latin Small Letter Eth"},
|
|
{0xF1, "Latin Small Letter N With Tilde"},
|
|
{0xF2, "Latin Small Letter O With Grave"},
|
|
{0xF3, "Latin Small Letter O With Acute"},
|
|
{0xF4, "Latin Small Letter O With Circumflex"},
|
|
{0xF5, "Latin Small Letter O With Tilde"},
|
|
{0xF6, "Latin Small Letter O With Diaeresis"},
|
|
{0xF8, "Latin Small Letter O With Stroke"},
|
|
{0xF9, "Latin Small Letter U With Grave"},
|
|
{0xFA, "Latin Small Letter U With Acute"},
|
|
{0xFB, "Latin Small Letter U With Circumflex"},
|
|
{0xFC, "Latin Small Letter U With Diaeresis"},
|
|
{0xFD, "Latin Small Letter Y With Acute"},
|
|
{0xFE, "Latin Small Letter Thorn"},
|
|
{0xFF, "Latin Small Letter Y With Diaeresis"},
|
|
{0x9A, "Latin Small Letter S With Caron"},
|
|
{0x9C, "Latin Small Ligature OE"},
|
|
{0x9E, "Latin Small Letter Z With Caron"},
|
|
{0x83, "Latin Small Letter F With Hook"},
|
|
};
|
|
|
|
// Typographic punctuation.
|
|
static const Glyph PUNCT[] = {
|
|
{0xA1, "Inverted Exclamation Mark"},
|
|
{0xBF, "Inverted Question Mark"},
|
|
{0x91, "Left Single Quotation Mark"},
|
|
{0x92, "Right Single Quotation Mark"},
|
|
{0x93, "Left Double Quotation Mark"},
|
|
{0x94, "Right Double Quotation Mark"},
|
|
{0x82, "Single Low-9 Quotation Mark"},
|
|
{0x84, "Double Low-9 Quotation Mark"},
|
|
{0xAB, "Left-Pointing Double Angle Quotation Mark"},
|
|
{0xBB, "Right-Pointing Double Angle Quotation Mark"},
|
|
{0x8B, "Single Left-Pointing Angle Quotation Mark"},
|
|
{0x9B, "Single Right-Pointing Angle Quotation Mark"},
|
|
{0x96, "En Dash"},
|
|
{0x97, "Em Dash"},
|
|
{0x85, "Horizontal Ellipsis"},
|
|
{0x95, "Bullet"},
|
|
{0xB7, "Middle Dot"},
|
|
{0x86, "Dagger"},
|
|
{0x87, "Double Dagger"},
|
|
{0xB6, "Pilcrow Sign"},
|
|
{0xA7, "Section Sign"},
|
|
{0x89, "Per Mille Sign"},
|
|
};
|
|
|
|
// Currency symbols.
|
|
static const Glyph CURRENCY[] = {
|
|
{0x24, "Dollar Sign"},
|
|
{0xA2, "Cent Sign"},
|
|
{0xA3, "Pound Sign"},
|
|
{0xA5, "Yen Sign"},
|
|
{0x80, "Euro Sign"},
|
|
{0xA4, "Currency Sign"},
|
|
{0x83, "Latin Small Letter F With Hook (Florin)"},
|
|
};
|
|
|
|
// Math, technical, and miscellaneous symbols.
|
|
static const Glyph SYMBOLS[] = {
|
|
{0xA9, "Copyright Sign"},
|
|
{0xAE, "Registered Sign"},
|
|
{0x99, "Trade Mark Sign"},
|
|
{0xB0, "Degree Sign"},
|
|
{0xB1, "Plus-Minus Sign"},
|
|
{0xD7, "Multiplication Sign"},
|
|
{0xF7, "Division Sign"},
|
|
{0xB5, "Micro Sign"},
|
|
{0xAC, "Not Sign"},
|
|
{0xBC, "Vulgar Fraction One Quarter"},
|
|
{0xBD, "Vulgar Fraction One Half"},
|
|
{0xBE, "Vulgar Fraction Three Quarters"},
|
|
{0xB9, "Superscript One"},
|
|
{0xB2, "Superscript Two"},
|
|
{0xB3, "Superscript Three"},
|
|
{0xAA, "Feminine Ordinal Indicator"},
|
|
{0xBA, "Masculine Ordinal Indicator"},
|
|
{0xA6, "Broken Bar"},
|
|
{0xB4, "Acute Accent"},
|
|
{0xA8, "Diaeresis"},
|
|
{0xAF, "Macron"},
|
|
{0xB8, "Cedilla"},
|
|
{0x88, "Modifier Letter Circumflex Accent"},
|
|
{0x98, "Small Tilde"},
|
|
};
|
|
|
|
#define SET(arr, label) { label, arr, (int)(sizeof(arr) / sizeof(arr[0])) }
|
|
static const CharSet SETS[] = {
|
|
SET(LATIN, "Latin"),
|
|
SET(PUNCT, "Punctuation"),
|
|
SET(CURRENCY, "Currency"),
|
|
SET(SYMBOLS, "Symbols"),
|
|
};
|
|
static constexpr int SET_COUNT = (int)(sizeof(SETS) / sizeof(SETS[0]));
|
|
|
|
// ==== Layout constants ====
|
|
|
|
static constexpr int INIT_W = 680;
|
|
static constexpr int INIT_H = 448;
|
|
static constexpr int TAB_H = 36; // matches mtk theme.tab_h / Settings TAB_BAR_H
|
|
static constexpr int FOOTER_H = 84;
|
|
static constexpr int GRID_PAD = 12;
|
|
static constexpr int CELL_GAP = 6;
|
|
static constexpr int CELL_TARGET = 54; // desired tile edge in px
|
|
|
|
static constexpr int CELL_SIZE = 26; // glyph font size inside a tile
|
|
static constexpr int PREVIEW_SIZE = 40;
|
|
static constexpr int NAME_SIZE = 19;
|
|
static constexpr int META_SIZE = 15;
|
|
|
|
static constexpr uint64_t COPIED_MS = 1600;
|
|
|
|
// ==== App state ====
|
|
|
|
static int g_set = 0; // active character set index
|
|
static int g_sel = 0; // selected glyph index within active set
|
|
static int g_hover = -1; // hovered glyph index, or -1
|
|
static bool g_copy_hover = false;
|
|
static bool g_copy_pressed = false;
|
|
static int g_scroll = 0; // vertical scroll offset in px
|
|
static bool g_sb_hover = false; // pointer over the scrollbar track
|
|
static bool g_sb_dragging = false; // dragging the scrollbar thumb
|
|
static int g_sb_drag_offset = 0; // grab point within the thumb
|
|
static uint64_t g_copied_until = 0; // show the "copied" status until this time
|
|
|
|
static mtk::Theme g_theme;
|
|
static const char* g_tab_labels[SET_COUNT] = {}; // populated from SETS in _start
|
|
|
|
// ==== Derived layout ====
|
|
|
|
struct Layout {
|
|
Rect tabs;
|
|
Rect grid; // interior area available for the tile grid (with margins)
|
|
Rect panel; // full content region between tabs and footer (scrollbar viewport)
|
|
Rect footer;
|
|
Rect copy_btn;
|
|
int cols;
|
|
int cell_w; // tile slot width (includes gap handling)
|
|
int cell_h; // tile slot height
|
|
int content_h; // full scrollable height
|
|
int max_scroll;
|
|
};
|
|
|
|
static const CharSet& cur_set() { return SETS[g_set]; }
|
|
|
|
static Layout compute_layout(int w, int h) {
|
|
Layout L {};
|
|
L.tabs = { 0, 0, w, TAB_H };
|
|
int grid_top = TAB_H;
|
|
L.footer = { 0, h - FOOTER_H, w, FOOTER_H };
|
|
|
|
// Scrollbar viewport: the whole panel between tabs and footer, so the
|
|
// shared MTK scrollbar hugs the window's right edge and spans full height
|
|
// (matching Devices/Music) — no inset above or beside it.
|
|
L.panel = { 0, grid_top, w, (h - FOOTER_H) - grid_top };
|
|
|
|
// Tile grid keeps left/top/bottom margins; its right edge leaves the
|
|
// scrollbar's width plus a GRID_PAD gap.
|
|
L.grid = { GRID_PAD, grid_top + GRID_PAD,
|
|
w - mtk::SCROLLBAR_W - GRID_PAD * 2,
|
|
(h - FOOTER_H) - grid_top - GRID_PAD * 2 };
|
|
if (L.grid.w < CELL_TARGET) L.grid.w = CELL_TARGET;
|
|
if (L.grid.h < 1) L.grid.h = 1;
|
|
|
|
int avail = L.grid.w;
|
|
L.cols = (avail + CELL_GAP) / (CELL_TARGET + CELL_GAP);
|
|
if (L.cols < 1) L.cols = 1;
|
|
L.cell_w = (avail - CELL_GAP * (L.cols - 1)) / L.cols;
|
|
if (L.cell_w < 8) L.cell_w = 8;
|
|
L.cell_h = L.cell_w;
|
|
|
|
int rows = (cur_set().count + L.cols - 1) / L.cols;
|
|
L.content_h = rows > 0 ? rows * L.cell_h + (rows - 1) * CELL_GAP : 0;
|
|
L.max_scroll = L.content_h - L.grid.h;
|
|
if (L.max_scroll < 0) L.max_scroll = 0;
|
|
|
|
// Copy button in the footer, right-aligned.
|
|
int btn_w = 96, btn_h = 34;
|
|
L.copy_btn = { w - GRID_PAD - btn_w,
|
|
L.footer.y + (FOOTER_H - btn_h) / 2, btn_w, btn_h };
|
|
return L;
|
|
}
|
|
|
|
// Screen rect of tile `i` (may be off-screen; caller clips).
|
|
static Rect tile_rect(const Layout& L, int i) {
|
|
int row = i / L.cols;
|
|
int col = i % L.cols;
|
|
int x = L.grid.x + col * (L.cell_w + CELL_GAP);
|
|
int y = L.grid.y + row * (L.cell_h + CELL_GAP) - g_scroll;
|
|
return { x, y, L.cell_w, L.cell_h };
|
|
}
|
|
|
|
static int hit_tile(const Layout& L, int mx, int my) {
|
|
if (my < L.grid.y || my >= L.grid.y + L.grid.h) return -1;
|
|
if (mx < L.grid.x || mx >= L.grid.x + L.grid.w) return -1;
|
|
for (int i = 0; i < cur_set().count; i++) {
|
|
Rect r = tile_rect(L, i);
|
|
if (r.contains(mx, my)) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static void clamp_scroll(const Layout& L) {
|
|
if (g_scroll > L.max_scroll) g_scroll = L.max_scroll;
|
|
if (g_scroll < 0) g_scroll = 0;
|
|
}
|
|
|
|
// Keep the selected tile fully visible (used after keyboard navigation).
|
|
static void ensure_visible(const Layout& L) {
|
|
int row = g_sel / L.cols;
|
|
int top = row * (L.cell_h + CELL_GAP);
|
|
int bot = top + L.cell_h;
|
|
if (top - g_scroll < 0) g_scroll = top;
|
|
else if (bot - g_scroll > L.grid.h) g_scroll = bot - L.grid.h;
|
|
clamp_scroll(L);
|
|
}
|
|
|
|
// ==== Helpers ====
|
|
|
|
static void glyph_str(uint8_t byte, char out[2]) {
|
|
out[0] = (char)byte;
|
|
out[1] = '\0';
|
|
}
|
|
|
|
static int codepoint_of(uint8_t byte) {
|
|
return decode_single_byte_codepoint((int)byte);
|
|
}
|
|
|
|
static void copy_selected() {
|
|
const Glyph& g = cur_set().glyphs[g_sel];
|
|
char s[2];
|
|
glyph_str(g.byte, s);
|
|
gui::clipboard_set_text(s, 1);
|
|
g_copied_until = montauk::get_milliseconds() + COPIED_MS;
|
|
}
|
|
|
|
// ==== Rendering ====
|
|
|
|
static void draw_centered_glyph(Canvas& c, const Rect& r, uint8_t byte,
|
|
Color color, int size) {
|
|
char s[2];
|
|
glyph_str(byte, s);
|
|
int tw = text_width(fonts::system_font, s, size);
|
|
int th = text_height(fonts::system_font, size);
|
|
draw_text(c, fonts::system_font, r.x + (r.w - tw) / 2,
|
|
r.y + (r.h - th) / 2, s, color, size);
|
|
}
|
|
|
|
static void render(Canvas& c) {
|
|
Layout L = compute_layout(c.w, c.h);
|
|
clamp_scroll(L);
|
|
|
|
c.fill(g_theme.window_bg);
|
|
|
|
// ---- Tile grid (drawn first; header/tabs/footer are painted over any
|
|
// spill from partially-scrolled edge rows) ----
|
|
const CharSet& set = cur_set();
|
|
for (int i = 0; i < set.count; i++) {
|
|
Rect r = tile_rect(L, i);
|
|
if (r.y + r.h <= L.grid.y || r.y >= L.grid.y + L.grid.h) continue;
|
|
|
|
bool selected = (i == g_sel);
|
|
bool hovered = (i == g_hover);
|
|
Color fill = g_theme.surface;
|
|
Color glyph = g_theme.text;
|
|
Color border = g_theme.border;
|
|
if (selected) {
|
|
fill = g_theme.accent;
|
|
glyph = g_theme.accent_fg;
|
|
border = g_theme.accent;
|
|
} else if (hovered) {
|
|
fill = g_theme.surface_hover;
|
|
}
|
|
c.fill_rounded_rect(r.x, r.y, r.w, r.h, g_theme.radius_md, border);
|
|
c.fill_rounded_rect(r.x + 1, r.y + 1, r.w - 2, r.h - 2,
|
|
g_theme.radius_md > 0 ? g_theme.radius_md - 1 : 0, fill);
|
|
draw_centered_glyph(c, r, set.glyphs[i].byte, glyph, CELL_SIZE);
|
|
}
|
|
|
|
// ---- Scrollbar (shared MTK widget; no-ops when the set fits) ----
|
|
Rect sb_track = mtk::scrollbar_track_rect(L.panel);
|
|
Rect sb_thumb = mtk::scrollbar_thumb_rect(sb_track, L.content_h, L.grid.h, g_scroll);
|
|
mtk::draw_scrollbar(c, sb_track, sb_thumb, g_sb_hover, g_sb_dragging, g_theme);
|
|
|
|
// ---- Tab bar (opaque) — canonical MontaukOS top-tab style, matching the
|
|
// Desktop Settings panel (surface bar, window_bg active tab, accent
|
|
// underline). Covers any grid spill above the grid top. ----
|
|
mtk::draw_tab_bar(c, L.tabs, g_tab_labels, SET_COUNT, g_set, g_theme);
|
|
|
|
// Bold font for the footer name and Copy button.
|
|
TrueTypeFont* title_font =
|
|
(fonts::system_bold && fonts::system_bold->valid) ? fonts::system_bold
|
|
: fonts::system_font;
|
|
|
|
// ---- Footer (opaque) ----
|
|
c.fill_rect(L.footer.x, L.footer.y, L.footer.w, L.footer.h, g_theme.surface_alt);
|
|
c.fill_rect(L.footer.x, L.footer.y, L.footer.w, 1, g_theme.border);
|
|
|
|
const Glyph& sg = set.glyphs[g_sel];
|
|
|
|
// Preview box.
|
|
int pv = FOOTER_H - 20;
|
|
Rect preview = { GRID_PAD, L.footer.y + 10, pv, pv };
|
|
c.fill_rounded_rect(preview.x, preview.y, preview.w, preview.h,
|
|
g_theme.radius_md, g_theme.border);
|
|
c.fill_rounded_rect(preview.x + 1, preview.y + 1, preview.w - 2, preview.h - 2,
|
|
g_theme.radius_md - 1, colors::WHITE);
|
|
draw_centered_glyph(c, preview, sg.byte, g_theme.text, PREVIEW_SIZE);
|
|
|
|
// Name + metadata, as a two-line block vertically centered on the preview.
|
|
int cp = codepoint_of(sg.byte);
|
|
int text_x = preview.x + preview.w + 14;
|
|
char meta[64];
|
|
snprintf(meta, sizeof(meta), "U+%04X dec %d Alt 0%d",
|
|
cp, cp, (int)sg.byte);
|
|
|
|
int name_h = text_height(title_font, NAME_SIZE);
|
|
int meta_h = text_height(fonts::system_font, META_SIZE);
|
|
int line_gap = 6;
|
|
int block_y = preview.y + (preview.h - (name_h + line_gap + meta_h)) / 2;
|
|
|
|
draw_text(c, title_font, text_x, block_y, sg.name, g_theme.text, NAME_SIZE);
|
|
draw_text(c, fonts::system_font, text_x, block_y + name_h + line_gap,
|
|
meta, g_theme.text_subtle, META_SIZE);
|
|
|
|
// Copy button — canonical MTK primary button, like other Montauk apps.
|
|
// After a copy it flips to a greyed-out "Copied" for a moment (the disabled
|
|
// state, matching the Bluetooth app's "Scanning..." button) as confirmation.
|
|
bool just_copied = g_copied_until && montauk::get_milliseconds() < g_copied_until;
|
|
mtk::WidgetState copy_state = mtk::widget_state(false, g_copy_hover, !just_copied);
|
|
mtk::draw_button(c, L.copy_btn, just_copied ? "Copied" : "Copy",
|
|
mtk::BUTTON_PRIMARY, copy_state, g_theme);
|
|
}
|
|
|
|
// ==== Event handling ====
|
|
|
|
static bool handle_mouse(const montauk::abi::WinEvent& ev, int w, int h) {
|
|
Layout L = compute_layout(w, h);
|
|
clamp_scroll(L);
|
|
bool redraw = false;
|
|
|
|
int mx = ev.mouse.x, my = ev.mouse.y;
|
|
|
|
bool left_down = (ev.mouse.buttons & 1) != 0;
|
|
bool pressed = (ev.mouse.buttons & 1) && !(ev.mouse.prev_buttons & 1);
|
|
bool released = !(ev.mouse.buttons & 1) && (ev.mouse.prev_buttons & 1);
|
|
|
|
// Scrollbar geometry (shared MTK widget).
|
|
Rect sb_track = mtk::scrollbar_track_rect(L.panel);
|
|
Rect sb_thumb = mtk::scrollbar_thumb_rect(sb_track, L.content_h, L.grid.h, g_scroll);
|
|
bool scrollable = !sb_track.empty() && !sb_thumb.empty();
|
|
|
|
// Wheel scroll.
|
|
if (ev.mouse.scroll != 0) {
|
|
g_scroll -= ev.mouse.scroll * (L.cell_h + CELL_GAP) / 2;
|
|
clamp_scroll(L);
|
|
redraw = true;
|
|
}
|
|
|
|
// Release ends any active thumb drag.
|
|
if (released && g_sb_dragging) { g_sb_dragging = false; redraw = true; }
|
|
|
|
// Active drag follows the pointer.
|
|
if (g_sb_dragging && left_down && scrollable) {
|
|
g_scroll = mtk::scrollbar_offset_from_thumb_top(
|
|
sb_track, L.content_h, L.grid.h, sb_thumb.h, my - g_sb_drag_offset);
|
|
clamp_scroll(L);
|
|
redraw = true;
|
|
}
|
|
|
|
// Thumb hover highlight (only meaningful when the set scrolls).
|
|
bool sb_hover_now = scrollable && sb_track.contains(mx, my);
|
|
if (sb_hover_now != g_sb_hover) { g_sb_hover = sb_hover_now; redraw = true; }
|
|
|
|
int tile = hit_tile(L, mx, my);
|
|
if (tile != g_hover) { g_hover = tile; redraw = true; }
|
|
|
|
int tab = mtk::hit_tab_bar(L.tabs, SET_COUNT, mx, my);
|
|
|
|
bool copy_hov = L.copy_btn.contains(mx, my);
|
|
if (copy_hov != g_copy_hover) { g_copy_hover = copy_hov; redraw = true; }
|
|
|
|
if (pressed) {
|
|
if (scrollable && sb_thumb.contains(mx, my)) {
|
|
// Grab the thumb.
|
|
g_sb_dragging = true;
|
|
g_sb_drag_offset = my - sb_thumb.y;
|
|
redraw = true;
|
|
} else if (scrollable && sb_track.contains(mx, my)) {
|
|
// Click the track: jump the thumb under the pointer, then drag.
|
|
g_sb_dragging = true;
|
|
g_sb_drag_offset = sb_thumb.h / 2;
|
|
g_scroll = mtk::scrollbar_offset_from_thumb_top(
|
|
sb_track, L.content_h, L.grid.h, sb_thumb.h, my - sb_thumb.h / 2);
|
|
clamp_scroll(L);
|
|
redraw = true;
|
|
} else if (tab >= 0 && tab != g_set) {
|
|
g_set = tab;
|
|
g_sel = 0;
|
|
g_scroll = 0;
|
|
redraw = true;
|
|
} else if (tile >= 0) {
|
|
g_sel = tile;
|
|
copy_selected(); // click a tile = select + copy
|
|
redraw = true;
|
|
} else if (copy_hov) {
|
|
g_copy_pressed = true;
|
|
redraw = true;
|
|
}
|
|
}
|
|
|
|
if (released && g_copy_pressed) {
|
|
g_copy_pressed = false;
|
|
if (copy_hov) copy_selected();
|
|
redraw = true;
|
|
}
|
|
|
|
return redraw;
|
|
}
|
|
|
|
static bool handle_key(const montauk::abi::KeyEvent& key, int w, int h) {
|
|
if (!key.pressed) return false;
|
|
Layout L = compute_layout(w, h);
|
|
clamp_scroll(L);
|
|
const int count = cur_set().count;
|
|
bool redraw = false;
|
|
|
|
switch (key.scancode) {
|
|
case 0x4B: // Left
|
|
if (g_sel > 0) { g_sel--; ensure_visible(L); redraw = true; }
|
|
break;
|
|
case 0x4D: // Right
|
|
if (g_sel < count - 1) { g_sel++; ensure_visible(L); redraw = true; }
|
|
break;
|
|
case 0x48: // Up
|
|
if (g_sel - L.cols >= 0) { g_sel -= L.cols; ensure_visible(L); redraw = true; }
|
|
break;
|
|
case 0x50: // Down
|
|
if (g_sel + L.cols < count) { g_sel += L.cols; ensure_visible(L); redraw = true; }
|
|
break;
|
|
case 0x0F: // Tab -> next character set
|
|
g_set = (g_set + (key.shift ? SET_COUNT - 1 : 1)) % SET_COUNT;
|
|
g_sel = 0; g_scroll = 0; redraw = true;
|
|
break;
|
|
case 0x1C: // Enter
|
|
case 0x39: // Space
|
|
copy_selected();
|
|
redraw = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return redraw;
|
|
}
|
|
|
|
extern "C" void _start() {
|
|
fonts::init();
|
|
g_theme = mtk::make_theme();
|
|
for (int i = 0; i < SET_COUNT; i++) g_tab_labels[i] = SETS[i].label;
|
|
|
|
WsWindow win;
|
|
if (!win.create("Character Map", INIT_W, INIT_H))
|
|
montauk::exit(1);
|
|
|
|
{
|
|
Canvas canvas = win.canvas();
|
|
render(canvas);
|
|
}
|
|
win.present();
|
|
|
|
bool toast_shown = true;
|
|
while (win.id >= 0 && !win.closed) {
|
|
montauk::abi::WinEvent ev;
|
|
int r = win.poll(&ev);
|
|
|
|
if (r < 0) break;
|
|
if (r == 0) {
|
|
// Clear the "copied" status once it expires, even when idle.
|
|
if (toast_shown && g_copied_until &&
|
|
montauk::get_milliseconds() >= g_copied_until) {
|
|
Canvas canvas = win.canvas();
|
|
render(canvas);
|
|
win.present();
|
|
toast_shown = false;
|
|
}
|
|
montauk::sleep_ms(16);
|
|
continue;
|
|
}
|
|
|
|
bool redraw = false;
|
|
if (ev.type == 3) break; // close
|
|
if (ev.type == 2 || ev.type == 4) { // resize / scale
|
|
g_hover = -1;
|
|
g_sb_hover = false;
|
|
g_sb_dragging = false;
|
|
redraw = true;
|
|
} else if (ev.type == 1) {
|
|
redraw = handle_mouse(ev, win.width, win.height);
|
|
} else if (ev.type == 0) {
|
|
redraw = handle_key(ev.key, win.width, win.height);
|
|
}
|
|
|
|
if (redraw) {
|
|
Canvas canvas = win.canvas();
|
|
render(canvas);
|
|
win.present();
|
|
toast_shown = true;
|
|
}
|
|
}
|
|
|
|
win.destroy();
|
|
montauk::exit(0);
|
|
}
|