forked from Blendman974/faceclaw
Remove gesture-help bottom-bars from many places in the UI, adjust layouts to be able to handle larger fonts, and other small UI fixes.
418 lines
16 KiB
TypeScript
418 lines
16 KiB
TypeScript
import { type BdfFont } from "../../graphics/bdffont";
|
|
import { getDefaultSmallFont } from "../../graphics/ui-fonts";
|
|
import { truncateText } from "../../graphics/textwrap";
|
|
import { GrayImage } from "../../graphics/image";
|
|
import { type Plane } from "../../graphics/plane";
|
|
import { renderIcon, type IconName } from "../../graphics/icons";
|
|
import { clamp } from "../../util/numeric-util";
|
|
import { DashboardInputEvent, Layer, LayerActions, LayerContext } from "../../ui/layers";
|
|
import { drawSelectionHighlight, MenuLayer, scrollToKeepSelectionVisible, type MenuItem } from "../../ui/menu";
|
|
import { iconGridMinRowHeight } from "../../ui/metrics";
|
|
import { WINDOW_MENU_LAYOUT } from "../../ui/window-menu";
|
|
import { onAnySettingChanged } from "../../ui/dashboard-settings";
|
|
import { createInProcessWindow } from "../../ui/shell/in-process-window";
|
|
import {
|
|
getFolderAssignments,
|
|
getFolders,
|
|
getFolderStateFingerprint,
|
|
setAppFolder,
|
|
unusedNewFolderName,
|
|
} from "./launcher-folders";
|
|
import { shell, type ShellWindow } from "../../ui/shell/shell";
|
|
|
|
export type LauncherAppEntry = {
|
|
appId: string;
|
|
label: string;
|
|
icon: IconName;
|
|
uninstallable?: boolean;
|
|
/** Dynamic artwork for installed apps; icon remains the fallback. */
|
|
renderIcon?: (size: number) => GrayImage | null;
|
|
iconKey?: string;
|
|
};
|
|
|
|
export type LauncherOptions = {
|
|
actions: LayerActions;
|
|
apps: () => LauncherAppEntry[];
|
|
launchApp: (appId: string) => Promise<void> | void;
|
|
uninstallApp: (appId: string) => Promise<void> | void;
|
|
/** Submit a painted viewport-sized frame (as planes) to this window's surface. */
|
|
submitFrame: (planes: Plane[], paintMs: number, frameId: number) => Promise<void>;
|
|
/** Flip the launcher's compositor surface visibility on foreground changes. */
|
|
setSurfaceVisible: (visible: boolean) => void;
|
|
};
|
|
|
|
export const LAUNCHER_WINDOW_ID = "launcher";
|
|
export const LAUNCHER_SURFACE_ID = "window:launcher";
|
|
|
|
const COLS = 5;
|
|
const GRID_TOP = 6;
|
|
const ICON_SIZE = 44;
|
|
const LABEL_GAP = 2;
|
|
|
|
type LauncherMode = "row" | "item";
|
|
|
|
/** One cell of the grid: an app, or a folder holding some of the apps. */
|
|
type LauncherGridEntry =
|
|
| { kind: "app"; label: string; icon: IconName; appId: string; renderIcon?: (size: number) => GrayImage | null }
|
|
| { kind: "folder"; label: string; name: string };
|
|
|
|
/**
|
|
* The launcher grid: app and folder icons with labels, arranged in a grid.
|
|
* Navigation has two levels so the max number of swipes to any app is halved:
|
|
* entering from the sidebar starts in "row" mode (scroll picks a row); a tap
|
|
* drops into "item" mode on that row, defaulting to the middle column (scroll
|
|
* picks the item); a tap launches an app or opens a folder (the same grid,
|
|
* restricted to that folder's apps). Double-click backs out one level (item →
|
|
* row, folder → top grid), and from the top level yields to the sidebar.
|
|
*
|
|
* The folder grouping lives in the settings store (see launcher-folders.ts)
|
|
* and is re-read every paint, so assistant folder tools take effect without
|
|
* the layer holding any copy of the state.
|
|
*/
|
|
class LauncherGridLayer implements Layer {
|
|
private mode: LauncherMode = "row";
|
|
private selectedRow = 0;
|
|
private selectedCol = 1;
|
|
private scrollRow = 0;
|
|
/** Folder whose contents the grid is showing, or null for the top grid. */
|
|
private currentFolder: string | null = null;
|
|
|
|
constructor(private readonly options: LauncherOptions) {}
|
|
|
|
/**
|
|
* The cells to show, computed fresh from the folder state. Self-heals
|
|
* currentFolder: if the open folder no longer exists (the assistant
|
|
* disbanded it), the view falls back to the top grid.
|
|
*/
|
|
private entries(): LauncherGridEntry[] {
|
|
const apps = this.options.apps();
|
|
const byAppId = new Map(apps.map((app) => [app.appId, app]));
|
|
if (this.currentFolder !== null) {
|
|
const members = (getFolders().get(this.currentFolder) ?? [])
|
|
.map((appId) => byAppId.get(appId))
|
|
.filter(Boolean) as LauncherAppEntry[];
|
|
if (members.length > 0) {
|
|
return members
|
|
.map((app): LauncherGridEntry => ({
|
|
kind: "app",
|
|
label: app.label,
|
|
icon: app.icon,
|
|
appId: app.appId,
|
|
renderIcon: app.renderIcon,
|
|
}))
|
|
.sort((a, b) => a.label.localeCompare(b.label));
|
|
}
|
|
this.currentFolder = null;
|
|
}
|
|
const assignments = getFolderAssignments();
|
|
const entries: LauncherGridEntry[] = [];
|
|
// A folder cell appears only when it holds at least one known app; stale
|
|
// assignments to removed apps are ignored.
|
|
for (const [name, members] of getFolders()) {
|
|
if (members.some((appId) => byAppId.has(appId))) {
|
|
entries.push({ kind: "folder", label: name, name });
|
|
}
|
|
}
|
|
for (const app of apps) {
|
|
if (!assignments[app.appId]) {
|
|
entries.push({
|
|
kind: "app",
|
|
label: app.label,
|
|
icon: app.icon,
|
|
appId: app.appId,
|
|
renderIcon: app.renderIcon,
|
|
});
|
|
}
|
|
}
|
|
return entries.sort((a, b) => a.label.localeCompare(b.label));
|
|
}
|
|
|
|
private rowCount(entryCount: number): number {
|
|
return Math.max(1, Math.ceil(entryCount / COLS));
|
|
}
|
|
|
|
private itemsInRow(entryCount: number, row: number): number {
|
|
return Math.max(0, Math.min(COLS, entryCount - row * COLS));
|
|
}
|
|
|
|
/** Leave the current folder, putting the selection back on its cell. */
|
|
private exitFolder(): void {
|
|
const folder = this.currentFolder;
|
|
this.currentFolder = null;
|
|
this.mode = "row";
|
|
const index = this.entries().findIndex((entry) => entry.kind === "folder" && entry.name === folder);
|
|
this.selectedRow = index >= 0 ? Math.floor(index / COLS) : 0;
|
|
}
|
|
|
|
/**
|
|
* App-specific entries for the window's long-press menu. Only item mode
|
|
* pins the selection to a single cell, and only apps can move to folders,
|
|
* so anywhere else the menu falls back to just the defaults.
|
|
*/
|
|
menuItems(): MenuItem[] {
|
|
if (this.mode !== "item") return [];
|
|
const entry = this.entries()[this.selectedRow * COLS + this.selectedCol];
|
|
if (!entry || entry.kind !== "app") return [];
|
|
return [
|
|
{
|
|
label: "Move to folder",
|
|
onSelect: (ctx) => {
|
|
ctx.stack.pop();
|
|
ctx.stack.push(
|
|
new MenuLayer("Move to folder", this.moveToFolderItems(entry.appId), WINDOW_MENU_LAYOUT),
|
|
);
|
|
},
|
|
},
|
|
...(this.options.apps().find((app) => app.appId === entry.appId)?.uninstallable
|
|
? [{
|
|
label: "Uninstall",
|
|
onSelect: (ctx: LayerContext) => {
|
|
ctx.stack.pop();
|
|
ctx.stack.push(
|
|
new MenuLayer(
|
|
"Uninstall app?",
|
|
[
|
|
{
|
|
label: "Confirm uninstall",
|
|
onSelect: async (confirmCtx) => {
|
|
confirmCtx.stack.pop();
|
|
setAppFolder(entry.appId, null);
|
|
await this.options.uninstallApp(entry.appId);
|
|
this.mode = "row";
|
|
},
|
|
},
|
|
{ label: "Cancel", onSelect: (confirmCtx) => confirmCtx.stack.pop() },
|
|
],
|
|
WINDOW_MENU_LAYOUT,
|
|
),
|
|
);
|
|
},
|
|
} satisfies MenuItem]
|
|
: []),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* The folder-picker submenu: every existing folder except the app's own,
|
|
* plus a generated-name "New folder" (ring input has no text entry) and,
|
|
* when the app is in a folder, an escape back to the top level.
|
|
*/
|
|
private moveToFolderItems(appId: string): MenuItem[] {
|
|
const currentFolder = getFolderAssignments()[appId] ?? null;
|
|
const items: MenuItem[] = [];
|
|
for (const name of getFolders().keys()) {
|
|
if (name === currentFolder) continue;
|
|
items.push({
|
|
label: name,
|
|
onSelect: (ctx) => {
|
|
setAppFolder(appId, name);
|
|
ctx.stack.pop();
|
|
},
|
|
});
|
|
}
|
|
items.push({
|
|
label: "New folder",
|
|
onSelect: (ctx) => {
|
|
setAppFolder(appId, unusedNewFolderName());
|
|
ctx.stack.pop();
|
|
},
|
|
});
|
|
if (currentFolder !== null) {
|
|
items.push({
|
|
label: "Remove from folder",
|
|
onSelect: (ctx) => {
|
|
setAppFolder(appId, null);
|
|
ctx.stack.pop();
|
|
},
|
|
});
|
|
}
|
|
return items;
|
|
}
|
|
|
|
paint(ctx: LayerContext): GrayImage {
|
|
const font = getDefaultSmallFont();
|
|
const { width, height } = ctx.stack.getBaseSize();
|
|
const image = new GrayImage(width, height, 0);
|
|
const focused = ctx.stack.isFocused();
|
|
const entries = this.entries();
|
|
const rows = this.rowCount(entries.length);
|
|
this.selectedRow = clamp(this.selectedRow, 0, rows - 1);
|
|
this.selectedCol = clamp(
|
|
this.selectedCol,
|
|
0,
|
|
Math.max(0, this.itemsInRow(entries.length, this.selectedRow) - 1),
|
|
);
|
|
|
|
// The folder-name header band scales with the font.
|
|
const gridTop = this.currentFolder !== null ? GRID_TOP + font.lineHeight + 4 : GRID_TOP;
|
|
if (this.currentFolder !== null) {
|
|
image.drawText(font, 8, GRID_TOP - 2, truncateText(font, this.currentFolder, width - 16), 160);
|
|
}
|
|
const gridBottom = height - 4;
|
|
// Rows are exactly as tall as their content (icon + label + breathing
|
|
// room), so row height tracks the font instead of stretching to fill the
|
|
// viewport. Leftover space below the last full row shows the top of the
|
|
// next row when there are more apps to scroll to.
|
|
const rowH = iconGridMinRowHeight(font, ICON_SIZE, LABEL_GAP);
|
|
const fullRows = Math.max(1, Math.floor((gridBottom - gridTop) / rowH));
|
|
const colW = width / COLS;
|
|
|
|
// Scroll to keep the selected row among the fully-visible rows.
|
|
this.scrollRow = scrollToKeepSelectionVisible(this.scrollRow, this.selectedRow, fullRows, rows);
|
|
|
|
const rowY = (row: number) => gridTop + (row - this.scrollRow) * rowH;
|
|
|
|
// Selection highlight (row band, or a single cell in item mode).
|
|
const selY = rowY(this.selectedRow);
|
|
if (this.mode === "row") {
|
|
drawSelectionHighlight(image, 4, selY + 2, width - 8, rowH - 4, focused, 6);
|
|
} else {
|
|
drawSelectionHighlight(image, this.selectedCol * colW + 6, selY + 2, colW - 12, rowH - 4, focused, 6);
|
|
}
|
|
|
|
for (let index = 0; index < entries.length; index++) {
|
|
const entry = entries[index]!;
|
|
const row = Math.floor(index / COLS);
|
|
if (row < this.scrollRow) continue;
|
|
const blockTop = rowY(row) + Math.max(2, (rowH - ICON_SIZE - font.lineHeight - LABEL_GAP) / 2);
|
|
if (blockTop >= gridBottom) break; // fully below the grid
|
|
const centerX = (index % COLS) * colW + colW / 2;
|
|
const icon = entry.kind === "app"
|
|
? entry.renderIcon?.(ICON_SIZE) ?? renderIcon(entry.icon, ICON_SIZE)
|
|
: renderIcon("folder-filled", ICON_SIZE);
|
|
if (icon) {
|
|
// Clip the icon at the grid bottom so a peeking row shows only its top.
|
|
// A fully visible icon goes through the deferred-image path (texture
|
|
// cacheable); the clipped peeking row falls back to a raster blit,
|
|
// since cached draws are whole-image only.
|
|
// Icons narrower/shorter than ICON_SIZE (a non-square logo scaled to
|
|
// fit) are centered in the square the row reserves for them.
|
|
const iconX = Math.round(centerX - icon.width / 2);
|
|
const iconY = Math.round(blockTop + Math.max(0, (ICON_SIZE - icon.height) / 2));
|
|
const clipHeight = Math.min(icon.height, Math.floor(gridBottom - iconY));
|
|
if (clipHeight >= icon.height) {
|
|
image.drawImage(icon, iconX, iconY);
|
|
} else if (clipHeight > 0) {
|
|
image.bitBlt(icon, iconX, iconY, { height: clipHeight, transparentZero: true });
|
|
}
|
|
}
|
|
const labelY = Math.round(blockTop + ICON_SIZE + LABEL_GAP);
|
|
if (labelY + font.lineHeight <= gridBottom) {
|
|
const label = truncateText(font, entry.label, colW - 8);
|
|
image.drawText(font, Math.round(centerX - font.measureText(label) / 2), labelY, label, 210);
|
|
}
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
async handleInput(event: DashboardInputEvent, ctx: LayerContext): Promise<void> {
|
|
const entries = this.entries();
|
|
const rows = this.rowCount(entries.length);
|
|
switch (event.type) {
|
|
case "scroll-up":
|
|
case "scroll-down": {
|
|
const delta = event.type === "scroll-down" ? 1 : -1;
|
|
if (this.mode === "row") {
|
|
this.selectedRow = clamp(this.selectedRow + delta, 0, rows - 1);
|
|
} else {
|
|
// Item selection traverses the grid linearly: past a row's edge it
|
|
// continues onto the adjacent row (stopping at the grid's ends).
|
|
const itemCount = this.itemsInRow(entries.length, this.selectedRow);
|
|
const next = clamp(this.selectedCol, 0, itemCount - 1) + delta;
|
|
if (next >= 0 && next < itemCount) {
|
|
this.selectedCol = next;
|
|
} else if (next < 0 && this.selectedRow > 0) {
|
|
this.selectedRow--;
|
|
this.selectedCol = this.itemsInRow(entries.length, this.selectedRow) - 1;
|
|
} else if (next >= itemCount && this.selectedRow < rows - 1) {
|
|
this.selectedRow++;
|
|
this.selectedCol = 0;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
case "click": {
|
|
if (this.mode === "row") {
|
|
this.mode = "item";
|
|
// Default to the middle column (clamped to the row's item count).
|
|
this.selectedCol = Math.min(
|
|
Math.floor(COLS / 2),
|
|
this.itemsInRow(entries.length, this.selectedRow) - 1,
|
|
);
|
|
} else {
|
|
const entry = entries[this.selectedRow * COLS + this.selectedCol];
|
|
if (!entry) return;
|
|
if (entry.kind === "folder") {
|
|
this.currentFolder = entry.name;
|
|
this.mode = "row";
|
|
this.selectedRow = 0;
|
|
this.scrollRow = 0;
|
|
} else {
|
|
// Return to the top grid before launching, so the launcher never
|
|
// shows (even briefly) stale folder contents when re-entered.
|
|
if (this.currentFolder !== null) this.exitFolder();
|
|
this.mode = "row";
|
|
await this.options.launchApp(entry.appId);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
case "double-click":
|
|
if (this.mode === "item") {
|
|
this.mode = "row";
|
|
} else if (this.currentFolder !== null) {
|
|
this.exitFolder();
|
|
} else {
|
|
shell.yieldFocusToSidebar();
|
|
}
|
|
return;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The launcher: a pinned, uncloseable in-process window presenting the app
|
|
* grid. Selecting an app asks the controller to launch it and foregrounds the
|
|
* new window.
|
|
*/
|
|
export function createLauncherWindow(options: LauncherOptions): ShellWindow {
|
|
const gridLayer = new LauncherGridLayer(options);
|
|
const created = createInProcessWindow({
|
|
appId: "launcher",
|
|
windowId: LAUNCHER_WINDOW_ID,
|
|
title: "Apps",
|
|
iconLetter: "A",
|
|
icon: "layout-grid",
|
|
closeable: false,
|
|
menuItems: () => gridLayer.menuItems(),
|
|
actions: options.actions,
|
|
// Not wrapped in YieldAtRootLayer: the grid handles double-click itself to
|
|
// back out of item selection before yielding to the sidebar.
|
|
baseLayer: gridLayer,
|
|
submitFrame: options.submitFrame,
|
|
setSurfaceVisible: options.setSurfaceVisible,
|
|
});
|
|
// The assistant's folder tools change the grouping from outside the window;
|
|
// the settings broadcast is the change signal, and the fingerprint check
|
|
// keeps every unrelated setting change from repainting the launcher. The
|
|
// launcher is pinned for the app's lifetime, so the subscription never needs
|
|
// tearing down.
|
|
let lastState = `${getFolderStateFingerprint()}\n${launcherAppsFingerprint(options.apps())}`;
|
|
onAnySettingChanged(() => {
|
|
const state = `${getFolderStateFingerprint()}\n${launcherAppsFingerprint(options.apps())}`;
|
|
if (state === lastState) return;
|
|
lastState = state;
|
|
created.requestRender();
|
|
});
|
|
return created.window;
|
|
}
|
|
|
|
function launcherAppsFingerprint(apps: LauncherAppEntry[]): string {
|
|
return apps
|
|
.map((app) => `${app.appId}:${app.label}:${app.icon}:${app.iconKey ?? ""}:${app.uninstallable ? 1 : 0}`)
|
|
.join("|");
|
|
}
|