3277 lines
109 KiB
C
3277 lines
109 KiB
C
// dvx_app.c — Layer 5: Application API for DV/X GUI
|
|
|
|
#include "dvxApp.h"
|
|
#include "dvxWidget.h"
|
|
#include "widgets/widgetInternal.h"
|
|
#include "dvxFont.h"
|
|
#include "dvxCursor.h"
|
|
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <time.h>
|
|
#include <dpmi.h>
|
|
#include <signal.h>
|
|
|
|
#include "thirdparty/stb_image_write.h"
|
|
|
|
#define DBLCLICK_THRESHOLD (CLOCKS_PER_SEC / 2)
|
|
#define ICON_REFRESH_INTERVAL 8
|
|
#define KB_MOVE_STEP 8
|
|
#define MENU_CHECK_WIDTH 14
|
|
#define SUBMENU_ARROW_WIDTH 12
|
|
#define TOOLTIP_DELAY_MS 500
|
|
#define TOOLTIP_PAD 3
|
|
|
|
// ============================================================
|
|
// Prototypes
|
|
// ============================================================
|
|
|
|
static uint8_t *bufferToRgb(const DisplayT *d, const uint8_t *buf, int32_t w, int32_t h, int32_t pitch);
|
|
static void calcPopupSize(const AppContextT *ctx, const MenuT *menu, int32_t *pw, int32_t *ph);
|
|
static bool checkAccelTable(AppContextT *ctx, WindowT *win, int32_t key, int32_t modifiers);
|
|
static void clickMenuCheckRadio(MenuT *menu, int32_t itemIdx);
|
|
static void closeAllPopups(AppContextT *ctx);
|
|
static void closePopupLevel(AppContextT *ctx);
|
|
static void closeSysMenu(AppContextT *ctx);
|
|
static void compositeAndFlush(AppContextT *ctx);
|
|
static void dirtyCursorArea(AppContextT *ctx, int32_t x, int32_t y);
|
|
static bool dispatchAccelKey(AppContextT *ctx, char key);
|
|
static void dispatchEvents(AppContextT *ctx);
|
|
static void drawCursorAt(AppContextT *ctx, int32_t x, int32_t y);
|
|
static void drawPopupLevel(AppContextT *ctx, DisplayT *d, const BlitOpsT *ops, const MenuT *menu, int32_t px, int32_t py, int32_t pw, int32_t ph, int32_t hoverItem, const RectT *clipTo);
|
|
static void executeSysMenuCmd(AppContextT *ctx, int32_t cmd);
|
|
static WindowT *findWindowById(AppContextT *ctx, int32_t id);
|
|
static void handleMouseButton(AppContextT *ctx, int32_t mx, int32_t my, int32_t buttons);
|
|
static void initColorScheme(AppContextT *ctx);
|
|
static void initMouse(AppContextT *ctx);
|
|
static void openContextMenu(AppContextT *ctx, WindowT *win, MenuT *menu, int32_t screenX, int32_t screenY);
|
|
static void openPopupAtMenu(AppContextT *ctx, WindowT *win, int32_t menuIdx);
|
|
static void openSubMenu(AppContextT *ctx);
|
|
static void openSysMenu(AppContextT *ctx, WindowT *win);
|
|
static void pollAnsiTermWidgets(AppContextT *ctx);
|
|
static void pollAnsiTermWidgetsWalk(AppContextT *ctx, WidgetT *w, WindowT *win);
|
|
static void pollKeyboard(AppContextT *ctx);
|
|
static void pollMouse(AppContextT *ctx);
|
|
static void refreshMinimizedIcons(AppContextT *ctx);
|
|
static void updateCursorShape(AppContextT *ctx);
|
|
static void updateTooltip(AppContextT *ctx);
|
|
|
|
// Button pressed via keyboard — shared with widgetEvent.c for Space/Enter
|
|
WidgetT *sKeyPressedBtn = NULL;
|
|
|
|
// Alt+key scan code to ASCII lookup table (indexed by scan code)
|
|
// BIOS INT 16h returns these scan codes with ascii=0 for Alt+key combos
|
|
static const char sAltScanToAscii[256] = {
|
|
// Alt+letters
|
|
[0x10] = 'q', [0x11] = 'w', [0x12] = 'e', [0x13] = 'r',
|
|
[0x14] = 't', [0x15] = 'y', [0x16] = 'u', [0x17] = 'i',
|
|
[0x18] = 'o', [0x19] = 'p', [0x1E] = 'a', [0x1F] = 's',
|
|
[0x20] = 'd', [0x21] = 'f', [0x22] = 'g', [0x23] = 'h',
|
|
[0x24] = 'j', [0x25] = 'k', [0x26] = 'l', [0x2C] = 'z',
|
|
[0x2D] = 'x', [0x2E] = 'c', [0x2F] = 'v', [0x30] = 'b',
|
|
[0x31] = 'n', [0x32] = 'm',
|
|
// Alt+digits
|
|
[0x78] = '1', [0x79] = '2', [0x7A] = '3', [0x7B] = '4',
|
|
[0x7C] = '5', [0x7D] = '6', [0x7E] = '7', [0x7F] = '8',
|
|
[0x80] = '9', [0x81] = '0',
|
|
};
|
|
|
|
|
|
// ============================================================
|
|
// calcPopupSize — compute popup width and height for a menu
|
|
// ============================================================
|
|
|
|
static uint8_t *bufferToRgb(const DisplayT *d, const uint8_t *buf, int32_t w, int32_t h, int32_t pitch) {
|
|
uint8_t *rgb = (uint8_t *)malloc((size_t)w * h * 3);
|
|
|
|
if (!rgb) {
|
|
return NULL;
|
|
}
|
|
|
|
int32_t bpp = d->format.bytesPerPixel;
|
|
uint8_t *dst = rgb;
|
|
|
|
for (int32_t y = 0; y < h; y++) {
|
|
const uint8_t *row = buf + y * pitch;
|
|
|
|
for (int32_t x = 0; x < w; x++) {
|
|
uint32_t pixel;
|
|
|
|
if (bpp == 1) {
|
|
pixel = row[x];
|
|
} else if (bpp == 2) {
|
|
pixel = ((const uint16_t *)row)[x];
|
|
} else {
|
|
pixel = ((const uint32_t *)row)[x];
|
|
}
|
|
|
|
if (d->format.bitsPerPixel == 8) {
|
|
int32_t idx = pixel & 0xFF;
|
|
dst[0] = d->palette[idx * 3 + 0];
|
|
dst[1] = d->palette[idx * 3 + 1];
|
|
dst[2] = d->palette[idx * 3 + 2];
|
|
} else {
|
|
uint32_t rv = (pixel >> d->format.redShift) & ((1u << d->format.redBits) - 1);
|
|
uint32_t gv = (pixel >> d->format.greenShift) & ((1u << d->format.greenBits) - 1);
|
|
uint32_t bv = (pixel >> d->format.blueShift) & ((1u << d->format.blueBits) - 1);
|
|
dst[0] = (uint8_t)(rv << (8 - d->format.redBits));
|
|
dst[1] = (uint8_t)(gv << (8 - d->format.greenBits));
|
|
dst[2] = (uint8_t)(bv << (8 - d->format.blueBits));
|
|
}
|
|
|
|
dst += 3;
|
|
}
|
|
}
|
|
|
|
return rgb;
|
|
}
|
|
|
|
|
|
static void calcPopupSize(const AppContextT *ctx, const MenuT *menu, int32_t *pw, int32_t *ph) {
|
|
int32_t maxW = 0;
|
|
bool hasSub = false;
|
|
bool hasCheck = false;
|
|
|
|
for (int32_t k = 0; k < menu->itemCount; k++) {
|
|
int32_t itemW = textWidthAccel(&ctx->font, menu->items[k].label);
|
|
|
|
if (itemW > maxW) {
|
|
maxW = itemW;
|
|
}
|
|
|
|
if (menu->items[k].subMenu) {
|
|
hasSub = true;
|
|
}
|
|
|
|
if (menu->items[k].type == MenuItemCheckE || menu->items[k].type == MenuItemRadioE) {
|
|
hasCheck = true;
|
|
}
|
|
}
|
|
|
|
*pw = maxW + CHROME_TITLE_PAD * 2 + 8 + (hasSub ? SUBMENU_ARROW_WIDTH : 0) + (hasCheck ? MENU_CHECK_WIDTH : 0);
|
|
*ph = menu->itemCount * ctx->font.charHeight + 4;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// checkAccelTable — test key against window's accelerator table
|
|
// ============================================================
|
|
|
|
static bool checkAccelTable(AppContextT *ctx, WindowT *win, int32_t key, int32_t modifiers) {
|
|
if (!win->accelTable || !win->onMenu) {
|
|
return false;
|
|
}
|
|
|
|
// Normalize Ctrl+letter: BIOS returns ASCII 0x01-0x1A for Ctrl+A..Z
|
|
// Map back to uppercase letter for matching
|
|
int32_t matchKey = key;
|
|
|
|
if ((modifiers & ACCEL_CTRL) && matchKey >= 0x01 && matchKey <= 0x1A) {
|
|
matchKey = matchKey + 'A' - 1;
|
|
}
|
|
|
|
// Uppercase for case-insensitive letter matching
|
|
if (matchKey >= 'a' && matchKey <= 'z') {
|
|
matchKey = matchKey - 32;
|
|
}
|
|
|
|
int32_t requiredMods = modifiers & (ACCEL_CTRL | ACCEL_ALT);
|
|
AccelTableT *table = win->accelTable;
|
|
|
|
for (int32_t i = 0; i < table->count; i++) {
|
|
AccelEntryT *e = &table->entries[i];
|
|
|
|
// Uppercase the entry key too
|
|
int32_t entryKey = e->key;
|
|
|
|
if (entryKey >= 'a' && entryKey <= 'z') {
|
|
entryKey = entryKey - 32;
|
|
}
|
|
|
|
int32_t entryMods = e->modifiers & (ACCEL_CTRL | ACCEL_ALT);
|
|
|
|
if (entryKey == matchKey && entryMods == requiredMods) {
|
|
win->onMenu(win, e->cmdId);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
(void)ctx;
|
|
return false;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// clickMenuCheckRadio — toggle check or select radio on click
|
|
// ============================================================
|
|
|
|
static void clickMenuCheckRadio(MenuT *menu, int32_t itemIdx) {
|
|
MenuItemT *item = &menu->items[itemIdx];
|
|
|
|
if (item->type == MenuItemCheckE) {
|
|
item->checked = !item->checked;
|
|
} else if (item->type == MenuItemRadioE) {
|
|
// Uncheck all radio items in the same group (consecutive radio items)
|
|
// Search backward to find group start
|
|
int32_t groupStart = itemIdx;
|
|
|
|
while (groupStart > 0 && menu->items[groupStart - 1].type == MenuItemRadioE) {
|
|
groupStart--;
|
|
}
|
|
|
|
// Search forward to find group end
|
|
int32_t groupEnd = itemIdx;
|
|
|
|
while (groupEnd < menu->itemCount - 1 && menu->items[groupEnd + 1].type == MenuItemRadioE) {
|
|
groupEnd++;
|
|
}
|
|
|
|
// Uncheck all in group, check the clicked one
|
|
for (int32_t i = groupStart; i <= groupEnd; i++) {
|
|
menu->items[i].checked = (i == itemIdx);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// closeAllPopups — dirty all popup levels and deactivate
|
|
// ============================================================
|
|
|
|
static void closeAllPopups(AppContextT *ctx) {
|
|
if (!ctx->popup.active) {
|
|
return;
|
|
}
|
|
|
|
// Dirty current (deepest) level
|
|
dirtyListAdd(&ctx->dirty, ctx->popup.popupX, ctx->popup.popupY,
|
|
ctx->popup.popupW, ctx->popup.popupH);
|
|
|
|
// Dirty all parent levels
|
|
for (int32_t i = 0; i < ctx->popup.depth; i++) {
|
|
PopupLevelT *pl = &ctx->popup.parentStack[i];
|
|
dirtyListAdd(&ctx->dirty, pl->popupX, pl->popupY, pl->popupW, pl->popupH);
|
|
}
|
|
|
|
ctx->popup.active = false;
|
|
ctx->popup.depth = 0;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// closePopupLevel — close one submenu level (or deactivate if top)
|
|
// ============================================================
|
|
|
|
static void closePopupLevel(AppContextT *ctx) {
|
|
if (!ctx->popup.active) {
|
|
return;
|
|
}
|
|
|
|
// Dirty current level
|
|
dirtyListAdd(&ctx->dirty, ctx->popup.popupX, ctx->popup.popupY,
|
|
ctx->popup.popupW, ctx->popup.popupH);
|
|
|
|
if (ctx->popup.depth > 0) {
|
|
// Pop parent
|
|
ctx->popup.depth--;
|
|
PopupLevelT *pl = &ctx->popup.parentStack[ctx->popup.depth];
|
|
ctx->popup.menu = pl->menu;
|
|
ctx->popup.menuIdx = pl->menuIdx;
|
|
ctx->popup.popupX = pl->popupX;
|
|
ctx->popup.popupY = pl->popupY;
|
|
ctx->popup.popupW = pl->popupW;
|
|
ctx->popup.popupH = pl->popupH;
|
|
ctx->popup.hoverItem = pl->hoverItem;
|
|
} else {
|
|
ctx->popup.active = false;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// closeSysMenu
|
|
// ============================================================
|
|
|
|
static void closeSysMenu(AppContextT *ctx) {
|
|
if (ctx->sysMenu.active) {
|
|
dirtyListAdd(&ctx->dirty, ctx->sysMenu.popupX, ctx->sysMenu.popupY,
|
|
ctx->sysMenu.popupW, ctx->sysMenu.popupH);
|
|
ctx->sysMenu.active = false;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// compositeAndFlush
|
|
// ============================================================
|
|
|
|
static void compositeAndFlush(AppContextT *ctx) {
|
|
DisplayT *d = &ctx->display;
|
|
BlitOpsT *ops = &ctx->blitOps;
|
|
DirtyListT *dl = &ctx->dirty;
|
|
WindowStackT *ws = &ctx->stack;
|
|
|
|
dirtyListMerge(dl);
|
|
|
|
for (int32_t i = 0; i < dl->count; i++) {
|
|
RectT *dr = &dl->rects[i];
|
|
|
|
// Clip dirty rect to screen bounds
|
|
if (dr->x < 0) { dr->w += dr->x; dr->x = 0; }
|
|
if (dr->y < 0) { dr->h += dr->y; dr->y = 0; }
|
|
if (dr->x + dr->w > d->width) { dr->w = d->width - dr->x; }
|
|
if (dr->y + dr->h > d->height) { dr->h = d->height - dr->y; }
|
|
if (dr->w <= 0 || dr->h <= 0) { continue; }
|
|
|
|
// Set clip rect to this dirty rect
|
|
setClipRect(d, dr->x, dr->y, dr->w, dr->h);
|
|
|
|
// 1. Draw desktop background
|
|
rectFill(d, ops, dr->x, dr->y, dr->w, dr->h, ctx->colors.desktop);
|
|
|
|
// 2. Draw minimized window icons (under all windows)
|
|
wmDrawMinimizedIcons(d, ops, &ctx->colors, ws, dr);
|
|
|
|
// 3. Walk window stack bottom-to-top
|
|
for (int32_t j = 0; j < ws->count; j++) {
|
|
WindowT *win = ws->windows[j];
|
|
|
|
if (!win->visible || win->minimized) {
|
|
continue;
|
|
}
|
|
|
|
// Check if window intersects this dirty rect
|
|
RectT winRect = {win->x, win->y, win->w, win->h};
|
|
RectT isect;
|
|
|
|
if (!rectIntersect(dr, &winRect, &isect)) {
|
|
continue;
|
|
}
|
|
|
|
wmDrawChrome(d, ops, &ctx->font, &ctx->colors, win, dr);
|
|
wmDrawContent(d, ops, win, dr);
|
|
if (win->vScroll || win->hScroll) {
|
|
wmDrawScrollbars(d, ops, &ctx->colors, win, dr);
|
|
}
|
|
}
|
|
|
|
// 4. Draw popup menu if active (all levels)
|
|
if (ctx->popup.active) {
|
|
// Draw parent levels first (bottom to top)
|
|
for (int32_t lvl = 0; lvl < ctx->popup.depth; lvl++) {
|
|
PopupLevelT *pl = &ctx->popup.parentStack[lvl];
|
|
drawPopupLevel(ctx, d, ops, pl->menu, pl->popupX, pl->popupY, pl->popupW, pl->popupH, pl->hoverItem, dr);
|
|
}
|
|
|
|
// Draw current (deepest) level
|
|
drawPopupLevel(ctx, d, ops, ctx->popup.menu, ctx->popup.popupX, ctx->popup.popupY, ctx->popup.popupW, ctx->popup.popupH, ctx->popup.hoverItem, dr);
|
|
}
|
|
|
|
// 4b. Draw system menu if active
|
|
if (ctx->sysMenu.active) {
|
|
RectT smRect = { ctx->sysMenu.popupX, ctx->sysMenu.popupY, ctx->sysMenu.popupW, ctx->sysMenu.popupH };
|
|
RectT smIsect;
|
|
|
|
if (rectIntersect(dr, &smRect, &smIsect)) {
|
|
BevelStyleT smBevel;
|
|
smBevel.highlight = ctx->colors.windowHighlight;
|
|
smBevel.shadow = ctx->colors.windowShadow;
|
|
smBevel.face = ctx->colors.menuBg;
|
|
smBevel.width = 2;
|
|
drawBevel(d, ops, ctx->sysMenu.popupX, ctx->sysMenu.popupY, ctx->sysMenu.popupW, ctx->sysMenu.popupH, &smBevel);
|
|
|
|
int32_t itemY = ctx->sysMenu.popupY + 2;
|
|
|
|
for (int32_t k = 0; k < ctx->sysMenu.itemCount; k++) {
|
|
SysMenuItemT *item = &ctx->sysMenu.items[k];
|
|
|
|
if (item->separator) {
|
|
drawHLine(d, ops, ctx->sysMenu.popupX + 2, itemY + ctx->font.charHeight / 2, ctx->sysMenu.popupW - 4, ctx->colors.windowShadow);
|
|
itemY += ctx->font.charHeight;
|
|
continue;
|
|
}
|
|
|
|
uint32_t bg = ctx->colors.menuBg;
|
|
uint32_t fg = item->enabled ? ctx->colors.menuFg : ctx->colors.windowShadow;
|
|
|
|
if (k == ctx->sysMenu.hoverItem && item->enabled) {
|
|
bg = ctx->colors.menuHighlightBg;
|
|
fg = ctx->colors.menuHighlightFg;
|
|
}
|
|
|
|
rectFill(d, ops, ctx->sysMenu.popupX + 2, itemY, ctx->sysMenu.popupW - 4, ctx->font.charHeight, bg);
|
|
drawTextAccel(d, ops, &ctx->font, ctx->sysMenu.popupX + CHROME_TITLE_PAD + 2, itemY, item->label, fg, bg, true);
|
|
|
|
itemY += ctx->font.charHeight;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 5. Draw tooltip
|
|
if (ctx->tooltipText) {
|
|
RectT ttRect = { ctx->tooltipX, ctx->tooltipY, ctx->tooltipW, ctx->tooltipH };
|
|
RectT ttIsect;
|
|
|
|
if (rectIntersect(dr, &ttRect, &ttIsect)) {
|
|
rectFill(d, ops, ctx->tooltipX, ctx->tooltipY, ctx->tooltipW, ctx->tooltipH, ctx->colors.menuBg);
|
|
drawHLine(d, ops, ctx->tooltipX, ctx->tooltipY, ctx->tooltipW, ctx->colors.contentFg);
|
|
drawHLine(d, ops, ctx->tooltipX, ctx->tooltipY + ctx->tooltipH - 1, ctx->tooltipW, ctx->colors.contentFg);
|
|
drawVLine(d, ops, ctx->tooltipX, ctx->tooltipY, ctx->tooltipH, ctx->colors.contentFg);
|
|
drawVLine(d, ops, ctx->tooltipX + ctx->tooltipW - 1, ctx->tooltipY, ctx->tooltipH, ctx->colors.contentFg);
|
|
drawText(d, ops, &ctx->font, ctx->tooltipX + TOOLTIP_PAD, ctx->tooltipY + TOOLTIP_PAD, ctx->tooltipText, ctx->colors.menuFg, ctx->colors.menuBg, true);
|
|
}
|
|
}
|
|
|
|
// 6. Draw cursor
|
|
drawCursorAt(ctx, ctx->mouseX, ctx->mouseY);
|
|
|
|
// 6. Flush this dirty rect to LFB
|
|
flushRect(d, dr);
|
|
}
|
|
|
|
resetClipRect(d);
|
|
dirtyListClear(dl);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dirtyCursorArea
|
|
// ============================================================
|
|
|
|
static void dirtyCursorArea(AppContextT *ctx, int32_t x, int32_t y) {
|
|
// Dirty the union of all cursor shapes at this position to handle shape changes
|
|
// All cursors are 16x16 with hotspot at either (0,0) or (7,7), so worst case
|
|
// covers from (x-7, y-7) to (x+15, y+15) = 23x23 area
|
|
dirtyListAdd(&ctx->dirty, x - 7, y - 7, 23, 23);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dispatchAccelKey — route Alt+key to menu or widget
|
|
// ============================================================
|
|
|
|
static bool dispatchAccelKey(AppContextT *ctx, char key) {
|
|
if (ctx->stack.focusedIdx < 0) {
|
|
return false;
|
|
}
|
|
|
|
WindowT *win = ctx->stack.windows[ctx->stack.focusedIdx];
|
|
|
|
// Check menu bar first
|
|
if (win->menuBar) {
|
|
for (int32_t i = 0; i < win->menuBar->menuCount; i++) {
|
|
if (win->menuBar->menus[i].accelKey == key) {
|
|
openPopupAtMenu(ctx, win, i);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check widget tree
|
|
if (win->widgetRoot) {
|
|
WidgetT *target = widgetFindByAccel(win->widgetRoot, key);
|
|
|
|
if (target) {
|
|
switch (target->type) {
|
|
case WidgetButtonE:
|
|
if (sFocusedWidget) { sFocusedWidget->focused = false; }
|
|
sFocusedWidget = target;
|
|
target->focused = true;
|
|
target->as.button.pressed = true;
|
|
sKeyPressedBtn = target;
|
|
wgtInvalidate(target);
|
|
return true;
|
|
|
|
case WidgetCheckboxE:
|
|
if (sFocusedWidget) { sFocusedWidget->focused = false; }
|
|
widgetCheckboxOnMouse(target, win->widgetRoot, 0, 0);
|
|
sFocusedWidget = target;
|
|
wgtInvalidate(target);
|
|
return true;
|
|
|
|
case WidgetRadioE:
|
|
if (sFocusedWidget) { sFocusedWidget->focused = false; }
|
|
widgetRadioOnMouse(target, win->widgetRoot, 0, 0);
|
|
sFocusedWidget = target;
|
|
wgtInvalidate(target);
|
|
return true;
|
|
|
|
case WidgetImageButtonE:
|
|
if (sFocusedWidget) { sFocusedWidget->focused = false; }
|
|
sFocusedWidget = target;
|
|
target->focused = true;
|
|
target->as.imageButton.pressed = true;
|
|
sKeyPressedBtn = target;
|
|
wgtInvalidate(target);
|
|
return true;
|
|
|
|
case WidgetTabPageE:
|
|
{
|
|
// Close any open dropdown/combobox popup
|
|
if (sOpenPopup) {
|
|
if (sOpenPopup->type == WidgetDropdownE) {
|
|
sOpenPopup->as.dropdown.open = false;
|
|
} else if (sOpenPopup->type == WidgetComboBoxE) {
|
|
sOpenPopup->as.comboBox.open = false;
|
|
}
|
|
|
|
sOpenPopup = NULL;
|
|
}
|
|
|
|
// Activate this tab in its parent TabControl
|
|
if (target->parent && target->parent->type == WidgetTabControlE) {
|
|
int32_t tabIdx = 0;
|
|
|
|
for (WidgetT *c = target->parent->firstChild; c; c = c->nextSibling) {
|
|
if (c == target) {
|
|
wgtTabControlSetActive(target->parent, tabIdx);
|
|
wgtInvalidate(win->widgetRoot);
|
|
break;
|
|
}
|
|
|
|
if (c->type == WidgetTabPageE) {
|
|
tabIdx++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
case WidgetDropdownE:
|
|
target->as.dropdown.open = true;
|
|
target->as.dropdown.hoverIdx = target->as.dropdown.selectedIdx;
|
|
sOpenPopup = target;
|
|
if (sFocusedWidget) { sFocusedWidget->focused = false; }
|
|
sFocusedWidget = target;
|
|
target->focused = true;
|
|
wgtInvalidate(win->widgetRoot);
|
|
return true;
|
|
|
|
case WidgetComboBoxE:
|
|
target->as.comboBox.open = true;
|
|
target->as.comboBox.hoverIdx = target->as.comboBox.selectedIdx;
|
|
sOpenPopup = target;
|
|
if (sFocusedWidget) { sFocusedWidget->focused = false; }
|
|
sFocusedWidget = target;
|
|
target->focused = true;
|
|
wgtInvalidate(win->widgetRoot);
|
|
return true;
|
|
|
|
case WidgetLabelE:
|
|
case WidgetFrameE:
|
|
{
|
|
// Focus the next focusable widget
|
|
WidgetT *next = widgetFindNextFocusable(win->widgetRoot, target);
|
|
|
|
if (next) {
|
|
if (sFocusedWidget) { sFocusedWidget->focused = false; }
|
|
sFocusedWidget = next;
|
|
next->focused = true;
|
|
|
|
// Open dropdown/combobox if that's the focused target
|
|
if (next->type == WidgetDropdownE) {
|
|
next->as.dropdown.open = true;
|
|
next->as.dropdown.hoverIdx = next->as.dropdown.selectedIdx;
|
|
sOpenPopup = next;
|
|
} else if (next->type == WidgetComboBoxE) {
|
|
next->as.comboBox.open = true;
|
|
next->as.comboBox.hoverIdx = next->as.comboBox.selectedIdx;
|
|
sOpenPopup = next;
|
|
}
|
|
|
|
wgtInvalidate(win->widgetRoot);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
default:
|
|
// For focusable widgets, just focus them
|
|
if (widgetIsFocusable(target->type)) {
|
|
if (sFocusedWidget) { sFocusedWidget->focused = false; }
|
|
sFocusedWidget = target;
|
|
target->focused = true;
|
|
wgtInvalidate(win->widgetRoot);
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dispatchEvents
|
|
// ============================================================
|
|
|
|
static void dispatchEvents(AppContextT *ctx) {
|
|
int32_t mx = ctx->mouseX;
|
|
int32_t my = ctx->mouseY;
|
|
int32_t buttons = ctx->mouseButtons;
|
|
int32_t prevBtn = ctx->prevMouseButtons;
|
|
|
|
// Mouse movement always dirties old and new cursor positions
|
|
if (mx != ctx->prevMouseX || my != ctx->prevMouseY) {
|
|
dirtyCursorArea(ctx, ctx->prevMouseX, ctx->prevMouseY);
|
|
dirtyCursorArea(ctx, mx, my);
|
|
|
|
// Update cursor shape based on what the mouse is hovering over
|
|
updateCursorShape(ctx);
|
|
}
|
|
|
|
// Handle active drag
|
|
if (ctx->stack.dragWindow >= 0) {
|
|
if (buttons & 1) {
|
|
wmDragMove(&ctx->stack, &ctx->dirty, mx, my);
|
|
} else {
|
|
wmDragEnd(&ctx->stack);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Handle active resize
|
|
if (ctx->stack.resizeWindow >= 0) {
|
|
if (buttons & 1) {
|
|
wmResizeMove(&ctx->stack, &ctx->dirty, &ctx->display, mx, my);
|
|
} else {
|
|
wmResizeEnd(&ctx->stack);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Handle active scrollbar thumb drag
|
|
if (ctx->stack.scrollWindow >= 0) {
|
|
if (buttons & 1) {
|
|
wmScrollbarDrag(&ctx->stack, &ctx->dirty, mx, my);
|
|
} else {
|
|
wmScrollbarEnd(&ctx->stack);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Handle system menu interaction
|
|
if (ctx->sysMenu.active) {
|
|
if (mx >= ctx->sysMenu.popupX && mx < ctx->sysMenu.popupX + ctx->sysMenu.popupW &&
|
|
my >= ctx->sysMenu.popupY && my < ctx->sysMenu.popupY + ctx->sysMenu.popupH) {
|
|
|
|
// Hover tracking
|
|
int32_t relY = my - ctx->sysMenu.popupY - 2;
|
|
int32_t itemIdx = relY / ctx->font.charHeight;
|
|
|
|
if (itemIdx >= 0 && itemIdx < ctx->sysMenu.itemCount && ctx->sysMenu.items[itemIdx].separator) {
|
|
itemIdx = -1;
|
|
}
|
|
|
|
if (itemIdx != ctx->sysMenu.hoverItem) {
|
|
ctx->sysMenu.hoverItem = itemIdx;
|
|
dirtyListAdd(&ctx->dirty, ctx->sysMenu.popupX, ctx->sysMenu.popupY, ctx->sysMenu.popupW, ctx->sysMenu.popupH);
|
|
}
|
|
|
|
// Click on item
|
|
if ((buttons & 1) && !(prevBtn & 1)) {
|
|
if (itemIdx >= 0 && itemIdx < ctx->sysMenu.itemCount) {
|
|
SysMenuItemT *item = &ctx->sysMenu.items[itemIdx];
|
|
|
|
if (item->enabled && !item->separator) {
|
|
executeSysMenuCmd(ctx, item->cmd);
|
|
}
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Click outside system menu — close it, let event fall through
|
|
if ((buttons & 1) && !(prevBtn & 1)) {
|
|
closeSysMenu(ctx);
|
|
}
|
|
}
|
|
|
|
// Handle popup menu interaction (with cascading submenu support)
|
|
if (ctx->popup.active) {
|
|
// Check if mouse is inside current (deepest) popup level
|
|
bool inCurrent = (mx >= ctx->popup.popupX && mx < ctx->popup.popupX + ctx->popup.popupW &&
|
|
my >= ctx->popup.popupY && my < ctx->popup.popupY + ctx->popup.popupH);
|
|
|
|
if (inCurrent) {
|
|
// Hover tracking in current level
|
|
int32_t relY = my - ctx->popup.popupY - 2;
|
|
int32_t itemIdx = relY / ctx->font.charHeight;
|
|
|
|
if (itemIdx < 0) {
|
|
itemIdx = 0;
|
|
}
|
|
|
|
if (ctx->popup.menu && itemIdx >= ctx->popup.menu->itemCount) {
|
|
itemIdx = ctx->popup.menu->itemCount - 1;
|
|
}
|
|
|
|
if (itemIdx != ctx->popup.hoverItem) {
|
|
int32_t prevHover = ctx->popup.hoverItem;
|
|
ctx->popup.hoverItem = itemIdx;
|
|
dirtyListAdd(&ctx->dirty, ctx->popup.popupX, ctx->popup.popupY,
|
|
ctx->popup.popupW, ctx->popup.popupH);
|
|
|
|
// If hovering a submenu item, open the submenu
|
|
if (ctx->popup.menu && itemIdx >= 0 && itemIdx < ctx->popup.menu->itemCount) {
|
|
MenuItemT *hItem = &ctx->popup.menu->items[itemIdx];
|
|
|
|
if (hItem->subMenu && hItem->enabled) {
|
|
openSubMenu(ctx);
|
|
}
|
|
}
|
|
|
|
// If we moved away from a submenu item to a non-submenu item,
|
|
// close any child submenus that were opened from this level
|
|
if (prevHover >= 0 && ctx->popup.menu && prevHover < ctx->popup.menu->itemCount) {
|
|
// Already handled: openSubMenu replaces the child, and if current
|
|
// item is not a submenu, no child opens. But we may still have
|
|
// a stale child — check if depth was increased by a previous hover.
|
|
// This case is handled below by the parent-level hit test popping levels.
|
|
}
|
|
}
|
|
|
|
// Click on item in current level
|
|
if ((buttons & 1) && !(prevBtn & 1)) {
|
|
if (ctx->popup.menu && itemIdx >= 0 && itemIdx < ctx->popup.menu->itemCount) {
|
|
MenuItemT *item = &ctx->popup.menu->items[itemIdx];
|
|
|
|
if (item->subMenu && item->enabled) {
|
|
// Clicking a submenu item opens it (already open from hover, but ensure)
|
|
openSubMenu(ctx);
|
|
} else if (item->enabled && !item->separator) {
|
|
// Toggle check/radio state before closing
|
|
if (item->type == MenuItemCheckE || item->type == MenuItemRadioE) {
|
|
clickMenuCheckRadio(ctx->popup.menu, itemIdx);
|
|
}
|
|
|
|
// Close popup BEFORE calling onMenu (onMenu may run a nested event loop)
|
|
int32_t menuId = item->id;
|
|
WindowT *win = findWindowById(ctx, ctx->popup.windowId);
|
|
closeAllPopups(ctx);
|
|
|
|
if (win && win->onMenu) {
|
|
win->onMenu(win, menuId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Mouse is not in current popup — check parent levels (deepest first)
|
|
bool inParent = false;
|
|
|
|
for (int32_t lvl = ctx->popup.depth - 1; lvl >= 0; lvl--) {
|
|
PopupLevelT *pl = &ctx->popup.parentStack[lvl];
|
|
|
|
if (mx >= pl->popupX && mx < pl->popupX + pl->popupW &&
|
|
my >= pl->popupY && my < pl->popupY + pl->popupH) {
|
|
|
|
// Close all levels deeper than this one
|
|
while (ctx->popup.depth > lvl + 1) {
|
|
closePopupLevel(ctx);
|
|
}
|
|
|
|
// Now close the level that was the "current" when we entered this parent
|
|
closePopupLevel(ctx);
|
|
|
|
// Now current level IS this parent — update hover
|
|
int32_t relY = my - ctx->popup.popupY - 2;
|
|
int32_t itemIdx = relY / ctx->font.charHeight;
|
|
|
|
if (itemIdx < 0) {
|
|
itemIdx = 0;
|
|
}
|
|
|
|
if (ctx->popup.menu && itemIdx >= ctx->popup.menu->itemCount) {
|
|
itemIdx = ctx->popup.menu->itemCount - 1;
|
|
}
|
|
|
|
ctx->popup.hoverItem = itemIdx;
|
|
dirtyListAdd(&ctx->dirty, ctx->popup.popupX, ctx->popup.popupY,
|
|
ctx->popup.popupW, ctx->popup.popupH);
|
|
|
|
// If the newly hovered item has a submenu, open it
|
|
if (ctx->popup.menu && itemIdx >= 0 && itemIdx < ctx->popup.menu->itemCount) {
|
|
MenuItemT *hItem = &ctx->popup.menu->items[itemIdx];
|
|
|
|
if (hItem->subMenu && hItem->enabled) {
|
|
openSubMenu(ctx);
|
|
}
|
|
}
|
|
|
|
inParent = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!inParent) {
|
|
if (ctx->popup.isContextMenu) {
|
|
// Context menu: any click outside closes it
|
|
if ((buttons & 1) && !(prevBtn & 1)) {
|
|
closeAllPopups(ctx);
|
|
}
|
|
} else {
|
|
// Menu bar popup: check if mouse is on the menu bar for switching
|
|
WindowT *win = findWindowById(ctx, ctx->popup.windowId);
|
|
|
|
if (win && win->menuBar) {
|
|
int32_t barY = win->y + CHROME_BORDER_WIDTH + CHROME_TITLE_HEIGHT;
|
|
|
|
if (my >= barY && my < barY + CHROME_MENU_HEIGHT &&
|
|
mx >= win->x + CHROME_TOTAL_SIDE &&
|
|
mx < win->x + win->w - CHROME_TOTAL_SIDE) {
|
|
|
|
int32_t relX = mx - win->x;
|
|
|
|
for (int32_t i = 0; i < win->menuBar->menuCount; i++) {
|
|
MenuT *menu = &win->menuBar->menus[i];
|
|
|
|
if (relX >= menu->barX && relX < menu->barX + menu->barW) {
|
|
if (i != ctx->popup.menuIdx || ctx->popup.depth > 0) {
|
|
openPopupAtMenu(ctx, win, i);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
} else if ((buttons & 1) && !(prevBtn & 1)) {
|
|
closeAllPopups(ctx);
|
|
}
|
|
} else if ((buttons & 1) && !(prevBtn & 1)) {
|
|
closeAllPopups(ctx);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Handle left button press
|
|
if ((buttons & 1) && !(prevBtn & 1)) {
|
|
handleMouseButton(ctx, mx, my, buttons);
|
|
}
|
|
|
|
// Handle right button press — context menus
|
|
if ((buttons & 2) && !(prevBtn & 2)) {
|
|
int32_t hitPart;
|
|
int32_t hitIdx = wmHitTest(&ctx->stack, mx, my, &hitPart);
|
|
|
|
if (hitIdx >= 0 && hitPart == 0) {
|
|
WindowT *win = ctx->stack.windows[hitIdx];
|
|
|
|
// Raise and focus if not already
|
|
if (hitIdx != ctx->stack.focusedIdx) {
|
|
wmRaiseWindow(&ctx->stack, &ctx->dirty, hitIdx);
|
|
hitIdx = ctx->stack.count - 1;
|
|
wmSetFocus(&ctx->stack, &ctx->dirty, hitIdx);
|
|
win = ctx->stack.windows[hitIdx];
|
|
}
|
|
|
|
// Check widget context menu first
|
|
MenuT *ctxMenu = NULL;
|
|
|
|
if (win->widgetRoot) {
|
|
int32_t relX = mx - win->x - win->contentX;
|
|
int32_t relY = my - win->y - win->contentY;
|
|
WidgetT *hit = widgetHitTest(win->widgetRoot, relX, relY);
|
|
|
|
// Walk up the tree to find a context menu
|
|
while (hit && !hit->contextMenu) {
|
|
hit = hit->parent;
|
|
}
|
|
|
|
if (hit) {
|
|
ctxMenu = hit->contextMenu;
|
|
}
|
|
}
|
|
|
|
// Fall back to window context menu
|
|
if (!ctxMenu) {
|
|
ctxMenu = win->contextMenu;
|
|
}
|
|
|
|
if (ctxMenu) {
|
|
openContextMenu(ctx, win, ctxMenu, mx, my);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handle button release on content — send to focused window
|
|
if (!(buttons & 1) && (prevBtn & 1)) {
|
|
if (ctx->stack.focusedIdx >= 0) {
|
|
WindowT *win = ctx->stack.windows[ctx->stack.focusedIdx];
|
|
|
|
if (win->onMouse) {
|
|
int32_t relX = mx - win->x - win->contentX;
|
|
int32_t relY = my - win->y - win->contentY;
|
|
win->onMouse(win, relX, relY, buttons);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Mouse movement in content area — send to focused window
|
|
if ((mx != ctx->prevMouseX || my != ctx->prevMouseY) &&
|
|
ctx->stack.focusedIdx >= 0 && (buttons & 1)) {
|
|
WindowT *win = ctx->stack.windows[ctx->stack.focusedIdx];
|
|
|
|
if (win->onMouse) {
|
|
int32_t relX = mx - win->x - win->contentX;
|
|
int32_t relY = my - win->y - win->contentY;
|
|
win->onMouse(win, relX, relY, buttons);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// drawCursorAt
|
|
// ============================================================
|
|
|
|
static void drawCursorAt(AppContextT *ctx, int32_t x, int32_t y) {
|
|
const CursorT *cur = &ctx->cursors[ctx->cursorId];
|
|
|
|
drawMaskedBitmap(&ctx->display, &ctx->blitOps, x - cur->hotX, y - cur->hotY, cur->width, cur->height, cur->andMask, cur->xorData, ctx->cursorFg, ctx->cursorBg);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// drawPopupLevel — draw one popup menu (bevel + items)
|
|
// ============================================================
|
|
|
|
static void drawPopupLevel(AppContextT *ctx, DisplayT *d, const BlitOpsT *ops, const MenuT *menu, int32_t px, int32_t py, int32_t pw, int32_t ph, int32_t hoverItem, const RectT *clipTo) {
|
|
RectT popRect = { px, py, pw, ph };
|
|
RectT popIsect;
|
|
|
|
if (!rectIntersect(clipTo, &popRect, &popIsect)) {
|
|
return;
|
|
}
|
|
|
|
// Detect if menu has check/radio items (for left margin)
|
|
bool hasCheck = false;
|
|
|
|
for (int32_t k = 0; k < menu->itemCount; k++) {
|
|
if (menu->items[k].type == MenuItemCheckE || menu->items[k].type == MenuItemRadioE) {
|
|
hasCheck = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
int32_t checkMargin = hasCheck ? MENU_CHECK_WIDTH : 0;
|
|
|
|
// Draw popup background
|
|
BevelStyleT popBevel;
|
|
popBevel.highlight = ctx->colors.windowHighlight;
|
|
popBevel.shadow = ctx->colors.windowShadow;
|
|
popBevel.face = ctx->colors.menuBg;
|
|
popBevel.width = 2;
|
|
drawBevel(d, ops, px, py, pw, ph, &popBevel);
|
|
|
|
// Draw menu items
|
|
int32_t itemY = py + 2;
|
|
|
|
for (int32_t k = 0; k < menu->itemCount; k++) {
|
|
const MenuItemT *item = &menu->items[k];
|
|
|
|
if (item->separator) {
|
|
drawHLine(d, ops, px + 2, itemY + ctx->font.charHeight / 2, pw - 4, ctx->colors.windowShadow);
|
|
itemY += ctx->font.charHeight;
|
|
continue;
|
|
}
|
|
|
|
uint32_t bg = ctx->colors.menuBg;
|
|
uint32_t fg = ctx->colors.menuFg;
|
|
|
|
if (k == hoverItem) {
|
|
bg = ctx->colors.menuHighlightBg;
|
|
fg = ctx->colors.menuHighlightFg;
|
|
}
|
|
|
|
rectFill(d, ops, px + 2, itemY, pw - 4, ctx->font.charHeight, bg);
|
|
drawTextAccel(d, ops, &ctx->font, px + CHROME_TITLE_PAD + 2 + checkMargin, itemY, item->label, fg, bg, true);
|
|
|
|
// Draw check/radio indicator
|
|
if (item->checked) {
|
|
int32_t cy = itemY + ctx->font.charHeight / 2;
|
|
int32_t cx = px + 2 + MENU_CHECK_WIDTH / 2;
|
|
|
|
if (item->type == MenuItemCheckE) {
|
|
// Checkmark: small tick shape
|
|
drawVLine(d, ops, cx - 2, cy - 1, 2, fg);
|
|
drawVLine(d, ops, cx - 1, cy, 2, fg);
|
|
drawVLine(d, ops, cx, cy + 1, 2, fg);
|
|
drawVLine(d, ops, cx + 1, cy, 2, fg);
|
|
drawVLine(d, ops, cx + 2, cy - 1, 2, fg);
|
|
drawVLine(d, ops, cx + 3, cy - 2, 2, fg);
|
|
} else if (item->type == MenuItemRadioE) {
|
|
// Filled diamond bullet (5x5)
|
|
drawHLine(d, ops, cx, cy - 2, 1, fg);
|
|
drawHLine(d, ops, cx - 1, cy - 1, 3, fg);
|
|
drawHLine(d, ops, cx - 2, cy, 5, fg);
|
|
drawHLine(d, ops, cx - 1, cy + 1, 3, fg);
|
|
drawHLine(d, ops, cx, cy + 2, 1, fg);
|
|
}
|
|
}
|
|
|
|
// Draw submenu arrow indicator
|
|
if (item->subMenu) {
|
|
int32_t arrowX = px + pw - SUBMENU_ARROW_WIDTH - 2;
|
|
int32_t arrowY = itemY + ctx->font.charHeight / 2;
|
|
|
|
for (int32_t row = -3; row <= 3; row++) {
|
|
int32_t len = 4 - (row < 0 ? -row : row);
|
|
|
|
if (len > 0) {
|
|
drawHLine(d, ops, arrowX + (row < 0 ? 3 + row : 3 - row), arrowY + row, len, fg);
|
|
}
|
|
}
|
|
}
|
|
|
|
itemY += ctx->font.charHeight;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxCreateWindow
|
|
// ============================================================
|
|
|
|
WindowT *dvxCreateWindow(AppContextT *ctx, const char *title, int32_t x, int32_t y, int32_t w, int32_t h, bool resizable) {
|
|
WindowT *win = wmCreateWindow(&ctx->stack, &ctx->display, title, x, y, w, h, resizable);
|
|
|
|
if (win) {
|
|
// Raise and focus
|
|
int32_t idx = ctx->stack.count - 1;
|
|
wmSetFocus(&ctx->stack, &ctx->dirty, idx);
|
|
dirtyListAdd(&ctx->dirty, win->x, win->y, win->w, win->h);
|
|
}
|
|
|
|
return win;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxAddAccel
|
|
// ============================================================
|
|
|
|
void dvxAddAccel(AccelTableT *table, int32_t key, int32_t modifiers, int32_t cmdId) {
|
|
if (!table || table->count >= MAX_ACCEL_ENTRIES) {
|
|
return;
|
|
}
|
|
|
|
AccelEntryT *e = &table->entries[table->count++];
|
|
e->key = key;
|
|
e->modifiers = modifiers;
|
|
e->cmdId = cmdId;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxClipboardCopy
|
|
// ============================================================
|
|
|
|
void dvxClipboardCopy(const char *text, int32_t len) {
|
|
clipboardCopy(text, len);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxClipboardGet
|
|
// ============================================================
|
|
|
|
const char *dvxClipboardGet(int32_t *outLen) {
|
|
return clipboardGet(outLen);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxCascadeWindows
|
|
// ============================================================
|
|
//
|
|
// Arrange all visible, non-minimized windows in a staggered
|
|
// diagonal pattern from the top-left corner.
|
|
|
|
void dvxCascadeWindows(AppContextT *ctx) {
|
|
int32_t screenW = ctx->display.width;
|
|
int32_t screenH = ctx->display.height;
|
|
int32_t offsetX = 0;
|
|
int32_t offsetY = 0;
|
|
int32_t step = CHROME_TITLE_HEIGHT + CHROME_BORDER_WIDTH;
|
|
|
|
// Default cascade size: 2/3 of screen
|
|
int32_t winW = screenW * 2 / 3;
|
|
int32_t winH = screenH * 2 / 3;
|
|
|
|
if (winW < MIN_WINDOW_W) {
|
|
winW = MIN_WINDOW_W;
|
|
}
|
|
|
|
if (winH < MIN_WINDOW_H) {
|
|
winH = MIN_WINDOW_H;
|
|
}
|
|
|
|
for (int32_t i = 0; i < ctx->stack.count; i++) {
|
|
WindowT *win = ctx->stack.windows[i];
|
|
|
|
if (win->minimized || !win->visible) {
|
|
continue;
|
|
}
|
|
|
|
// Un-maximize if needed
|
|
if (win->maximized) {
|
|
win->maximized = false;
|
|
}
|
|
|
|
// Dirty old position
|
|
dirtyListAdd(&ctx->dirty, win->x, win->y, win->w, win->h);
|
|
|
|
win->x = offsetX;
|
|
win->y = offsetY;
|
|
win->w = winW;
|
|
win->h = winH;
|
|
|
|
wmUpdateContentRect(win);
|
|
wmReallocContentBuf(win, &ctx->display);
|
|
|
|
if (win->onResize) {
|
|
win->onResize(win, win->contentW, win->contentH);
|
|
}
|
|
|
|
if (win->onPaint) {
|
|
RectT fullRect = {0, 0, win->contentW, win->contentH};
|
|
win->onPaint(win, &fullRect);
|
|
win->contentDirty = true;
|
|
}
|
|
|
|
// Dirty new position
|
|
dirtyListAdd(&ctx->dirty, win->x, win->y, win->w, win->h);
|
|
|
|
offsetX += step;
|
|
offsetY += step;
|
|
|
|
// Wrap around if we'd go off screen
|
|
if (offsetX + winW > screenW || offsetY + winH > screenH) {
|
|
offsetX = 0;
|
|
offsetY = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxCreateAccelTable
|
|
// ============================================================
|
|
|
|
AccelTableT *dvxCreateAccelTable(void) {
|
|
AccelTableT *table = (AccelTableT *)calloc(1, sizeof(AccelTableT));
|
|
return table;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxDestroyWindow
|
|
// ============================================================
|
|
|
|
void dvxDestroyWindow(AppContextT *ctx, WindowT *win) {
|
|
dirtyListAdd(&ctx->dirty, win->x, win->y, win->w, win->h);
|
|
wmDestroyWindow(&ctx->stack, win);
|
|
|
|
// Focus the new top window
|
|
if (ctx->stack.count > 0) {
|
|
wmSetFocus(&ctx->stack, &ctx->dirty, ctx->stack.count - 1);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxFitWindow
|
|
// ============================================================
|
|
|
|
void dvxFitWindow(AppContextT *ctx, WindowT *win) {
|
|
if (!ctx || !win || !win->widgetRoot) {
|
|
return;
|
|
}
|
|
|
|
// Measure the widget tree to get minimum content size
|
|
widgetCalcMinSizeTree(win->widgetRoot, &ctx->font);
|
|
|
|
int32_t contentW = win->widgetRoot->calcMinW;
|
|
int32_t contentH = win->widgetRoot->calcMinH;
|
|
|
|
// Compute chrome overhead
|
|
int32_t topChrome = CHROME_TOTAL_TOP;
|
|
if (win->menuBar) {
|
|
topChrome += CHROME_MENU_HEIGHT;
|
|
}
|
|
|
|
int32_t newW = contentW + CHROME_TOTAL_SIDE * 2;
|
|
int32_t newH = contentH + topChrome + CHROME_TOTAL_BOTTOM;
|
|
|
|
// Dirty old position
|
|
dirtyListAdd(&ctx->dirty, win->x, win->y, win->w, win->h);
|
|
|
|
// Resize
|
|
win->w = newW;
|
|
win->h = newH;
|
|
wmUpdateContentRect(win);
|
|
wmReallocContentBuf(win, &ctx->display);
|
|
|
|
// Dirty new position
|
|
dirtyListAdd(&ctx->dirty, win->x, win->y, win->w, win->h);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxFreeAccelTable
|
|
// ============================================================
|
|
|
|
void dvxFreeAccelTable(AccelTableT *table) {
|
|
free(table);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxGetBlitOps
|
|
// ============================================================
|
|
|
|
const BlitOpsT *dvxGetBlitOps(const AppContextT *ctx) {
|
|
return &ctx->blitOps;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxGetColors
|
|
// ============================================================
|
|
|
|
const ColorSchemeT *dvxGetColors(const AppContextT *ctx) {
|
|
return &ctx->colors;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxGetDisplay
|
|
// ============================================================
|
|
|
|
DisplayT *dvxGetDisplay(AppContextT *ctx) {
|
|
return &ctx->display;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxGetFont
|
|
// ============================================================
|
|
|
|
const BitmapFontT *dvxGetFont(const AppContextT *ctx) {
|
|
return &ctx->font;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxInit
|
|
// ============================================================
|
|
|
|
int32_t dvxInit(AppContextT *ctx, int32_t requestedW, int32_t requestedH, int32_t preferredBpp) {
|
|
memset(ctx, 0, sizeof(*ctx));
|
|
|
|
// Disable Ctrl+C/Break termination
|
|
signal(SIGINT, SIG_IGN);
|
|
|
|
// Initialize video
|
|
if (videoInit(&ctx->display, requestedW, requestedH, preferredBpp) != 0) {
|
|
return -1;
|
|
}
|
|
|
|
// Initialize blit ops
|
|
drawInit(&ctx->blitOps, &ctx->display);
|
|
|
|
// Initialize window stack
|
|
wmInit(&ctx->stack);
|
|
|
|
// Initialize dirty list
|
|
dirtyListInit(&ctx->dirty);
|
|
|
|
// Set up font (use 8x16)
|
|
ctx->font = dvxFont8x16;
|
|
|
|
// Set up cursors
|
|
memcpy(ctx->cursors, dvxCursors, sizeof(dvxCursors));
|
|
ctx->cursorId = CURSOR_ARROW;
|
|
|
|
// Initialize colors
|
|
initColorScheme(ctx);
|
|
|
|
// Cache cursor colors
|
|
ctx->cursorFg = packColor(&ctx->display, 255, 255, 255);
|
|
ctx->cursorBg = packColor(&ctx->display, 0, 0, 0);
|
|
|
|
// Initialize mouse
|
|
initMouse(ctx);
|
|
|
|
ctx->running = true;
|
|
ctx->lastIconClickId = -1;
|
|
ctx->lastIconClickTime = 0;
|
|
ctx->lastCloseClickId = -1;
|
|
ctx->lastCloseClickTime = 0;
|
|
|
|
// Dirty the entire screen for first paint
|
|
dirtyListAdd(&ctx->dirty, 0, 0, ctx->display.width, ctx->display.height);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxInvalidateRect
|
|
// ============================================================
|
|
|
|
void dvxInvalidateRect(AppContextT *ctx, WindowT *win, int32_t x, int32_t y, int32_t w, int32_t h) {
|
|
// Convert from content-relative to screen coordinates
|
|
int32_t screenX = win->x + win->contentX + x;
|
|
int32_t screenY = win->y + win->contentY + y;
|
|
|
|
dirtyListAdd(&ctx->dirty, screenX, screenY, w, h);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxInvalidateWindow
|
|
// ============================================================
|
|
|
|
void dvxInvalidateWindow(AppContextT *ctx, WindowT *win) {
|
|
dirtyListAdd(&ctx->dirty, win->x, win->y, win->w, win->h);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxMaximizeWindow
|
|
// ============================================================
|
|
|
|
void dvxMaximizeWindow(AppContextT *ctx, WindowT *win) {
|
|
wmMaximize(&ctx->stack, &ctx->dirty, &ctx->display, win);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxMinimizeWindow
|
|
// ============================================================
|
|
|
|
void dvxMinimizeWindow(AppContextT *ctx, WindowT *win) {
|
|
wmMinimize(&ctx->stack, &ctx->dirty, win);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxQuit
|
|
// ============================================================
|
|
|
|
void dvxQuit(AppContextT *ctx) {
|
|
ctx->running = false;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxRun
|
|
// ============================================================
|
|
|
|
void dvxRun(AppContextT *ctx) {
|
|
while (dvxUpdate(ctx)) {
|
|
// dvxUpdate returns false when the GUI wants to exit
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxUpdate
|
|
// ============================================================
|
|
|
|
bool dvxUpdate(AppContextT *ctx) {
|
|
if (!ctx->running) {
|
|
return false;
|
|
}
|
|
|
|
pollMouse(ctx);
|
|
pollKeyboard(ctx);
|
|
dispatchEvents(ctx);
|
|
updateTooltip(ctx);
|
|
pollAnsiTermWidgets(ctx);
|
|
|
|
// Periodically refresh one minimized window thumbnail (staggered)
|
|
ctx->frameCount++;
|
|
|
|
if (ctx->frameCount % ICON_REFRESH_INTERVAL == 0) {
|
|
refreshMinimizedIcons(ctx);
|
|
}
|
|
|
|
if (ctx->dirty.count > 0) {
|
|
compositeAndFlush(ctx);
|
|
} else if (ctx->idleCallback) {
|
|
ctx->idleCallback(ctx->idleCtx);
|
|
} else {
|
|
__dpmi_yield();
|
|
}
|
|
|
|
// After compositing, release key-pressed button (one frame of animation)
|
|
if (sKeyPressedBtn) {
|
|
if (sKeyPressedBtn->type == WidgetImageButtonE) {
|
|
sKeyPressedBtn->as.imageButton.pressed = false;
|
|
} else {
|
|
sKeyPressedBtn->as.button.pressed = false;
|
|
}
|
|
|
|
if (sKeyPressedBtn->onClick) {
|
|
sKeyPressedBtn->onClick(sKeyPressedBtn);
|
|
}
|
|
|
|
wgtInvalidate(sKeyPressedBtn);
|
|
sKeyPressedBtn = NULL;
|
|
}
|
|
|
|
ctx->prevMouseX = ctx->mouseX;
|
|
ctx->prevMouseY = ctx->mouseY;
|
|
ctx->prevMouseButtons = ctx->mouseButtons;
|
|
|
|
return ctx->running;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxScreenshot
|
|
// ============================================================
|
|
//
|
|
// Save the entire screen (backbuffer) to a PNG file.
|
|
|
|
int32_t dvxScreenshot(AppContextT *ctx, const char *path) {
|
|
DisplayT *d = &ctx->display;
|
|
uint8_t *rgb = bufferToRgb(d, d->backBuf, d->width, d->height, d->pitch);
|
|
|
|
if (!rgb) {
|
|
return -1;
|
|
}
|
|
|
|
int32_t result = stbi_write_png(path, d->width, d->height, 3, rgb, d->width * 3) ? 0 : -1;
|
|
|
|
free(rgb);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxShutdown
|
|
// ============================================================
|
|
|
|
void dvxShutdown(AppContextT *ctx) {
|
|
// Destroy all remaining windows
|
|
while (ctx->stack.count > 0) {
|
|
wmDestroyWindow(&ctx->stack, ctx->stack.windows[ctx->stack.count - 1]);
|
|
}
|
|
|
|
videoShutdown(&ctx->display);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxSetTitle
|
|
// ============================================================
|
|
|
|
void dvxSetTitle(AppContextT *ctx, WindowT *win, const char *title) {
|
|
wmSetTitle(win, &ctx->dirty, title);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxSetWindowIcon
|
|
// ============================================================
|
|
|
|
int32_t dvxSetWindowIcon(AppContextT *ctx, WindowT *win, const char *path) {
|
|
return wmSetIcon(win, path, &ctx->display);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxWindowScreenshot
|
|
// ============================================================
|
|
//
|
|
// Save a window's content buffer to a PNG file. This captures the
|
|
// full content area regardless of whether the window is occluded.
|
|
|
|
int32_t dvxWindowScreenshot(AppContextT *ctx, WindowT *win, const char *path) {
|
|
if (!win || !win->contentBuf) {
|
|
return -1;
|
|
}
|
|
|
|
uint8_t *rgb = bufferToRgb(&ctx->display, win->contentBuf, win->contentW, win->contentH, win->contentPitch);
|
|
|
|
if (!rgb) {
|
|
return -1;
|
|
}
|
|
|
|
int32_t result = stbi_write_png(path, win->contentW, win->contentH, 3, rgb, win->contentW * 3) ? 0 : -1;
|
|
|
|
free(rgb);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxTileWindows
|
|
// ============================================================
|
|
//
|
|
// Tile all visible, non-minimized windows in a grid pattern.
|
|
// Columns = ceil(sqrt(count)), rows = ceil(count / cols).
|
|
// Last row may have fewer windows, which are widened to fill.
|
|
|
|
void dvxTileWindows(AppContextT *ctx) {
|
|
int32_t screenW = ctx->display.width;
|
|
int32_t screenH = ctx->display.height;
|
|
|
|
// Count eligible windows
|
|
int32_t count = 0;
|
|
|
|
for (int32_t i = 0; i < ctx->stack.count; i++) {
|
|
WindowT *win = ctx->stack.windows[i];
|
|
|
|
if (!win->minimized && win->visible) {
|
|
count++;
|
|
}
|
|
}
|
|
|
|
if (count == 0) {
|
|
return;
|
|
}
|
|
|
|
// Integer ceil(sqrt(count)) for column count
|
|
int32_t cols = 1;
|
|
|
|
while (cols * cols < count) {
|
|
cols++;
|
|
}
|
|
|
|
int32_t rows = (count + cols - 1) / cols;
|
|
int32_t tileW = screenW / cols;
|
|
int32_t tileH = screenH / rows;
|
|
|
|
if (tileW < MIN_WINDOW_W) {
|
|
tileW = MIN_WINDOW_W;
|
|
}
|
|
|
|
if (tileH < MIN_WINDOW_H) {
|
|
tileH = MIN_WINDOW_H;
|
|
}
|
|
|
|
int32_t slot = 0;
|
|
|
|
for (int32_t i = 0; i < ctx->stack.count; i++) {
|
|
WindowT *win = ctx->stack.windows[i];
|
|
|
|
if (win->minimized || !win->visible) {
|
|
continue;
|
|
}
|
|
|
|
if (win->maximized) {
|
|
win->maximized = false;
|
|
}
|
|
|
|
dirtyListAdd(&ctx->dirty, win->x, win->y, win->w, win->h);
|
|
|
|
int32_t row = slot / cols;
|
|
int32_t col = slot % cols;
|
|
|
|
// Last row: fewer windows get wider tiles
|
|
int32_t remaining = count - row * cols;
|
|
int32_t rowCols = (remaining < cols) ? remaining : cols;
|
|
int32_t cellW = screenW / rowCols;
|
|
|
|
win->x = col * cellW;
|
|
win->y = row * tileH;
|
|
win->w = cellW;
|
|
win->h = tileH;
|
|
|
|
wmUpdateContentRect(win);
|
|
wmReallocContentBuf(win, &ctx->display);
|
|
|
|
if (win->onResize) {
|
|
win->onResize(win, win->contentW, win->contentH);
|
|
}
|
|
|
|
if (win->onPaint) {
|
|
RectT fullRect = {0, 0, win->contentW, win->contentH};
|
|
win->onPaint(win, &fullRect);
|
|
win->contentDirty = true;
|
|
}
|
|
|
|
dirtyListAdd(&ctx->dirty, win->x, win->y, win->w, win->h);
|
|
|
|
slot++;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxTileWindowsH
|
|
// ============================================================
|
|
//
|
|
// Tile all visible, non-minimized windows horizontally:
|
|
// side by side left to right, each window gets full screen height.
|
|
|
|
void dvxTileWindowsH(AppContextT *ctx) {
|
|
int32_t screenW = ctx->display.width;
|
|
int32_t screenH = ctx->display.height;
|
|
|
|
// Count eligible windows
|
|
int32_t count = 0;
|
|
|
|
for (int32_t i = 0; i < ctx->stack.count; i++) {
|
|
WindowT *win = ctx->stack.windows[i];
|
|
|
|
if (!win->minimized && win->visible) {
|
|
count++;
|
|
}
|
|
}
|
|
|
|
if (count == 0) {
|
|
return;
|
|
}
|
|
|
|
int32_t tileW = screenW / count;
|
|
|
|
if (tileW < MIN_WINDOW_W) {
|
|
tileW = MIN_WINDOW_W;
|
|
}
|
|
|
|
int32_t slot = 0;
|
|
|
|
for (int32_t i = 0; i < ctx->stack.count; i++) {
|
|
WindowT *win = ctx->stack.windows[i];
|
|
|
|
if (win->minimized || !win->visible) {
|
|
continue;
|
|
}
|
|
|
|
if (win->maximized) {
|
|
win->maximized = false;
|
|
}
|
|
|
|
dirtyListAdd(&ctx->dirty, win->x, win->y, win->w, win->h);
|
|
|
|
win->x = slot * tileW;
|
|
win->y = 0;
|
|
win->w = tileW;
|
|
win->h = screenH;
|
|
|
|
wmUpdateContentRect(win);
|
|
wmReallocContentBuf(win, &ctx->display);
|
|
|
|
if (win->onResize) {
|
|
win->onResize(win, win->contentW, win->contentH);
|
|
}
|
|
|
|
if (win->onPaint) {
|
|
RectT fullRect = {0, 0, win->contentW, win->contentH};
|
|
win->onPaint(win, &fullRect);
|
|
win->contentDirty = true;
|
|
}
|
|
|
|
dirtyListAdd(&ctx->dirty, win->x, win->y, win->w, win->h);
|
|
|
|
slot++;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// dvxTileWindowsV
|
|
// ============================================================
|
|
//
|
|
// Tile all visible, non-minimized windows vertically:
|
|
// stacked top to bottom, each window gets full screen width.
|
|
|
|
void dvxTileWindowsV(AppContextT *ctx) {
|
|
int32_t screenW = ctx->display.width;
|
|
int32_t screenH = ctx->display.height;
|
|
|
|
// Count eligible windows
|
|
int32_t count = 0;
|
|
|
|
for (int32_t i = 0; i < ctx->stack.count; i++) {
|
|
WindowT *win = ctx->stack.windows[i];
|
|
|
|
if (!win->minimized && win->visible) {
|
|
count++;
|
|
}
|
|
}
|
|
|
|
if (count == 0) {
|
|
return;
|
|
}
|
|
|
|
int32_t tileH = screenH / count;
|
|
|
|
if (tileH < MIN_WINDOW_H) {
|
|
tileH = MIN_WINDOW_H;
|
|
}
|
|
|
|
int32_t slot = 0;
|
|
|
|
for (int32_t i = 0; i < ctx->stack.count; i++) {
|
|
WindowT *win = ctx->stack.windows[i];
|
|
|
|
if (win->minimized || !win->visible) {
|
|
continue;
|
|
}
|
|
|
|
if (win->maximized) {
|
|
win->maximized = false;
|
|
}
|
|
|
|
dirtyListAdd(&ctx->dirty, win->x, win->y, win->w, win->h);
|
|
|
|
win->x = 0;
|
|
win->y = slot * tileH;
|
|
win->w = screenW;
|
|
win->h = tileH;
|
|
|
|
wmUpdateContentRect(win);
|
|
wmReallocContentBuf(win, &ctx->display);
|
|
|
|
if (win->onResize) {
|
|
win->onResize(win, win->contentW, win->contentH);
|
|
}
|
|
|
|
if (win->onPaint) {
|
|
RectT fullRect = {0, 0, win->contentW, win->contentH};
|
|
win->onPaint(win, &fullRect);
|
|
win->contentDirty = true;
|
|
}
|
|
|
|
dirtyListAdd(&ctx->dirty, win->x, win->y, win->w, win->h);
|
|
|
|
slot++;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// executeSysMenuCmd
|
|
// ============================================================
|
|
|
|
static void executeSysMenuCmd(AppContextT *ctx, int32_t cmd) {
|
|
WindowT *win = findWindowById(ctx, ctx->sysMenu.windowId);
|
|
|
|
closeSysMenu(ctx);
|
|
|
|
if (!win) {
|
|
return;
|
|
}
|
|
|
|
switch (cmd) {
|
|
case SysMenuRestoreE:
|
|
if (win->maximized) {
|
|
wmRestore(&ctx->stack, &ctx->dirty, &ctx->display, win);
|
|
}
|
|
break;
|
|
|
|
case SysMenuMoveE:
|
|
ctx->kbMoveResize.mode = KbModeMoveE;
|
|
ctx->kbMoveResize.windowId = win->id;
|
|
ctx->kbMoveResize.origX = win->x;
|
|
ctx->kbMoveResize.origY = win->y;
|
|
break;
|
|
|
|
case SysMenuSizeE:
|
|
ctx->kbMoveResize.mode = KbModeResizeE;
|
|
ctx->kbMoveResize.windowId = win->id;
|
|
ctx->kbMoveResize.origX = win->x;
|
|
ctx->kbMoveResize.origY = win->y;
|
|
ctx->kbMoveResize.origW = win->w;
|
|
ctx->kbMoveResize.origH = win->h;
|
|
break;
|
|
|
|
case SysMenuMinimizeE:
|
|
if (ctx->modalWindow != win) {
|
|
wmMinimize(&ctx->stack, &ctx->dirty, win);
|
|
dirtyListAdd(&ctx->dirty, 0, ctx->display.height - ICON_TOTAL_SIZE - ICON_SPACING, ctx->display.width, ICON_TOTAL_SIZE + ICON_SPACING);
|
|
}
|
|
break;
|
|
|
|
case SysMenuMaximizeE:
|
|
if (win->resizable && !win->maximized) {
|
|
wmMaximize(&ctx->stack, &ctx->dirty, &ctx->display, win);
|
|
}
|
|
break;
|
|
|
|
case SysMenuCloseE:
|
|
if (win->onClose) {
|
|
win->onClose(win);
|
|
} else {
|
|
dvxDestroyWindow(ctx, win);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// findWindowById
|
|
// ============================================================
|
|
|
|
static WindowT *findWindowById(AppContextT *ctx, int32_t id) {
|
|
for (int32_t i = 0; i < ctx->stack.count; i++) {
|
|
if (ctx->stack.windows[i]->id == id) {
|
|
return ctx->stack.windows[i];
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// handleMouseButton
|
|
// ============================================================
|
|
|
|
static void handleMouseButton(AppContextT *ctx, int32_t mx, int32_t my, int32_t buttons) {
|
|
// Modal window gating: only the modal window receives clicks
|
|
if (ctx->modalWindow) {
|
|
int32_t hitPart;
|
|
int32_t hitIdx = wmHitTest(&ctx->stack, mx, my, &hitPart);
|
|
|
|
if (hitIdx >= 0 && ctx->stack.windows[hitIdx] != ctx->modalWindow) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Check for click on minimized icon first
|
|
int32_t iconIdx = wmMinimizedIconHit(&ctx->stack, &ctx->display, mx, my);
|
|
|
|
if (iconIdx >= 0) {
|
|
WindowT *iconWin = ctx->stack.windows[iconIdx];
|
|
clock_t now = clock();
|
|
|
|
if (ctx->lastIconClickId == iconWin->id &&
|
|
(now - ctx->lastIconClickTime) < DBLCLICK_THRESHOLD) {
|
|
// Double-click: restore minimized window
|
|
// Dirty the entire icon strip area
|
|
dirtyListAdd(&ctx->dirty, 0,
|
|
ctx->display.height - ICON_TOTAL_SIZE - ICON_SPACING,
|
|
ctx->display.width, ICON_TOTAL_SIZE + ICON_SPACING);
|
|
wmRestoreMinimized(&ctx->stack, &ctx->dirty, iconWin);
|
|
ctx->lastIconClickId = -1;
|
|
} else {
|
|
// First click — record for double-click detection
|
|
ctx->lastIconClickTime = now;
|
|
ctx->lastIconClickId = iconWin->id;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
int32_t hitPart;
|
|
int32_t hitIdx = wmHitTest(&ctx->stack, mx, my, &hitPart);
|
|
|
|
if (hitIdx < 0) {
|
|
return; // clicked on desktop
|
|
}
|
|
|
|
WindowT *win = ctx->stack.windows[hitIdx];
|
|
|
|
// Raise and focus if not already
|
|
if (hitIdx != ctx->stack.focusedIdx) {
|
|
wmRaiseWindow(&ctx->stack, &ctx->dirty, hitIdx);
|
|
// After raise, the window is now at count-1
|
|
hitIdx = ctx->stack.count - 1;
|
|
wmSetFocus(&ctx->stack, &ctx->dirty, hitIdx);
|
|
}
|
|
|
|
switch (hitPart) {
|
|
case 0: // content
|
|
if (win->onMouse) {
|
|
int32_t relX = mx - win->x - win->contentX;
|
|
int32_t relY = my - win->y - win->contentY;
|
|
win->onMouse(win, relX, relY, buttons);
|
|
}
|
|
break;
|
|
|
|
case 1: // title bar — start drag
|
|
wmDragBegin(&ctx->stack, hitIdx, mx, my);
|
|
break;
|
|
|
|
case 2: // close button (double-click to close, single-click opens system menu)
|
|
{
|
|
clock_t now = clock();
|
|
|
|
if (ctx->lastCloseClickId == win->id &&
|
|
(now - ctx->lastCloseClickTime) < DBLCLICK_THRESHOLD) {
|
|
ctx->lastCloseClickId = -1;
|
|
closeSysMenu(ctx);
|
|
|
|
if (win->onClose) {
|
|
win->onClose(win);
|
|
} else {
|
|
dvxDestroyWindow(ctx, win);
|
|
}
|
|
} else {
|
|
ctx->lastCloseClickTime = now;
|
|
ctx->lastCloseClickId = win->id;
|
|
openSysMenu(ctx, win);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 3: // resize edge
|
|
{
|
|
int32_t edge = wmResizeEdgeHit(win, mx, my);
|
|
wmResizeBegin(&ctx->stack, hitIdx, edge, mx, my);
|
|
}
|
|
break;
|
|
|
|
case 4: // menu bar
|
|
{
|
|
if (!win->menuBar) {
|
|
break;
|
|
}
|
|
|
|
int32_t relX = mx - win->x;
|
|
|
|
for (int32_t i = 0; i < win->menuBar->menuCount; i++) {
|
|
MenuT *menu = &win->menuBar->menus[i];
|
|
|
|
if (relX >= menu->barX && relX < menu->barX + menu->barW) {
|
|
openPopupAtMenu(ctx, win, i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 5: // vertical scrollbar
|
|
wmScrollbarClick(&ctx->stack, &ctx->dirty, hitIdx, 0, mx, my);
|
|
break;
|
|
|
|
case 6: // horizontal scrollbar
|
|
wmScrollbarClick(&ctx->stack, &ctx->dirty, hitIdx, 1, mx, my);
|
|
break;
|
|
|
|
case 7: // minimize (not allowed for modal windows)
|
|
if (ctx->modalWindow != win) {
|
|
wmMinimize(&ctx->stack, &ctx->dirty, win);
|
|
// Dirty the icon strip area so the new icon gets drawn
|
|
dirtyListAdd(&ctx->dirty, 0,
|
|
ctx->display.height - ICON_TOTAL_SIZE - ICON_SPACING,
|
|
ctx->display.width, ICON_TOTAL_SIZE + ICON_SPACING);
|
|
}
|
|
break;
|
|
|
|
case 8: // maximize / restore
|
|
if (win->maximized) {
|
|
wmRestore(&ctx->stack, &ctx->dirty, &ctx->display, win);
|
|
} else {
|
|
wmMaximize(&ctx->stack, &ctx->dirty, &ctx->display, win);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// initColorScheme
|
|
// ============================================================
|
|
|
|
static void initColorScheme(AppContextT *ctx) {
|
|
DisplayT *d = &ctx->display;
|
|
|
|
// GEOS Ensemble Motif-style color scheme
|
|
ctx->colors.desktop = packColor(d, 0, 128, 128); // GEOS teal desktop
|
|
ctx->colors.windowFace = packColor(d, 192, 192, 192); // standard Motif grey
|
|
ctx->colors.windowHighlight = packColor(d, 255, 255, 255);
|
|
ctx->colors.windowShadow = packColor(d, 128, 128, 128);
|
|
ctx->colors.activeTitleBg = packColor(d, 48, 48, 48); // GEOS dark charcoal
|
|
ctx->colors.activeTitleFg = packColor(d, 255, 255, 255);
|
|
ctx->colors.inactiveTitleBg = packColor(d, 160, 160, 160); // lighter grey
|
|
ctx->colors.inactiveTitleFg = packColor(d, 64, 64, 64);
|
|
ctx->colors.contentBg = packColor(d, 192, 192, 192);
|
|
ctx->colors.contentFg = packColor(d, 0, 0, 0);
|
|
ctx->colors.menuBg = packColor(d, 192, 192, 192);
|
|
ctx->colors.menuFg = packColor(d, 0, 0, 0);
|
|
ctx->colors.menuHighlightBg = packColor(d, 48, 48, 48);
|
|
ctx->colors.menuHighlightFg = packColor(d, 255, 255, 255);
|
|
ctx->colors.buttonFace = packColor(d, 192, 192, 192);
|
|
ctx->colors.scrollbarBg = packColor(d, 192, 192, 192);
|
|
ctx->colors.scrollbarFg = packColor(d, 128, 128, 128);
|
|
ctx->colors.scrollbarTrough = packColor(d, 160, 160, 160); // GEOS lighter trough
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// initMouse
|
|
// ============================================================
|
|
|
|
static void initMouse(AppContextT *ctx) {
|
|
__dpmi_regs r;
|
|
|
|
// Reset mouse driver
|
|
memset(&r, 0, sizeof(r));
|
|
r.x.ax = 0x0000;
|
|
__dpmi_int(0x33, &r);
|
|
|
|
// Set horizontal range to match screen width
|
|
memset(&r, 0, sizeof(r));
|
|
r.x.ax = 0x0007;
|
|
r.x.cx = 0;
|
|
r.x.dx = ctx->display.width - 1;
|
|
__dpmi_int(0x33, &r);
|
|
|
|
// Set vertical range to match screen height
|
|
memset(&r, 0, sizeof(r));
|
|
r.x.ax = 0x0008;
|
|
r.x.cx = 0;
|
|
r.x.dx = ctx->display.height - 1;
|
|
__dpmi_int(0x33, &r);
|
|
|
|
// Position cursor at center of screen
|
|
ctx->mouseX = ctx->display.width / 2;
|
|
ctx->mouseY = ctx->display.height / 2;
|
|
ctx->prevMouseX = ctx->mouseX;
|
|
ctx->prevMouseY = ctx->mouseY;
|
|
|
|
// Set mouse position
|
|
memset(&r, 0, sizeof(r));
|
|
r.x.ax = 0x0004;
|
|
r.x.cx = ctx->mouseX;
|
|
r.x.dx = ctx->mouseY;
|
|
__dpmi_int(0x33, &r);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// openContextMenu — open a context menu at a screen position
|
|
// ============================================================
|
|
|
|
static void openContextMenu(AppContextT *ctx, WindowT *win, MenuT *menu, int32_t screenX, int32_t screenY) {
|
|
if (!menu || menu->itemCount <= 0) {
|
|
return;
|
|
}
|
|
|
|
closeAllPopups(ctx);
|
|
closeSysMenu(ctx);
|
|
|
|
ctx->popup.active = true;
|
|
ctx->popup.isContextMenu = true;
|
|
ctx->popup.windowId = win->id;
|
|
ctx->popup.menuIdx = -1;
|
|
ctx->popup.menu = menu;
|
|
ctx->popup.hoverItem = -1;
|
|
ctx->popup.depth = 0;
|
|
|
|
calcPopupSize(ctx, menu, &ctx->popup.popupW, &ctx->popup.popupH);
|
|
|
|
// Position at mouse, clamped to screen
|
|
ctx->popup.popupX = screenX;
|
|
ctx->popup.popupY = screenY;
|
|
|
|
if (ctx->popup.popupX + ctx->popup.popupW > ctx->display.width) {
|
|
ctx->popup.popupX = ctx->display.width - ctx->popup.popupW;
|
|
}
|
|
|
|
if (ctx->popup.popupY + ctx->popup.popupH > ctx->display.height) {
|
|
ctx->popup.popupY = ctx->display.height - ctx->popup.popupH;
|
|
}
|
|
|
|
dirtyListAdd(&ctx->dirty, ctx->popup.popupX, ctx->popup.popupY,
|
|
ctx->popup.popupW, ctx->popup.popupH);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// openPopupAtMenu — open top-level popup for a menu bar menu
|
|
// ============================================================
|
|
|
|
static void openPopupAtMenu(AppContextT *ctx, WindowT *win, int32_t menuIdx) {
|
|
if (!win->menuBar || menuIdx < 0 || menuIdx >= win->menuBar->menuCount) {
|
|
return;
|
|
}
|
|
|
|
// Close any existing popup chain first
|
|
closeAllPopups(ctx);
|
|
|
|
MenuT *menu = &win->menuBar->menus[menuIdx];
|
|
|
|
ctx->popup.active = true;
|
|
ctx->popup.isContextMenu = false;
|
|
ctx->popup.windowId = win->id;
|
|
ctx->popup.menuIdx = menuIdx;
|
|
ctx->popup.menu = menu;
|
|
ctx->popup.popupX = win->x + menu->barX;
|
|
ctx->popup.popupY = win->y + CHROME_BORDER_WIDTH + CHROME_TITLE_HEIGHT + CHROME_MENU_HEIGHT;
|
|
ctx->popup.hoverItem = -1;
|
|
ctx->popup.depth = 0;
|
|
|
|
calcPopupSize(ctx, menu, &ctx->popup.popupW, &ctx->popup.popupH);
|
|
|
|
dirtyListAdd(&ctx->dirty, ctx->popup.popupX, ctx->popup.popupY,
|
|
ctx->popup.popupW, ctx->popup.popupH);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// openSubMenu — open submenu for the currently hovered item
|
|
// ============================================================
|
|
|
|
static void openSubMenu(AppContextT *ctx) {
|
|
if (!ctx->popup.active || !ctx->popup.menu) {
|
|
return;
|
|
}
|
|
|
|
int32_t idx = ctx->popup.hoverItem;
|
|
|
|
if (idx < 0 || idx >= ctx->popup.menu->itemCount) {
|
|
return;
|
|
}
|
|
|
|
MenuItemT *item = &ctx->popup.menu->items[idx];
|
|
|
|
if (!item->subMenu) {
|
|
return;
|
|
}
|
|
|
|
if (ctx->popup.depth >= MAX_SUBMENU_DEPTH) {
|
|
return;
|
|
}
|
|
|
|
// Push current state to parent stack
|
|
PopupLevelT *pl = &ctx->popup.parentStack[ctx->popup.depth];
|
|
pl->menu = ctx->popup.menu;
|
|
pl->menuIdx = ctx->popup.menuIdx;
|
|
pl->popupX = ctx->popup.popupX;
|
|
pl->popupY = ctx->popup.popupY;
|
|
pl->popupW = ctx->popup.popupW;
|
|
pl->popupH = ctx->popup.popupH;
|
|
pl->hoverItem = ctx->popup.hoverItem;
|
|
ctx->popup.depth++;
|
|
|
|
// Open submenu at right edge of current popup, aligned with hovered item
|
|
ctx->popup.menu = item->subMenu;
|
|
ctx->popup.popupX = pl->popupX + pl->popupW - 2;
|
|
ctx->popup.popupY = pl->popupY + 2 + idx * ctx->font.charHeight;
|
|
ctx->popup.hoverItem = -1;
|
|
|
|
calcPopupSize(ctx, ctx->popup.menu, &ctx->popup.popupW, &ctx->popup.popupH);
|
|
|
|
dirtyListAdd(&ctx->dirty, ctx->popup.popupX, ctx->popup.popupY,
|
|
ctx->popup.popupW, ctx->popup.popupH);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// openSysMenu
|
|
// ============================================================
|
|
|
|
static void openSysMenu(AppContextT *ctx, WindowT *win) {
|
|
// Close any existing popup menus first
|
|
closeAllPopups(ctx);
|
|
|
|
if (ctx->sysMenu.active) {
|
|
closeSysMenu(ctx);
|
|
return;
|
|
}
|
|
|
|
ctx->sysMenu.itemCount = 0;
|
|
ctx->sysMenu.windowId = win->id;
|
|
|
|
// Restore — enabled only when maximized
|
|
SysMenuItemT *item = &ctx->sysMenu.items[ctx->sysMenu.itemCount++];
|
|
strncpy(item->label, "&Restore", MAX_MENU_LABEL - 1);
|
|
item->cmd = SysMenuRestoreE;
|
|
item->separator = false;
|
|
item->enabled = win->maximized;
|
|
item->accelKey = accelParse(item->label);
|
|
|
|
// Move — disabled when maximized
|
|
item = &ctx->sysMenu.items[ctx->sysMenu.itemCount++];
|
|
strncpy(item->label, "&Move", MAX_MENU_LABEL - 1);
|
|
item->cmd = SysMenuMoveE;
|
|
item->separator = false;
|
|
item->enabled = !win->maximized;
|
|
item->accelKey = accelParse(item->label);
|
|
|
|
// Size — only if resizable and not maximized
|
|
item = &ctx->sysMenu.items[ctx->sysMenu.itemCount++];
|
|
strncpy(item->label, "&Size", MAX_MENU_LABEL - 1);
|
|
item->cmd = SysMenuSizeE;
|
|
item->separator = false;
|
|
item->enabled = win->resizable && !win->maximized;
|
|
item->accelKey = accelParse(item->label);
|
|
|
|
// Minimize — not available on modal windows
|
|
item = &ctx->sysMenu.items[ctx->sysMenu.itemCount++];
|
|
strncpy(item->label, "Mi&nimize", MAX_MENU_LABEL - 1);
|
|
item->cmd = SysMenuMinimizeE;
|
|
item->separator = false;
|
|
item->enabled = !win->modal;
|
|
item->accelKey = accelParse(item->label);
|
|
|
|
// Maximize — only if resizable and not maximized
|
|
item = &ctx->sysMenu.items[ctx->sysMenu.itemCount++];
|
|
strncpy(item->label, "Ma&ximize", MAX_MENU_LABEL - 1);
|
|
item->cmd = SysMenuMaximizeE;
|
|
item->separator = false;
|
|
item->enabled = win->resizable && !win->maximized;
|
|
item->accelKey = accelParse(item->label);
|
|
|
|
// Separator
|
|
item = &ctx->sysMenu.items[ctx->sysMenu.itemCount++];
|
|
memset(item, 0, sizeof(*item));
|
|
item->separator = true;
|
|
|
|
// Close
|
|
item = &ctx->sysMenu.items[ctx->sysMenu.itemCount++];
|
|
strncpy(item->label, "&Close", MAX_MENU_LABEL - 1);
|
|
item->cmd = SysMenuCloseE;
|
|
item->separator = false;
|
|
item->enabled = true;
|
|
item->accelKey = accelParse(item->label);
|
|
|
|
// Compute popup geometry — position below the close gadget
|
|
ctx->sysMenu.popupX = win->x + CHROME_BORDER_WIDTH;
|
|
ctx->sysMenu.popupY = win->y + CHROME_BORDER_WIDTH + CHROME_TITLE_HEIGHT;
|
|
|
|
if (win->menuBar) {
|
|
ctx->sysMenu.popupY += CHROME_MENU_HEIGHT;
|
|
}
|
|
|
|
int32_t maxW = 0;
|
|
|
|
for (int32_t i = 0; i < ctx->sysMenu.itemCount; i++) {
|
|
if (!ctx->sysMenu.items[i].separator) {
|
|
int32_t w = textWidthAccel(&ctx->font, ctx->sysMenu.items[i].label);
|
|
|
|
if (w > maxW) {
|
|
maxW = w;
|
|
}
|
|
}
|
|
}
|
|
|
|
ctx->sysMenu.popupW = maxW + CHROME_TITLE_PAD * 2 + 8;
|
|
ctx->sysMenu.popupH = ctx->sysMenu.itemCount * ctx->font.charHeight + 4;
|
|
ctx->sysMenu.hoverItem = -1;
|
|
ctx->sysMenu.active = true;
|
|
|
|
dirtyListAdd(&ctx->dirty, ctx->sysMenu.popupX, ctx->sysMenu.popupY, ctx->sysMenu.popupW, ctx->sysMenu.popupH);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// pollAnsiTermWidgets — poll and repaint all ANSI term widgets
|
|
// ============================================================
|
|
|
|
static void pollAnsiTermWidgets(AppContextT *ctx) {
|
|
for (int32_t i = 0; i < ctx->stack.count; i++) {
|
|
WindowT *win = ctx->stack.windows[i];
|
|
|
|
if (win->widgetRoot) {
|
|
pollAnsiTermWidgetsWalk(ctx, win->widgetRoot, win);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// pollAnsiTermWidgetsWalk — recursive helper
|
|
// ============================================================
|
|
|
|
static void pollAnsiTermWidgetsWalk(AppContextT *ctx, WidgetT *w, WindowT *win) {
|
|
if (w->type == WidgetAnsiTermE) {
|
|
wgtAnsiTermPoll(w);
|
|
|
|
int32_t dirtyY = 0;
|
|
int32_t dirtyH = 0;
|
|
|
|
if (wgtAnsiTermRepaint(w, &dirtyY, &dirtyH) > 0) {
|
|
win->contentDirty = true;
|
|
|
|
// Dirty only the affected rows (in screen coords) instead of
|
|
// the entire window. This dramatically reduces compositor and
|
|
// LFB flush work for cursor blink and single-row updates.
|
|
int32_t scrollY = win->vScroll ? win->vScroll->value : 0;
|
|
int32_t rectX = win->x + win->contentX;
|
|
int32_t rectY = win->y + win->contentY + dirtyY - scrollY;
|
|
int32_t rectW = win->contentW;
|
|
dirtyListAdd(&ctx->dirty, rectX, rectY, rectW, dirtyH);
|
|
}
|
|
}
|
|
|
|
for (WidgetT *child = w->firstChild; child; child = child->nextSibling) {
|
|
pollAnsiTermWidgetsWalk(ctx, child, win);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// pollKeyboard
|
|
// ============================================================
|
|
|
|
static void pollKeyboard(AppContextT *ctx) {
|
|
__dpmi_regs r;
|
|
|
|
// Read shift state once per poll (INT 16h, AH=12h)
|
|
memset(&r, 0, sizeof(r));
|
|
r.x.ax = 0x1200;
|
|
__dpmi_int(0x16, &r);
|
|
int32_t shiftFlags = r.x.ax & 0xFF;
|
|
ctx->keyModifiers = shiftFlags;
|
|
bool shiftHeld = (shiftFlags & 0x03) != 0; // left or right shift
|
|
|
|
// Process buffered keys
|
|
while (1) {
|
|
// Check if key is available (INT 16h, enhanced function 11h)
|
|
r.x.ax = 0x1100;
|
|
__dpmi_int(0x16, &r);
|
|
|
|
// Zero flag set = no key available
|
|
if (r.x.flags & 0x40) {
|
|
break;
|
|
}
|
|
|
|
// Read the key (INT 16h, enhanced function 10h)
|
|
r.x.ax = 0x1000;
|
|
__dpmi_int(0x16, &r);
|
|
|
|
int32_t scancode = (r.x.ax >> 8) & 0xFF;
|
|
int32_t ascii = r.x.ax & 0xFF;
|
|
|
|
// Enhanced INT 16h returns ascii=0xE0 for grey/extended keys
|
|
// (arrows, Home, End, Insert, Delete, etc. on 101-key keyboards).
|
|
// Normalize to 0 so all extended key checks work uniformly.
|
|
if (ascii == 0xE0) {
|
|
ascii = 0;
|
|
}
|
|
|
|
// Alt+Tab / Shift+Alt+Tab — cycle windows
|
|
// Alt+Tab: scancode=0xA5, ascii=0x00
|
|
if (ascii == 0 && scancode == 0xA5) {
|
|
if (ctx->stack.count > 1) {
|
|
if (shiftHeld) {
|
|
// Shift+Alt+Tab — focus the bottom window, raise it
|
|
wmRaiseWindow(&ctx->stack, &ctx->dirty, 0);
|
|
wmSetFocus(&ctx->stack, &ctx->dirty, ctx->stack.count - 1);
|
|
} else {
|
|
// Alt+Tab — send top window to bottom, focus new top
|
|
WindowT *top = ctx->stack.windows[ctx->stack.count - 1];
|
|
dirtyListAdd(&ctx->dirty, top->x, top->y, top->w, top->h);
|
|
|
|
// Shift all windows up
|
|
for (int32_t i = ctx->stack.count - 1; i > 0; i--) {
|
|
ctx->stack.windows[i] = ctx->stack.windows[i - 1];
|
|
}
|
|
|
|
ctx->stack.windows[0] = top;
|
|
top->focused = false;
|
|
|
|
// Focus the new top window
|
|
wmSetFocus(&ctx->stack, &ctx->dirty, ctx->stack.count - 1);
|
|
dirtyListAdd(&ctx->dirty, ctx->stack.windows[ctx->stack.count - 1]->x,
|
|
ctx->stack.windows[ctx->stack.count - 1]->y,
|
|
ctx->stack.windows[ctx->stack.count - 1]->w,
|
|
ctx->stack.windows[ctx->stack.count - 1]->h);
|
|
}
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// Alt+F4 — close focused window
|
|
if (ascii == 0 && scancode == 0x6B) {
|
|
if (ctx->stack.focusedIdx >= 0) {
|
|
WindowT *win = ctx->stack.windows[ctx->stack.focusedIdx];
|
|
|
|
if (win->onClose) {
|
|
win->onClose(win);
|
|
}
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// F10 — activate menu bar
|
|
if (ascii == 0 && scancode == 0x44) {
|
|
if (ctx->stack.focusedIdx >= 0) {
|
|
WindowT *win = ctx->stack.windows[ctx->stack.focusedIdx];
|
|
|
|
if (win->menuBar && win->menuBar->menuCount > 0) {
|
|
if (ctx->popup.active) {
|
|
closeAllPopups(ctx);
|
|
} else {
|
|
dispatchAccelKey(ctx, win->menuBar->menus[0].accelKey);
|
|
}
|
|
}
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// Keyboard move/resize mode — intercept all keys
|
|
if (ctx->kbMoveResize.mode != KbModeNoneE) {
|
|
WindowT *kbWin = findWindowById(ctx, ctx->kbMoveResize.windowId);
|
|
|
|
if (!kbWin) {
|
|
ctx->kbMoveResize.mode = KbModeNoneE;
|
|
continue;
|
|
}
|
|
|
|
if (ascii == 0x1B) {
|
|
// Cancel — restore original position/size
|
|
dirtyListAdd(&ctx->dirty, kbWin->x, kbWin->y, kbWin->w, kbWin->h);
|
|
kbWin->x = ctx->kbMoveResize.origX;
|
|
kbWin->y = ctx->kbMoveResize.origY;
|
|
|
|
if (ctx->kbMoveResize.mode == KbModeResizeE) {
|
|
kbWin->w = ctx->kbMoveResize.origW;
|
|
kbWin->h = ctx->kbMoveResize.origH;
|
|
wmUpdateContentRect(kbWin);
|
|
wmReallocContentBuf(kbWin, &ctx->display);
|
|
|
|
if (kbWin->onResize) {
|
|
kbWin->onResize(kbWin, kbWin->contentW, kbWin->contentH);
|
|
}
|
|
|
|
if (kbWin->onPaint) {
|
|
kbWin->onPaint(kbWin, NULL);
|
|
}
|
|
}
|
|
|
|
dirtyListAdd(&ctx->dirty, kbWin->x, kbWin->y, kbWin->w, kbWin->h);
|
|
ctx->kbMoveResize.mode = KbModeNoneE;
|
|
continue;
|
|
}
|
|
|
|
if (ascii == 0x0D) {
|
|
// Confirm
|
|
ctx->kbMoveResize.mode = KbModeNoneE;
|
|
continue;
|
|
}
|
|
|
|
if (ctx->kbMoveResize.mode == KbModeMoveE) {
|
|
if (ascii == 0 && scancode == 0x48) {
|
|
dirtyListAdd(&ctx->dirty, kbWin->x, kbWin->y, kbWin->w, kbWin->h);
|
|
kbWin->y -= KB_MOVE_STEP;
|
|
dirtyListAdd(&ctx->dirty, kbWin->x, kbWin->y, kbWin->w, kbWin->h);
|
|
} else if (ascii == 0 && scancode == 0x50) {
|
|
dirtyListAdd(&ctx->dirty, kbWin->x, kbWin->y, kbWin->w, kbWin->h);
|
|
kbWin->y += KB_MOVE_STEP;
|
|
dirtyListAdd(&ctx->dirty, kbWin->x, kbWin->y, kbWin->w, kbWin->h);
|
|
} else if (ascii == 0 && scancode == 0x4B) {
|
|
dirtyListAdd(&ctx->dirty, kbWin->x, kbWin->y, kbWin->w, kbWin->h);
|
|
kbWin->x -= KB_MOVE_STEP;
|
|
dirtyListAdd(&ctx->dirty, kbWin->x, kbWin->y, kbWin->w, kbWin->h);
|
|
} else if (ascii == 0 && scancode == 0x4D) {
|
|
dirtyListAdd(&ctx->dirty, kbWin->x, kbWin->y, kbWin->w, kbWin->h);
|
|
kbWin->x += KB_MOVE_STEP;
|
|
dirtyListAdd(&ctx->dirty, kbWin->x, kbWin->y, kbWin->w, kbWin->h);
|
|
}
|
|
} else {
|
|
// KbModeResizeE
|
|
int32_t newW = kbWin->w;
|
|
int32_t newH = kbWin->h;
|
|
|
|
if (ascii == 0 && scancode == 0x4D) {
|
|
newW += KB_MOVE_STEP;
|
|
} else if (ascii == 0 && scancode == 0x4B) {
|
|
newW -= KB_MOVE_STEP;
|
|
} else if (ascii == 0 && scancode == 0x50) {
|
|
newH += KB_MOVE_STEP;
|
|
} else if (ascii == 0 && scancode == 0x48) {
|
|
newH -= KB_MOVE_STEP;
|
|
}
|
|
|
|
if (newW < MIN_WINDOW_W) {
|
|
newW = MIN_WINDOW_W;
|
|
}
|
|
|
|
if (newH < MIN_WINDOW_H) {
|
|
newH = MIN_WINDOW_H;
|
|
}
|
|
|
|
if (kbWin->maxW > 0 && newW > kbWin->maxW) {
|
|
newW = kbWin->maxW;
|
|
}
|
|
|
|
if (kbWin->maxH > 0 && newH > kbWin->maxH) {
|
|
newH = kbWin->maxH;
|
|
}
|
|
|
|
if (newW != kbWin->w || newH != kbWin->h) {
|
|
dirtyListAdd(&ctx->dirty, kbWin->x, kbWin->y, kbWin->w, kbWin->h);
|
|
kbWin->w = newW;
|
|
kbWin->h = newH;
|
|
wmUpdateContentRect(kbWin);
|
|
wmReallocContentBuf(kbWin, &ctx->display);
|
|
|
|
if (kbWin->onResize) {
|
|
kbWin->onResize(kbWin, kbWin->contentW, kbWin->contentH);
|
|
}
|
|
|
|
if (kbWin->onPaint) {
|
|
kbWin->onPaint(kbWin, NULL);
|
|
}
|
|
|
|
dirtyListAdd(&ctx->dirty, kbWin->x, kbWin->y, kbWin->w, kbWin->h);
|
|
}
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// Alt+Space — open/close system menu
|
|
// Enhanced INT 16h: Alt+Space returns scancode 0x02, ascii 0x20
|
|
if (scancode == 0x02 && ascii == 0x20) {
|
|
if (ctx->sysMenu.active) {
|
|
closeSysMenu(ctx);
|
|
} else if (ctx->stack.focusedIdx >= 0) {
|
|
WindowT *win = ctx->stack.windows[ctx->stack.focusedIdx];
|
|
openSysMenu(ctx, win);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// System menu keyboard navigation
|
|
if (ctx->sysMenu.active) {
|
|
// Alt+key — close system menu and let it fall through to accel dispatch
|
|
if (ascii == 0 && scancode < 256 && sAltScanToAscii[scancode]) {
|
|
closeSysMenu(ctx);
|
|
// Fall through to dispatchAccelKey below
|
|
} else if (ascii == 0x1B) {
|
|
closeSysMenu(ctx);
|
|
continue;
|
|
} else if (ascii == 0 && scancode == 0x48) {
|
|
// Up arrow
|
|
int32_t idx = ctx->sysMenu.hoverItem;
|
|
|
|
for (int32_t tries = 0; tries < ctx->sysMenu.itemCount; tries++) {
|
|
idx--;
|
|
|
|
if (idx < 0) {
|
|
idx = ctx->sysMenu.itemCount - 1;
|
|
}
|
|
|
|
if (!ctx->sysMenu.items[idx].separator) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
ctx->sysMenu.hoverItem = idx;
|
|
dirtyListAdd(&ctx->dirty, ctx->sysMenu.popupX, ctx->sysMenu.popupY, ctx->sysMenu.popupW, ctx->sysMenu.popupH);
|
|
continue;
|
|
} else if (ascii == 0 && scancode == 0x50) {
|
|
// Down arrow
|
|
int32_t idx = ctx->sysMenu.hoverItem;
|
|
|
|
for (int32_t tries = 0; tries < ctx->sysMenu.itemCount; tries++) {
|
|
idx++;
|
|
|
|
if (idx >= ctx->sysMenu.itemCount) {
|
|
idx = 0;
|
|
}
|
|
|
|
if (!ctx->sysMenu.items[idx].separator) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
ctx->sysMenu.hoverItem = idx;
|
|
dirtyListAdd(&ctx->dirty, ctx->sysMenu.popupX, ctx->sysMenu.popupY, ctx->sysMenu.popupW, ctx->sysMenu.popupH);
|
|
continue;
|
|
} else if (ascii == 0x0D) {
|
|
// Enter — execute selected item
|
|
if (ctx->sysMenu.hoverItem >= 0 && ctx->sysMenu.hoverItem < ctx->sysMenu.itemCount) {
|
|
SysMenuItemT *item = &ctx->sysMenu.items[ctx->sysMenu.hoverItem];
|
|
|
|
if (item->enabled && !item->separator) {
|
|
executeSysMenuCmd(ctx, item->cmd);
|
|
}
|
|
} else {
|
|
closeSysMenu(ctx);
|
|
}
|
|
continue;
|
|
} else if (ascii != 0) {
|
|
// Accelerator key match
|
|
char lc = (char)tolower(ascii);
|
|
|
|
for (int32_t k = 0; k < ctx->sysMenu.itemCount; k++) {
|
|
if (ctx->sysMenu.items[k].accelKey == lc && ctx->sysMenu.items[k].enabled && !ctx->sysMenu.items[k].separator) {
|
|
executeSysMenuCmd(ctx, ctx->sysMenu.items[k].cmd);
|
|
goto nextKey;
|
|
}
|
|
}
|
|
|
|
// No sys menu match — try menu bar accelerators
|
|
closeSysMenu(ctx);
|
|
if (ctx->stack.focusedIdx >= 0) {
|
|
WindowT *win = ctx->stack.windows[ctx->stack.focusedIdx];
|
|
|
|
if (win->menuBar) {
|
|
for (int32_t i = 0; i < win->menuBar->menuCount; i++) {
|
|
if (win->menuBar->menus[i].accelKey == lc) {
|
|
dispatchAccelKey(ctx, lc);
|
|
goto nextKey;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Check for Alt+key (BIOS returns ascii=0 with specific scancodes)
|
|
if (ascii == 0 && scancode < 256 && sAltScanToAscii[scancode]) {
|
|
char accelKey = sAltScanToAscii[scancode];
|
|
|
|
if (dispatchAccelKey(ctx, accelKey)) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Popup menu keyboard navigation (arrows, enter, esc)
|
|
if (ctx->popup.active && ascii == 0) {
|
|
MenuT *curMenu = ctx->popup.menu;
|
|
|
|
// Up arrow
|
|
if (scancode == 0x48) {
|
|
if (curMenu && curMenu->itemCount > 0) {
|
|
int32_t idx = ctx->popup.hoverItem;
|
|
|
|
for (int32_t tries = 0; tries < curMenu->itemCount; tries++) {
|
|
idx--;
|
|
|
|
if (idx < 0) {
|
|
idx = curMenu->itemCount - 1;
|
|
}
|
|
|
|
if (!curMenu->items[idx].separator) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
ctx->popup.hoverItem = idx;
|
|
dirtyListAdd(&ctx->dirty, ctx->popup.popupX, ctx->popup.popupY, ctx->popup.popupW, ctx->popup.popupH);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// Down arrow
|
|
if (scancode == 0x50) {
|
|
if (curMenu && curMenu->itemCount > 0) {
|
|
int32_t idx = ctx->popup.hoverItem;
|
|
|
|
for (int32_t tries = 0; tries < curMenu->itemCount; tries++) {
|
|
idx++;
|
|
|
|
if (idx >= curMenu->itemCount) {
|
|
idx = 0;
|
|
}
|
|
|
|
if (!curMenu->items[idx].separator) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
ctx->popup.hoverItem = idx;
|
|
dirtyListAdd(&ctx->dirty, ctx->popup.popupX, ctx->popup.popupY, ctx->popup.popupW, ctx->popup.popupH);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// Left arrow — close submenu, or switch to previous top-level menu
|
|
if (scancode == 0x4B) {
|
|
if (ctx->popup.depth > 0) {
|
|
closePopupLevel(ctx);
|
|
} else {
|
|
WindowT *win = findWindowById(ctx, ctx->popup.windowId);
|
|
|
|
if (win && win->menuBar && win->menuBar->menuCount > 1) {
|
|
int32_t newIdx = ctx->popup.menuIdx - 1;
|
|
|
|
if (newIdx < 0) {
|
|
newIdx = win->menuBar->menuCount - 1;
|
|
}
|
|
|
|
openPopupAtMenu(ctx, win, newIdx);
|
|
}
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// Right arrow — open submenu, or switch to next top-level menu
|
|
if (scancode == 0x4D) {
|
|
// If hovered item has a submenu, open it
|
|
if (curMenu && ctx->popup.hoverItem >= 0 && ctx->popup.hoverItem < curMenu->itemCount) {
|
|
MenuItemT *hItem = &curMenu->items[ctx->popup.hoverItem];
|
|
|
|
if (hItem->subMenu && hItem->enabled) {
|
|
openSubMenu(ctx);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Otherwise switch to next top-level menu
|
|
WindowT *win = findWindowById(ctx, ctx->popup.windowId);
|
|
|
|
if (win && win->menuBar && win->menuBar->menuCount > 1) {
|
|
int32_t newIdx = ctx->popup.menuIdx + 1;
|
|
|
|
if (newIdx >= win->menuBar->menuCount) {
|
|
newIdx = 0;
|
|
}
|
|
|
|
openPopupAtMenu(ctx, win, newIdx);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Enter executes highlighted popup menu item (or opens submenu)
|
|
if (ctx->popup.active && ascii == 0x0D) {
|
|
MenuT *curMenu = ctx->popup.menu;
|
|
|
|
if (curMenu && ctx->popup.hoverItem >= 0 && ctx->popup.hoverItem < curMenu->itemCount) {
|
|
MenuItemT *item = &curMenu->items[ctx->popup.hoverItem];
|
|
|
|
if (item->subMenu && item->enabled) {
|
|
openSubMenu(ctx);
|
|
} else if (item->enabled && !item->separator) {
|
|
int32_t menuId = item->id;
|
|
WindowT *win = findWindowById(ctx, ctx->popup.windowId);
|
|
closeAllPopups(ctx);
|
|
|
|
if (win && win->onMenu) {
|
|
win->onMenu(win, menuId);
|
|
}
|
|
}
|
|
} else {
|
|
closeAllPopups(ctx);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// Check for plain key accelerator in open popup menu
|
|
if (ctx->popup.active && ascii != 0) {
|
|
char lc = (ascii >= 'A' && ascii <= 'Z') ? (char)(ascii + 32) : (char)ascii;
|
|
MenuT *curMenu = ctx->popup.menu;
|
|
|
|
// Try matching an item in the current popup
|
|
if (curMenu) {
|
|
for (int32_t k = 0; k < curMenu->itemCount; k++) {
|
|
MenuItemT *item = &curMenu->items[k];
|
|
|
|
if (item->accelKey == lc && item->enabled && !item->separator) {
|
|
if (item->subMenu) {
|
|
ctx->popup.hoverItem = k;
|
|
dirtyListAdd(&ctx->dirty, ctx->popup.popupX, ctx->popup.popupY, ctx->popup.popupW, ctx->popup.popupH);
|
|
openSubMenu(ctx);
|
|
} else {
|
|
int32_t menuId = item->id;
|
|
WindowT *win = findWindowById(ctx, ctx->popup.windowId);
|
|
closeAllPopups(ctx);
|
|
|
|
if (win && win->onMenu) {
|
|
win->onMenu(win, menuId);
|
|
}
|
|
}
|
|
|
|
goto nextKey;
|
|
}
|
|
}
|
|
}
|
|
|
|
// No match in current popup — try switching to another top-level menu
|
|
WindowT *win = findWindowById(ctx, ctx->popup.windowId);
|
|
|
|
if (win && win->menuBar) {
|
|
for (int32_t i = 0; i < win->menuBar->menuCount; i++) {
|
|
if (win->menuBar->menus[i].accelKey == lc && i != ctx->popup.menuIdx) {
|
|
openPopupAtMenu(ctx, win, i);
|
|
goto nextKey;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ESC closes open dropdown/combobox popup
|
|
if (sOpenPopup && ascii == 0x1B) {
|
|
// Dirty the popup list area
|
|
WindowT *popWin = sOpenPopup->window;
|
|
int32_t popX;
|
|
int32_t popY;
|
|
int32_t popW;
|
|
int32_t popH;
|
|
widgetDropdownPopupRect(sOpenPopup, &ctx->font, popWin->contentH, &popX, &popY, &popW, &popH);
|
|
dirtyListAdd(&ctx->dirty, popWin->x + popWin->contentX + popX, popWin->y + popWin->contentY + popY, popW, popH);
|
|
|
|
WidgetT *closing = sOpenPopup;
|
|
sOpenPopup = NULL;
|
|
|
|
if (closing->type == WidgetDropdownE) {
|
|
closing->as.dropdown.open = false;
|
|
} else if (closing->type == WidgetComboBoxE) {
|
|
closing->as.comboBox.open = false;
|
|
}
|
|
|
|
wgtInvalidate(closing);
|
|
continue;
|
|
}
|
|
|
|
// ESC closes one popup level (or all if at top level)
|
|
if (ctx->popup.active && ascii == 0x1B) {
|
|
closePopupLevel(ctx);
|
|
continue;
|
|
}
|
|
|
|
// Check accelerator table on focused window
|
|
if (ctx->stack.focusedIdx >= 0) {
|
|
WindowT *win = ctx->stack.windows[ctx->stack.focusedIdx];
|
|
int32_t key = ascii ? ascii : (scancode | 0x100);
|
|
|
|
if (checkAccelTable(ctx, win, key, shiftFlags)) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Tab / Shift-Tab — cycle focus between widgets
|
|
// Tab: scancode=0x0F, ascii=0x09
|
|
// Shift-Tab: scancode=0x0F, ascii=0x00
|
|
if (scancode == 0x0F && (ascii == 0x09 || ascii == 0)) {
|
|
if (ctx->stack.focusedIdx >= 0) {
|
|
WindowT *win = ctx->stack.windows[ctx->stack.focusedIdx];
|
|
|
|
if (win->widgetRoot) {
|
|
// Find currently focused widget
|
|
WidgetT *current = NULL;
|
|
WidgetT *fstack[64];
|
|
int32_t ftop = 0;
|
|
fstack[ftop++] = win->widgetRoot;
|
|
|
|
while (ftop > 0) {
|
|
WidgetT *w = fstack[--ftop];
|
|
|
|
if (w->focused && widgetIsFocusable(w->type)) {
|
|
// Don't tab out of the terminal — it swallows Tab
|
|
if (w->type == WidgetAnsiTermE) {
|
|
current = NULL;
|
|
break;
|
|
}
|
|
|
|
current = w;
|
|
break;
|
|
}
|
|
|
|
for (WidgetT *c = w->firstChild; c; c = c->nextSibling) {
|
|
if (c->visible && ftop < 64) {
|
|
fstack[ftop++] = c;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Terminal swallowed Tab — send to widget system instead
|
|
if (current == NULL) {
|
|
// Check if a terminal is focused
|
|
ftop = 0;
|
|
fstack[ftop++] = win->widgetRoot;
|
|
bool termFocused = false;
|
|
|
|
while (ftop > 0) {
|
|
WidgetT *w = fstack[--ftop];
|
|
|
|
if (w->focused && w->type == WidgetAnsiTermE) {
|
|
termFocused = true;
|
|
break;
|
|
}
|
|
|
|
for (WidgetT *c = w->firstChild; c; c = c->nextSibling) {
|
|
if (c->visible && ftop < 64) {
|
|
fstack[ftop++] = c;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (termFocused) {
|
|
// Terminal has focus — send Tab to it
|
|
if (win->onKey) {
|
|
win->onKey(win, ascii ? ascii : (scancode | 0x100), shiftFlags);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
WidgetT *next;
|
|
|
|
if (ascii == 0x09) {
|
|
next = widgetFindNextFocusable(win->widgetRoot, current);
|
|
} else {
|
|
next = widgetFindPrevFocusable(win->widgetRoot, current);
|
|
}
|
|
|
|
if (next) {
|
|
sOpenPopup = NULL;
|
|
if (sFocusedWidget) {
|
|
sFocusedWidget->focused = false;
|
|
}
|
|
sFocusedWidget = next;
|
|
next->focused = true;
|
|
|
|
// Scroll the widget into view if needed
|
|
int32_t scrollX = win->hScroll ? win->hScroll->value : 0;
|
|
int32_t scrollY = win->vScroll ? win->vScroll->value : 0;
|
|
int32_t virtX = next->x + scrollX;
|
|
int32_t virtY = next->y + scrollY;
|
|
|
|
if (win->vScroll) {
|
|
if (virtY < win->vScroll->value) {
|
|
win->vScroll->value = virtY;
|
|
} else if (virtY + next->h > win->vScroll->value + win->contentH) {
|
|
win->vScroll->value = virtY + next->h - win->contentH;
|
|
}
|
|
|
|
win->vScroll->value = clampInt(win->vScroll->value, win->vScroll->min, win->vScroll->max);
|
|
}
|
|
|
|
if (win->hScroll) {
|
|
if (virtX < win->hScroll->value) {
|
|
win->hScroll->value = virtX;
|
|
} else if (virtX + next->w > win->hScroll->value + win->contentW) {
|
|
win->hScroll->value = virtX + next->w - win->contentW;
|
|
}
|
|
|
|
win->hScroll->value = clampInt(win->hScroll->value, win->hScroll->min, win->hScroll->max);
|
|
}
|
|
|
|
wgtInvalidate(win->widgetRoot);
|
|
}
|
|
}
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// Send to focused window
|
|
if (ctx->stack.focusedIdx >= 0) {
|
|
WindowT *win = ctx->stack.windows[ctx->stack.focusedIdx];
|
|
|
|
if (win->onKey) {
|
|
win->onKey(win, ascii ? ascii : (scancode | 0x100), shiftFlags);
|
|
}
|
|
}
|
|
|
|
continue;
|
|
nextKey:;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// pollMouse
|
|
// ============================================================
|
|
|
|
static void pollMouse(AppContextT *ctx) {
|
|
__dpmi_regs r;
|
|
|
|
memset(&r, 0, sizeof(r));
|
|
r.x.ax = 0x0003;
|
|
__dpmi_int(0x33, &r);
|
|
|
|
ctx->mouseX = r.x.cx;
|
|
ctx->mouseY = r.x.dx;
|
|
ctx->mouseButtons = r.x.bx;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// refreshMinimizedIcons
|
|
// ============================================================
|
|
//
|
|
// Dirty the next minimized window icon whose content has changed
|
|
// since the last refresh. Only considers windows without custom
|
|
// iconData. Called every ICON_REFRESH_INTERVAL frames to stagger.
|
|
|
|
static void refreshMinimizedIcons(AppContextT *ctx) {
|
|
WindowStackT *ws = &ctx->stack;
|
|
DisplayT *d = &ctx->display;
|
|
int32_t count = 0;
|
|
int32_t iconIdx = 0;
|
|
|
|
for (int32_t i = 0; i < ws->count; i++) {
|
|
WindowT *win = ws->windows[i];
|
|
|
|
if (!win->visible || !win->minimized) {
|
|
continue;
|
|
}
|
|
|
|
if (!win->iconData && win->contentDirty) {
|
|
if (count >= ctx->iconRefreshIdx) {
|
|
int32_t ix = ICON_SPACING + iconIdx * (ICON_TOTAL_SIZE + ICON_SPACING);
|
|
int32_t iy = d->height - ICON_TOTAL_SIZE - ICON_SPACING;
|
|
dirtyListAdd(&ctx->dirty, ix, iy, ICON_TOTAL_SIZE, ICON_TOTAL_SIZE);
|
|
win->contentDirty = false;
|
|
ctx->iconRefreshIdx = count + 1;
|
|
return;
|
|
}
|
|
|
|
count++;
|
|
}
|
|
|
|
iconIdx++;
|
|
}
|
|
|
|
// Wrapped past the end — reset for next cycle
|
|
ctx->iconRefreshIdx = 0;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// updateCursorShape
|
|
// ============================================================
|
|
|
|
static void updateCursorShape(AppContextT *ctx) {
|
|
int32_t newCursor = CURSOR_ARROW;
|
|
int32_t mx = ctx->mouseX;
|
|
int32_t my = ctx->mouseY;
|
|
|
|
// During active resize, keep the resize cursor
|
|
if (ctx->stack.resizeWindow >= 0) {
|
|
int32_t edge = ctx->stack.resizeEdge;
|
|
bool horiz = (edge & (RESIZE_LEFT | RESIZE_RIGHT)) != 0;
|
|
bool vert = (edge & (RESIZE_TOP | RESIZE_BOTTOM)) != 0;
|
|
|
|
if (horiz && vert) {
|
|
if ((edge & RESIZE_LEFT && edge & RESIZE_TOP) ||
|
|
(edge & RESIZE_RIGHT && edge & RESIZE_BOTTOM)) {
|
|
newCursor = CURSOR_RESIZE_DIAG_NWSE;
|
|
} else {
|
|
newCursor = CURSOR_RESIZE_DIAG_NESW;
|
|
}
|
|
} else if (horiz) {
|
|
newCursor = CURSOR_RESIZE_H;
|
|
} else {
|
|
newCursor = CURSOR_RESIZE_V;
|
|
}
|
|
}
|
|
// Active ListView column resize drag
|
|
else if (sResizeListView) {
|
|
newCursor = CURSOR_RESIZE_H;
|
|
}
|
|
// Active splitter drag
|
|
else if (sDragSplitter) {
|
|
newCursor = sDragSplitter->as.splitter.vertical ? CURSOR_RESIZE_H : CURSOR_RESIZE_V;
|
|
}
|
|
// Not in an active drag/resize — check what we're hovering
|
|
else if (ctx->stack.dragWindow < 0 && ctx->stack.scrollWindow < 0) {
|
|
int32_t hitPart;
|
|
int32_t hitIdx = wmHitTest(&ctx->stack, mx, my, &hitPart);
|
|
|
|
if (hitIdx >= 0 && hitPart == 3) {
|
|
// Hovering over a resize edge
|
|
WindowT *win = ctx->stack.windows[hitIdx];
|
|
int32_t edge = wmResizeEdgeHit(win, mx, my);
|
|
bool horiz = (edge & (RESIZE_LEFT | RESIZE_RIGHT)) != 0;
|
|
bool vert = (edge & (RESIZE_TOP | RESIZE_BOTTOM)) != 0;
|
|
|
|
if (horiz && vert) {
|
|
if ((edge & RESIZE_LEFT && edge & RESIZE_TOP) ||
|
|
(edge & RESIZE_RIGHT && edge & RESIZE_BOTTOM)) {
|
|
newCursor = CURSOR_RESIZE_DIAG_NWSE;
|
|
} else {
|
|
newCursor = CURSOR_RESIZE_DIAG_NESW;
|
|
}
|
|
} else if (horiz) {
|
|
newCursor = CURSOR_RESIZE_H;
|
|
} else if (vert) {
|
|
newCursor = CURSOR_RESIZE_V;
|
|
}
|
|
} else if (hitIdx >= 0 && hitPart == 0) {
|
|
// Hovering over content area — check for ListView column border
|
|
WindowT *win = ctx->stack.windows[hitIdx];
|
|
|
|
if (win->widgetRoot) {
|
|
int32_t cx = mx - win->x - win->contentX;
|
|
int32_t cy = my - win->y - win->contentY;
|
|
int32_t scrollX = win->hScroll ? win->hScroll->value : 0;
|
|
int32_t scrollY = win->vScroll ? win->vScroll->value : 0;
|
|
int32_t vx = cx + scrollX;
|
|
int32_t vy = cy + scrollY;
|
|
|
|
WidgetT *hit = widgetHitTest(win->widgetRoot, vx, vy);
|
|
|
|
if (hit && hit->type == WidgetListViewE && widgetListViewColBorderHit(hit, vx, vy)) {
|
|
newCursor = CURSOR_RESIZE_H;
|
|
}
|
|
|
|
// Walk into splitters (NO_HIT_RECURSE stops widgetHitTest at the outermost one)
|
|
while (hit && hit->type == WidgetSplitterE) {
|
|
int32_t pos = hit->as.splitter.dividerPos;
|
|
bool onBar;
|
|
|
|
if (hit->as.splitter.vertical) {
|
|
int32_t barX = hit->x + pos;
|
|
onBar = (vx >= barX && vx < barX + SPLITTER_BAR_W);
|
|
} else {
|
|
int32_t barY = hit->y + pos;
|
|
onBar = (vy >= barY && vy < barY + SPLITTER_BAR_W);
|
|
}
|
|
|
|
if (onBar) {
|
|
newCursor = hit->as.splitter.vertical ? CURSOR_RESIZE_H : CURSOR_RESIZE_V;
|
|
break;
|
|
}
|
|
|
|
// Not on this splitter's bar — check children for nested splitters
|
|
WidgetT *inner = NULL;
|
|
|
|
for (WidgetT *c = hit->firstChild; c; c = c->nextSibling) {
|
|
if (c->visible && vx >= c->x && vx < c->x + c->w && vy >= c->y && vy < c->y + c->h) {
|
|
inner = c;
|
|
}
|
|
}
|
|
|
|
hit = inner;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If cursor shape changed, dirty the cursor area
|
|
if (newCursor != ctx->cursorId) {
|
|
dirtyCursorArea(ctx, mx, my);
|
|
ctx->cursorId = newCursor;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// updateTooltip — show/hide tooltip based on hover state
|
|
// ============================================================
|
|
|
|
static void updateTooltip(AppContextT *ctx) {
|
|
clock_t now = clock();
|
|
clock_t threshold = (clock_t)TOOLTIP_DELAY_MS * CLOCKS_PER_SEC / 1000;
|
|
int32_t mx = ctx->mouseX;
|
|
int32_t my = ctx->mouseY;
|
|
|
|
// Mouse moved or button pressed — hide tooltip and reset timer
|
|
if (mx != ctx->prevMouseX || my != ctx->prevMouseY || ctx->mouseButtons) {
|
|
if (ctx->tooltipText) {
|
|
// Dirty old tooltip area
|
|
dirtyListAdd(&ctx->dirty, ctx->tooltipX, ctx->tooltipY, ctx->tooltipW, ctx->tooltipH);
|
|
ctx->tooltipText = NULL;
|
|
}
|
|
|
|
ctx->tooltipHoverStart = now;
|
|
return;
|
|
}
|
|
|
|
// Already showing a tooltip
|
|
if (ctx->tooltipText) {
|
|
return;
|
|
}
|
|
|
|
// Not enough time has passed
|
|
if ((now - ctx->tooltipHoverStart) < threshold) {
|
|
return;
|
|
}
|
|
|
|
// Don't show tooltips while popups/menus are active
|
|
if (ctx->popup.active || ctx->sysMenu.active) {
|
|
return;
|
|
}
|
|
|
|
// Find the widget under the cursor
|
|
int32_t hitPart;
|
|
int32_t hitIdx = wmHitTest(&ctx->stack, mx, my, &hitPart);
|
|
|
|
if (hitIdx < 0 || hitPart != 0) {
|
|
return;
|
|
}
|
|
|
|
WindowT *win = ctx->stack.windows[hitIdx];
|
|
|
|
if (!win->widgetRoot) {
|
|
return;
|
|
}
|
|
|
|
int32_t cx = mx - win->x - win->contentX;
|
|
int32_t cy = my - win->y - win->contentY;
|
|
int32_t scrollX = win->hScroll ? win->hScroll->value : 0;
|
|
int32_t scrollY = win->vScroll ? win->vScroll->value : 0;
|
|
int32_t vx = cx + scrollX;
|
|
int32_t vy = cy + scrollY;
|
|
|
|
WidgetT *hit = widgetHitTest(win->widgetRoot, vx, vy);
|
|
|
|
// Walk into NO_HIT_RECURSE containers to find deepest child
|
|
while (hit && hit->wclass && (hit->wclass->flags & WCLASS_NO_HIT_RECURSE)) {
|
|
WidgetT *inner = NULL;
|
|
|
|
for (WidgetT *c = hit->firstChild; c; c = c->nextSibling) {
|
|
if (c->visible && vx >= c->x && vx < c->x + c->w && vy >= c->y && vy < c->y + c->h) {
|
|
inner = c;
|
|
}
|
|
}
|
|
|
|
if (!inner) {
|
|
break;
|
|
}
|
|
|
|
// If the inner child has a tooltip, use it; otherwise check if it's another container
|
|
if (inner->tooltip) {
|
|
hit = inner;
|
|
break;
|
|
}
|
|
|
|
if (inner->wclass && (inner->wclass->flags & WCLASS_NO_HIT_RECURSE)) {
|
|
hit = inner;
|
|
} else {
|
|
WidgetT *deep = widgetHitTest(inner, vx, vy);
|
|
hit = deep ? deep : inner;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!hit || !hit->tooltip) {
|
|
return;
|
|
}
|
|
|
|
// Show the tooltip
|
|
ctx->tooltipText = hit->tooltip;
|
|
|
|
int32_t tw = textWidth(&ctx->font, hit->tooltip) + TOOLTIP_PAD * 2;
|
|
int32_t th = ctx->font.charHeight + TOOLTIP_PAD * 2;
|
|
|
|
// Position below and right of cursor
|
|
ctx->tooltipX = mx + 12;
|
|
ctx->tooltipY = my + 16;
|
|
|
|
// Keep on screen
|
|
if (ctx->tooltipX + tw > ctx->display.width) {
|
|
ctx->tooltipX = ctx->display.width - tw;
|
|
}
|
|
|
|
if (ctx->tooltipY + th > ctx->display.height) {
|
|
ctx->tooltipY = my - th - 4;
|
|
}
|
|
|
|
ctx->tooltipW = tw;
|
|
ctx->tooltipH = th;
|
|
|
|
// Dirty the tooltip area
|
|
dirtyListAdd(&ctx->dirty, ctx->tooltipX, ctx->tooltipY, tw, th);
|
|
}
|