diff --git a/app/apps/compass/calibration-layer.ts b/app/apps/compass/calibration-layer.ts index 55acb41d..772fccef 100644 --- a/app/apps/compass/calibration-layer.ts +++ b/app/apps/compass/calibration-layer.ts @@ -80,7 +80,7 @@ export class CompassCalibrationLayer implements Layer { // The crosshair marks where the wearer is looking, so its horizontal // position must be the true centre of the display, not of the app - // viewport the sidebar has pushed to the right. Vertically it just sits in + // viewport a side strip has pushed off centre. Vertically it just sits in // the free space between the instructions and the readouts; the window // band's own placement on screen is the wearer's Display setting and // doesn't affect the heading being aimed. diff --git a/app/apps/compass/compass-app.ts b/app/apps/compass/compass-app.ts index 00e0c818..15beac96 100644 --- a/app/apps/compass/compass-app.ts +++ b/app/apps/compass/compass-app.ts @@ -161,7 +161,7 @@ class CompassLayer implements Layer { const readoutHeight = headingFont.lineHeight; // One column centred on the display's true centre, so the rose sits where - // the wearer is looking rather than 32px right of it. + // the wearer is looking rather than 32px beside it (with a side strip). const cx = screenCenterInViewportX(); // The rose is sized and placed first — it hangs off the bottom edge — and diff --git a/app/g2/dashboard-controller.ts b/app/g2/dashboard-controller.ts index b7abb99b..b8d9ae6f 100644 --- a/app/g2/dashboard-controller.ts +++ b/app/g2/dashboard-controller.ts @@ -68,10 +68,10 @@ import { ALL_APPS } from "../apps/all-apps"; import { type AppContext, type AppDefinition, type AppLaunchParams, type TextEditorHost } from "../apps/app-definition"; import { type InProcessAppOptions, type InProcessWindow } from "../ui/shell/in-process-window"; import { loadPersistedOpenApps, savePersistedOpenApps } from "../ui/shell/open-apps-persistence"; -import { appViewportRect, SIDEBAR_WIDTH, sidebarStripVisible, type WindowHeightMode } from "../ui/shell/geometry"; +import { appViewportRect, isOnSwitcherEdge, sidebarStripVisible, type WindowHeightMode } from "../ui/shell/geometry"; import { type LayerActions, type TextSettingsEditToggle } from "../ui/layers"; import { type KeyboardInputSession } from "../ui/shell/keyboard-input"; -import { assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, getBrightnessPreferences, displayModeSetting, navigateDisplayModeSetting, navigateVerticalPositionSetting, terminalDisplayModeSetting, terminalVerticalPositionSetting, elevenLabsApiKeySetting, getStringSettingById, openAiApiKeySetting, nightscoutApiTokenSetting, firmwareDebugFlagsSetting, lockScreenEnabledSetting, nightscoutSiteUrlSetting, onAnySettingChanged, previewColorSetting, ringConnectionModeSetting, saveVoiceRecordingsSetting, sonioxApiKeySetting, screenTimeoutSetting, screenTimeoutSettingToMs, suspendEvenHubWhenScreenOffSetting, verticalPositionSetting, voiceProviderSetting, wakeWordActionSetting, type ConfigSettingString } from "../ui/dashboard-settings"; +import { appSwitcherPositionSetting, assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, getBrightnessPreferences, displayModeSetting, navigateDisplayModeSetting, navigateVerticalPositionSetting, terminalDisplayModeSetting, terminalVerticalPositionSetting, elevenLabsApiKeySetting, getStringSettingById, openAiApiKeySetting, nightscoutApiTokenSetting, firmwareDebugFlagsSetting, lockScreenEnabledSetting, nightscoutSiteUrlSetting, onAnySettingChanged, previewColorSetting, ringConnectionModeSetting, saveVoiceRecordingsSetting, sonioxApiKeySetting, screenTimeoutSetting, screenTimeoutSettingToMs, suspendEvenHubWhenScreenOffSetting, verticalPositionSetting, voiceProviderSetting, wakeWordActionSetting, type ConfigSettingString } from "../ui/dashboard-settings"; import { isIgnoringBatteryOptimizations, requestIgnoreBatteryOptimizations } from "../native/battery-optimization"; import { getInstalledEvenHubAppById, @@ -181,6 +181,19 @@ const EVEN_APP_DETECTED_MESSAGE = // The launcher grid's app list; also fixes the app ids apps.launch accepts. const LAUNCHABLE_APPS = ALL_APPS.filter((app) => app.showInLauncher !== false); +/** + * The global settings window viewport sizes depend on: the display mode, and + * whether the app switcher takes width beside windows or height below them. + */ +function viewportSizesKey(): string { + return `${displayModeSetting.get()}|${appSwitcherPositionSetting.get() === "bottom" ? "row" : "strip"}`; +} + +/** The global settings that move window surfaces without resizing them. */ +function windowPlacementKey(): string { + return `${verticalPositionSetting.get()}|${appSwitcherPositionSetting.get()}`; +} + function createInitialDisplayPreview(): ImageSource | null { return grayImageToPreviewSource(new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0)); } @@ -427,8 +440,10 @@ class DashboardController { this.pushFirmwareDebugFlags(); this.pushBrightness(); this.syncEvenHubScreenOffSetting(); - this.applyVerticalPositionIfChanged(); + // Display mode first: a reflow repositions every surface too, so the + // vertical-position check after it then has nothing left to do. this.applyDisplayModeIfChanged(); + this.applyVerticalPositionIfChanged(); this.applyAppLayoutsIfChanged(); this.syncAssistantBridgeIfChanged(); this.syncLockScreenSettingIfChanged(); @@ -506,24 +521,28 @@ class DashboardController { }); } - // Vertical-position changes move every window surface (and the chrome that - // aligns with them); the value is tracked so unrelated setting changes - // don't trigger a full reposition. - private lastVerticalPosition = verticalPositionSetting.get(); + // Vertical-position changes (and moving the app switcher between the left + // and right edges) move every window surface and the chrome that aligns + // with them; the values are tracked so unrelated setting changes don't + // trigger a full reposition. + private lastWindowPlacement = windowPlacementKey(); - private lastDisplayMode = displayModeSetting.get(); + private lastViewportSizes = viewportSizesKey(); /** - * Display mode changed (Settings > Display, or the phone page's picker): - * every window's viewport size changes. In-process windows re-measure in - * place; workers that support resizing receive the new viewport. Other - * worker windows are closed and launched again at the new size. + * Display mode changed (Settings > Display, or the phone page's picker), + * or the app switcher moved to or from the bottom edge: every window's + * viewport size changes. In-process windows re-measure in place; workers + * that support resizing receive the new viewport. Other worker windows are + * closed and launched again at the new size. */ private applyDisplayModeIfChanged(): void { - const mode = displayModeSetting.get(); - if (mode === this.lastDisplayMode) return; - this.lastDisplayMode = mode; - this.appendLog(`display mode: ${mode}`); + const sizes = viewportSizesKey(); + if (sizes === this.lastViewportSizes) return; + this.lastViewportSizes = sizes; + // The reflow below reconfigures every surface, covering any move too. + this.lastWindowPlacement = windowPlacementKey(); + this.appendLog(`display layout: ${sizes}`); const foregroundWindowId = shell.foregroundWindow()?.windowId; void (async () => { const relaunch: string[] = []; @@ -579,9 +598,9 @@ class DashboardController { } private applyVerticalPositionIfChanged(): void { - const position = verticalPositionSetting.get(); - if (position === this.lastVerticalPosition) return; - this.lastVerticalPosition = position; + const placement = windowPlacementKey(); + if (placement === this.lastWindowPlacement) return; + this.lastWindowPlacement = placement; void (async () => { for (const window of shell.getWindows()) { await this.configureWindowSurface( @@ -1925,9 +1944,10 @@ class DashboardController { } const x = Math.round(Math.min(1, Math.max(0, nx)) * G2_LENS_WIDTH); const y = Math.round(Math.min(1, Math.max(0, ny)) * G2_LENS_HEIGHT); - const stripShown = sidebarStripVisible(shell.getFocus(), shell.foregroundWindow()?.appId); + const foreground = shell.foregroundWindow(); + const stripShown = sidebarStripVisible(shell.getFocus(), foreground?.appId); this.appendLog(`mirror tap at ${x},${y}`); - if (!shell.hasOverlay() && stripShown && x < SIDEBAR_WIDTH) { + if (!shell.hasOverlay() && stripShown && isOnSwitcherEdge(x, y, foreground?.heightMode ?? "min", foreground?.appId)) { const target = shell.windowAtSidebarPoint(x, y); if (target) { this.appendLog(`mirror tap: sidebar -> ${target.title}`); diff --git a/app/g2/ios-preview-controller.ts b/app/g2/ios-preview-controller.ts index a0da264f..1d4bf056 100644 --- a/app/g2/ios-preview-controller.ts +++ b/app/g2/ios-preview-controller.ts @@ -39,7 +39,7 @@ import { makeInputEvent, type InputEvent, type InputEventPayload } from '../ui/g import { noopLayerActions, type LayerActions } from '../ui/layers' import { TextViewerLayer } from '../apps/files/text-viewer' import { shell, rawInputEventToInputEvent, type ShellWindow } from '../ui/shell/shell' -import { appViewportRect, SIDEBAR_WIDTH, sidebarStripVisible } from '../ui/shell/geometry' +import { appViewportRect, isOnSwitcherEdge, sidebarStripVisible } from '../ui/shell/geometry' import { DISPLAY_MODE_VALUES, displayModeLabel, displayModeSetting, onAnySettingChanged, previewColorSetting, lockScreenEnabledSetting, getBrightnessPreferences, getStringSettingById, nightscoutSiteUrlSetting, nightscoutApiTokenSetting } from '../ui/dashboard-settings' @@ -531,7 +531,8 @@ export class IosPreviewController { const x = Math.max(0, Math.min(639, Math.floor(nx * 640))) const y = Math.max(0, Math.min(479, Math.floor(ny * 480))) const window = shell.foregroundWindow() - if (!shell.hasOverlay() && sidebarStripVisible(shell.getFocus(), window?.appId) && x < SIDEBAR_WIDTH) { + if (!shell.hasOverlay() && sidebarStripVisible(shell.getFocus(), window?.appId) + && isOnSwitcherEdge(x, y, window?.heightMode ?? 'min', window?.appId)) { const target = shell.windowAtSidebarPoint(x, y) if (target) { shell.focusWindow(target.windowId); target.requestRender(); this.requestShellRender() } return diff --git a/app/graphics/shell-scene.ts b/app/graphics/shell-scene.ts index 640ca5f5..06207366 100644 --- a/app/graphics/shell-scene.ts +++ b/app/graphics/shell-scene.ts @@ -10,8 +10,12 @@ export function shellCrop(image: GrayImage, x: number, y: number, width: number, return { image: crop, x, y, shellKey: key } } -/** Shared Kotlin receives original 8-bit pixels and quantizes once, before composing. */ -export function encodeShellScene(planes: readonly Plane[]): Uint8Array { +/** + * Shared Kotlin receives original 8-bit pixels and quantizes once, before + * composing. `screenDepth` is the whole display's stereo depth (geometry.ts + * uiDepth), trailing the layers. + */ +export function encodeShellScene(planes: readonly Plane[], screenDepth = 0): Uint8Array { const layers: { image: GrayImage; x: number; y: number; key: number; depth: number; dim: number; selections: Uint8Array[] }[] = [] for (const plane of planes) { const image = plane.image.withDrawsBaked(false) @@ -30,10 +34,11 @@ export function encodeShellScene(planes: readonly Plane[]): Uint8Array { presentation: { ...d.presentation!, depth: d.presentation!.depth + (plane.depth ?? 0) } })) layers.push({ depth: plane.depth ?? 0, selections, image: cropped.image, x: plane.x + left, y: plane.y + top, key: plane.shellKey!, dim: Math.round((plane.dimUnderneath ?? 1) * 256) }) } - const result = new Uint8Array(2 + layers.reduce((n, l) => n + 16 + l.image.pixels.length + l.selections.reduce((sum, b) => sum + b.length, 0), 0)) + const result = new Uint8Array(4 + layers.reduce((n, l) => n + 16 + l.image.pixels.length + l.selections.reduce((sum, b) => sum + b.length, 0), 0)) const view = new DataView(result.buffer); let p = 0 const word = (n: number) => { view.setUint16(p, n, true); p += 2 } word(layers.length) for (const l of layers) { word(l.key); word(l.x); word(l.y); word(l.image.width); word(l.image.height); word(l.dim); word(l.selections.length); word(l.depth); result.set(l.image.pixels, p); p += l.image.pixels.length; for (const selection of l.selections) { result.set(selection, p); p += selection.length } } + word(screenDepth) return result } diff --git a/app/ui/dashboard-settings.ts b/app/ui/dashboard-settings.ts index 8ae9c943..c07f7b41 100644 --- a/app/ui/dashboard-settings.ts +++ b/app/ui/dashboard-settings.ts @@ -308,19 +308,32 @@ export const timeFormatSetting = new ConfigSettingEnum({ * How much of the 640x480 panel the UI uses. "576x288" is the stock band * (sidebar + a 288px-tall window at the vertical position); "576x480" keeps * the sidebar and gives every window the full height; "640x480" is the whole - * panel, with the sidebar an overlay that shows only while it has focus. + * panel, with the sidebar an overlay that shows only while it has focus. The + * values name the sizes beside a side strip; with the app switcher along the + * bottom, the tall height loses the switcher row (displayModeLabel shows the + * actual size). */ export const DISPLAY_MODE_VALUES = ["576x288", "576x480", "640x480"] as const; export type DisplayModeSetting = (typeof DISPLAY_MODE_VALUES)[number]; -const DISPLAY_MODE_LABELS: Record = { - "576x288": "Band · 576×288", - "576x480": "Tall · 576×480", - "640x480": "Full panel · 640×480", +const DISPLAY_MODE_NAMES: Record = { + "576x288": "Band", + "576x480": "Tall", + "640x480": "Full panel", +}; + +/** Window size per mode with the app switcher along the bottom (see geometry.ts). */ +const BOTTOM_SWITCHER_SIZES: Record = { + "576x288": "576×288", + "576x480": "576×444", + "640x480": "640×480", }; export function displayModeLabel(value: DisplayModeSetting): string { - return DISPLAY_MODE_LABELS[value] ?? value; + const name = DISPLAY_MODE_NAMES[value]; + if (!name) return value; + const size = appSwitcherPositionSetting.get() === "bottom" ? BOTTOM_SWITCHER_SIZES[value] : value.replace("x", "×"); + return `${name} · ${size}`; } export const displayModeSetting = new ConfigSettingEnum({ @@ -331,7 +344,52 @@ export const displayModeSetting = new ConfigSettingEnum({ values: DISPLAY_MODE_VALUES, formatValue: displayModeLabel, description: - "Band: the stock 576×288 window beside the sidebar. Tall: the sidebar plus full-height windows. Full panel: the whole 640×480 display; the sidebar overlays the app only while you are in it. Open apps reopen in the new size.", + "Band: the stock 288px-tall window beside the app switcher. Tall: the app switcher plus full-height windows. Full panel: the whole 640×480 display; the app switcher overlays the app only while you are in it. Open apps reopen in the new size.", +}); + +/** Which edge of the display the app switcher (the strip of open-window icons) sits on. */ +export type AppSwitcherPosition = "left" | "right" | "bottom"; + +const APP_SWITCHER_POSITION_LABELS: Record = { + left: "Left", + right: "Right", + bottom: "Bottom", +}; + +export const appSwitcherPositionSetting = new ConfigSettingEnum({ + id: "app-switcher-position", + label: "App switcher position", + storageKey: "display.appSwitcherPosition", + defaultValue: "left", + values: ["left", "right", "bottom"], + formatValue: (value) => APP_SWITCHER_POSITION_LABELS[value] ?? value, + description: + "Which edge of the display the strip of open-app icons sits on. Left and right take a column beside windows; bottom puts a row beneath the window, which leaves room at the sides to set the display's depth, and makes full-height windows a little shorter. Moving it to or from the bottom reopens open apps in the new size.", +}); + +const UI_DEPTH_VALUES = ["-64", "-48", "-32", "-16", "0", "16", "32", "48", "64"] as const; +export type UiDepth = (typeof UI_DEPTH_VALUES)[number]; + +/** + * Stereo depth of the whole display, in the firmware's depth units: the + * lenses shift everything by half this many pixels each, in opposite + * directions. Only applies with the app switcher at the bottom, where the + * windows' 576px width leaves 32px at each side to shift into (see + * geometry.ts uiDepth); values stay even so the per-lens halves of nested + * depths add exactly. + */ +export const uiDepthSetting = new ConfigSettingEnum({ + id: "ui-depth", + label: "Depth", + storageKey: "display.uiDepth", + defaultValue: "0", + values: UI_DEPTH_VALUES, + formatValue: (value) => { + const depth = Number(value); + return depth === 0 ? "0" : depth > 0 ? `+${depth} (nearer)` : `${depth} (farther)`; + }, + description: + "Moves the whole display nearer (positive) or farther away (negative) by shifting it in opposite directions on the two lenses. Available with the app switcher at the bottom. Full-panel windows lose a sliver at the edges.", }); export const brightnessSetting = new ConfigSettingEnum({ diff --git a/app/ui/dashboard/settings-menus.ts b/app/ui/dashboard/settings-menus.ts index 5bf6b411..7aa6564c 100644 --- a/app/ui/dashboard/settings-menus.ts +++ b/app/ui/dashboard/settings-menus.ts @@ -28,6 +28,8 @@ import { drawRightValueMenuItem, openModalMenu, type MenuItem } from "../menu"; import { shell } from "../shell/shell"; import { anthropicApiKeySetting, + appSwitcherPositionSetting, + uiDepthSetting, assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, @@ -84,6 +86,7 @@ export function createSettingsPanelLayer(): SettingsPanelLayer { } function settingsSections(): SettingsSection[] { + const customizationItems = customizationRows(); const sections: SettingsSection[] = [ { label: "Display", @@ -107,16 +110,11 @@ function settingsSections(): SettingsSection[] { }, { label: "Customization", - items: [ - // Submenu: top-bar battery indicator style plus per-device visibility. - batteryIndicatorsMenuItem(), - // Submenu: toggles for menu/icon-grid motion and the screen on/off fade. - animationsMenuItem(), - // Controls the top-bar clock (24-hour vs 12-hour). - enumSettingMenuItem(timeFormatSetting), - // Opens the modal font picker (face, weight, size) for UI text. - uiFontPickerMenuItem(), - ], + // Depth only applies (and only shows) with the app switcher at the + // bottom; the panel re-reads the rows each paint. + get items() { + return customizationItems(); + }, }, { label: "Voice", @@ -234,6 +232,31 @@ function settingsSections(): SettingsSection[] { }); } +/** + * The Customization rows, as a function of the current settings: the same + * array while the switcher position stays put, so the panel's menu sees a + * stable list between paints. + */ +function customizationRows(): () => MenuItem[] { + // Left / right / bottom edge; the dashboard controller moves (or, to and + // from the bottom, resizes) windows on change. + const position = enumSettingMenuItem(appSwitcherPositionSetting); + // The whole display's stereo depth; the shell sends it with its scene. + const depth = enumSettingMenuItem(uiDepthSetting); + const rest = [ + // Submenu: top-bar battery indicator style plus per-device visibility. + batteryIndicatorsMenuItem(), + // Submenu: toggles for menu/icon-grid motion and the screen on/off fade. + animationsMenuItem(), + // Controls the top-bar clock (24-hour vs 12-hour). + enumSettingMenuItem(timeFormatSetting), + // Opens the modal font picker (face, weight, size) for UI text. + uiFontPickerMenuItem(), + ]; + const withDepth = [position, depth, ...rest], withoutDepth = [position, ...rest]; + return () => appSwitcherPositionSetting.get() === "bottom" ? withDepth : withoutDepth; +} + function autoBrightnessMenuItem(): MenuItem { return { label: "Auto-brightness", diff --git a/app/ui/dashboard/settings-panel.ts b/app/ui/dashboard/settings-panel.ts index 1dd957df..687c3f97 100644 --- a/app/ui/dashboard/settings-panel.ts +++ b/app/ui/dashboard/settings-panel.ts @@ -10,7 +10,8 @@ import { shell } from "../shell/shell"; /** * One left-column entry. `items` are the right-column rows (reusing the shared - * MenuItem builders). `renderDetail`, when set, draws custom informational + * MenuItem builders); it may be a getter for rows that come and go with other + * settings, since the panel re-reads it on every paint. `renderDetail`, when set, draws custom informational * content (e.g. About) at the top of the pane and returns the pixel height it * consumed; the row list renders below it. Returning nothing claims the whole * pane (an info-only section). diff --git a/app/ui/shell/chrome-layer.ts b/app/ui/shell/chrome-layer.ts index e192df9a..30a644a3 100644 --- a/app/ui/shell/chrome-layer.ts +++ b/app/ui/shell/chrome-layer.ts @@ -16,6 +16,7 @@ import { phoneBatteryVisibilitySetting, ringBatteryVisibilitySetting, watchBatteryVisibilitySetting, + type AppSwitcherPosition, type BatteryIndicatorVisibility, } from "../dashboard-settings"; import { formatClockDate, formatClockTime } from "../clock-format"; @@ -24,34 +25,43 @@ import { Layer, LayerStack } from "../layers"; import { scrollToKeepSelectionVisible } from "../menu"; import { lineStep } from "../metrics"; import { + appViewportRect, MIN_WINDOW_HEIGHT, minWindowTop, SHELL_OPAQUE_BLACK, SIDEBAR_WIDTH, sidebarStripVisible, + SWITCHER_ROW_HEIGHT, + switcherPosition, + switcherRect, TOP_BAR_HEIGHT, windowTop, type WindowHeightMode, } from "./geometry"; /** - * Sidebar icon layout comes in two variants. Few enough windows for a single - * column keeps the roomy 36px slots (32px icons) right-aligned against the - * separator; past one column's worth it switches to two 32px slots (28px - * icons) that exactly fill the 64px sidebar. In the two-column variant the - * right column (against the app area) fills first and windows past that - * overflow into the left column, so the common case keeps every icon next to - * the content it belongs to. + * Sidebar icon layout (the app switcher on the left or right edge) comes in + * two variants. Few enough windows for a single column keeps the roomy 36px + * slots (32px icons) aligned against the separator; past one column's worth + * it switches to two 32px slots (28px icons) that exactly fill the 64px + * sidebar. In the two-column variant the column against the app area fills + * first and windows past that overflow into the outer column, so the common + * case keeps every icon next to the content it belongs to. A bottom row + * always uses the roomy slots, laid out left to right. */ type SidebarVariant = { columns: number; columnWidth: number; iconSize: number }; const ONE_COLUMN: SidebarVariant = { columns: 1, columnWidth: 36, iconSize: 32 }; const TWO_COLUMN: SidebarVariant = { columns: 2, columnWidth: 32, iconSize: 28 }; const ICON_SPACING = 8; -/** Icon list top/bottom margins within the sidebar band, below the top bar. */ +/** Icon list top/bottom margins within the sidebar band, below the top bar (and a bottom row's end margins). */ const LIST_MARGIN = 10; const LIST_HEIGHT = MIN_WINDOW_HEIGHT - TOP_BAR_HEIGHT - 2 * LIST_MARGIN; +/** Bottom-row icons: one tall tab's worth of row, the icon inset 2px all round. */ +const ROW_ICON_SIZE = SWITCHER_ROW_HEIGHT - 4; +const ROW_STEP = ROW_ICON_SIZE + ICON_SPACING; + /** Icon rows that fit in one sidebar column. */ function rowsPerColumn(variant: SidebarVariant): number { return Math.max(1, ((LIST_HEIGHT + ICON_SPACING) / (variant.iconSize + ICON_SPACING)) | 0); @@ -61,23 +71,14 @@ function sidebarVariant(windowCount: number): SidebarVariant { return windowCount > rowsPerColumn(ONE_COLUMN) ? TWO_COLUMN : ONE_COLUMN; } -/** Left x of a sidebar column; columns pack rightward against the separator. */ -function columnLeft(variant: SidebarVariant, column: number): number { - return SIDEBAR_WIDTH - (variant.columns - column) * variant.columnWidth; -} - /** - * Column and top y of a visible sidebar slot; `position` counts from the - * first visible (scrolled-to) icon. Slots fill the rightmost column top to - * bottom, then overflow leftward. The single source of slot geometry for - * both drawing and hit testing. + * Left x of a sidebar column. Column 0 sits against the separator (the + * strip's inner edge, toward the app area); further columns pack outward. */ -function slotPosition(variant: SidebarVariant, listTop: number, position: number): { column: number; y: number } { - const rows = rowsPerColumn(variant); - return { - column: variant.columns - 1 - ((position / rows) | 0), - y: listTop + (position % rows) * (variant.iconSize + ICON_SPACING), - }; +function columnLeft(variant: SidebarVariant, column: number, position: AppSwitcherPosition): number { + return position === "right" + ? G2_LENS_WIDTH - SIDEBAR_WIDTH + column * variant.columnWidth + : SIDEBAR_WIDTH - (column + 1) * variant.columnWidth; } /** Top y of the sidebar's icon list (below the band's top bar). */ @@ -86,12 +87,88 @@ function sidebarListTop(appId?: string): number { } /** - * Left edge of the sidebar region that actually holds icons: the one-column - * variant leaves a dead strip left of its single right-aligned column. - * Screenshot cropping uses this to trim the unused part. + * One visible switcher icon's selection cell: the 2px-margined box around + * the icon that a selection tab or box fills. `atSeparator` is whether the + * cell touches the separator, so the selection can divert it (a tab) rather + * than sit apart from it (a box, for sidebar overflow-column icons). */ -export function sidebarContentLeft(windowCount: number): number { - return columnLeft(sidebarVariant(windowCount), 0); +type SwitcherCell = { x: number; y: number; width: number; height: number; atSeparator: boolean }; + +type SwitcherLayout = { + position: AppSwitcherPosition; + iconSize: number; + /** How many icons fit at once; the list scrolls to keep the selection among them. */ + visibleCount: number; + /** + * Cell of the icon `slot` places past the first visible (scrolled-to) one. + * The single source of slot geometry for both drawing and hit testing. + */ + cell: (slot: number) => SwitcherCell; +}; + +/** Switcher geometry for the foreground window (a bottom row sits under it). */ +function switcherLayout(windowCount: number, heightMode: WindowHeightMode, appId?: string): SwitcherLayout { + const position = switcherPosition(); + if (position === "bottom") { + const row = switcherRect(heightMode, appId); + return { + position, + iconSize: ROW_ICON_SIZE, + visibleCount: Math.max(1, ((row.width - 2 * LIST_MARGIN + ICON_SPACING) / ROW_STEP) | 0), + cell: (slot) => ({ + x: row.x + LIST_MARGIN - 2 + slot * ROW_STEP, y: row.y, width: ROW_ICON_SIZE + 4, height: SWITCHER_ROW_HEIGHT, + atSeparator: true, + }), + }; + } + // Slots fill the column against the separator top to bottom, then + // overflow outward. + const variant = sidebarVariant(windowCount); + const rows = rowsPerColumn(variant); + const listTop = sidebarListTop(appId); + return { + position, + iconSize: variant.iconSize, + visibleCount: rows * variant.columns, + cell: (slot) => { + const column = (slot / rows) | 0; + return { + x: columnLeft(variant, column, position), + y: listTop + (slot % rows) * (variant.iconSize + ICON_SPACING) - 2, + width: variant.columnWidth, + height: variant.iconSize + 4, + atSeparator: column === 0, + }; + }, + }; +} + +/** + * Horizontal extent of the sidebar region that actually holds icons: the + * one-column variant leaves a dead strip on the outer side of its single + * column. Screenshot cropping uses this to trim the unused part. + */ +export function sidebarContentSpan(windowCount: number): { left: number; right: number } { + const variant = sidebarVariant(windowCount); + const width = variant.columns * variant.columnWidth; + return switcherPosition() === "right" + ? { left: G2_LENS_WIDTH - SIDEBAR_WIDTH, right: G2_LENS_WIDTH - SIDEBAR_WIDTH + width } + : { left: SIDEBAR_WIDTH - width, right: SIDEBAR_WIDTH }; +} + +/** + * Horizontal extent of the top bar: the foreground window's, short of a side + * strip overlaid on it (full-panel mode, sidebar focused). + */ +function topBarSpan(state: ShellChromeState): { left: number; right: number } { + const viewport = appViewportRect(state.foregroundHeightMode, state.foregroundAppId); + let left = viewport.x, right = viewport.x + viewport.width; + if (sidebarStripVisible(state.focus, state.foregroundAppId)) { + const position = switcherPosition(); + if (position === "left") left = Math.max(left, SIDEBAR_WIDTH); + if (position === "right") right = Math.min(right, G2_LENS_WIDTH - SIDEBAR_WIDTH); + } + return { left, right }; } const NOTIFICATION_ICON_SIZE = 24; const BORDER_VALUE = 40; @@ -195,12 +272,12 @@ export function makeImageWindowIcon( } /** - * Base layer of the shell surface: the window sidebar on the left and the - * status top bar. Everything not explicitly painted stays 0 (transparent on - * the color-key shell surface), so the app viewport shows through. + * Base layer of the shell surface: the window sidebar (or bottom row) and + * the status top bar. Everything not explicitly painted stays 0 (transparent + * on the color-key shell surface), so the app viewport shows through. */ export class ShellChromeLayer implements Layer { - // First sidebar row shown; adjusted each paint to keep the selection visible. + // First switcher icon shown; adjusted each paint to keep the selection visible. private scrollRow = 0; constructor(private readonly getState: () => ShellChromeState) {} @@ -214,7 +291,7 @@ export class ShellChromeLayer implements Layer { this.drawSidebar(image, state); } this.drawTopBar(image, state); - drawAmbientCards(image); + drawAmbientCards(image, topBarSpan(state).right); return image; } @@ -223,13 +300,14 @@ export class ShellChromeLayer implements Layer { if (sidebarStripVisible(state.focus, state.foregroundAppId)) { const canvas = new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0); this.drawSidebar(canvas, state); - parts.push(shellCrop(canvas, 0, minWindowTop(state.foregroundAppId), SIDEBAR_WIDTH, MIN_WINDOW_HEIGHT, 1)); + const strip = switcherRect(state.foregroundHeightMode, state.foregroundAppId); + parts.push(shellCrop(canvas, strip.x, strip.y, strip.width, strip.height, 1)); } const canvas = new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0); this.drawTopBar(canvas, state); - const left = sidebarStripVisible(state.focus, state.foregroundAppId) ? SIDEBAR_WIDTH : 0; - parts.push({ ...shellCrop(canvas, left, windowTop(state.foregroundHeightMode, state.foregroundAppId), G2_LENS_WIDTH-left, TOP_BAR_HEIGHT, 2), depth: -2 }); - drawAmbientCards(canvas, parts); + const bar = topBarSpan(state); + parts.push({ ...shellCrop(canvas, bar.left, windowTop(state.foregroundHeightMode, state.foregroundAppId), bar.right - bar.left, TOP_BAR_HEIGHT, 2), depth: -2 }); + drawAmbientCards(canvas, bar.right, parts); return parts; } @@ -239,19 +317,18 @@ export class ShellChromeLayer implements Layer { } /** - * Which window's sidebar icon is under (x, y) on screen, if any — the same - * slot geometry drawSidebar uses, so a touch on the phone's mirror lands on - * the icon the mirror showed. + * Which window's switcher icon is under (x, y) on screen, if any — the + * same slot geometry drawSidebar uses, so a touch on the phone's mirror + * lands on the icon the mirror showed. */ windowIndexAt(x: number, y: number, windowCount: number): number | null { - if (x < 0 || x >= SIDEBAR_WIDTH || windowCount === 0) return null; - const variant = sidebarVariant(windowCount); - const listTop = sidebarListTop(this.getState().foregroundAppId); - const lastVisible = Math.min(windowCount, this.scrollRow + rowsPerColumn(variant) * variant.columns); + if (windowCount === 0) return null; + const state = this.getState(); + const layout = switcherLayout(windowCount, state.foregroundHeightMode, state.foregroundAppId); + const lastVisible = Math.min(windowCount, this.scrollRow + layout.visibleCount); for (let index = this.scrollRow; index < lastVisible; index++) { - const { column, y: slotY } = slotPosition(variant, listTop, index - this.scrollRow); - const left = columnLeft(variant, column); - if (x >= left && x < left + variant.columnWidth && y >= slotY - 2 && y < slotY + variant.iconSize + 2) { + const cell = layout.cell(index - this.scrollRow); + if (x >= cell.x && x < cell.x + cell.width && y >= cell.y && y < cell.y + cell.height) { return index; } } @@ -259,60 +336,48 @@ export class ShellChromeLayer implements Layer { } private drawSidebar(image: GrayImage, state: ShellChromeState): void { - // Align the sidebar with the app's preferred band. Legacy tall terminal - // sessions keep the sidebar at the global band position. - const bandTop = minWindowTop(state.foregroundAppId); - const bandBottom = bandTop + MIN_WINDOW_HEIGHT; - image.fillRect(0, bandTop, SIDEBAR_WIDTH, MIN_WINDOW_HEIGHT, SHELL_OPAQUE_BLACK); + // A side strip aligns with the app's preferred band (legacy tall + // terminal sessions keep it at the global band position); a bottom row + // sits under the foreground window. + const strip = switcherRect(state.foregroundHeightMode, state.foregroundAppId); + image.fillRect(strip.x, strip.y, strip.width, strip.height, SHELL_OPAQUE_BLACK); // Scroll the icon list to keep the selection visible; chevrons mark - // windows off-screen above/below. Icons fill the right column top to - // bottom, then overflow into the left one, so a visible slot's column is - // decided by its position within the scrolled window. + // windows off-screen before/after. Sidebar icons fill the column against + // the separator top to bottom, then overflow into the outer one, so a + // visible slot's column is decided by its position within the scrolled + // window. const count = state.windows.length; - const variant = sidebarVariant(count); - const iconSize = variant.iconSize; - const iconMarginX = ((variant.columnWidth - iconSize) / 2) | 0; - // Column index of the rightmost column (the one that fills first). - const firstColumn = variant.columns - 1; - const listTop = sidebarListTop(state.foregroundAppId); - const visibleCount = rowsPerColumn(variant) * variant.columns; - this.scrollRow = scrollToKeepSelectionVisible(this.scrollRow, state.selectedIndex, visibleCount, count); - const lastVisible = Math.min(count, this.scrollRow + visibleCount); - const slotOf = (index: number) => slotPosition(variant, listTop, index - this.scrollRow); + const layout = switcherLayout(count, state.foregroundHeightMode, state.foregroundAppId); + const { iconSize, position } = layout; + this.scrollRow = scrollToKeepSelectionVisible(this.scrollRow, state.selectedIndex, layout.visibleCount, count); + const lastVisible = Math.min(count, this.scrollRow + layout.visibleCount); + const cellOf = (index: number) => layout.cell(index - this.scrollRow); - // The selection is a "diversion" of the sidebar/main separator line: the - // line bulges right around the selected icon (rounded on the left, open - // to the main area on the right), so the separator is drawn with a gap - // there. When the sidebar has focus, the diversion is filled white and - // the icon drawn inverted. Only the right column touches the separator; - // a selected overflow icon gets a self-contained box instead. - const sep = SIDEBAR_WIDTH - 1; - // Start beside the app content, leaving the area alongside the top bar open. - const sepTop = Math.max(bandTop, windowTop(state.foregroundHeightMode, state.foregroundAppId) + TOP_BAR_HEIGHT); + // The selection is a "diversion" of the switcher/main separator line: + // the line bulges toward the main area around the selected icon (rounded + // on the outer side, open to the main area), so the separator is drawn + // with a gap there. When the switcher has focus, the diversion is filled + // white and the icon drawn inverted. Only the sidebar column against the + // separator touches it; a selected overflow icon gets a self-contained + // box instead. const selVisible = state.selectedIndex >= this.scrollRow && state.selectedIndex < lastVisible; - const selSlot = selVisible ? slotOf(state.selectedIndex) : null; - const selTabTop = selSlot && selSlot.column === firstColumn ? selSlot.y - 2 : null; - if (selTabTop !== null) { - image.drawLine(sep, sepTop, sep, selTabTop, BORDER_VALUE); - image.drawLine(sep, selTabTop + iconSize + 4, sep, bandBottom - 1, BORDER_VALUE); - } else { - image.drawLine(sep, sepTop, sep, bandBottom - 1, BORDER_VALUE); - } + const selCell = selVisible ? cellOf(state.selectedIndex) : null; + drawSeparator(image, state, strip, selCell?.atSeparator ? selCell : null); for (let index = this.scrollRow; index < lastVisible; index++) { const window = state.windows[index]!; - const { column, y } = slotOf(index); - const left = columnLeft(variant, column); - const x = left + iconMarginX; + const cell = cellOf(index); + const x = cell.x + (((cell.width - iconSize) / 2) | 0); + const y = cell.y + (((cell.height - iconSize) / 2) | 0); const selected = index === state.selectedIndex; const focused = selected && state.focus === "sidebar"; - if (selected && column === firstColumn) { - drawSelectionTab(image, left, y - 2, y + iconSize + 2, focused); + if (selected && cell.atSeparator) { + drawSelectionTab(image, cell, position, focused); } else if (selected) { // Spans the full column: only 2px of margin flanks the icon in its // slot, so anything wider would clip at the screen edge. - drawSelectionBox(image, left, y - 2, variant.columnWidth, iconSize + 4, focused); + drawSelectionBox(image, cell.x, cell.y, cell.width, cell.height, focused); } // Paint unselected icons into their own resource so only the replayed copy moves. const icon = selected ? image : new GrayImage(iconSize, iconSize + 1); @@ -327,14 +392,26 @@ export class ShellChromeLayer implements Layer { if (!selected) image.drawDepthImage(icon, x, y - 1, -2); } + if (position === "bottom") { + // Chevrons sit in the row's end margins, pointing off either end. + const chevronY = strip.y + ((strip.height / 2) | 0); + if (this.scrollRow > 0) { + drawChevron(image, strip.x + 6, chevronY, "left"); + } + if (lastVisible < count) { + drawChevron(image, strip.x + strip.width - 6, chevronY, "right"); + } + return; + } // Chevrons center over the icon area, which in the one-column variant is // narrower than the sidebar strip. - const chevronX = ((columnLeft(variant, 0) + SIDEBAR_WIDTH) / 2) | 0; + const span = sidebarContentSpan(count); + const chevronX = ((span.left + span.right) / 2) | 0; if (this.scrollRow > 0) { - drawChevron(image, chevronX, bandTop + TOP_BAR_HEIGHT + 6, -1); + drawChevron(image, chevronX, strip.y + TOP_BAR_HEIGHT + 6, "up"); } if (lastVisible < count) { - drawChevron(image, chevronX, bandBottom - 6, 1); + drawChevron(image, chevronX, strip.y + strip.height - 6, "down"); } } @@ -344,11 +421,11 @@ export class ShellChromeLayer implements Layer { // its height mode puts that (screen top for max height). It moves when // the foreground switches to a window of a different height. const barTop = windowTop(state.foregroundHeightMode, state.foregroundAppId); - // The bar spans the app viewport; with the sidebar overlaid (full-panel - // mode, sidebar focused) it still starts past the strip. - const barLeft = sidebarStripVisible(state.focus, state.foregroundAppId) ? SIDEBAR_WIDTH : 0; - image.fillRect(barLeft, barTop, G2_LENS_WIDTH - barLeft, TOP_BAR_HEIGHT, SHELL_OPAQUE_BLACK); - image.drawLine(barLeft, barTop + TOP_BAR_HEIGHT - 1, G2_LENS_WIDTH - 1, barTop + TOP_BAR_HEIGHT - 1, BORDER_VALUE); + // The bar spans the app viewport; with a side strip overlaid (full-panel + // mode, sidebar focused) it still stops at the strip. + const { left: barLeft, right: barRight } = topBarSpan(state); + image.fillRect(barLeft, barTop, barRight - barLeft, TOP_BAR_HEIGHT, SHELL_OPAQUE_BLACK); + image.drawLine(barLeft, barTop + TOP_BAR_HEIGHT - 1, barRight - 1, barTop + TOP_BAR_HEIGHT - 1, BORDER_VALUE); const now = new Date(); const clock = `${formatClockDate(now)} ${formatClockTime(now)}`; @@ -356,7 +433,7 @@ export class ShellChromeLayer implements Layer { const textY = barTop + Math.max(0, ((TOP_BAR_HEIGHT - font.lineHeight) / 2) | 0); image.drawText(font, clockX, textY, clock, 210); - const batteryLeft = this.drawTopBarBatteries(image, state, barTop); + const batteryLeft = this.drawTopBarBatteries(image, state, barTop, barRight); const trayLeft = drawTrayIcons(image, state.trayIcons, batteryLeft, barTop); const iconsX = clockX + font.measureText(clock) + 16; @@ -379,9 +456,10 @@ export class ShellChromeLayer implements Layer { * running the Faceclaw watch app is reachable (no placeholder otherwise). * The Settings > Customization > Battery indicators submenu picks the style (label beside a gauge icon or percentage, or stacked above * either) and, per device, whether the indicator shows always, only below - * 50%, or never. Returns the left edge of the battery block. + * 50%, or never. `barRight` is the bar's right edge (short of a right-hand + * sidebar). Returns the left edge of the battery block. */ - private drawTopBarBatteries(image: GrayImage, state: ShellChromeState, barTop: number): number { + private drawTopBarBatteries(image: GrayImage, state: ShellChromeState, barTop: number, barRight: number): number { const mode = batteryDisplayModeSetting.get(); const items: BatteryItem[] = []; const phone = readPhoneBatteryState(); @@ -401,9 +479,9 @@ export class ShellChromeLayer implements Layer { pushBatteryItem(items, ringBatteryVisibilitySetting.get(), "R1", state.battery.ring, Boolean(state.battery.ringCharging)); } - if (!items.length) return G2_LENS_WIDTH; + if (!items.length) return barRight; if (mode === "stacked" || mode === "stacked-percentage") { - return drawStackedBatteries(image, items, barTop, mode === "stacked-percentage"); + return drawStackedBatteries(image, items, barTop, barRight, mode === "stacked-percentage"); } const font = getDefaultSmallFont(); @@ -411,7 +489,7 @@ export class ShellChromeLayer implements Layer { const labelGap = 5; const itemGap = 12; const textY = barTop + Math.max(0, ((TOP_BAR_HEIGHT - font.lineHeight) / 2) | 0); - let x = G2_LENS_WIDTH - BATTERY_BLOCK_RIGHT_MARGIN; + let x = barRight - BATTERY_BLOCK_RIGHT_MARGIN; for (let index = items.length - 1; index >= 0; index--) { const item = items[index]!; const percentText = `${item.percent}%`; @@ -474,14 +552,14 @@ const STACKED_ITEM_GAP = 10; /** * Stacked styles: each label centered above its gauge icon (or percentage - * text), right-aligned in the bar. Returns the left edge of the battery - * block. + * text), right-aligned in the bar (ending at barRight). Returns the left edge + * of the battery block. */ -function drawStackedBatteries(image: GrayImage, items: BatteryItem[], barTop: number, percentage: boolean): number { +function drawStackedBatteries(image: GrayImage, items: BatteryItem[], barTop: number, barRight: number, percentage: boolean): number { const font = getFont("terminusv12"); const labelTop = barTop + STACKED_LABEL_BASELINE - font.ascent; const percentTop = barTop + STACKED_PERCENT_BASELINE - font.ascent; - let x = G2_LENS_WIDTH - BATTERY_BLOCK_RIGHT_MARGIN; + let x = barRight - BATTERY_BLOCK_RIGHT_MARGIN; for (let index = items.length - 1; index >= 0; index--) { const item = items[index]!; const percentText = `${item.percent}%`; @@ -521,16 +599,18 @@ const AMBIENT_MAX_LINES_PER_CARD = 3; /** * Paint the active ambient cards bottom-up: the oldest card sits at the very * bottom of the window band and newer ones stack above it. Cards that would - * cross into the top bar are dropped rather than clipped. + * cross into the top bar are dropped rather than clipped. `right` is the + * top bar's right edge, which the cards align to. */ const ambientKeys = new Map(); -function drawAmbientCards(image: GrayImage, parts?: Plane[]): void { +function drawAmbientCards(image: GrayImage, right: number, parts?: Plane[]): void { const cards = activeAmbientCards(); if (!cards.length) return; const font = getDefaultSmallFont(); const bandTop = minWindowTop(); const bandBottom = bandTop + MIN_WINDOW_HEIGHT; - const x = G2_LENS_WIDTH - AMBIENT_CARD_WIDTH - AMBIENT_CARD_MARGIN; + // Right-aligned with the top bar: clear of a right-hand sidebar. + const x = right - AMBIENT_CARD_WIDTH - AMBIENT_CARD_MARGIN; const textWidth = AMBIENT_CARD_WIDTH - 2 * AMBIENT_CARD_PADDING_X; let bottom = bandBottom - AMBIENT_CARD_MARGIN; for (const card of cards) { @@ -591,33 +671,81 @@ const TAB_EXTEND = 0; const TAB_STROKE = 150; /** - * Draw the selection "diversion" of the separator line around a sidebar icon - * in the rightmost column: rounded on the left, square and open on the right, - * extending a few px past the separator into the main area. Focused = filled - * white; otherwise an outline. `left` is the column's left edge, which the - * rounded corners curve in from. + * Draw the switcher/main separator line along the strip's inner edge, with + * a gap where the selection tab `gap` diverts it. */ -function drawSelectionTab(image: GrayImage, left: number, top: number, bottom: number, focused: boolean): void { - const right = SIDEBAR_WIDTH - 1 + TAB_EXTEND; - if (focused) { - for (let yy = top; yy < bottom; yy++) { - const x = left + tabLeftInset(yy, top, bottom, TAB_RADIUS); - image.fillRect(x, yy, right - x + 1, 1, 255); +function drawSeparator( + image: GrayImage, + state: ShellChromeState, + strip: { x: number; y: number; width: number; height: number }, + gap: SwitcherCell | null, +): void { + if (switcherPosition() === "bottom") { + // Along the row's top edge, the full width of the row. + const y = strip.y, right = strip.x + strip.width - 1; + if (gap) { + image.drawLine(strip.x, y, gap.x, y, BORDER_VALUE); + image.drawLine(gap.x + gap.width, y, right, y, BORDER_VALUE); + } else { + image.drawLine(strip.x, y, right, y, BORDER_VALUE); } return; } - // Outline: the tab shape minus the same shape inset by a pixel, row by row. - // Stroking the curve one pixel per row instead would leave gaps wherever the - // corner steps in by more than one pixel, and the top/bottom edges have to - // start at the same inset the curve uses or they part company from it. - for (let yy = top; yy < bottom; yy++) { - const outer = left + tabLeftInset(yy, top, bottom, TAB_RADIUS); - // The top and bottom rows are the horizontal edges: solid out to the open - // right side. In between only the left edge is stroked. - const inner = yy > top && yy < bottom - 1 - ? left + 1 + tabLeftInset(yy, top + 1, bottom - 1, TAB_RADIUS - 1) - : right + 1; - image.fillRect(outer, yy, Math.max(1, Math.min(inner, right + 1) - outer), 1, TAB_STROKE); + const sep = switcherPosition() === "right" ? strip.x : strip.x + strip.width - 1; + const bottom = strip.y + strip.height - 1; + // Start beside the app content, leaving the area alongside the top bar open. + const top = Math.max(strip.y, windowTop(state.foregroundHeightMode, state.foregroundAppId) + TOP_BAR_HEIGHT); + if (gap) { + image.drawLine(sep, top, sep, gap.y, BORDER_VALUE); + image.drawLine(sep, gap.y + gap.height, sep, bottom, BORDER_VALUE); + } else { + image.drawLine(sep, top, sep, bottom, BORDER_VALUE); + } +} + +/** + * Draw the selection "diversion" of the separator line around a switcher + * icon whose cell touches the separator: rounded on the outer side, square + * and open on the side toward the main area, extending TAB_EXTEND px past + * the separator into it. Focused = filled white; otherwise an outline. + * + * Drawn in tab-local coordinates: `along` runs parallel to the separator, + * `across` from the rounded outer edge (0) to the open edge, and fillAcross + * maps a run of one along-line onto the screen for the strip's orientation. + */ +function drawSelectionTab(image: GrayImage, cell: SwitcherCell, position: AppSwitcherPosition, focused: boolean): void { + const vertical = position !== "bottom"; + const along = vertical ? cell.height : cell.width; + const across = (vertical ? cell.width : cell.height) + TAB_EXTEND; + const fillAcross = (i: number, from: number, to: number, value: number) => { + switch (position) { + case "left": + image.fillRect(cell.x + from, cell.y + i, to - from, 1, value); + break; + case "right": + image.fillRect(cell.x + cell.width - to, cell.y + i, to - from, 1, value); + break; + default: + image.fillRect(cell.x + i, cell.y + cell.height - to, 1, to - from, value); + } + }; + if (focused) { + for (let i = 0; i < along; i++) { + fillAcross(i, tabInset(i, 0, along, TAB_RADIUS), across, 255); + } + return; + } + // Outline: the tab shape minus the same shape inset by a pixel, line by + // line. Stroking the curve one pixel per line instead would leave gaps + // wherever the corner steps in by more than one pixel, and the two edges + // running across have to start at the same inset the curve uses or they + // part company from it. + for (let i = 0; i < along; i++) { + const outer = tabInset(i, 0, along, TAB_RADIUS); + // The first and last lines are the edges running across: solid out to + // the open side. In between only the outer edge is stroked. + const inner = i > 0 && i < along - 1 ? 1 + tabInset(i, 1, along - 1, TAB_RADIUS - 1) : across; + fillAcross(i, outer, Math.max(outer + 1, Math.min(inner, across)), TAB_STROKE); } } @@ -634,24 +762,36 @@ function drawSelectionBox(image: GrayImage, x: number, y: number, width: number, } } -/** Left boundary x of the tab at row yy: 0 in the middle, curving to the rounded left corners. */ -function tabLeftInset(yy: number, top: number, bottom: number, radius: number): number { - const cy = yy + 0.5; - let dy = 0; - if (cy < top + radius) { - dy = top + radius - cy; - } else if (cy > bottom - radius) { - dy = cy - (bottom - radius); +/** + * How far the tab's outer edge is inset at along-line i (of the tab spanning + * start..end): 0 in the middle, curving in toward the rounded corners. + */ +function tabInset(i: number, start: number, end: number, radius: number): number { + const c = i + 0.5; + let d = 0; + if (c < start + radius) { + d = start + radius - c; + } else if (c > end - radius) { + d = c - (end - radius); } else { return 0; } - return Math.max(0, Math.round(radius - Math.sqrt(Math.max(0, radius * radius - dy * dy)))); + return Math.max(0, Math.round(radius - Math.sqrt(Math.max(0, radius * radius - d * d)))); } -/** Small triangle marker for sidebar overflow; direction -1 = up, 1 = down. */ -function drawChevron(image: GrayImage, centerX: number, y: number, direction: -1 | 1): void { +/** + * Small triangle marker for switcher overflow, pointing the way the hidden + * icons are; (x, y) is the middle of its base. + */ +function drawChevron(image: GrayImage, x: number, y: number, direction: "up" | "down" | "left" | "right"): void { const half = 5; - const tipY = direction < 0 ? y - 3 : y + 3; - image.drawLine(centerX - half, y, centerX, tipY, 140); - image.drawLine(centerX, tipY, centerX + half, y, 140); + if (direction === "left" || direction === "right") { + const tipX = direction === "left" ? x - 3 : x + 3; + image.drawLine(x, y - half, tipX, y, 140); + image.drawLine(tipX, y, x, y + half, 140); + return; + } + const tipY = direction === "up" ? y - 3 : y + 3; + image.drawLine(x - half, y, x, tipY, 140); + image.drawLine(x, tipY, x + half, y, 140); } diff --git a/app/ui/shell/geometry.ts b/app/ui/shell/geometry.ts index 58454526..2a983b22 100644 --- a/app/ui/shell/geometry.ts +++ b/app/ui/shell/geometry.ts @@ -1,5 +1,7 @@ import { G2_LENS_HEIGHT, G2_LENS_WIDTH } from "../../graphics/image"; import { + appSwitcherPositionSetting, + type AppSwitcherPosition, displayModeSetting, type DisplayModeSetting, verticalPositionSetting, @@ -7,19 +9,36 @@ import { navigateVerticalPositionSetting, terminalDisplayModeSetting, terminalVerticalPositionSetting, + uiDepthSetting, } from "../dashboard-settings"; /** Top bar: 24px notification icons plus a little padding. */ export const TOP_BAR_HEIGHT = 28; /** - * Width of the sidebar strip as painted. Leaves the app viewport exactly - * 576px wide — the surface width EvenHub apps expect — except in the - * full-panel display mode, where the strip overlays the app (see - * sidebarWidth). Icon column layout within the strip (one wide column vs. - * two narrow ones) is the chrome layer's business. + * Width of the sidebar strip as painted (the app switcher on the left or + * right edge). App windows get the other 576px — the surface width EvenHub + * apps expect — and keep that width with the switcher at the bottom too, + * except in the full-panel display mode, where the switcher overlays the + * app (see sidebarWidth). Icon column layout within the strip (one wide + * column vs. two narrow ones) is the chrome layer's business. */ export const SIDEBAR_WIDTH = 64; +/** + * Height of the app switcher as a row under the window: one tall tab, the + * same 36px (a 32px icon plus 2px either side) as a one-column sidebar slot. + * The row is wide enough that it never needs the sidebar's smaller + * two-column icons. It comes out of the height available to windows; their + * width stays 576, centred, leaving SIDEBAR_WIDTH / 2 at each side for the + * whole display's stereo shift (uiDepth). + */ +export const SWITCHER_ROW_HEIGHT = 36; + +/** Which edge the app switcher is on (Settings > Customization). */ +export function switcherPosition(): AppSwitcherPosition { + return appSwitcherPositionSetting.get(); +} + /** The Display > Display mode setting (see dashboard-settings.ts). */ function appDisplayMode(appId?: string) { return appId === "navigate" ? navigateDisplayModeSetting.get() @@ -31,21 +50,110 @@ export function displayMode(appId?: string): DisplayModeSetting { return mode === "global" || mode === "default" ? displayModeSetting.get() : mode; } -/** - * How much of the screen's width the sidebar takes away from app windows: - * the strip, or nothing in the full-panel mode (where the chrome paints the - * strip over the window while the sidebar has focus). - */ -export function sidebarWidth(appId?: string): number { - return displayMode(appId) === "640x480" ? 0 : SIDEBAR_WIDTH; +/** The full-panel mode: windows fill the panel; the switcher overlays them only while it has focus. */ +function fullPanel(appId?: string): boolean { + return displayMode(appId) === "640x480"; } /** - * Whether the sidebar strip is on screen: always when it reserves width; in + * How much of the screen's width the sidebar takes away from app windows: + * the strip, or nothing when the switcher is a bottom row or in the + * full-panel mode (where the chrome paints the strip over the window while + * the sidebar has focus). + */ +export function sidebarWidth(appId?: string): number { + return fullPanel(appId) || switcherPosition() === "bottom" ? 0 : SIDEBAR_WIDTH; +} + +/** + * How much of the screen's height a bottom switcher row takes away from app + * windows: the row, or nothing beside a side strip or in the full-panel mode + * (where the row overlays the window's bottom edge while it has focus). + */ +export function switcherRowHeight(appId?: string): number { + return !fullPanel(appId) && switcherPosition() === "bottom" ? SWITCHER_ROW_HEIGHT : 0; +} + +/** + * Whether the switcher strip is on screen: always when it reserves room; in * the full-panel mode (where it overlays the window) only while it has focus. */ export function sidebarStripVisible(focus: "sidebar" | "window", appId?: string): boolean { - return sidebarWidth(appId) > 0 || focus === "sidebar"; + return !fullPanel(appId) || focus === "sidebar"; +} + +/** + * Screen rect of the switcher strip. A side strip aligns to the min-height + * band (like the shell overlays). A bottom row sits right under the given + * (foreground) window and spans its width, so a band shorter than the + * screen has no gap below it; it moves when the foreground switches to a + * window of another height, as the top bar does. In the full-panel mode the + * row overlays the bottom edge of the screen. + */ +export function switcherRect(heightMode: WindowHeightMode, appId?: string): { x: number; y: number; width: number; height: number } { + switch (switcherPosition()) { + case "bottom": + return { + x: appViewportLeft(appId), + y: switcherRowHeight(appId) > 0 + ? windowTop(heightMode, appId) + windowBandHeight(heightMode, appId) + : G2_LENS_HEIGHT - SWITCHER_ROW_HEIGHT, + width: appViewportWidth(appId), + height: SWITCHER_ROW_HEIGHT, + }; + case "right": + return { x: G2_LENS_WIDTH - SIDEBAR_WIDTH, y: minWindowTop(appId), width: SIDEBAR_WIDTH, height: MIN_WINDOW_HEIGHT }; + default: + return { x: 0, y: minWindowTop(appId), width: SIDEBAR_WIDTH, height: MIN_WINDOW_HEIGHT }; + } +} + +/** + * Whether a screen point lies on the switcher's side of the screen, for + * touches on the phone's mirror: anywhere in a side strip's column, or from + * the top of a bottom row (under the given foreground window) down. + */ +export function isOnSwitcherEdge(x: number, y: number, heightMode: WindowHeightMode, appId?: string): boolean { + switch (switcherPosition()) { + case "bottom": + return y >= switcherRect(heightMode, appId).y; + case "right": + return x >= G2_LENS_WIDTH - SIDEBAR_WIDTH; + default: + return x < SIDEBAR_WIDTH; + } +} + +/** Width of app windows: the panel's in the full-panel mode, else 576 (see SIDEBAR_WIDTH). */ +function appViewportWidth(appId?: string): number { + return fullPanel(appId) ? G2_LENS_WIDTH : G2_LENS_WIDTH - SIDEBAR_WIDTH; +} + +/** + * Left edge (x) of app windows: past a left strip, centred above a bottom + * row (see SWITCHER_ROW_HEIGHT), else the screen edge. + */ +export function appViewportLeft(appId?: string): number { + if (fullPanel(appId)) return 0; + switch (switcherPosition()) { + case "left": + return SIDEBAR_WIDTH; + case "bottom": + return SIDEBAR_WIDTH / 2; + default: + return 0; + } +} + +/** + * Stereo depth of the whole display (Settings > Customization > Depth), in + * the firmware's depth units; the shell scene carries it to the compositor, + * which shifts the screen and everything drawn over it per lens. Only with + * the switcher at the bottom, where the windows' side margins leave room for + * the shift. + */ +export function uiDepth(): number { + return switcherPosition() === "bottom" ? Number(uiDepthSetting.get()) : 0; } /** @@ -57,13 +165,13 @@ export function effectiveHeightMode(mode: WindowHeightMode, appId?: string): Win } /** - * X of the display's true horizontal centre, in app-viewport coordinates. The - * sidebar pushes the viewport to the right, so UI the wearer physically aims - * with — a compass rose, a calibration crosshair — has to offset by it rather - * than use the viewport's own centre. + * X of the display's true horizontal centre, in app-viewport coordinates. A + * side strip pushes the viewport off centre, so UI the wearer physically + * aims with — a compass rose, a calibration crosshair — has to offset by it + * rather than use the viewport's own centre. */ export function screenCenterInViewportX(): number { - return Math.round(G2_LENS_WIDTH / 2) - sidebarWidth(); + return Math.round(G2_LENS_WIDTH / 2) - appViewportLeft(); } /** @@ -78,20 +186,27 @@ export const SHELL_OPAQUE_BLACK = 1; * firmware uses, leaving most of the field of view clear; "medium" is one * top bar taller, so the content area below the bar is a full 288px (the * EvenHub app surface height); "max" uses the whole 480px screen (terminal - * views). All include a top bar drawn by the shell at the window's top edge. + * views), less a bottom switcher row. All include a top bar drawn by the + * shell at the window's top edge. */ export type WindowHeightMode = "min" | "medium" | "max"; /** Total height (top bar + content) of a min-height window. */ export const MIN_WINDOW_HEIGHT = 288; -/** Farthest down a min-height window can start. */ -export const MIN_WINDOW_MAX_TOP = G2_LENS_HEIGHT - MIN_WINDOW_HEIGHT; + +/** + * Height of the screen area windows are placed in: the whole screen, less + * a bottom switcher row's height. + */ +function windowAreaHeight(appId?: string): number { + return G2_LENS_HEIGHT - switcherRowHeight(appId); +} /** Total height (top bar + content) of a window's band in the given mode. */ export function windowBandHeight(mode: WindowHeightMode, appId?: string): number { switch (effectiveHeightMode(mode, appId)) { case "max": - return G2_LENS_HEIGHT; + return windowAreaHeight(appId); case "medium": return MIN_WINDOW_HEIGHT + TOP_BAR_HEIGHT; default: @@ -129,15 +244,19 @@ export function minWindowTop(appId?: string): number { return windowTop("min", appId); } -/** Top edge (y) of a window's top bar; max-height windows pin to the screen top. */ +/** + * Top edge (y) of a window's top bar; max-height windows pin to the screen + * top. A bottom switcher row hangs under the band, so the band and row + * together distribute the screen's slack. + */ export function windowTop(mode: WindowHeightMode, appId?: string): number { - return Math.round((G2_LENS_HEIGHT - windowBandHeight(mode, appId)) * verticalPositionFraction(appId)); + return Math.round((windowAreaHeight(appId) - windowBandHeight(mode, appId)) * verticalPositionFraction(appId)); } /** App-content viewport size for a height mode (independent of vertical position). */ export function appViewportSize(mode: WindowHeightMode, appId?: string): { width: number; height: number } { return { - width: G2_LENS_WIDTH - sidebarWidth(appId), + width: appViewportWidth(appId), height: windowBandHeight(mode, appId) - TOP_BAR_HEIGHT, }; } @@ -150,7 +269,7 @@ export function appViewportRect(mode: WindowHeightMode, appId?: string): { height: number; } { return { - x: sidebarWidth(appId), + x: appViewportLeft(appId), y: windowTop(mode, appId) + TOP_BAR_HEIGHT, ...appViewportSize(mode, appId), }; diff --git a/app/ui/shell/shell.ts b/app/ui/shell/shell.ts index 8ce042c8..d73f6bdf 100644 --- a/app/ui/shell/shell.ts +++ b/app/ui/shell/shell.ts @@ -7,6 +7,7 @@ import { acceptInput } from "../input-monitor"; import type { RawInputEvent } from "../../native/faceclaw-communicator"; import { directionalFallback, + type DirectionalInputEvent, GESTURE_SHORT_THEN_LONG_PRESS, gestureHints, InputEvent, @@ -44,19 +45,23 @@ import { wakeWordActionSetting, } from "../dashboard-settings"; import { onAmbientCardsChanged } from "./ambient-cards"; -import { ShellChromeLayer, sidebarContentLeft, type ShellChromeState, type ShellChromeWindow } from "./chrome-layer"; +import { ShellChromeLayer, sidebarContentSpan, type ShellChromeState, type ShellChromeWindow } from "./chrome-layer"; import { ShellModalLayer } from "./modal-layer"; import { ToolDebugMenuLayer } from "./tool-debug-layer"; import { BrightnessPickerLayer } from "./brightness-picker-layer"; import { toolRegistry } from "../../assistant/tool-registry"; import { + appViewportRect, minWindowTop, sidebarWidth, - TOP_BAR_HEIGHT, + switcherPosition, + switcherRowHeight, + uiDepth, windowBandHeight, windowTop, type WindowHeightMode, } from "./geometry"; +import type { AppSwitcherPosition } from "../dashboard-settings"; /** * The shell: owns the window registry, focus, screen on/off, and the shell @@ -228,12 +233,14 @@ class ShellOverlayMenuLayer extends MenuLayer { constructor(items: MenuItem[], footer: string | undefined, private readonly onClosed: () => void) { // Aligned to the min-height window band (like the sidebar), wherever the // vertical position setting currently puts it; centered over the - // application area, i.e. the part of the screen past the sidebar strip - // (the whole screen in the full-panel mode, where the strip overlays). + // application area, i.e. the part of the screen beside a side strip + // (the whole width with a bottom row, or in the full-panel mode, where + // the strip overlays). const width = 272; + const area = appViewportRect("min"); super("System", items, { - x: sidebarWidth() + (((G2_LENS_WIDTH - sidebarWidth() - width) / 2) | 0), - y: minWindowTop() + TOP_BAR_HEIGHT + 8, + x: area.x + (((area.width - width) / 2) | 0), + y: area.y + 8, width, minHeight: 150, squareCorners: true, @@ -308,9 +315,28 @@ class ShellAlertLayer implements Layer { } } -/** Every setting the top bar paints from, as one comparable string. */ -function topBarSettingsKey(): string { - return `${batteryIndicatorSettingsKey()}|${timeFormatSetting.get()}`; +/** + * What a watch swipe means while the app switcher has focus, as the ring + * gesture it stands for. Swipes are spatial: along the strip they move the + * selection, toward the app area they enter the selected window, and away + * from it there is nowhere further to go (ignored). + */ +const SWITCHER_SWIPES: Record< + AppSwitcherPosition, + Partial> +> = { + left: { "swipe-up": "scroll-up", "swipe-down": "scroll-down", "swipe-right": "click" }, + right: { "swipe-up": "scroll-up", "swipe-down": "scroll-down", "swipe-left": "click" }, + bottom: { "swipe-left": "scroll-up", "swipe-right": "scroll-down", "swipe-up": "click" }, +}; + +/** + * Every setting the shell's paint depends on that nothing else repaints it + * for (the top bar's contents, the scene's stereo depth), as one comparable + * string. + */ +function chromeSettingsKey(): string { + return `${batteryIndicatorSettingsKey()}|${timeFormatSetting.get()}|${uiDepth()}`; } class Shell { @@ -373,8 +399,8 @@ class Shell { // Top-bar settings we mirror into the chrome; a change to any of them // repaints the shell surface so the top bar reflects it immediately. - private topBarSettingsSubscribed = false; - private lastTopBarSettingsKey: string | null = null; + private chromeSettingsSubscribed = false; + private lastChromeSettingsKey: string | null = null; configure(config: ShellConfig): void { // Nearly every state change ends in a shell render request, so it is @@ -387,7 +413,7 @@ class Shell { }, }; this.stack.setActions(config.actions); - this.subscribeToTopBarSettings(); + this.subscribeToChromeSettings(); this.subscribeToAmbientCards(); } @@ -405,14 +431,14 @@ class Shell { }); } - private subscribeToTopBarSettings(): void { - if (this.topBarSettingsSubscribed) return; - this.topBarSettingsSubscribed = true; - this.lastTopBarSettingsKey = topBarSettingsKey(); + private subscribeToChromeSettings(): void { + if (this.chromeSettingsSubscribed) return; + this.chromeSettingsSubscribed = true; + this.lastChromeSettingsKey = chromeSettingsKey(); onAnySettingChanged(() => { - const key = topBarSettingsKey(); - if (key === this.lastTopBarSettingsKey) return; - this.lastTopBarSettingsKey = key; + const key = chromeSettingsKey(); + if (key === this.lastChromeSettingsKey) return; + this.lastChromeSettingsKey = key; this.config.requestShellRender(); }); } @@ -701,8 +727,13 @@ class Shell { this.config.requestShellRender(); } - /** Paint the shell surface: transparent chrome, or all-transparent when asleep. */ - paintScene(): Uint8Array { return encodeShellScene(this.screenOn ? this.stack.paintUndimmed() : []); } + /** + * Paint the shell surface: transparent chrome, or all-transparent when + * asleep. The scene also carries the whole display's stereo depth. + */ + paintScene(): Uint8Array { + return this.screenOn ? encodeShellScene(this.stack.paintUndimmed(), uiDepth()) : encodeShellScene([]); + } paintSurface(): Plane[] { if (!this.screenOn) { @@ -904,20 +935,24 @@ class Shell { /** * Screen rect actually occupied by content, for cropping screenshots: the - * foreground window's band (full screen for a max-height window, the - * vertical-position-dependent 288px band otherwise), minus the sidebar - * strip left of the icon columns when the one-column variant is active. + * foreground window's band (full height for a max-height window, the + * vertical-position-dependent 288px band otherwise) plus the switcher: a + * side strip's icon columns (minus the outer dead strip the one-column + * variant leaves), or the row under it. */ screenshotCropRect(): { x: number; y: number; width: number; height: number } { const appId = this.foregroundWindow()?.appId; const heightMode = this.foregroundWindow()?.heightMode ?? "min"; - const x = sidebarWidth(appId) === 0 ? 0 : sidebarContentLeft(this.windows.length); - return { - x, - y: windowTop(heightMode, appId), - width: G2_LENS_WIDTH - x, - height: windowBandHeight(heightMode, appId), - }; + const viewport = appViewportRect(heightMode, appId); + let left = viewport.x, right = viewport.x + viewport.width; + if (sidebarWidth(appId) > 0) { + const strip = sidebarContentSpan(this.windows.length); + left = Math.min(left, strip.left); + right = Math.max(right, strip.right); + } + const y = windowTop(heightMode, appId); + const bottom = y + windowBandHeight(heightMode, appId) + switcherRowHeight(appId); + return { x: left, y, width: right - left, height: bottom - y }; } /** @@ -966,7 +1001,8 @@ class Shell { } private handleSidebarInput(event: InputEvent): ShellInputOutcome { - switch (event.type) { + const type = isDirectionalInput(event) ? SWITCHER_SWIPES[switcherPosition()][event.type] : event.type; + switch (type) { case "double-click": // A double-tap at the root (the app switcher selected) turns the // display off — from the ring and the watch scheme alike; watch-scheme @@ -974,17 +1010,12 @@ class Shell { this.sleep(); return { shell: true, window: false }; case "scroll-up": - case "swipe-up": this.moveSelection(-1); return { shell: true, window: false }; case "scroll-down": - case "swipe-down": this.moveSelection(1); return { shell: true, window: false }; case "click": - case "swipe-right": - // Right: into the selected window (spatially, the window is to the - // sidebar's right). Left has nowhere further to go and is ignored. if (this.windows.length) { this.focus = "window"; this.foregroundWindow()?.onFocus?.(this.lastInput); diff --git a/app/ui/shell/tool-debug-layer.ts b/app/ui/shell/tool-debug-layer.ts index 6dcdd333..752b4548 100644 --- a/app/ui/shell/tool-debug-layer.ts +++ b/app/ui/shell/tool-debug-layer.ts @@ -1,4 +1,4 @@ -import { G2_LENS_WIDTH, GrayImage } from "../../graphics/image"; +import { GrayImage } from "../../graphics/image"; import { getDefaultSmallFont } from "../../graphics/ui-fonts"; import { wrapText } from "../../graphics/textwrap"; import { clamp } from "../../util/numeric-util"; @@ -6,7 +6,7 @@ import type { ToolDebugEntry } from "../../assistant/tool-registry"; import { InputEvent } from "../gestures"; import { Layer, LayerContext, PaintBelow } from "../layers"; import { MenuLayer, drawListScrollbar, type MenuItem } from "../menu"; -import { minWindowTop, sidebarWidth, TOP_BAR_HEIGHT } from "./geometry"; +import { appViewportRect } from "./geometry"; import { lineStep } from "../metrics"; /** @@ -21,18 +21,19 @@ const DIALOG_WIDTH = 420; // the band below the top bar with an 8px margin on each side. const DETAIL_HEIGHT = 208; -/** Dialog left edge: past the sidebar strip where one reserves width. */ +/** Dialog left edge: inside the app area, clear of a left sidebar strip. */ function dialogX(): number { - return sidebarWidth() + 8; + return appViewportRect("min").x + 8; } +/** Detail box width: the app area (clear of a right sidebar strip) less margins. */ function detailWidth(): number { - return G2_LENS_WIDTH - dialogX() - 8; + return appViewportRect("min").width - 16; } /** Dialog top edge, aligned to the min-height band's content area. */ function dialogY(): number { - return minWindowTop() + TOP_BAR_HEIGHT + 8; + return appViewportRect("min").y + 8; } const DETAIL_PADDING = 14; diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/DrawProtocol.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/DrawProtocol.kt index 7ab1b12d..6567a056 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/DrawProtocol.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/DrawProtocol.kt @@ -62,6 +62,27 @@ object DrawProtocol { write: DrawWriter.() -> Unit): ByteArray = call(op, encode(write), target, depth, clip) + /** + * [call] moved [extra] depth units further, as if played from a list called at that depth: + * adds to its depth field, or inserts one (after any target override) when it has none. The + * sum saturates at the field's range rather than failing the whole presentation. + */ + fun withAddedDepth(call: ByteArray, extra: Int): ByteArray { + if (extra == 0) return call + val flags = call[1].toInt() and 255 + val at = if (flags and DRAW_FLAG_RESOURCE_TARGET != 0) 4 else 2 + val result = if (flags and DRAW_FLAG_DEPTH != 0) { + call.copyOf().also { it[at] = addDepth(call[at].toInt(), extra).toByte() } + } else { + call.copyOfRange(0, at) + byteArrayOf(addDepth(0, extra).toByte()) + call.copyOfRange(at, call.size) + } + result[1] = (flags or DRAW_FLAG_DEPTH).toByte() + return result + } + + /** Two depths combined, saturated to the s8 depth field. */ + fun addDepth(depth: Int, extra: Int): Int = (depth + extra).coerceIn(-128, 127) + fun depthOffset(depth: Int, right: Boolean): Int = if (right) -floorHalf(depth + 1) else floorHalf(depth) diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/ShellScene.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/ShellScene.kt index fa0c46ed..62544f8a 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/ShellScene.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/ShellScene.kt @@ -1,6 +1,10 @@ package com.faceclaw.app -/** Immutable shell snapshot. Keys identify writable surfaces across repaints, not their pixels. */ +/** + * Immutable shell snapshot. Keys identify writable surfaces across repaints, not their pixels. + * [screenDepth] is the stereo depth of the whole presentation: the screen copy and everything + * drawn over it shift together per lens (see [calls]). + */ class ShellScene(val layers: List, val selections: List = emptyList(), val screenDepth: Int = 0) { class Layer(val key: Int, val x: Int, val y: Int, val width: Int, val height: Int, val dim: Int, val packed: ByteArray, val selections: List = emptyList(), val depth: Int = 0) { // Layers are reused by every composite until the shell repaints, and hashing packed @@ -13,22 +17,32 @@ class ShellScene(val layers: List, val selections: List val retainedResources = allSelections.flatMap { it.resources } init { require(retainedResources.size + layers.size < 511 && screenDepth in -128..127) } val fingerprint: String = layers.joinToString(";") { it.fingerprint } + selections.joinToString { it.fingerprint } + "|depth:$screenDepth" + /** + * The root list. A nonzero [screenDepth] adds to every positional call's own depth, so the + * scene moves as one; depths are even (see uiDepthSetting) so the per-lens halves add + * exactly. Dim LUTs stay put: they cover the whole target, and a shifted one would leave an + * undimmed strip at one edge. + */ fun calls(width: Int, height: Int, surfaces: IntArray, selected: IntArray): List { val calls = ArrayList(); var rowId = 0 val now = drawAnimationTimeMs() + fun shifted(call: ByteArray) = DrawProtocol.withAddedDepth(call, screenDepth) calls.addAll(DrawProtocol.screenCopy(width, height, screenDepth)) fun add(row: RetainedDrawing) { - calls.addAll(row.calls(selected.copyOfRange(rowId, rowId + row.resources.size), now)) + for (call in row.calls(selected.copyOfRange(rowId, rowId + row.resources.size), now)) calls.add(shifted(call)) rowId += row.resources.size } for (row in selections) add(row) for ((index, layer) in layers.withIndex()) { if (layer.dim < 256) calls.add(DrawProtocol.lut(width, height, layer.dim)) - calls.add(DrawProtocol.image(surfaces[index], layer.x, layer.y, depth = layer.depth)) + calls.add(DrawProtocol.image(surfaces[index], layer.x, layer.y, depth = DrawProtocol.addDepth(layer.depth, screenDepth))) for (row in layer.selections) add(row) } return calls } + /** This scene without its whole-presentation shift: the phone mirror's view (see SurfaceCompositor.previewScene). */ + fun unshifted(): ShellScene = if (screenDepth == 0) this else ShellScene(layers, selections, 0) + fun preview(screenGray: ByteArray, width: Int, height: Int, rightLens: Boolean = false): ByteArray { val screen = BmpUtil.pack4bppFromGray8(screenGray, width, height) val output = ByteArray(screen.size); val resources = HashMap() @@ -89,10 +103,11 @@ class ShellScene(val layers: List, val selections: List val selections = List(selectionCount) { readRetainedDrawing(reader, reader.get().toInt()) } layers.add(Layer(key, x, y, w, h, dim, BmpUtil.pack4bppFromGray8(gray, w, h), selections, depth)) } - require(reader.remaining() == 0) + require(reader.remaining() == 2) + val screenDepth = reader.getShort().toInt() require(layers.sumOf { layer -> layer.selections.sumOf { it.resources.size } } + layers.size < 511) require(layers.map { it.key }.toSet().size == layers.size) - return ShellScene(layers) + return ShellScene(layers, screenDepth = screenDepth) } } } diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/SurfaceCompositor.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/SurfaceCompositor.kt index 4fea1860..19f60f16 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/SurfaceCompositor.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/SurfaceCompositor.kt @@ -316,10 +316,14 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr private var lastScene: ShellScene? = null private var previewKey: String? = null + /** + * The phone mirror's view of [scene]: without the whole-screen stereo shift, which would move + * it off centre by half the depth and put mirror touches that far from what they land on. + */ private fun previewScene(scene: ShellScene, gray: ByteArray, key: String): ByteArray { if (previewKey != key) { animatedPreview?.player?.stop() - animatedPreview = scene.animatedPreview(gray, screenWidth, screenHeight, + animatedPreview = scene.unshifted().animatedPreview(gray, screenWidth, screenHeight, schedule = { delay, action -> scheduleDrawRedraw(delay) { lock.withLock(action) } }) previewKey = key } @@ -480,12 +484,16 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr } } - /** The screen's stereo depth: see setSurfaceDepth. */ + /** + * The screen's stereo depth: a covering surface's own (see setSurfaceDepth), else the shell + * scene's depth for the whole display (the regular UI's Depth setting). + */ private fun screenDepthLocked(ordered: List): Int { - val top = ordered.lastOrNull { it.visible } ?: return 0 + val uiDepth = shellScene?.screenDepth ?: 0 + val top = ordered.lastOrNull { it.visible } ?: return uiDepth val covers = top.transparency == TRANSPARENCY_OPAQUE && top.x <= 0 && top.y <= 0 && top.x + top.width >= screenWidth && top.y + top.height >= screenHeight - return if (covers) top.depth else 0 + return if (covers) top.depth else uiDepth } /** diff --git a/tests/ai-chat.test.cjs b/tests/ai-chat.test.cjs index bfbcf03b..ddc6b05b 100644 --- a/tests/ai-chat.test.cjs +++ b/tests/ai-chat.test.cjs @@ -261,7 +261,10 @@ function shellEnv({ wakeAction = 'voice-input', skipConfirmation = false } = {}) '../notifications': {}, '../dashboard-settings': settings, './ambient-cards': {}, './chrome-layer': { ShellChromeLayer: class {} }, './modal-layer': {}, './tool-debug-layer': {}, './brightness-picker-layer': {}, - '../../assistant/tool-registry': {}, './geometry': { sidebarWidth: () => 64, minWindowTop: () => 96, TOP_BAR_HEIGHT: 28 }, + '../../assistant/tool-registry': {}, './geometry': { + sidebarWidth: () => 64, minWindowTop: () => 96, switcherPosition: () => 'left', uiDepth: () => 0, + appViewportRect: () => ({ x: 64, y: 124, width: 576, height: 260 }), + }, }); const { createInProcessWindow } = load('app/ui/shell/in-process-window.ts', { '../../graphics/image': images, '../../native/frame-timings': timings, diff --git a/tests/app-layout.test.cjs b/tests/app-layout.test.cjs index 26f6e4d2..1b451f48 100644 --- a/tests/app-layout.test.cjs +++ b/tests/app-layout.test.cjs @@ -14,6 +14,7 @@ function geometry() { displayModeSetting: '576x288', verticalPositionSetting: 'middle', navigateDisplayModeSetting: 'global', navigateVerticalPositionSetting: 'global', terminalDisplayModeSetting: 'default', terminalVerticalPositionSetting: 'global', + appSwitcherPositionSetting: 'left', uiDepthSetting: '0', }).map(([name, value]) => [name, { value, get() { return this.value; } }])); const context = { exports: {}, require: (name) => { if (name === '../../graphics/image') return { G2_LENS_WIDTH: 640, G2_LENS_HEIGHT: 480 }; @@ -65,23 +66,74 @@ test('Terminal can disable its tall default, inherit position or override both d test('all explicit size/position combinations stay within the display and align content below the bar', () => { const g = geometry(); - for (const globalMode of ['576x288', '576x480', '640x480']) { - g.settings.displayModeSetting.value = globalMode; - for (const appId of ['navigate', 'terminal']) { - for (const mode of ['global', '576x288', '576x480', '640x480']) { - g.settings[`${appId}DisplayModeSetting`].value = mode; - for (const position of ['global', 'top', 'upper', 'middle', 'lower', 'bottom']) { - g.settings[`${appId}VerticalPositionSetting`].value = position; - const rect = g.rect('max', appId); - assert.equal(rect.x + rect.width, 640); - assert.equal(rect.y, g.windowTop('max', appId) + g.TOP_BAR_HEIGHT); - assert.ok(rect.y >= 28 && rect.y + rect.height <= 480); + for (const switcher of ['left', 'right', 'bottom']) { + g.settings.appSwitcherPositionSetting.value = switcher; + for (const globalMode of ['576x288', '576x480', '640x480']) { + g.settings.displayModeSetting.value = globalMode; + for (const appId of ['navigate', 'terminal']) { + for (const mode of ['global', '576x288', '576x480', '640x480']) { + g.settings[`${appId}DisplayModeSetting`].value = mode; + for (const position of ['global', 'top', 'upper', 'middle', 'lower', 'bottom']) { + g.settings[`${appId}VerticalPositionSetting`].value = position; + for (const heightMode of ['min', 'medium', 'max']) { + const rect = g.rect(heightMode, appId); + const fullPanel = g.displayMode(appId) === '640x480'; + assert.equal(rect.x + rect.width, fullPanel ? 640 : { left: 640, right: 576, bottom: 608 }[switcher]); + assert.equal(rect.y, g.windowTop(heightMode, appId) + g.TOP_BAR_HEIGHT); + assert.ok(rect.y >= 28 && rect.y + rect.height <= 480 - g.switcherRowHeight(appId)); + const row = g.switcherRect(heightMode, appId); + assert.ok(row.y + row.height <= 480); + // A reserved bottom row hangs right under the window, as wide as it. + if (g.switcherRowHeight(appId)) assert.deepEqual([row.x, row.y, row.width], [rect.x, rect.y + rect.height, rect.width]); + } + } } } } } }); +test('the app switcher can sit on the right edge', () => { + const g = geometry(); + g.settings.appSwitcherPositionSetting.value = 'right'; + assert.deepEqual(g.rect('min'), { x: 0, y: 124, width: 576, height: 260 }); + assert.deepEqual({ ...g.switcherRect('max') }, { x: 576, y: 96, width: 64, height: 288 }); + assert.equal(g.screenCenterInViewportX(), 320); + assert.equal(g.isOnSwitcherEdge(600, 10, 'min'), true); + assert.equal(g.isOnSwitcherEdge(10, 200, 'min'), false); + // Depth needs the bottom row's side margins. + g.settings.uiDepthSetting.value = '32'; + assert.equal(g.uiDepth(), 0); + g.settings.displayModeSetting.value = '640x480'; + assert.deepEqual(g.rect('max'), { x: 0, y: 28, width: 640, height: 452 }); +}); + +test('a bottom app switcher centres 576-wide windows and hangs one tall tab under them', () => { + const g = geometry(); + g.settings.appSwitcherPositionSetting.value = 'bottom'; + assert.equal(g.SWITCHER_ROW_HEIGHT, 36); + assert.deepEqual(g.rect('max', 'terminal'), { x: 32, y: 28, width: 576, height: 416 }); + assert.deepEqual({ ...g.switcherRect('max', 'terminal') }, { x: 32, y: 444, width: 576, height: 36 }); + // Band and row share the slack: no gap under a band shorter than the screen. + assert.deepEqual(g.rect('min'), { x: 32, y: 106, width: 576, height: 260 }); + assert.deepEqual({ ...g.switcherRect('min') }, { x: 32, y: 366, width: 576, height: 36 }); + assert.equal(g.isOnSwitcherEdge(10, 370, 'min'), true); + assert.equal(g.isOnSwitcherEdge(10, 360, 'min'), false); + g.settings.verticalPositionSetting.value = 'bottom'; + assert.equal(g.switcherRect('min').y, 444); + // The true centre is the viewport's own with the window centred. + assert.equal(g.screenCenterInViewportX(), 288); + // Depth applies only here. + g.settings.uiDepthSetting.value = '-48'; + assert.equal(g.uiDepth(), -48); + // Full panel: windows fill the panel and the row overlays the bottom edge while focused. + g.settings.displayModeSetting.value = '640x480'; + assert.deepEqual(g.rect('max'), { x: 0, y: 28, width: 640, height: 452 }); + assert.deepEqual({ ...g.switcherRect('max') }, { x: 0, y: 444, width: 640, height: 36 }); + assert.equal(g.sidebarStripVisible('window'), false); + assert.equal(g.sidebarStripVisible('sidebar'), true); +}); + // Exercise the real worker message handler with platform work stubbed out. function resizeHandler(file, globals) { const source = ts.createSourceFile(file, read(file), ts.ScriptTarget.Latest, true); diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/DisplayListTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/DisplayListTest.kt index db3110a1..92419258 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/DisplayListTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/DisplayListTest.kt @@ -299,6 +299,48 @@ class DisplayListTest { assertEquals(0, output.get(if (right) 639 else 0, 240)) // cleared, not stale } } + @Test fun addedDepthJoinsOrInsertsTheDepthField() { + val copy = DrawProtocol.rectCopy(DrawProtocol.SCREEN, 0, 0, 4, 4, 0, 0) + assertContentEquals(DrawProtocol.rectCopy(DrawProtocol.SCREEN, 0, 0, 4, 4, 0, 0, depth = 8), DrawProtocol.withAddedDepth(copy, 8)) + val targeted = DrawProtocol.image(3, 1, 2, target = 5, depth = -2) + assertContentEquals(DrawProtocol.image(3, 1, 2, target = 5, depth = 6), DrawProtocol.withAddedDepth(targeted, 8)) + assertSame(copy, DrawProtocol.withAddedDepth(copy, 0)) + assertContentEquals(DrawProtocol.image(3, 1, 2, depth = 127), DrawProtocol.withAddedDepth(DrawProtocol.image(3, 1, 2, depth = 120), 16)) + } + /** The bottom switcher's Depth setting: the shell scene's depth moves the screen, shell layers and selections together. */ + @Test fun shellSceneDepthShiftsTheWholePresentationButNotDimming() { + val c = SurfaceCompositor() + c.configureScreen(640, 480) + c.configureSurface("app", 32, 0, 576, 480, 0, 0) + c.submitSurface("app", ArrayByteReader(ByteArray(576 * 480) { if (it % 576 in 100 until 110) 255.toByte() else 0 }), + 0, 0, 576, 480, "stripe") + // One white 2x1 shell layer at (200, 10), dimming what is under it, at layer depth -2; scene depth 8. + val header = listOf(1, 1, 200, 10, 2, 1, 128, 0, -2).flatMap { listOf(it.toByte(), (it shr 8).toByte()) }.toByteArray() + c.setShellScene(ArrayByteReader(header + byteArrayOf(-1, -1) + DrawProtocol.word(8))) + val composite = c.composite() + assertEquals(8, composite.shellScene.screenDepth) + val calls = composite.shellScene.calls(640, 480, intArrayOf(1), IntArray(0)) + assertTrue(calls.any { it.contentEquals(DrawProtocol.lut(640, 480, 128)) }) // the dim stays whole-screen + val screen = BmpUtil.pack4bppFromGray8(composite.screenGray, 640, 480) + for (right in listOf(false, true)) { + val glasses = Glasses(right) + glasses.apply(ScenePlanner(ResourceCacheState()).plan(screen, 640, 480, null, composite.shellScene, 1).commands) + val output = DisplayListRenderer.Target(glasses.composition, 640, 480) + // Screen: half of 8 per lens. Layer: depth -2 + 8, so one pixel less than the screen's shift on each lens. + val shift = if (right) -4 else 4 + val layerShift = if (right) -3 else 3 + assertEquals(0, output.get(131 + shift, 200)); assertTrue(output.get(132 + shift, 200) > 0) + assertTrue(output.get(141 + shift, 200) > 0); assertEquals(0, output.get(142 + shift, 200)) + assertEquals(15, output.get(200 + layerShift, 10)); assertEquals(15, output.get(201 + layerShift, 10)) + } + // The phone mirror shows the scene unshifted, so touches land where they look. + val preview = assertNotNull(c.previewComposite()).gray + assertEquals(0, preview[131].toInt() and 255); assertTrue((preview[132].toInt() and 255) > 0) + // A covering surface's own depth still wins over the scene's. + c.configureSurface("glance", 0, 0, 640, 480, 900, 0) + c.setSurfaceDepth("glance", -16) + assertEquals(-16, c.composite().shellScene.screenDepth) + } @Test fun noisyFramesRemainBoundedAndResourceBudgetIs192KiB() { val cache=ResourceCacheState();val planner=ScenePlanner(cache);val glasses=Glasses() val app=ByteArray(640*480/2){(it*37).toByte()} diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/FrameDisplayListTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/FrameDisplayListTest.kt index 72d29f46..3f23ecd5 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/FrameDisplayListTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/FrameDisplayListTest.kt @@ -98,7 +98,7 @@ class FrameDisplayListTest { // One opaque 1x1 shell layer, with one generic list after its pixels. val layer = DrawProtocol.word(1) + DrawProtocol.word(1) + DrawProtocol.word(0) + DrawProtocol.word(0) + DrawProtocol.word(1) + DrawProtocol.word(1) + DrawProtocol.word(256) + DrawProtocol.word(1) + - DrawProtocol.word(0) + byteArrayOf(32) + hex(multi) + DrawProtocol.word(0) + byteArrayOf(32) + hex(multi) + DrawProtocol.word(0) val shell = ShellScene.decode(ArrayByteReader(layer)) assertEquals(2, shell.retainedResources.size) assertEquals(240, shell.preview(ByteArray(64) { 32 }, 8, 8)[21].toInt() and 255) diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/PreviewPackingTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/PreviewPackingTest.kt index 7d197217..a48fd42d 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/PreviewPackingTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/PreviewPackingTest.kt @@ -43,7 +43,7 @@ class PreviewPackingTest { compositor.configureSurface("app", 0, 0, 3, 2, 0, SurfaceCompositor.TRANSPARENCY_OPAQUE) // One white 2x1 shell layer at (0,0), with no dimming or selection. val header = listOf(1, 1, 0, 0, 2, 1, 256, 0, 0).flatMap { listOf(it.toByte(), (it shr 8).toByte()) }.toByteArray() - compositor.setShellScene(ArrayByteReader(header + byteArrayOf(-16, -16))) + compositor.setShellScene(ArrayByteReader(header + byteArrayOf(-16, -16) + DrawProtocol.word(0))) val wire = compositor.applyAndComposite("app", ArrayByteReader(ByteArray(6) { 32 }), 0, 0, 3, 2, "first") assertSame(wire.screenGray, wire.gray) // ShellScene.preview allocates its own pixels. assertContentEquals(ByteArray(6) { 32 }, wire.screenGray) diff --git a/tests/menu-display-list.test.cjs b/tests/menu-display-list.test.cjs index ef29615b..afb11032 100644 --- a/tests/menu-display-list.test.cjs +++ b/tests/menu-display-list.test.cjs @@ -79,7 +79,8 @@ test('unselected sidebar icons retain -2 depth through shell cropping, including '../../native/notification-icons':{},'../../native/phone-battery':{},'../../util/render-freshness':{}, '../../graphics/icons':{},'../dashboard-settings':{},'../clock-format':{},'../../graphics/bdffont':{}, '../layers':{LayerStack},'../menu':{scrollToKeepSelectionVisible:()=>0},'../metrics':{}, - './geometry':{MIN_WINDOW_HEIGHT:280,minWindowTop:()=>0,windowTop:()=>0,SHELL_OPAQUE_BLACK:1,SIDEBAR_WIDTH:64,TOP_BAR_HEIGHT:24}, + './geometry':{MIN_WINDOW_HEIGHT:280,minWindowTop:()=>0,windowTop:()=>0,SHELL_OPAQUE_BLACK:1,SIDEBAR_WIDTH:64,TOP_BAR_HEIGHT:24, + SWITCHER_ROW_HEIGHT:36,switcherPosition:()=>'left',switcherRect:()=>({x:0,y:0,width:64,height:280})}, }); const state={selectedIndex:0,focus:'sidebar',windows:[0,1,2].map(n=>({attention:n===1,drawIcon:(image,x,y)=>image.fillRect(x,y,4,4,240)}))}; const chrome=new ShellChromeLayer(()=>state),image=new graphics.GrayImage(640,480);