mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
1387 lines
51 KiB
TypeScript
1387 lines
51 KiB
TypeScript
/**
|
|
* The Timers app window: one screen for countdown timers, the stopwatch and
|
|
* alarms. See notes/timers-app-design.md for the design.
|
|
*
|
|
* Layout is stage + list. The right ~40% is a list of rows under three
|
|
* section headers (TIMERS / STOPWATCH / ALARMS); the selected row is shown
|
|
* large on the left stage. Scroll moves the selection, click does the
|
|
* obvious thing for the selected row (pause, resume, start, stop, toggle,
|
|
* dismiss), tap-then-hold opens the row's context menu, double-click leaves
|
|
* the app. Pickers (the duration dial, the fine-tune fields, the alarm time
|
|
* fields) and a ringing item's buttons are transient states of the same
|
|
* screen and double-click cancels them.
|
|
*
|
|
* All state lives in the engine (timer-engine.ts); this file only paints it
|
|
* and turns gestures into engine calls.
|
|
*/
|
|
import { GrayImage, type UiFont } from "../../graphics/image";
|
|
import { getFont } from "../../graphics/bdffont";
|
|
import { ensurePreinstalledFonts, installedFontPath } from "../../graphics/installed-fonts";
|
|
import { truncateText } from "../../graphics/textwrap";
|
|
import { TtfFont } from "../../graphics/ttf-font";
|
|
import { getDefaultMediumFont, getDefaultSmallFont } from "../../graphics/ui-fonts";
|
|
import { timeFormatSetting } from "../../ui/dashboard-settings";
|
|
import {
|
|
GESTURE_CLICK,
|
|
GESTURE_DOUBLE_CLICK,
|
|
GESTURE_SCROLL,
|
|
GESTURE_SHORT_THEN_LONG_PRESS,
|
|
gestureHints,
|
|
type InputEvent,
|
|
} from "../../ui/gestures";
|
|
import { type Layer, type LayerContext } from "../../ui/layers";
|
|
import {
|
|
drawRightValueMenuItem,
|
|
drawToggleMenuItem,
|
|
TextPageLayer,
|
|
type MenuItem,
|
|
} from "../../ui/menu";
|
|
import { Menu, type MenuDrawArgs } from "../../ui/menu-core";
|
|
import { LIST_ROW_TEXT_INSET, lineStep, listRowHeight } from "../../ui/metrics";
|
|
import { createInProcessWindow, type InProcessAppOptions, type InProcessWindow } from "../../ui/shell/in-process-window";
|
|
import { shell } from "../../ui/shell/shell";
|
|
import { WindowMenuLayer } from "../../ui/window-menu";
|
|
import { clamp } from "../../util/numeric-util";
|
|
import {
|
|
soonestRunningTimerRemainingMs,
|
|
timerEngine,
|
|
timersSnoozeSetting,
|
|
timersSoundSetting,
|
|
timersWakeSetting,
|
|
type RingingItem,
|
|
type SnoozeMinutes,
|
|
} from "./timer-engine";
|
|
import {
|
|
alarmNextRingMs,
|
|
DAY_BITS,
|
|
DAY_FULL_NAMES,
|
|
DAY_LETTERS,
|
|
DEFAULT_TIMER_DURATION_MS,
|
|
DURATION_LADDER_MS,
|
|
EVERY_DAY_MASK,
|
|
formatClockAt,
|
|
formatCountdown,
|
|
formatDays,
|
|
formatDurationWords,
|
|
formatElapsed,
|
|
formatSpanWords,
|
|
formatTimeOfDay,
|
|
nearestLadderIndex,
|
|
sortAlarms,
|
|
sortTimers,
|
|
stopwatchElapsedMs,
|
|
stopwatchIsRunning,
|
|
timerDisplayName,
|
|
timerPhase,
|
|
timerRemainingMs,
|
|
timerProgress,
|
|
WEEKDAYS_MASK,
|
|
WEEKEND_MASK,
|
|
type Alarm,
|
|
type CountdownTimer,
|
|
} from "./timer-model";
|
|
|
|
export const TIMER_WINDOW_ID = "timer";
|
|
export const TIMER_SURFACE_ID = "window:timer";
|
|
|
|
/** Width of the list column, as a share of the viewport, and its bounds. */
|
|
const LIST_SHARE = 0.4;
|
|
const LIST_MIN_WIDTH = 190;
|
|
const LIST_MAX_WIDTH = 240;
|
|
const LIST_TOP = 6;
|
|
/** Pixels between consecutive list rows' selection boxes. */
|
|
const LIST_ROW_GAP = 1;
|
|
const STAGE_X = 10;
|
|
/** Gap between the stage's right edge and the list's divider. */
|
|
const STAGE_LIST_GAP = 14;
|
|
/** Brightness factor for the list while a picker owns the stage. */
|
|
const LIST_DIM = 0.4;
|
|
/** Big-digit sizes tried largest first until the text fits the stage. */
|
|
const DIGIT_SIZES = [96, 80, 64, 52, 40];
|
|
/** Field digits in the pickers. */
|
|
const FIELD_DIGIT_SIZE = 56;
|
|
const MINUTE_MS = 60_000;
|
|
|
|
type RowKind = "header" | "timer" | "new-timer" | "stopwatch" | "alarm" | "new-alarm";
|
|
|
|
type Row = {
|
|
key: string;
|
|
kind: RowKind;
|
|
title?: string;
|
|
timer?: CountdownTimer;
|
|
alarm?: Alarm;
|
|
};
|
|
|
|
/**
|
|
* Screen state beyond the selection. "list" is the resting state; the rest
|
|
* are pickers that own the stage and the scroll wheel until they finish or
|
|
* a double-click cancels them.
|
|
*/
|
|
type Mode =
|
|
| { kind: "list" }
|
|
| { kind: "dial"; index: number; label: string }
|
|
| { kind: "fine"; hours: number; minutes: number; seconds: number; field: number; label: string }
|
|
| { kind: "alarm-time"; alarmId: number | null; hour: number; minute: number; field: number };
|
|
|
|
type LabelTarget = { kind: "timer" | "alarm"; id: number } | { kind: "new-timer" };
|
|
|
|
function timerKey(timer: CountdownTimer): string {
|
|
return `timer:${timer.id}`;
|
|
}
|
|
|
|
function alarmKey(alarm: Alarm): string {
|
|
return `alarm:${alarm.id}`;
|
|
}
|
|
|
|
function ringingKey(item: RingingItem): string {
|
|
return item.kind === "timer" ? timerKey(item.timer) : alarmKey(item.alarm);
|
|
}
|
|
|
|
function twelveHour(): boolean {
|
|
return timeFormatSetting.get() === "12h";
|
|
}
|
|
|
|
function smallFont(): UiFont {
|
|
return getDefaultSmallFont();
|
|
}
|
|
|
|
function mediumFont(): UiFont {
|
|
return getDefaultMediumFont();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Big digits
|
|
|
|
let digitFontsEnsured = false;
|
|
|
|
/** The bundled Roboto Bold at a pixel size, or the largest bitmap face off-Android. */
|
|
function digitFont(sizePx: number): UiFont {
|
|
if (!digitFontsEnsured) {
|
|
digitFontsEnsured = true;
|
|
try {
|
|
ensurePreinstalledFonts();
|
|
} catch (error) {
|
|
console.warn(`timers digit font preinstall failed: ${error}`);
|
|
}
|
|
}
|
|
return TtfFont.load(installedFontPath("Roboto-Bold.ttf"), sizePx) ?? getFont("terminus32");
|
|
}
|
|
|
|
/** The biggest digit font whose rendering of `text` fits `maxWidth`. */
|
|
function fittingDigitFont(text: string, maxWidth: number, sizes: readonly number[] = DIGIT_SIZES): UiFont {
|
|
let font = digitFont(sizes[0]!);
|
|
for (const size of sizes) {
|
|
font = digitFont(size);
|
|
if (font.measureText(text) <= maxWidth) return font;
|
|
}
|
|
return font;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// The layer
|
|
|
|
export class TimersLayer implements Layer {
|
|
readonly acceptsDirectional = true;
|
|
|
|
/**
|
|
* The selected row's key: the source of truth for the selection, which
|
|
* survives row rebuilds and is pinned to newly ringing items. The list
|
|
* menu is re-synced from it before each paint, hit test and move.
|
|
*/
|
|
private selectionKey = "";
|
|
private readonly list = new Menu<Row>({
|
|
wrap: true,
|
|
rowGap: LIST_ROW_GAP,
|
|
highlight: { radius: 6 },
|
|
getHeight: () => listRowHeight(smallFont()),
|
|
isSelectable: (row) => row.kind !== "header",
|
|
draw: (args) => this.drawListRow(args),
|
|
});
|
|
/** Per-paint inputs to drawListRow. */
|
|
private listPaint = { dim: 1, now: 0 };
|
|
private mode: Mode = { kind: "list" };
|
|
/** Which of the ringing stage's two buttons is highlighted. */
|
|
private ringButton = 0;
|
|
/** Where the next text input (a label) goes; null means the selected item. */
|
|
private labelTarget: LabelTarget | null = null;
|
|
/** Ringing items already jumped to, so a second ring doesn't re-pin. */
|
|
private seenRinging = new Set<string>();
|
|
/** Set the first time this layer paints, to land the selection sensibly. */
|
|
private initialised = false;
|
|
/** Feedback shown on the stage after a picker refuses (e.g. zero duration). */
|
|
private notice = "";
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Rows
|
|
|
|
private buildRows(now: number): Row[] {
|
|
const state = timerEngine.state;
|
|
const rows: Row[] = [{ key: "h:timers", kind: "header", title: "TIMERS" }];
|
|
for (const timer of sortTimers(state.timers, now)) rows.push({ key: timerKey(timer), kind: "timer", timer });
|
|
rows.push({ key: "new-timer", kind: "new-timer" });
|
|
rows.push({ key: "h:stopwatch", kind: "header", title: "STOPWATCH" }, { key: "stopwatch", kind: "stopwatch" });
|
|
rows.push({ key: "h:alarms", kind: "header", title: "ALARMS" });
|
|
for (const alarm of sortAlarms(state.alarms)) rows.push({ key: alarmKey(alarm), kind: "alarm", alarm });
|
|
rows.push({ key: "new-alarm", kind: "new-alarm" });
|
|
return rows;
|
|
}
|
|
|
|
/** The most urgent row: ringing, then a running timer, a running stopwatch, else New timer. */
|
|
private defaultSelection(rows: Row[]): string {
|
|
const ringing = timerEngine.ringingItems()[0];
|
|
if (ringing) return ringingKey(ringing);
|
|
const running = rows.find((row) => row.timer && timerPhase(row.timer) === "running");
|
|
if (running) return running.key;
|
|
if (stopwatchIsRunning(timerEngine.state.stopwatch)) return "stopwatch";
|
|
return "new-timer";
|
|
}
|
|
|
|
/** Keep the selection on a real, selectable row after the rows change. */
|
|
private reconcileSelection(rows: Row[]): number {
|
|
if (!this.initialised) {
|
|
this.initialised = true;
|
|
this.selectionKey = this.defaultSelection(rows);
|
|
for (const item of timerEngine.ringingItems()) this.seenRinging.add(ringingKey(item));
|
|
}
|
|
let index = rows.findIndex((row) => row.key === this.selectionKey);
|
|
if (index < 0) {
|
|
// The row went away (a dismissed timer, a deleted alarm): stay in place.
|
|
const firstVisibleRow = Math.floor(this.list.scrollTop / listRowHeight(smallFont()));
|
|
index = clamp(firstVisibleRow, 0, rows.length - 1);
|
|
while (index < rows.length && rows[index]!.kind === "header") index++;
|
|
if (index >= rows.length) index = rows.findIndex((row) => row.kind !== "header");
|
|
this.selectionKey = rows[index]!.key;
|
|
}
|
|
return index;
|
|
}
|
|
|
|
private selectedRow(rows: Row[]): Row {
|
|
return rows[this.reconcileSelection(rows)]!;
|
|
}
|
|
|
|
/** Point the list menu at these rows and the current selection. */
|
|
private syncList(rows: Row[]): void {
|
|
this.list.setItems(rows, this.reconcileSelection(rows));
|
|
}
|
|
|
|
private moveSelection(rows: Row[], delta: -1 | 1): void {
|
|
this.syncList(rows);
|
|
this.list.moveSelection(delta);
|
|
const index = this.list.selectedIndex;
|
|
if (index !== null) this.selectionKey = rows[index]!.key;
|
|
}
|
|
|
|
/** Called on every engine change: jump to a newly ringing item. */
|
|
onEngineChanged(): void {
|
|
const ringing = timerEngine.ringingItems();
|
|
const keys = new Set(ringing.map(ringingKey));
|
|
for (const key of Array.from(this.seenRinging)) {
|
|
if (!keys.has(key)) this.seenRinging.delete(key);
|
|
}
|
|
for (const item of ringing) {
|
|
const key = ringingKey(item);
|
|
if (this.seenRinging.has(key)) continue;
|
|
this.seenRinging.add(key);
|
|
this.selectionKey = key;
|
|
this.ringButton = 0;
|
|
this.mode = { kind: "list" };
|
|
this.notice = "";
|
|
}
|
|
}
|
|
|
|
private ringingOf(row: Row): RingingItem | null {
|
|
if (row.timer && row.timer.rungAtMs !== null) return { kind: "timer", timer: row.timer };
|
|
if (row.alarm && row.alarm.ringingSinceMs !== null) return { kind: "alarm", alarm: row.alarm };
|
|
return null;
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Input
|
|
|
|
async handleInput(event: InputEvent, _ctx: LayerContext): Promise<void> {
|
|
timerEngine.check();
|
|
const now = Date.now();
|
|
const rows = this.buildRows(now);
|
|
switch (this.mode.kind) {
|
|
case "dial":
|
|
this.handleDialInput(event, this.mode);
|
|
return;
|
|
case "fine":
|
|
this.handleFineInput(event, this.mode);
|
|
return;
|
|
case "alarm-time":
|
|
this.handleAlarmTimeInput(event, this.mode);
|
|
return;
|
|
default:
|
|
this.handleListInput(event, rows);
|
|
}
|
|
}
|
|
|
|
private handleListInput(event: InputEvent, rows: Row[]): void {
|
|
const row = this.selectedRow(rows);
|
|
const ringing = this.ringingOf(row);
|
|
switch (event.type) {
|
|
case "scroll-up":
|
|
case "swipe-up":
|
|
if (ringing) this.ringButton = 0;
|
|
else this.moveSelection(rows, -1);
|
|
return;
|
|
case "scroll-down":
|
|
case "swipe-down":
|
|
if (ringing) this.ringButton = 1;
|
|
else this.moveSelection(rows, 1);
|
|
return;
|
|
case "swipe-left":
|
|
if (ringing) this.ringButton = 0;
|
|
else shell.yieldFocusToSidebar();
|
|
return;
|
|
case "swipe-right":
|
|
if (ringing) this.ringButton = 1;
|
|
else this.activateRow(row);
|
|
return;
|
|
case "click":
|
|
this.activateRow(row);
|
|
return;
|
|
case "double-click":
|
|
shell.yieldFocusToSidebar();
|
|
return;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
/** Click on a row: its primary action. */
|
|
private activateRow(row: Row): void {
|
|
this.notice = "";
|
|
switch (row.kind) {
|
|
case "timer": {
|
|
const timer = row.timer!;
|
|
switch (timerPhase(timer)) {
|
|
case "running":
|
|
timerEngine.pauseTimer(timer.id);
|
|
return;
|
|
case "paused":
|
|
timerEngine.resumeTimer(timer.id);
|
|
return;
|
|
case "rung":
|
|
if (this.ringButton === 0) timerEngine.removeTimer(timer.id);
|
|
else timerEngine.restartTimer(timer.id);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
case "new-timer":
|
|
this.openDial("");
|
|
return;
|
|
case "stopwatch":
|
|
timerEngine.stopwatchToggle();
|
|
return;
|
|
case "alarm": {
|
|
const alarm = row.alarm!;
|
|
if (alarm.ringingSinceMs !== null) {
|
|
if (this.ringButton === 0) timerEngine.dismissAlarm(alarm.id);
|
|
else timerEngine.snoozeAlarm(alarm.id);
|
|
return;
|
|
}
|
|
timerEngine.setAlarmEnabled(alarm.id, !alarm.enabled);
|
|
return;
|
|
}
|
|
case "new-alarm":
|
|
this.openAlarmTime(null);
|
|
return;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
private openDial(label: string): void {
|
|
const last = timerEngine.state.recentDurationsMs[0] ?? DEFAULT_TIMER_DURATION_MS;
|
|
this.mode = { kind: "dial", index: nearestLadderIndex(last), label };
|
|
}
|
|
|
|
private openFine(label: string, durationMs: number): void {
|
|
const totalSeconds = Math.round(durationMs / 1000);
|
|
this.mode = {
|
|
kind: "fine",
|
|
hours: Math.min(23, Math.floor(totalSeconds / 3600)),
|
|
minutes: Math.floor(totalSeconds / 60) % 60,
|
|
seconds: totalSeconds % 60,
|
|
field: 0,
|
|
label,
|
|
};
|
|
}
|
|
|
|
private openAlarmTime(alarm: Alarm | null): void {
|
|
this.mode = {
|
|
kind: "alarm-time",
|
|
alarmId: alarm?.id ?? null,
|
|
hour: alarm?.hour ?? 7,
|
|
minute: alarm?.minute ?? 0,
|
|
field: 0,
|
|
};
|
|
}
|
|
|
|
private startTimer(durationMs: number, label: string): void {
|
|
const timer = timerEngine.startTimer(durationMs, label);
|
|
this.selectionKey = timerKey(timer);
|
|
this.mode = { kind: "list" };
|
|
this.notice = "";
|
|
}
|
|
|
|
private handleDialInput(event: InputEvent, mode: Extract<Mode, { kind: "dial" }>): void {
|
|
switch (event.type) {
|
|
case "scroll-up":
|
|
case "swipe-up":
|
|
mode.index = Math.min(DURATION_LADDER_MS.length - 1, mode.index + 1);
|
|
return;
|
|
case "scroll-down":
|
|
case "swipe-down":
|
|
mode.index = Math.max(0, mode.index - 1);
|
|
return;
|
|
case "click":
|
|
case "swipe-right":
|
|
this.startTimer(DURATION_LADDER_MS[mode.index]!, mode.label);
|
|
return;
|
|
case "double-click":
|
|
case "swipe-left":
|
|
this.mode = { kind: "list" };
|
|
return;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
private handleFineInput(event: InputEvent, mode: Extract<Mode, { kind: "fine" }>): void {
|
|
const adjust = (delta: number) => {
|
|
if (mode.field === 0) mode.hours = (mode.hours + delta + 24) % 24;
|
|
else if (mode.field === 1) mode.minutes = (mode.minutes + delta + 60) % 60;
|
|
else mode.seconds = (mode.seconds + delta + 60) % 60;
|
|
this.notice = "";
|
|
};
|
|
switch (event.type) {
|
|
case "scroll-up":
|
|
case "swipe-up":
|
|
adjust(1);
|
|
return;
|
|
case "scroll-down":
|
|
case "swipe-down":
|
|
adjust(-1);
|
|
return;
|
|
case "swipe-right":
|
|
mode.field = Math.min(2, mode.field + 1);
|
|
return;
|
|
case "swipe-left":
|
|
mode.field = Math.max(0, mode.field - 1);
|
|
return;
|
|
case "click": {
|
|
if (mode.field < 2) {
|
|
mode.field++;
|
|
return;
|
|
}
|
|
const durationMs = ((mode.hours * 60 + mode.minutes) * 60 + mode.seconds) * 1000;
|
|
if (durationMs <= 0) {
|
|
this.notice = "Choose a duration longer than zero";
|
|
mode.field = 0;
|
|
return;
|
|
}
|
|
this.startTimer(durationMs, mode.label);
|
|
return;
|
|
}
|
|
case "double-click":
|
|
if (mode.field > 0) mode.field--;
|
|
else this.mode = { kind: "list" };
|
|
return;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
/** Field count of the alarm time picker: hour, minute tens, minute ones, and AM/PM in 12-hour mode. */
|
|
private alarmFieldCount(): number {
|
|
return twelveHour() ? 4 : 3;
|
|
}
|
|
|
|
private handleAlarmTimeInput(event: InputEvent, mode: Extract<Mode, { kind: "alarm-time" }>): void {
|
|
const fields = this.alarmFieldCount();
|
|
const adjust = (delta: number) => {
|
|
const tens = Math.floor(mode.minute / 10);
|
|
const ones = mode.minute % 10;
|
|
if (mode.field === 0) {
|
|
if (twelveHour()) {
|
|
// Step within the current half of the day (1..12 wraps without flipping AM/PM).
|
|
const pm = mode.hour >= 12;
|
|
const hour12 = ((mode.hour + 11) % 12) + 1;
|
|
const next = ((hour12 - 1 + delta + 12) % 12) + 1;
|
|
mode.hour = (next % 12) + (pm ? 12 : 0);
|
|
} else {
|
|
mode.hour = (mode.hour + delta + 24) % 24;
|
|
}
|
|
} else if (mode.field === 1) {
|
|
mode.minute = ((tens + delta + 6) % 6) * 10 + ones;
|
|
} else if (mode.field === 2) {
|
|
mode.minute = tens * 10 + ((ones + delta + 10) % 10);
|
|
} else {
|
|
mode.hour = (mode.hour + 12) % 24;
|
|
}
|
|
};
|
|
switch (event.type) {
|
|
case "scroll-up":
|
|
case "swipe-up":
|
|
adjust(1);
|
|
return;
|
|
case "scroll-down":
|
|
case "swipe-down":
|
|
adjust(-1);
|
|
return;
|
|
case "swipe-right":
|
|
mode.field = Math.min(fields - 1, mode.field + 1);
|
|
return;
|
|
case "swipe-left":
|
|
mode.field = Math.max(0, mode.field - 1);
|
|
return;
|
|
case "click": {
|
|
if (mode.field < fields - 1) {
|
|
mode.field++;
|
|
return;
|
|
}
|
|
if (mode.alarmId === null) {
|
|
const alarm = timerEngine.addAlarm(mode.hour, mode.minute, 0, "");
|
|
this.selectionKey = alarmKey(alarm);
|
|
} else {
|
|
timerEngine.setAlarmTime(mode.alarmId, mode.hour, mode.minute);
|
|
}
|
|
this.mode = { kind: "list" };
|
|
return;
|
|
}
|
|
case "double-click":
|
|
if (mode.field > 0) mode.field--;
|
|
else this.mode = { kind: "list" };
|
|
return;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
/** A mirror touch: on the list, select the row under it. */
|
|
hitTest(x: number, y: number, ctx: LayerContext): boolean {
|
|
if (this.mode.kind !== "list") return false;
|
|
const { width } = ctx.stack.getBaseSize();
|
|
const listX = width - listWidthFor(width);
|
|
if (x < listX) return false;
|
|
const rows = this.buildRows(Date.now());
|
|
this.syncList(rows);
|
|
const index = this.list.indexAt(y);
|
|
if (index === null) return true;
|
|
const row = rows[index]!;
|
|
if (this.selectionKey === row.key) {
|
|
this.activateRow(row);
|
|
} else {
|
|
this.selectionKey = row.key;
|
|
this.ringButton = 0;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Text input (labels)
|
|
|
|
receiveTextInput(text: string): void {
|
|
const label = text.trim();
|
|
const target = this.labelTarget;
|
|
this.labelTarget = null;
|
|
if (target?.kind === "new-timer" || (!target && (this.mode.kind === "dial" || this.mode.kind === "fine"))) {
|
|
if (this.mode.kind === "dial" || this.mode.kind === "fine") this.mode.label = label;
|
|
return;
|
|
}
|
|
if (target?.kind === "timer") {
|
|
timerEngine.setTimerLabel(target.id, label);
|
|
return;
|
|
}
|
|
if (target?.kind === "alarm") {
|
|
timerEngine.setAlarmLabel(target.id, label);
|
|
return;
|
|
}
|
|
const row = this.selectedRow(this.buildRows(Date.now()));
|
|
if (row.timer) timerEngine.setTimerLabel(row.timer.id, label);
|
|
else if (row.alarm) timerEngine.setAlarmLabel(row.alarm.id, label);
|
|
}
|
|
|
|
/** Aim the shell's text-entry dialog at a label, then open it. */
|
|
private askForLabel(target: LabelTarget): void {
|
|
this.labelTarget = target;
|
|
shell.startVoiceInput();
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Context menus
|
|
|
|
menuItems(): MenuItem[] {
|
|
if (this.mode.kind === "alarm-time") return [];
|
|
if (this.mode.kind === "dial" || this.mode.kind === "fine") return this.pickerMenuItems(this.mode);
|
|
const now = Date.now();
|
|
const row = this.selectedRow(this.buildRows(now));
|
|
const items: MenuItem[] = [];
|
|
switch (row.kind) {
|
|
case "timer":
|
|
items.push(...this.timerMenuItems(row.timer!));
|
|
break;
|
|
case "new-timer":
|
|
for (const durationMs of timerEngine.state.recentDurationsMs) {
|
|
items.push({
|
|
label: `Start ${formatDurationWords(durationMs)}`,
|
|
onSelect: (ctx) => {
|
|
ctx.stack.pop();
|
|
this.startTimer(durationMs, "");
|
|
},
|
|
});
|
|
}
|
|
items.push({
|
|
label: "Fine-tune a duration",
|
|
onSelect: (ctx) => {
|
|
ctx.stack.pop();
|
|
this.openFine("", timerEngine.state.recentDurationsMs[0] ?? DEFAULT_TIMER_DURATION_MS);
|
|
},
|
|
});
|
|
break;
|
|
case "stopwatch":
|
|
items.push(...this.stopwatchMenuItems());
|
|
break;
|
|
case "alarm":
|
|
items.push(...this.alarmMenuItems(row.alarm!));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
items.push({
|
|
label: "Settings",
|
|
onSelect: (ctx) => ctx.stack.push(new WindowMenuLayer("Timers settings", this.settingsMenuItems())),
|
|
});
|
|
return items;
|
|
}
|
|
|
|
private pickerMenuItems(mode: Extract<Mode, { kind: "dial" | "fine" }>): MenuItem[] {
|
|
const items: MenuItem[] = [];
|
|
if (mode.kind === "dial") {
|
|
items.push({
|
|
label: "Fine-tune (h:mm:ss)",
|
|
onSelect: (ctx) => {
|
|
ctx.stack.pop();
|
|
this.openFine(mode.label, DURATION_LADDER_MS[mode.index]!);
|
|
},
|
|
});
|
|
}
|
|
items.push({
|
|
label: mode.label ? `Label: ${mode.label}` : "Set a label",
|
|
onSelect: (ctx) => {
|
|
ctx.stack.pop();
|
|
this.askForLabel({ kind: "new-timer" });
|
|
},
|
|
});
|
|
items.push({
|
|
label: "Cancel",
|
|
onSelect: (ctx) => {
|
|
ctx.stack.pop();
|
|
this.mode = { kind: "list" };
|
|
},
|
|
});
|
|
return items;
|
|
}
|
|
|
|
private timerMenuItems(timer: CountdownTimer): MenuItem[] {
|
|
const phase = timerPhase(timer);
|
|
const items: MenuItem[] = [];
|
|
if (phase === "rung") {
|
|
items.push(
|
|
{ label: "Dismiss", onSelect: (ctx) => { ctx.stack.pop(); timerEngine.removeTimer(timer.id); } },
|
|
{ label: "Again", onSelect: (ctx) => { ctx.stack.pop(); timerEngine.restartTimer(timer.id); } },
|
|
);
|
|
}
|
|
items.push({
|
|
label: "+1 minute",
|
|
onSelect: (ctx) => {
|
|
ctx.stack.pop();
|
|
timerEngine.addTimerTime(timer.id, MINUTE_MS);
|
|
},
|
|
});
|
|
if (phase === "running") {
|
|
items.push({ label: "Pause", onSelect: (ctx) => { ctx.stack.pop(); timerEngine.pauseTimer(timer.id); } });
|
|
} else if (phase === "paused") {
|
|
items.push({ label: "Resume", onSelect: (ctx) => { ctx.stack.pop(); timerEngine.resumeTimer(timer.id); } });
|
|
}
|
|
if (phase !== "rung") {
|
|
items.push({ label: "Restart", onSelect: (ctx) => { ctx.stack.pop(); timerEngine.restartTimer(timer.id); } });
|
|
}
|
|
items.push({
|
|
label: timer.label ? `Label: ${timer.label}` : "Set a label",
|
|
onSelect: (ctx) => {
|
|
ctx.stack.pop();
|
|
this.askForLabel({ kind: "timer", id: timer.id });
|
|
},
|
|
});
|
|
if (phase !== "rung") {
|
|
items.push({ label: "Delete", onSelect: (ctx) => { ctx.stack.pop(); timerEngine.removeTimer(timer.id); } });
|
|
}
|
|
return items;
|
|
}
|
|
|
|
private stopwatchMenuItems(): MenuItem[] {
|
|
const stopwatch = timerEngine.state.stopwatch;
|
|
const running = stopwatchIsRunning(stopwatch);
|
|
const items: MenuItem[] = [];
|
|
if (running) {
|
|
items.push({ label: "Lap", onSelect: (ctx) => { ctx.stack.pop(); timerEngine.stopwatchLap(); } });
|
|
}
|
|
items.push({
|
|
label: running ? "Stop" : "Start",
|
|
onSelect: (ctx) => {
|
|
ctx.stack.pop();
|
|
timerEngine.stopwatchToggle();
|
|
},
|
|
});
|
|
items.push({
|
|
label: "Reset",
|
|
disabled: () => stopwatchElapsedMs(timerEngine.state.stopwatch, Date.now()) === 0,
|
|
onSelect: (ctx) => {
|
|
ctx.stack.pop();
|
|
timerEngine.stopwatchReset();
|
|
},
|
|
});
|
|
return items;
|
|
}
|
|
|
|
private alarmMenuItems(alarm: Alarm): MenuItem[] {
|
|
const items: MenuItem[] = [];
|
|
if (alarm.ringingSinceMs !== null) {
|
|
items.push(
|
|
{ label: "Dismiss", onSelect: (ctx) => { ctx.stack.pop(); timerEngine.dismissAlarm(alarm.id); } },
|
|
{
|
|
label: `Snooze ${timersSnoozeSetting.get()} min`,
|
|
onSelect: (ctx) => { ctx.stack.pop(); timerEngine.snoozeAlarm(alarm.id); },
|
|
},
|
|
);
|
|
} else {
|
|
items.push({
|
|
label: alarm.enabled ? "Turn off" : "Turn on",
|
|
onSelect: (ctx) => {
|
|
ctx.stack.pop();
|
|
timerEngine.setAlarmEnabled(alarm.id, !alarm.enabled);
|
|
},
|
|
});
|
|
}
|
|
items.push({
|
|
label: "Change time",
|
|
onSelect: (ctx) => {
|
|
ctx.stack.pop();
|
|
this.openAlarmTime(alarm);
|
|
},
|
|
});
|
|
items.push({
|
|
label: `Repeat: ${formatDays(alarm.days)}`,
|
|
onSelect: (ctx) => ctx.stack.push(new WindowMenuLayer("Repeat", this.repeatMenuItems(alarm.id))),
|
|
});
|
|
items.push({
|
|
label: alarm.label ? `Label: ${alarm.label}` : "Set a label",
|
|
onSelect: (ctx) => {
|
|
ctx.stack.pop();
|
|
this.askForLabel({ kind: "alarm", id: alarm.id });
|
|
},
|
|
});
|
|
items.push({ label: "Delete", onSelect: (ctx) => { ctx.stack.pop(); timerEngine.deleteAlarm(alarm.id); } });
|
|
return items;
|
|
}
|
|
|
|
/** Repeat presets, then one toggle per weekday; the menu stays open while toggling. */
|
|
private repeatMenuItems(alarmId: number): MenuItem[] {
|
|
const days = () => timerEngine.findAlarm(alarmId)?.days ?? 0;
|
|
const preset = (label: string, mask: number): MenuItem => ({
|
|
label,
|
|
onSelect: (ctx) => {
|
|
ctx.stack.pop();
|
|
timerEngine.setAlarmDays(alarmId, mask);
|
|
},
|
|
});
|
|
const items: MenuItem[] = [
|
|
preset("Once", 0),
|
|
preset("Weekdays", WEEKDAYS_MASK),
|
|
preset("Weekends", WEEKEND_MASK),
|
|
preset("Every day", EVERY_DAY_MASK),
|
|
];
|
|
for (let index = 0; index < 7; index++) {
|
|
const bit = DAY_BITS[index]!;
|
|
items.push({
|
|
label: DAY_FULL_NAMES[index]!,
|
|
onSelect: () => timerEngine.setAlarmDays(alarmId, days() ^ bit),
|
|
render: (args) =>
|
|
drawToggleMenuItem(args.image, smallFont(), args.x, args.y, args.width, args.text, (days() & bit) !== 0, args.selected),
|
|
});
|
|
}
|
|
return items;
|
|
}
|
|
|
|
private settingsMenuItems(): MenuItem[] {
|
|
const toggle = (label: string, get: () => boolean, set: (value: boolean) => void): MenuItem => ({
|
|
label,
|
|
onSelect: () => set(!get()),
|
|
render: (args) => drawToggleMenuItem(args.image, smallFont(), args.x, args.y, args.width, args.text, get(), args.selected),
|
|
});
|
|
return [
|
|
toggle(timersSoundSetting.label, () => timersSoundSetting.get(), (value) => timersSoundSetting.set(value)),
|
|
toggle(timersWakeSetting.label, () => timersWakeSetting.get(), (value) => timersWakeSetting.set(value)),
|
|
{
|
|
label: timersSnoozeSetting.label,
|
|
onSelect: () => {
|
|
const values = timersSnoozeSetting.values;
|
|
const next = values[(values.indexOf(timersSnoozeSetting.get()) + 1) % values.length] as SnoozeMinutes;
|
|
timersSnoozeSetting.set(next);
|
|
},
|
|
render: (args) =>
|
|
drawRightValueMenuItem(args.image, smallFont(), args.x, args.y, args.width, args.text, timersSnoozeSetting.displayValue()),
|
|
},
|
|
toggle("12-hour clock", () => twelveHour(), (value) => timeFormatSetting.set(value ? "12h" : "24h")),
|
|
{
|
|
label: "Phone alarm check",
|
|
onSelect: (ctx) => {
|
|
timerEngine.refreshReliability(true);
|
|
const issues = timerEngine.phoneReliabilityIssues();
|
|
const body =
|
|
issues.length === 0
|
|
? "No problems found: the phone can ring for alarms when the glasses cannot."
|
|
: issues.map((issue) => `- ${issue.message}`).join("\n") +
|
|
"\n\nFix these from the warning triangle on the phone's home screen.";
|
|
ctx.stack.push(new TextPageLayer("Phone alarm check", body));
|
|
},
|
|
},
|
|
];
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Painting
|
|
|
|
paint(ctx: LayerContext): GrayImage {
|
|
timerEngine.check();
|
|
const now = Date.now();
|
|
const { width, height } = ctx.stack.getBaseSize();
|
|
const image = new GrayImage(width, height, 0);
|
|
const rows = this.buildRows(now);
|
|
const selectedIndex = this.reconcileSelection(rows);
|
|
const listWidth = listWidthFor(width);
|
|
const listX = width - listWidth;
|
|
const picking = this.mode.kind !== "list";
|
|
|
|
this.paintList(image, rows, selectedIndex, listX, listWidth, height, ctx.stack.isFocused(), picking ? LIST_DIM : 1, now);
|
|
image.drawLine(listX - 7, 8, listX - 7, height - 8, picking ? 20 : 40);
|
|
|
|
const stage = { x: STAGE_X, y: 0, width: listX - 7 - STAGE_LIST_GAP - STAGE_X, height };
|
|
switch (this.mode.kind) {
|
|
case "dial":
|
|
this.paintDial(image, stage, this.mode, now);
|
|
break;
|
|
case "fine":
|
|
this.paintFine(image, stage, this.mode);
|
|
break;
|
|
case "alarm-time":
|
|
this.paintAlarmTime(image, stage, this.mode, now);
|
|
break;
|
|
default:
|
|
this.paintStage(image, stage, rows[selectedIndex]!, now, ctx.stack.isFocused());
|
|
}
|
|
return image;
|
|
}
|
|
|
|
private paintList(
|
|
image: GrayImage,
|
|
rows: Row[],
|
|
selectedIndex: number,
|
|
listX: number,
|
|
listWidth: number,
|
|
height: number,
|
|
focused: boolean,
|
|
dim: number,
|
|
now: number,
|
|
): void {
|
|
const rowHeight = listRowHeight(smallFont());
|
|
const visible = Math.max(1, Math.floor((height - 2 * LIST_TOP) / rowHeight));
|
|
this.listPaint = { dim, now };
|
|
// While a picker owns the stage the list has no live selection, so no
|
|
// highlight; drawListRow still brightens the selected row by key.
|
|
this.list.setItems(rows, dim === 1 ? selectedIndex : null);
|
|
this.list.paint(image, { x: listX, y: LIST_TOP, width: listWidth - 12, height: visible * rowHeight - LIST_ROW_GAP }, focused);
|
|
this.list.drawScrollbar(image, listX + listWidth - 7, LIST_TOP, visible * rowHeight - 4);
|
|
}
|
|
|
|
private drawListRow({ image, item: row, x, y, width, height }: MenuDrawArgs<Row>): void {
|
|
const font = smallFont();
|
|
const { dim, now } = this.listPaint;
|
|
const rowHeight = height + LIST_ROW_GAP;
|
|
const shade = (value: number) => Math.round(value * dim);
|
|
const textX = x + 8;
|
|
const textWidth = width - 12;
|
|
const textY = y + LIST_ROW_TEXT_INSET;
|
|
if (row.kind === "header") {
|
|
image.drawText(font, textX, textY, row.title!, shade(90));
|
|
return;
|
|
}
|
|
const selected = row.key === this.selectionKey;
|
|
const bright = shade(selected ? 250 : 210);
|
|
const soft = shade(selected ? 170 : 130);
|
|
switch (row.kind) {
|
|
case "timer": {
|
|
const timer = row.timer!;
|
|
const phase = timerPhase(timer);
|
|
const digits = phase === "rung" ? "0:00" : formatCountdown(timerRemainingMs(timer, now));
|
|
const digitsValue = phase === "rung" ? (Math.floor(now / 1000) % 2 ? bright : soft) : phase === "paused" ? soft : bright;
|
|
image.drawText(font, textX, textY, digits, digitsValue);
|
|
const digitsWidth = font.measureText(digits) + 8;
|
|
const nameWidth = textWidth - digitsWidth - (phase === "paused" ? 12 : 0);
|
|
if (nameWidth > 12) {
|
|
image.drawText(font, textX + digitsWidth, textY, truncateText(font, timerDisplayName(timer), nameWidth), soft);
|
|
}
|
|
if (phase === "paused") drawPauseMark(image, x + width - 10, y + Math.floor(rowHeight / 2) - 5, soft);
|
|
break;
|
|
}
|
|
case "new-timer":
|
|
image.drawText(font, textX, textY, "+ New timer", shade(selected ? 220 : 150));
|
|
break;
|
|
case "stopwatch": {
|
|
const stopwatch = timerEngine.state.stopwatch;
|
|
const running = stopwatchIsRunning(stopwatch);
|
|
const elapsed = formatElapsed(stopwatchElapsedMs(stopwatch, now), false);
|
|
image.drawText(font, textX, textY, "Stopwatch", running ? bright : soft);
|
|
image.drawText(font, x + width - 4 - font.measureText(elapsed), textY, elapsed, running ? bright : soft);
|
|
break;
|
|
}
|
|
case "alarm": {
|
|
const alarm = row.alarm!;
|
|
const on = alarm.enabled;
|
|
const time = formatTimeOfDay(alarm.hour, alarm.minute, twelveHour());
|
|
image.drawText(font, textX, textY, time, on ? bright : soft);
|
|
const timeWidth = font.measureText(time) + 8;
|
|
const daysWidth = textWidth - timeWidth - 14;
|
|
if (daysWidth > 12) {
|
|
image.drawText(font, textX + timeWidth, textY, truncateText(font, alarm.label || formatDays(alarm.days), daysWidth), on ? soft : shade(80));
|
|
}
|
|
const dotX = x + width - 10;
|
|
const dotY = y + Math.floor(rowHeight / 2) - 4;
|
|
if (alarm.ringingSinceMs !== null || on) image.fillRoundedRect(dotX, dotY, 8, 8, on ? shade(220) : shade(90), 4);
|
|
else image.drawRoundedRect(dotX, dotY, 8, 8, shade(90), 4);
|
|
break;
|
|
}
|
|
case "new-alarm":
|
|
image.drawText(font, textX, textY, "+ New alarm", shade(selected ? 220 : 150));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
private paintStage(image: GrayImage, stage: StageRect, row: Row, now: number, focused: boolean): void {
|
|
switch (row.kind) {
|
|
case "timer":
|
|
this.paintTimerStage(image, stage, row.timer!, now, focused);
|
|
return;
|
|
case "new-timer": {
|
|
const last = timerEngine.state.recentDurationsMs[0] ?? DEFAULT_TIMER_DURATION_MS;
|
|
const block = new StageBlock(stage);
|
|
block.title(image, "New timer", 200);
|
|
block.digits(image, formatCountdown(last), 110);
|
|
block.line(image, `${formatDurationWords(last)} last time`, 120);
|
|
block.hints(image, [[GESTURE_CLICK, "choose duration"], [GESTURE_SHORT_THEN_LONG_PRESS, "recent"]]);
|
|
return;
|
|
}
|
|
case "stopwatch":
|
|
this.paintStopwatchStage(image, stage, now);
|
|
return;
|
|
case "alarm":
|
|
this.paintAlarmStage(image, stage, row.alarm!, now, focused);
|
|
return;
|
|
case "new-alarm": {
|
|
const block = new StageBlock(stage);
|
|
block.title(image, "New alarm", 200);
|
|
block.digits(image, twelveHour() ? "7:00" : "07:00", 110);
|
|
block.line(image, "Rings once unless you set a repeat", 120);
|
|
block.hints(image, [[GESTURE_CLICK, "set time"]]);
|
|
return;
|
|
}
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
private paintTimerStage(image: GrayImage, stage: StageRect, timer: CountdownTimer, now: number, focused: boolean): void {
|
|
const block = new StageBlock(stage);
|
|
const phase = timerPhase(timer);
|
|
if (phase === "rung") {
|
|
const flash = Math.floor(now / 1000) % 2 === 0;
|
|
block.title(image, "Time's up", flash ? 255 : 170);
|
|
block.digits(image, `+${formatCountdown(now - timer.rungAtMs!)}`, 200);
|
|
block.line(image, `${timerDisplayName(timer)} · rang at ${formatClockAt(timer.rungAtMs!, twelveHour())}`, 150);
|
|
block.buttons(image, ["Dismiss", "Again"], this.ringButton, focused);
|
|
block.hints(image, [[GESTURE_SCROLL, "choose"], [GESTURE_CLICK, "select"]]);
|
|
return;
|
|
}
|
|
const remaining = timerRemainingMs(timer, now);
|
|
block.title(image, phase === "paused" ? `${timerDisplayName(timer)} · Paused` : timerDisplayName(timer), 200);
|
|
block.digits(image, formatCountdown(remaining), phase === "paused" ? 150 : 250);
|
|
block.progress(image, timerProgress(timer, now), phase === "paused" ? 120 : 200);
|
|
const info =
|
|
phase === "paused"
|
|
? `${formatDurationWords(timer.durationMs)} timer · ${formatCountdown(remaining)} left`
|
|
: `${formatDurationWords(timer.durationMs)} timer · ends ${formatClockAt(timer.endsAtMs!, twelveHour())}`;
|
|
block.line(image, info, 150);
|
|
block.hints(image, [[GESTURE_CLICK, phase === "paused" ? "resume" : "pause"], [GESTURE_SHORT_THEN_LONG_PRESS, "options"]]);
|
|
}
|
|
|
|
private paintStopwatchStage(image: GrayImage, stage: StageRect, now: number): void {
|
|
const stopwatch = timerEngine.state.stopwatch;
|
|
const running = stopwatchIsRunning(stopwatch);
|
|
const elapsed = stopwatchElapsedMs(stopwatch, now);
|
|
const block = new StageBlock(stage);
|
|
block.title(image, running ? "Stopwatch · Running" : elapsed > 0 ? "Stopwatch · Stopped" : "Stopwatch", 200);
|
|
// Tenths only while stopped: the display updates once a second while running.
|
|
block.digits(image, formatElapsed(elapsed, !running), running ? 250 : elapsed > 0 ? 200 : 130);
|
|
const laps = stopwatch.lapsMs;
|
|
if (laps.length > 0) {
|
|
const font = smallFont();
|
|
const shown = laps.slice(-Math.max(1, Math.min(4, block.linesLeft())));
|
|
for (let index = 0; index < shown.length; index++) {
|
|
const lapIndex = laps.length - shown.length + index;
|
|
const total = shown[index]!;
|
|
const split = total - (lapIndex > 0 ? laps[lapIndex - 1]! : 0);
|
|
block.columns(image, font, [`Lap ${lapIndex + 1}`, formatElapsed(split, true), formatElapsed(total, true)], index === shown.length - 1 ? 190 : 130);
|
|
}
|
|
} else {
|
|
block.line(image, running ? "" : "Laps appear here", 110);
|
|
}
|
|
block.hints(image, [[GESTURE_CLICK, running ? "stop" : "start"], [GESTURE_SHORT_THEN_LONG_PRESS, running ? "lap" : "reset"]]);
|
|
}
|
|
|
|
private paintAlarmStage(image: GrayImage, stage: StageRect, alarm: Alarm, now: number, focused: boolean): void {
|
|
const block = new StageBlock(stage);
|
|
const ringing = alarm.ringingSinceMs !== null;
|
|
const flash = Math.floor(now / 1000) % 2 === 0;
|
|
block.title(image, ringing ? (alarm.label ? `Alarm · ${alarm.label}` : "Alarm") : alarm.label || "Alarm", ringing ? (flash ? 255 : 170) : 200);
|
|
const time = formatTimeOfDay(alarm.hour, alarm.minute, false);
|
|
const suffix = twelveHour() ? (alarm.hour < 12 ? "AM" : "PM") : "";
|
|
block.digits(image, twelveHour() ? formatTimeOfDay(alarm.hour, alarm.minute, true).replace(/ [AP]M$/, "") : time, alarm.enabled ? 250 : 130, suffix);
|
|
block.days(image, alarm.days, alarm.enabled ? 230 : 110);
|
|
if (ringing) {
|
|
block.buttons(image, ["Dismiss", `Snooze ${timersSnoozeSetting.get()}m`], this.ringButton, focused);
|
|
block.hints(image, [[GESTURE_SCROLL, "choose"], [GESTURE_CLICK, "select"]]);
|
|
return;
|
|
}
|
|
let status: string;
|
|
if (!alarm.enabled) status = "Off";
|
|
else if (alarm.snoozedUntilMs !== null) status = `Snoozed until ${formatClockAt(alarm.snoozedUntilMs, twelveHour())}`;
|
|
else {
|
|
const next = alarmNextRingMs(alarm, now);
|
|
status = next === null ? "Off" : `Rings in ${formatSpanWords(next - now)}`;
|
|
}
|
|
block.line(image, status, 150);
|
|
const warning = timerEngine.phoneReliabilityIssues()[0];
|
|
if (alarm.enabled && warning) block.line(image, `Phone: ${warning.message}`, 120);
|
|
block.hints(image, [[GESTURE_CLICK, alarm.enabled ? "turn off" : "turn on"], [GESTURE_SHORT_THEN_LONG_PRESS, "edit"]]);
|
|
}
|
|
|
|
private paintDial(image: GrayImage, stage: StageRect, mode: Extract<Mode, { kind: "dial" }>, now: number): void {
|
|
const durationMs = DURATION_LADDER_MS[mode.index]!;
|
|
const block = new StageBlock(stage);
|
|
block.title(image, mode.label ? `New timer · ${mode.label}` : "New timer", 200);
|
|
block.digits(image, formatCountdown(durationMs), 250);
|
|
block.line(image, `${formatDurationWords(durationMs)} · ends ${formatClockAt(now + durationMs, twelveHour())}`, 150);
|
|
block.hints(image, [[GESTURE_SCROLL, "duration"], [GESTURE_CLICK, "start"], [GESTURE_DOUBLE_CLICK, "cancel"]]);
|
|
}
|
|
|
|
private paintFine(image: GrayImage, stage: StageRect, mode: Extract<Mode, { kind: "fine" }>): void {
|
|
const block = new StageBlock(stage);
|
|
block.title(image, mode.label ? `New timer · ${mode.label}` : "New timer", 200);
|
|
block.fields(image, [pad2(mode.hours), pad2(mode.minutes), pad2(mode.seconds)], [":", ":"], mode.field, ["hours", "min", "sec"]);
|
|
block.line(image, this.notice, 190);
|
|
block.hints(image, [[GESTURE_SCROLL, "adjust"], [GESTURE_CLICK, mode.field < 2 ? "next" : "start"], [GESTURE_DOUBLE_CLICK, "back"]]);
|
|
}
|
|
|
|
private paintAlarmTime(image: GrayImage, stage: StageRect, mode: Extract<Mode, { kind: "alarm-time" }>, now: number): void {
|
|
const block = new StageBlock(stage);
|
|
block.title(image, mode.alarmId === null ? "New alarm" : "Alarm time", 200);
|
|
const tens = String(Math.floor(mode.minute / 10));
|
|
const ones = String(mode.minute % 10);
|
|
if (twelveHour()) {
|
|
const hour12 = ((mode.hour + 11) % 12) + 1;
|
|
block.fields(image, [String(hour12), tens, ones, mode.hour < 12 ? "AM" : "PM"], [":", "", " "], mode.field, ["hour", "", "min", ""]);
|
|
} else {
|
|
block.fields(image, [pad2(mode.hour), tens, ones], [":", ""], mode.field, ["hour", "", "min"]);
|
|
}
|
|
const preview = alarmNextRingMs(
|
|
{ id: 0, hour: mode.hour, minute: mode.minute, days: 0, label: "", enabled: true, snoozedUntilMs: null, ringingSinceMs: null, lastFiredAtMs: null },
|
|
now,
|
|
);
|
|
block.line(image, preview === null ? "" : `Rings in ${formatSpanWords(preview - now)}`, 150);
|
|
const last = this.alarmFieldCount() - 1;
|
|
block.hints(image, [[GESTURE_SCROLL, "adjust"], [GESTURE_CLICK, mode.field < last ? "next" : "save"], [GESTURE_DOUBLE_CLICK, "back"]]);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Stage layout helpers
|
|
|
|
type StageRect = { x: number; y: number; width: number; height: number };
|
|
|
|
/**
|
|
* Lays the stage out top to bottom: a title line, the big digits, then
|
|
* whatever lines follow, with the gesture hints pinned to the bottom. Keeps
|
|
* a cursor so each element stacks under the previous one.
|
|
*/
|
|
class StageBlock {
|
|
private cursorY: number;
|
|
private readonly hintsTop: number;
|
|
|
|
constructor(private readonly rect: StageRect) {
|
|
this.cursorY = rect.y + 12;
|
|
this.hintsTop = rect.y + rect.height - 10 - lineStep(smallFont());
|
|
}
|
|
|
|
title(image: GrayImage, text: string, value: number): void {
|
|
const font = mediumFont();
|
|
image.drawText(font, this.rect.x + 4, this.cursorY, truncateText(font, text, this.rect.width - 8), value);
|
|
this.cursorY += font.lineHeight + 10;
|
|
}
|
|
|
|
/** The big number, centred; `suffix` (AM/PM) sits beside it in the medium font. */
|
|
digits(image: GrayImage, text: string, value: number, suffix = ""): void {
|
|
const suffixFont = mediumFont();
|
|
const suffixWidth = suffix ? suffixFont.measureText(suffix) + 10 : 0;
|
|
const font = fittingDigitFont(text, this.rect.width - 8 - suffixWidth);
|
|
const textWidth = font.measureText(text);
|
|
const x = this.rect.x + Math.max(0, Math.floor((this.rect.width - textWidth - suffixWidth) / 2));
|
|
image.drawText(font, x, this.cursorY, text, value);
|
|
if (suffix) {
|
|
image.drawText(suffixFont, x + textWidth + 10, this.cursorY + font.ascent - suffixFont.ascent, suffix, Math.round(value * 0.8));
|
|
}
|
|
this.cursorY += font.lineHeight + 8;
|
|
}
|
|
|
|
progress(image: GrayImage, fraction: number, value: number): void {
|
|
const x = this.rect.x + 6;
|
|
const width = this.rect.width - 12;
|
|
image.fillRoundedRect(x, this.cursorY, width, 6, 40, 3);
|
|
const filled = Math.round(width * clamp(fraction, 0, 1));
|
|
if (filled > 0) image.fillRoundedRect(x, this.cursorY, Math.max(6, filled), 6, value, 3);
|
|
this.cursorY += 14;
|
|
}
|
|
|
|
line(image: GrayImage, text: string, value: number): void {
|
|
if (!text) return;
|
|
const font = smallFont();
|
|
image.drawText(font, this.rect.x + 6, this.cursorY, truncateText(font, text, this.rect.width - 12), value);
|
|
this.cursorY += lineStep(font);
|
|
}
|
|
|
|
/** How many small-font lines fit between the cursor and the hints. */
|
|
linesLeft(): number {
|
|
return Math.floor((this.hintsTop - 6 - this.cursorY) / lineStep(smallFont()));
|
|
}
|
|
|
|
/** A three-column row (lap table). */
|
|
columns(image: GrayImage, font: UiFont, cells: string[], value: number): void {
|
|
if (this.cursorY + font.lineHeight > this.hintsTop - 4) return;
|
|
const x = this.rect.x + 6;
|
|
const width = this.rect.width - 12;
|
|
const columnWidth = Math.floor(width / cells.length);
|
|
for (let index = 0; index < cells.length; index++) {
|
|
const text = cells[index]!;
|
|
const cellX = index === 0 ? x : x + index * columnWidth + columnWidth - font.measureText(text);
|
|
image.drawText(font, cellX, this.cursorY, text, value);
|
|
}
|
|
this.cursorY += lineStep(font);
|
|
}
|
|
|
|
/** The seven weekday letters, lit for the days in `mask`; "Once" for none. */
|
|
days(image: GrayImage, mask: number, value: number): void {
|
|
const font = smallFont();
|
|
if (mask === 0) {
|
|
this.line(image, "Once", Math.round(value * 0.7));
|
|
return;
|
|
}
|
|
const step = Math.min(26, Math.floor((this.rect.width - 12) / 7));
|
|
const x = this.rect.x + 6;
|
|
for (let index = 0; index < 7; index++) {
|
|
const on = (mask & DAY_BITS[index]!) !== 0;
|
|
const letter = DAY_LETTERS[index]!;
|
|
const letterX = x + index * step + Math.floor((step - font.measureText(letter)) / 2);
|
|
if (on) image.fillRoundedRect(x + index * step + 1, this.cursorY - 2, step - 4, font.lineHeight + 4, 40, 4);
|
|
image.drawText(font, letterX, this.cursorY, letter, on ? value : Math.round(value * 0.35));
|
|
}
|
|
this.cursorY += lineStep(font) + 4;
|
|
}
|
|
|
|
/** Picker fields: boxed values with separators between and captions beneath. */
|
|
fields(image: GrayImage, values: string[], separators: string[], activeField: number, captions: string[]): void {
|
|
const font = digitFont(FIELD_DIGIT_SIZE);
|
|
const sepFont = mediumFont();
|
|
const small = smallFont();
|
|
const padX = 8;
|
|
const widths = values.map((value) => font.measureText(value) + 2 * padX);
|
|
const sepWidths = separators.map((separator) => (separator ? sepFont.measureText(separator) + 8 : 6));
|
|
const total = widths.reduce((sum, width) => sum + width, 0) + sepWidths.reduce((sum, width) => sum + width, 0);
|
|
let x = this.rect.x + Math.max(0, Math.floor((this.rect.width - total) / 2));
|
|
const boxHeight = font.lineHeight + 4;
|
|
for (let index = 0; index < values.length; index++) {
|
|
const width = widths[index]!;
|
|
const active = index === activeField;
|
|
if (active) {
|
|
image.fillRoundedRect(x, this.cursorY - 2, width, boxHeight, 35, 6);
|
|
image.drawRoundedRect(x, this.cursorY - 2, width, boxHeight, 130, 6);
|
|
}
|
|
image.drawText(font, x + padX, this.cursorY, values[index]!, active ? 250 : 170);
|
|
const caption = captions[index] ?? "";
|
|
if (caption) {
|
|
image.drawText(small, x + Math.floor((width - small.measureText(caption)) / 2), this.cursorY + boxHeight + 2, caption, 110);
|
|
}
|
|
x += width;
|
|
if (index < separators.length) {
|
|
const separator = separators[index]!;
|
|
if (separator.trim()) {
|
|
image.drawText(sepFont, x + 4, this.cursorY + font.ascent - sepFont.ascent, separator, 130);
|
|
}
|
|
x += sepWidths[index]!;
|
|
}
|
|
}
|
|
this.cursorY += boxHeight + 2 + small.lineHeight + 10;
|
|
}
|
|
|
|
/** A row of buttons; the highlighted one is filled, the rest outlined. */
|
|
buttons(image: GrayImage, labels: string[], selected: number, focused: boolean): void {
|
|
const font = smallFont();
|
|
const gap = 12;
|
|
const height = font.lineHeight + 14;
|
|
const width = Math.floor((this.rect.width - 12 - gap * (labels.length - 1)) / labels.length);
|
|
const y = Math.max(this.cursorY + 4, this.hintsTop - 10 - height);
|
|
for (let index = 0; index < labels.length; index++) {
|
|
const x = this.rect.x + 6 + index * (width + gap);
|
|
const active = index === selected;
|
|
if (active) {
|
|
image.fillRoundedRect(x, y, width, height, focused ? 40 : 15, 8);
|
|
image.drawRoundedRect(x, y, width, height, 150, 8);
|
|
} else {
|
|
image.drawRoundedRect(x, y, width, height, 70, 8);
|
|
}
|
|
const label = labels[index]!;
|
|
image.drawText(font, x + Math.floor((width - font.measureText(label)) / 2), y + 7, label, active ? 250 : 170);
|
|
}
|
|
this.cursorY = y + height + 6;
|
|
}
|
|
|
|
hints(image: GrayImage, pairs: Array<[string, string]>): void {
|
|
image.drawText(smallFont(), this.rect.x + 6, this.hintsTop, gestureHints(pairs), 110);
|
|
}
|
|
}
|
|
|
|
function listWidthFor(viewportWidth: number): number {
|
|
return clamp(Math.round(viewportWidth * LIST_SHARE), LIST_MIN_WIDTH, LIST_MAX_WIDTH);
|
|
}
|
|
|
|
function drawPauseMark(image: GrayImage, x: number, y: number, value: number): void {
|
|
image.fillRect(x, y, 3, 10, value);
|
|
image.fillRect(x + 5, y, 3, 10, value);
|
|
}
|
|
|
|
function pad2(value: number): string {
|
|
return String(value).padStart(2, "0");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Window
|
|
|
|
export function createTimerAppWindow(options: InProcessAppOptions): InProcessWindow {
|
|
const layer = new TimersLayer();
|
|
let tick: ReturnType<typeof setInterval> | null = null;
|
|
let unsubscribe: (() => void) | null = null;
|
|
const stopTick = () => {
|
|
if (tick !== null) {
|
|
clearInterval(tick);
|
|
tick = null;
|
|
}
|
|
};
|
|
const visible = () => shell.isScreenOn() && shell.foregroundWindow()?.windowId === TIMER_WINDOW_ID;
|
|
const app = createInProcessWindow({
|
|
appId: "timer",
|
|
windowId: TIMER_WINDOW_ID,
|
|
title: "Timers",
|
|
iconLetter: "T",
|
|
icon: "timer",
|
|
closeable: true,
|
|
actions: options.actions,
|
|
baseLayer: layer,
|
|
menuItems: () => layer.menuItems(),
|
|
receiveTextInput: (text) => {
|
|
layer.receiveTextInput(text);
|
|
app.requestRender();
|
|
},
|
|
submitFrame: options.submitFrame,
|
|
setSurfaceVisible: options.setSurfaceVisible,
|
|
removeSurface: options.removeSurface,
|
|
reconfigureSurface: options.reconfigureSurface,
|
|
onClosed: () => {
|
|
stopTick();
|
|
unsubscribe?.();
|
|
unsubscribe = null;
|
|
options.onClosed();
|
|
},
|
|
});
|
|
// Once a second while something on screen moves by itself and the window
|
|
// is actually visible; the shell's wake path repaints on its own.
|
|
tick = setInterval(() => {
|
|
if (visible() && timerEngine.isDynamic()) app.requestRender();
|
|
}, 1000);
|
|
unsubscribe = timerEngine.onChange(() => {
|
|
layer.onEngineChanged();
|
|
if (visible()) app.requestRender();
|
|
});
|
|
return app;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Tray icon
|
|
|
|
let trayText: string | null = null;
|
|
let trayTick: ReturnType<typeof setInterval> | null = null;
|
|
|
|
/**
|
|
* Keep a small "soonest timer" readout in the top bar while a timer runs,
|
|
* so any app can glance at it. Minute granularity until the last minute,
|
|
* so the shell isn't repainted every second for an hour.
|
|
*/
|
|
export function startTimersTrayIcon(): void {
|
|
const sync = () => {
|
|
const remaining = soonestRunningTimerRemainingMs(timerEngine);
|
|
let text: string | null = null;
|
|
if (remaining !== null) {
|
|
text = remaining >= MINUTE_MS ? `${Math.ceil(remaining / MINUTE_MS)}m` : `${Math.max(0, Math.ceil(remaining / 1000))}s`;
|
|
}
|
|
if (text === trayText) return;
|
|
trayText = text;
|
|
shell.setTrayIcon("timer", text === null ? null : renderTrayIcon(text));
|
|
if (text !== null && trayTick === null) {
|
|
trayTick = setInterval(sync, 1000);
|
|
} else if (text === null && trayTick !== null) {
|
|
clearInterval(trayTick);
|
|
trayTick = null;
|
|
}
|
|
};
|
|
timerEngine.onChange(sync);
|
|
sync();
|
|
}
|
|
|
|
function renderTrayIcon(text: string): GrayImage {
|
|
const font = getFont("terminus12");
|
|
const dial = 12;
|
|
const gap = 4;
|
|
const width = dial + gap + font.measureText(text);
|
|
const icon = new GrayImage(width, 16, 0);
|
|
// A little dial: a ring with a hand pointing up-right.
|
|
icon.drawRoundedRect(0, 2, dial, dial, 200, 6);
|
|
icon.drawLine(6, 8, 6, 5, 200);
|
|
icon.drawLine(6, 8, 8, 8, 200);
|
|
icon.drawText(font, dial + gap, 2, text, 220);
|
|
return icon;
|
|
}
|