mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
Add an option to move the app switcher to the right or bottom, and adjust screen depth if bottom
This commit is contained in:
1 parent
46fded856a
commit
8f99779f98
21 files changed
+827
-286
No files matched your search
@@ -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.
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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}`);
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -308,19 +308,32 @@ export const timeFormatSetting = new ConfigSettingEnum<TimeFormat>({
|
||||
* 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<DisplayModeSetting, string> = {
|
||||
"576x288": "Band · 576×288",
|
||||
"576x480": "Tall · 576×480",
|
||||
"640x480": "Full panel · 640×480",
|
||||
const DISPLAY_MODE_NAMES: Record<DisplayModeSetting, string> = {
|
||||
"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<DisplayModeSetting, string> = {
|
||||
"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<DisplayModeSetting>({
|
||||
@@ -331,7 +344,52 @@ export const displayModeSetting = new ConfigSettingEnum<DisplayModeSetting>({
|
||||
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<AppSwitcherPosition, string> = {
|
||||
left: "Left",
|
||||
right: "Right",
|
||||
bottom: "Bottom",
|
||||
};
|
||||
|
||||
export const appSwitcherPositionSetting = new ConfigSettingEnum<AppSwitcherPosition>({
|
||||
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<UiDepth>({
|
||||
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<BrightnessSetting>({
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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).
|
||||
|
||||
+286
-146
@@ -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<string, number>();
|
||||
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);
|
||||
}
|
||||
+146
-27
@@ -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),
|
||||
};
|
||||
|
||||
+68
-37
@@ -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<Record<DirectionalInputEvent["type"], "scroll-up" | "scroll-down" | "click">>
|
||||
> = {
|
||||
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);
|
||||
|
||||
@@ -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;
|
||||
|
||||
|
||||
+21
@@ -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)
|
||||
|
||||
|
||||
@@ -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<Layer>, val selections: List<RetainedDrawing> = 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<RetainedDrawing> = 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<Layer>, val selections: List<RetainedDrawing>
|
||||
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<ByteArray> {
|
||||
val calls = ArrayList<ByteArray>(); 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<Int, ByteArray>()
|
||||
@@ -89,10 +103,11 @@ class ShellScene(val layers: List<Layer>, val selections: List<RetainedDrawing>
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
+12
-4
@@ -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<Surface>): 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
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -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,
|
||||
|
||||
+63
-11
@@ -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);
|
||||
|
||||
@@ -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()}
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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);
|
||||
|
||||
Reference in new issue
Block a user