Files
faceclaw/app/apps/launcher/launcher-app.ts
T
James Babcock a02b849200 Borderless modes have different padding inside the builtin apps
Most of the builtin apps had some padding between the window edge and
their content, because they expect to be displayed with a line border on
their edge. We added a customization option to remove the border, so,
that padding is not always necessary. Make the layouts dynamically
adjust, to omit the padding when it isn't needed.
2026-11-11 15:19:29 -08:00

335 lines
12 KiB
TypeScript

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 { InputEvent } from "../../ui/gestures";
import { IconGrid, ICON_GRID_ICON_SIZE } from "../../ui/icon-grid";
import { Layer, LayerActions, LayerContext } from "../../ui/layers";
import { MenuLayer, type MenuItem } from "../../ui/menu";
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";
/** A folder's name, above its grid: how far in from the grid's side, and the gap under it. */
const FOLDER_NAME_INSET_X = 4;
const FOLDER_NAME_GAP = 6;
/** 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, in an IconGrid (which
* owns layout, selection and the ring/watch navigation schemes). Opening a
* folder shows the same grid restricted to that folder's apps; backing out
* of a folder returns to the top grid, and from the top grid 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 {
// Watch swipes are spatial: up/down move between rows, left/right between
// columns. From the leftmost column, left keeps going out: it leaves the
// open folder if there is one, else yields to the sidebar — "left" points
// toward the sidebar all the way out.
readonly acceptsDirectional = true;
/** Folder whose contents the grid is showing, or null for the top grid. */
private currentFolder: string | null = null;
private readonly grid = new IconGrid<LauncherGridEntry>({
items: () => this.entries(),
describe: (entry) => ({
label: entry.label,
icon: entry.kind === "app"
? entry.renderIcon?.(ICON_GRID_ICON_SIZE) ?? renderIcon(entry.icon, ICON_GRID_ICON_SIZE)
: renderIcon("folder-filled", ICON_GRID_ICON_SIZE),
}),
onActivate: (entry) => this.openEntry(entry),
onBack: () => this.back(),
});
constructor(private readonly options: LauncherOptions) {}
onFocus(lastInput: InputEvent | null): void {
this.grid.onFocus(lastInput);
}
/**
* 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));
}
/** Leave the current folder, putting the selection back on its cell. */
private exitFolder(): void {
const folder = this.currentFolder;
this.currentFolder = null;
this.grid.resetSelection();
const index = this.entries().findIndex((entry) => entry.kind === "folder" && entry.name === folder);
if (index >= 0) this.grid.selectIndex(index);
}
/** Enter a folder or launch an app; true when that left the grid (a launch). */
private async openEntry(entry: LauncherGridEntry): Promise<boolean> {
if (entry.kind === "folder") {
this.currentFolder = entry.name;
this.grid.resetSelection();
return false;
}
// 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.grid.enterRowMode();
await this.options.launchApp(entry.appId);
return true;
}
/** Leave the open folder, else yield to the sidebar; true when that left the grid. */
private back(): boolean {
if (this.currentFolder !== null) {
this.exitFolder();
return false;
}
shell.yieldFocusToSidebar();
return true;
}
/**
* App-specific entries for the window's context 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[] {
const entry = this.grid.selectedItem;
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.grid.enterRowMode();
},
},
{ 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, padding } = ctx.stack.getBaseSize();
const image = new GrayImage(width, height, 0);
const gridX = padding.left;
const gridWidth = width - padding.left - padding.right;
// The grid scrolls, so it runs to the window's top and bottom edges, the
// padding suggested for them inside it: its end rows keep clear of a
// border there, and a row cut off for scrolling meets the border rather
// than a blank strip. A folder's name stays put above its grid instead,
// in a band that scales with the font.
let gridTop = 0;
let padTop = padding.top;
if (this.currentFolder !== null) {
const nameX = gridX + FOLDER_NAME_INSET_X;
image.drawText(font, nameX, padding.top, truncateText(font, this.currentFolder, gridWidth - 2 * FOLDER_NAME_INSET_X), 160);
gridTop = padding.top + font.lineHeight + FOLDER_NAME_GAP;
padTop = 0;
}
this.grid.paint(image, { x: gridX, y: gridTop, width: gridWidth, height: height - gridTop, padTop, padBottom: padding.bottom },
ctx.stack.isFocused());
return image;
}
async handleInput(event: InputEvent, ctx: LayerContext): Promise<void> {
await this.grid.handleInput(event, ctx);
}
/** A touch on the phone's mirror opens the cell under it. */
async hitTest(x: number, y: number, ctx: LayerContext): Promise<boolean> {
return await this.grid.hitTest(x, y, ctx);
}
}
/**
* 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,
onFocus: (lastInput) => gridLayer.onFocus(lastInput),
// 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("|");
}