mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
Multi-row status/app-switcher bar layouts
This commit is contained in:
1 parent
f6201d8e41
commit
26e4396972
14 files changed
+706
-229
No files matched your search
@@ -290,8 +290,17 @@ global.onmessage = (event: { data: WorkerAppMessage }) => {
|
||||
updateTickTimer(window);
|
||||
}
|
||||
break;
|
||||
case "resize-window": {
|
||||
const window = windows.get(message.windowId);
|
||||
if (!window) break;
|
||||
window.viewportWidth = message.viewport.width;
|
||||
window.viewportHeight = message.viewport.height;
|
||||
window.menu?.resize({ width: window.viewportWidth, height: window.viewportHeight });
|
||||
window.lastSubmittedFingerprint = "";
|
||||
if (window.foreground) renderAndSubmit(window, 0);
|
||||
break;
|
||||
}
|
||||
case "navigation-sensors":
|
||||
case "resize-window":
|
||||
case "text-input":
|
||||
case "tool-call":
|
||||
break;
|
||||
|
||||
@@ -205,9 +205,18 @@ global.onmessage = (event: { data: WorkerAppMessage }) => {
|
||||
if (window.foreground) renderAndSubmit(window, 0);
|
||||
break;
|
||||
}
|
||||
case "resize-window": {
|
||||
const window = windows.get(message.windowId);
|
||||
if (!window) break;
|
||||
window.viewportWidth = message.viewport.width;
|
||||
window.viewportHeight = message.viewport.height;
|
||||
window.menu?.resize({ width: window.viewportWidth, height: window.viewportHeight });
|
||||
window.lastSubmittedFingerprint = "";
|
||||
if (window.foreground) renderAndSubmit(window, 0);
|
||||
break;
|
||||
}
|
||||
case "input-focus":
|
||||
case "navigation-sensors":
|
||||
case "resize-window":
|
||||
case "screen":
|
||||
case "text-input":
|
||||
case "tool-call":
|
||||
|
||||
@@ -250,8 +250,17 @@ global.onmessage = (event: { data: WorkerAppMessage }) => {
|
||||
syncClock(window);
|
||||
}
|
||||
break;
|
||||
case "resize-window": {
|
||||
const window = windows.get(message.windowId);
|
||||
if (!window) break;
|
||||
window.viewportWidth = message.viewport.width;
|
||||
window.viewportHeight = message.viewport.height;
|
||||
window.menu?.resize({ width: window.viewportWidth, height: window.viewportHeight });
|
||||
window.lastSubmittedFingerprint = "";
|
||||
if (window.foreground) renderAndSubmit(window, 0);
|
||||
break;
|
||||
}
|
||||
case "navigation-sensors":
|
||||
case "resize-window":
|
||||
case "text-input":
|
||||
case "tool-call":
|
||||
break;
|
||||
|
||||
@@ -411,8 +411,17 @@ global.onmessage = (event: { data: WorkerAppMessage }) => {
|
||||
syncTickTimer(window);
|
||||
}
|
||||
break;
|
||||
case "resize-window": {
|
||||
const window = windows.get(message.windowId);
|
||||
if (!window) break;
|
||||
window.viewportWidth = message.viewport.width;
|
||||
window.viewportHeight = message.viewport.height;
|
||||
window.menu?.resize({ width: window.viewportWidth, height: window.viewportHeight });
|
||||
window.lastSubmittedFingerprint = "";
|
||||
if (window.foreground) renderAndSubmit(window, 0);
|
||||
break;
|
||||
}
|
||||
case "navigation-sensors":
|
||||
case "resize-window":
|
||||
case "text-input":
|
||||
case "tool-call":
|
||||
break;
|
||||
|
||||
@@ -251,9 +251,17 @@ global.onmessage = (event: { data: WorkerAppMessage }) => {
|
||||
);
|
||||
break;
|
||||
}
|
||||
case "resize-window":
|
||||
if (!window || window.windowId !== message.windowId) break;
|
||||
window.viewportWidth = message.viewport.width;
|
||||
window.viewportHeight = message.viewport.height;
|
||||
window.view.resize(message.viewport.width - DOC_MARGIN * 2, message.viewport.height - HEADER_HEIGHT - BOTTOM_MARGIN);
|
||||
window.menu?.resize(message.viewport);
|
||||
window.lastSubmittedFingerprint = "";
|
||||
render();
|
||||
break;
|
||||
case "input-focus":
|
||||
case "navigation-sensors":
|
||||
case "resize-window":
|
||||
break;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -423,6 +423,7 @@ class DashboardController {
|
||||
},
|
||||
openNotificationsWindow: () =>
|
||||
this.openInProcessAppInBackground(NOTIFICATIONS_WINDOW_ID, NOTIFICATIONS_SURFACE_ID, createNotificationsAppWindow),
|
||||
onSwitcherBarHeightChanged: () => this.applySwitcherBarHeight(),
|
||||
onScreenStateChanged: (on) => {
|
||||
// Any wake of the regular UI replaces a showing Glanceboard.
|
||||
if (on) this.glance.dismiss();
|
||||
@@ -584,6 +585,29 @@ class DashboardController {
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* The bottom switcher's layout changed its height (shell.ts
|
||||
* onSwitcherBarHeightChanged): window bands move where the slack under
|
||||
* them runs out, and full-height windows resize; the rest stay as they
|
||||
* are. Windows that can't resize keep the surface they have, the switcher
|
||||
* covering any of it that it now overlaps, rather than being relaunched
|
||||
* for it.
|
||||
*/
|
||||
private applySwitcherBarHeight(): void {
|
||||
void (async () => {
|
||||
for (const window of Array.from(shell.getWindows())) {
|
||||
const rect = JSON.stringify(appViewportRect(window.heightMode, window.appId));
|
||||
if (!window.relayout || this.windowSurfaceRects.get(window.surfaceId) === rect) continue;
|
||||
window.relayout();
|
||||
await this.configureWindowSurface(window.surfaceId, this.isForegroundWindow(window.windowId), window.heightMode);
|
||||
}
|
||||
shell.foregroundWindow()?.requestRender();
|
||||
this.requestShellRender();
|
||||
})().catch((error) => {
|
||||
this.appendLog(`switcher height change failed: ${this.formatError(error)}`);
|
||||
});
|
||||
}
|
||||
|
||||
private lastAppLayouts = this.appLayouts();
|
||||
|
||||
private appLayouts(): Record<string, string> {
|
||||
@@ -2565,20 +2589,22 @@ class DashboardController {
|
||||
target: DisplayTarget | null = this.display,
|
||||
): Promise<void> {
|
||||
if (!target) return;
|
||||
await target.configureSurface(surfaceId, {
|
||||
...appViewportRect(heightMode, shell.getWindows().find((window) => window.surfaceId === surfaceId)?.appId),
|
||||
zOrder: 0,
|
||||
transparency: "opaque",
|
||||
});
|
||||
const rect = appViewportRect(heightMode, shell.getWindows().find((window) => window.surfaceId === surfaceId)?.appId);
|
||||
this.windowSurfaceRects.set(surfaceId, JSON.stringify(rect));
|
||||
await target.configureSurface(surfaceId, { ...rect, zOrder: 0, transparency: "opaque" });
|
||||
await target.setSurfaceVisible(surfaceId, typeof visible === "function" ? visible() : visible);
|
||||
}
|
||||
|
||||
/** Each window surface's rect as last configured (applySwitcherBarHeight skips those that stay). */
|
||||
private readonly windowSurfaceRects = new Map<string, string>();
|
||||
|
||||
/** A late answer to "is this window in front?", for configureWindowSurface. */
|
||||
private isForegroundWindow(windowId: string): () => boolean {
|
||||
return () => shell.foregroundWindow()?.windowId === windowId;
|
||||
}
|
||||
|
||||
private removeWindowSurface(surfaceId: string): void {
|
||||
this.windowSurfaceRects.delete(surfaceId);
|
||||
const display = this.display;
|
||||
if (!display) return;
|
||||
void display.removeSurface(surfaceId).catch((error) => {
|
||||
|
||||
@@ -181,6 +181,11 @@ export class IosPreviewController {
|
||||
getScreenTimeoutMs: () => null,
|
||||
requestShellRender: () => this.requestShellRender(),
|
||||
onWindowsChanged: () => { this.requestShellRender(); this.syncEvenHubPhoneUi() },
|
||||
onSwitcherBarHeightChanged: () => {
|
||||
this.relayout()
|
||||
shell.foregroundWindow()?.requestRender()
|
||||
this.requestShellRender()
|
||||
},
|
||||
onScreenStateChanged: on => {
|
||||
if (on) this.glance.dismiss()
|
||||
void this.display?.setScreenBlanked(!on).catch(error => this.fail(error))
|
||||
|
||||
@@ -58,19 +58,21 @@ export function readActiveNotificationIcons(maxIcons: number, allowStale: boolea
|
||||
const now = Date.now();
|
||||
if (cachedAtMs > 0 && now - cachedAtMs < ICON_CACHE_MS) {
|
||||
logCurrent("notification icons served from cache");
|
||||
return { icons: cachedIcons.map(icon => icon.clone()), keys: cachedKeys.slice(), stale: false };
|
||||
return cachedIconsResult(maxIcons, false);
|
||||
}
|
||||
if (allowStale) {
|
||||
logCurrent("notification icons served stale");
|
||||
return { icons: cachedIcons.map(icon => icon.clone()), keys: cachedKeys.slice(), stale: true };
|
||||
return cachedIconsResult(maxIcons, true);
|
||||
}
|
||||
|
||||
// Every icon, whatever this caller wants: the cache serves callers asking
|
||||
// for different counts (the switcher row needs them all to lay itself out).
|
||||
const keyList = new java.util.ArrayList();
|
||||
const bytes = spanCurrent("fetch-notification-icons", () =>
|
||||
toUint8Array(
|
||||
com.faceclaw.app.FaceclawMediaNotificationListenerService.getActiveNotificationIconGrays(
|
||||
ICON_SIZE,
|
||||
maxIcons,
|
||||
ALL_NOTIFICATIONS,
|
||||
keyList,
|
||||
),
|
||||
),
|
||||
@@ -91,7 +93,12 @@ export function readActiveNotificationIcons(maxIcons: number, allowStale: boolea
|
||||
cachedIcons = icons;
|
||||
cachedKeys = keys;
|
||||
cachedAtMs = now;
|
||||
return { icons: icons.map(icon => icon.clone()), keys: keys.slice(), stale: false };
|
||||
return cachedIconsResult(maxIcons, false);
|
||||
}
|
||||
|
||||
/** Copies of the first maxIcons cached icons, with their keys. */
|
||||
function cachedIconsResult(maxIcons: number, stale: boolean): NotificationIconsResult {
|
||||
return { icons: cachedIcons.slice(0, maxIcons).map(icon => icon.clone()), keys: cachedKeys.slice(0, maxIcons), stale };
|
||||
}
|
||||
|
||||
export type NotificationIconResult = {
|
||||
|
||||
@@ -49,10 +49,18 @@ export class DocumentView {
|
||||
private scrollLine = 0;
|
||||
|
||||
constructor(
|
||||
private readonly width: number,
|
||||
private readonly height: number,
|
||||
private width: number,
|
||||
private height: number,
|
||||
) {}
|
||||
|
||||
/** Re-wrap the document for a region of a new size, keeping the selection in view. */
|
||||
resize(width: number, height: number): void {
|
||||
if (width === this.width && height === this.height) return;
|
||||
this.width = width;
|
||||
this.height = height;
|
||||
if (this.root) this.setDocument(this.root);
|
||||
}
|
||||
|
||||
setDocument(root: DocumentRoot): void {
|
||||
const previousId = this.selectedNode()?.id;
|
||||
this.root = root;
|
||||
|
||||
+353
-157
@@ -6,7 +6,7 @@ import { getDefaultMediumFont, getDefaultSmallFont } from "../../graphics/ui-fon
|
||||
import { truncateText } from "../../graphics/textwrap";
|
||||
import { activeAmbientCards } from "./ambient-cards";
|
||||
import { BATTERY_ICON_WIDTH, DENSE_BATTERY_BLOCK_HEIGHT, drawBattery, drawDenseBatteries, type BatteryDevice } from "../../graphics/battery";
|
||||
import { readActiveNotificationIcons } from "../../native/notification-icons";
|
||||
import { ALL_NOTIFICATIONS, readActiveNotificationIcons } from "../../native/notification-icons";
|
||||
import { readPhoneBatteryState } from "../../native/phone-battery";
|
||||
import { noteStaleDataUsed, renderPassAllowsStaleData } from "../../util/render-freshness";
|
||||
import { renderIcon, renderIconWithGlyph, type IconActivity, type IconName } from "../../graphics/icons";
|
||||
@@ -30,6 +30,7 @@ import {
|
||||
isImmersive,
|
||||
MIN_WINDOW_HEIGHT,
|
||||
minWindowTop,
|
||||
setSwitcherBarHeight,
|
||||
SHELL_OPAQUE_BLACK,
|
||||
SIDEBAR_WIDTH,
|
||||
sidebarStripVisible,
|
||||
@@ -56,7 +57,8 @@ import {
|
||||
* 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.
|
||||
* always uses the roomy slots, laid out left to right, and when they don't
|
||||
* fit beside the status bar, in a second row (see planBottomBar).
|
||||
*/
|
||||
type SidebarVariant = { columns: number; columnWidth: number; iconSize: number };
|
||||
const ONE_COLUMN: SidebarVariant = { columns: 1, columnWidth: 36, iconSize: 32 };
|
||||
@@ -74,16 +76,25 @@ const ROW_STEP = ROW_ICON_SIZE + ICON_SPACING;
|
||||
// The status bar in the switcher row (geometry.ts statusInSwitcherRow) keeps
|
||||
// the top bar's layout, so every element sits as it does there: its 28 rows
|
||||
// (whose last is the divider, which the row has no use for) centred in the
|
||||
// row below its separator line.
|
||||
// row below its separator line. A second row of status items sits a top
|
||||
// bar's height under the first, or, beside two rows of windows, a row's
|
||||
// height under it, level with the second row of windows.
|
||||
const ROW_STATUS_TOP = 1 + ((SWITCHER_ROW_HEIGHT - TOP_BAR_HEIGHT) >> 1);
|
||||
// Its clock ends flush with the row's right end, which is the window's
|
||||
// right edge; batteries keep the top bar's clock-to-icons gap from it.
|
||||
// right edge; batteries keep the top bar's clock-to-icons gap from it, as
|
||||
// does whatever else comes right before the clock.
|
||||
const ROW_CLOCK_GAP = 16;
|
||||
// Between the windows' end of the row (its scroll chevron) and the status.
|
||||
const ROW_STATUS_GAP = 8;
|
||||
// Notification icons stop short of room for this many windows' slots (or
|
||||
// all of them, when there are fewer); the windows take whatever is left.
|
||||
// When the windows have to scroll anyway (planBottomBar's last layout),
|
||||
// notification icons stop short of room for this many windows' slots in a
|
||||
// row (or all of them, when there are fewer); the windows take whatever is
|
||||
// left.
|
||||
const ROW_MIN_WINDOW_SLOTS = 3;
|
||||
// After an app widget (tray icon), and between the last notification icon
|
||||
// and what follows it, as in the top bar.
|
||||
const TRAY_ICON_GAP = 10;
|
||||
const NOTIFICATIONS_GAP = 8;
|
||||
|
||||
// The popup switcher (geometry.ts "popup"): a box centred over the
|
||||
// foreground window's content, holding a row of window icons above the
|
||||
@@ -155,29 +166,34 @@ type SwitcherLayout = {
|
||||
|
||||
/**
|
||||
* Switcher geometry for the foreground window (a bottom row sits under it).
|
||||
* `windowsRight` is where a bottom row's window icons must end: short of
|
||||
* the status bar when it shares the row. `scrollRow` is the first visible
|
||||
* window's index.
|
||||
* A bottom switcher's window icons take `bar`'s slots (planBottomBar), the
|
||||
* row against the window first, then the one under it. `scrollRow` is the
|
||||
* first visible window's index.
|
||||
*/
|
||||
function switcherLayout(windowCount: number, heightMode: WindowHeightMode, appId?: string, windowsRight?: number, scrollRow = 0): SwitcherLayout {
|
||||
function switcherLayout(windowCount: number, heightMode: WindowHeightMode, appId: string | undefined, bar: BottomBarPlan | null, scrollRow = 0): SwitcherLayout {
|
||||
const position = switcherPosition();
|
||||
if (position === "bottom") {
|
||||
const row = switcherRect(heightMode, appId);
|
||||
const width = (windowsRight ?? row.x + row.width) - row.x;
|
||||
const { windowColumns, windowRows } = bar ?? planBottomBar(row.width, windowCount, []);
|
||||
const columns = Math.max(1, windowColumns);
|
||||
// Under a framed window the first window's cell (the launcher's) starts
|
||||
// at the frame's left side, one pixel outside the window, so a selection
|
||||
// tab there carries the side straight down (drawWindowFrame squares that
|
||||
// corner for it). Scrolled past it, the cells keep the margin the left
|
||||
// chevron needs. The count of slots stays the same either way.
|
||||
// chevron needs. The count of slots stays the same either way. Only the
|
||||
// first row's cells touch the separator; a second row's lines up under it.
|
||||
const first = windowFramed(appId) && scrollRow === 0 ? row.x - 1 : row.x + LIST_MARGIN - 2;
|
||||
return {
|
||||
position,
|
||||
iconSize: ROW_ICON_SIZE,
|
||||
visibleCount: Math.max(1, ((width - 2 * LIST_MARGIN + ICON_SPACING) / ROW_STEP) | 0),
|
||||
cell: (slot) => ({
|
||||
x: first + slot * ROW_STEP, y: row.y, width: ROW_ICON_SIZE + 4, height: SWITCHER_ROW_HEIGHT,
|
||||
atSeparator: true,
|
||||
}),
|
||||
visibleCount: columns * windowRows,
|
||||
cell: (slot) => {
|
||||
const line = (slot / columns) | 0;
|
||||
return {
|
||||
x: first + (slot % columns) * ROW_STEP, y: row.y + line * SWITCHER_ROW_HEIGHT,
|
||||
width: ROW_ICON_SIZE + 4, height: SWITCHER_ROW_HEIGHT, atSeparator: line === 0,
|
||||
};
|
||||
},
|
||||
};
|
||||
}
|
||||
// Slots fill the column against the separator top to bottom, then
|
||||
@@ -202,6 +218,126 @@ function switcherLayout(windowCount: number, heightMode: WindowHeightMode, appId
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* One of the status bar's items as the bottom switcher lays it out (see
|
||||
* planBottomBar): left to right, the notification icons, app widgets (tray
|
||||
* icons), the battery block and the clock.
|
||||
*/
|
||||
type RowStatusSize = { kind: "notification" | "tray" | "batteries" | "clock"; width: number };
|
||||
|
||||
/** A status item ready to draw with its left edge at x, in the top bar's layout from `top`. */
|
||||
type RowStatusItem = RowStatusSize & { draw: (image: GrayImage, x: number, top: number) => void };
|
||||
|
||||
/**
|
||||
* A layout of the bottom switcher (planBottomBar): its window icons in
|
||||
* `windowRows` rows of `windowColumns` slots, scrolling when there are more
|
||||
* windows than that; the status bar's items in `statusRows` (top first),
|
||||
* each right-aligned against the switcher's end, `statusPitch` apart; and
|
||||
* the height it all takes.
|
||||
*/
|
||||
export type BottomBarPlan<T extends RowStatusSize = RowStatusSize> = {
|
||||
/** Which of planBottomBar's layouts this is, 1 (the roomiest) to 4. */
|
||||
level: number;
|
||||
height: number;
|
||||
windowRows: number;
|
||||
windowColumns: number;
|
||||
statusRows: T[][];
|
||||
/** Width of the widest status row; the windows take what it leaves. */
|
||||
statusWidth: number;
|
||||
statusPitch: number;
|
||||
};
|
||||
|
||||
/**
|
||||
* Lay out the bottom switcher, `width` wide, for `windowCount` windows and
|
||||
* the status bar's items (none unless it shares the switcher; notification
|
||||
* icons first), trying denser layouts in turn until one fits:
|
||||
*
|
||||
* 1. One row: the windows, then the status bar's items.
|
||||
* 2. The status bar's items in two rows, broken where the two come nearest
|
||||
* the same width, beside the one row of windows. The extra height comes
|
||||
* out of the slack under a window band, or a full-height window's height
|
||||
* (geometry.ts windowTop).
|
||||
* 3. The windows in two rows too.
|
||||
* 4. As 3, but with only as many windows showing as fit, scrolling to the
|
||||
* rest, and notification icons dropped from the end as need be to leave
|
||||
* the windows room for a few slots a row.
|
||||
*
|
||||
* A layout fails when its windows don't all fit beside its status rows; the
|
||||
* last can't fail.
|
||||
*/
|
||||
export function planBottomBar<T extends RowStatusSize>(width: number, windowCount: number, status: T[]): BottomBarPlan<T> {
|
||||
const plan = (level: number, windowRows: number, statusRows: T[][]): BottomBarPlan<T> => {
|
||||
const statusWidth = Math.max(0, ...statusRows.map(statusRowWidth));
|
||||
return {
|
||||
level,
|
||||
height: windowRows > 1 ? windowRows * SWITCHER_ROW_HEIGHT
|
||||
: SWITCHER_ROW_HEIGHT + Math.max(0, statusRows.length - 1) * TOP_BAR_HEIGHT,
|
||||
windowRows,
|
||||
windowColumns: rowWindowColumns(width - (statusWidth > 0 ? statusWidth + ROW_STATUS_GAP : 0)),
|
||||
statusRows,
|
||||
statusWidth,
|
||||
statusPitch: windowRows > 1 ? SWITCHER_ROW_HEIGHT : TOP_BAR_HEIGHT,
|
||||
};
|
||||
};
|
||||
const twoRows = splitStatusRows(status);
|
||||
for (const candidate of [plan(1, 1, status.length ? [status] : []), plan(2, 1, twoRows), plan(3, 2, twoRows)]) {
|
||||
if (candidate.windowColumns * candidate.windowRows >= windowCount && candidate.statusWidth <= width) return candidate;
|
||||
}
|
||||
const notifications = status.filter((item) => item.kind === "notification").length;
|
||||
const room = width - ROW_STATUS_GAP - rowWindowsWidth(Math.min(Math.ceil(windowCount / 2), ROW_MIN_WINDOW_SLOTS));
|
||||
let last = plan(4, 2, twoRows);
|
||||
for (let kept = notifications - 1; kept >= 0 && last.statusWidth > room; kept--) {
|
||||
last = plan(4, 2, splitStatusRows([...status.slice(0, kept), ...status.slice(notifications)]));
|
||||
}
|
||||
return { ...last, windowColumns: Math.max(1, last.windowColumns) };
|
||||
}
|
||||
|
||||
/** Width `columns` window slots take in the bottom switcher, with its end margins. */
|
||||
function rowWindowsWidth(columns: number): number {
|
||||
return columns > 0 ? 2 * LIST_MARGIN + columns * ROW_STEP - ICON_SPACING : 0;
|
||||
}
|
||||
|
||||
/** How many window slots fit across `width` of the bottom switcher. */
|
||||
function rowWindowColumns(width: number): number {
|
||||
return Math.max(0, ((width - 2 * LIST_MARGIN + ICON_SPACING) / ROW_STEP) | 0);
|
||||
}
|
||||
|
||||
/** Space between two neighbouring status items, as the top bar spaces them. */
|
||||
function statusGap(left: RowStatusSize, right: RowStatusSize): number {
|
||||
if (right.kind === "clock" || left.kind === "batteries") return ROW_CLOCK_GAP;
|
||||
if (left.kind === "tray") return TRAY_ICON_GAP;
|
||||
return right.kind === "notification" ? NOTIFICATION_ICON_STEP - NOTIFICATION_ICON_SIZE : NOTIFICATIONS_GAP;
|
||||
}
|
||||
|
||||
/** Width of a row of status items, from the first's left edge to the last's right. */
|
||||
function statusRowWidth(items: readonly RowStatusSize[]): number {
|
||||
let width = 0;
|
||||
for (let index = 0; index < items.length; index++) {
|
||||
width += items[index]!.width + (index > 0 ? statusGap(items[index - 1]!, items[index]!) : 0);
|
||||
}
|
||||
return width;
|
||||
}
|
||||
|
||||
/**
|
||||
* Status items in two rows (one when there are fewer than two), broken
|
||||
* where the wider row is narrowest, so the two come out about as wide.
|
||||
*/
|
||||
function splitStatusRows<T extends RowStatusSize>(items: T[]): T[][] {
|
||||
if (items.length < 2) return items.length ? [items] : [];
|
||||
const total = statusRowWidth(items);
|
||||
let best = 1, bestWidth = Infinity, before = 0;
|
||||
for (let index = 1; index < items.length; index++) {
|
||||
// Items before `index` take the first row; the gap at the break goes.
|
||||
before += items[index - 1]!.width + (index > 1 ? statusGap(items[index - 2]!, items[index - 1]!) : 0);
|
||||
const widest = Math.max(before, total - before - statusGap(items[index - 1]!, items[index]!));
|
||||
if (widest < bestWidth) {
|
||||
best = index;
|
||||
bestWidth = widest;
|
||||
}
|
||||
}
|
||||
return [items.slice(0, best), items.slice(best)];
|
||||
}
|
||||
|
||||
/**
|
||||
* Popup switcher geometry for the foreground window: its box, centred over
|
||||
* the window's content (geometry.ts switcherRect), as wide as the icons
|
||||
@@ -296,6 +432,8 @@ function statusBarPlacement(state: ShellChromeState): StatusBarPlacement | null
|
||||
|
||||
const NOTIFICATION_ICON_SIZE = 24;
|
||||
const NOTIFICATION_ICON_STEP = NOTIFICATION_ICON_SIZE + 4;
|
||||
// Notification icons' top, in the top bar's layout.
|
||||
const NOTIFICATION_ICON_TOP = ((TOP_BAR_HEIGHT - NOTIFICATION_ICON_SIZE) / 2) | 0;
|
||||
// The box round a selected notification icon: clear of it by 2px either
|
||||
// side, and by 1px above and below, all a top bar leaves above its divider.
|
||||
const NOTIFICATION_BOX_MARGIN_X = 2;
|
||||
@@ -416,8 +554,8 @@ export class ShellChromeLayer implements Layer {
|
||||
private scrollRow = 0;
|
||||
// The popup switcher's shell surface.
|
||||
private popupKey: number | undefined;
|
||||
// Where the last paint ended a bottom row's window icons, for hit testing.
|
||||
private rowWindowsRight: number | undefined;
|
||||
// The bottom switcher's layout as the last paint planned it, for hit testing.
|
||||
private bottomBar: BottomBarPlan<RowStatusItem> | null = null;
|
||||
// Whether the last paint's selection tab carries the window frame's left
|
||||
// side down, so the frame's bottom-left corner is square.
|
||||
private frameCornerSquare = false;
|
||||
@@ -425,12 +563,21 @@ export class ShellChromeLayer implements Layer {
|
||||
// switcher's selection can move onto, and mirror touches hit.
|
||||
private notificationEntries: NotificationEntry[] = [];
|
||||
|
||||
constructor(private readonly getState: () => ShellChromeState) {}
|
||||
/**
|
||||
* `onBottomBarHeightChanged` is called, during a paint, when the bottom
|
||||
* switcher's layout changes its height so that windows have to move or
|
||||
* resize (see layoutBottomBar).
|
||||
*/
|
||||
constructor(
|
||||
private readonly getState: () => ShellChromeState,
|
||||
private readonly onBottomBarHeightChanged: () => void = () => {},
|
||||
) {}
|
||||
|
||||
paint(): GrayImage {
|
||||
const image = new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0);
|
||||
const state = this.getState();
|
||||
this.notificationEntries = [];
|
||||
this.bottomBar = this.layoutBottomBar(state);
|
||||
const statusInRow = statusInSwitcherRow(state.foregroundAppId);
|
||||
const popup = switcherPosition() === "popup";
|
||||
// Over an immersive window the strip is an overlay, present only while
|
||||
@@ -452,6 +599,7 @@ export class ShellChromeLayer implements Layer {
|
||||
paintParts(): Plane[] {
|
||||
const state = this.getState(), parts: Plane[] = [];
|
||||
this.notificationEntries = [];
|
||||
this.bottomBar = this.layoutBottomBar(state);
|
||||
const statusInRow = statusInSwitcherRow(state.foregroundAppId);
|
||||
const canvas = new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0);
|
||||
const span = topBarSpan(state);
|
||||
@@ -534,7 +682,7 @@ export class ShellChromeLayer implements Layer {
|
||||
if (windowCount === 0) return null;
|
||||
const state = this.getState();
|
||||
const layout = switcherPosition() === "popup" ? popupLayout(windowCount, state)
|
||||
: switcherLayout(windowCount, state.foregroundHeightMode, state.foregroundAppId, this.rowWindowsRight, this.scrollRow);
|
||||
: switcherLayout(windowCount, state.foregroundHeightMode, state.foregroundAppId, this.bottomBar, this.scrollRow);
|
||||
const lastVisible = Math.min(windowCount, this.scrollRow + layout.visibleCount);
|
||||
for (let index = this.scrollRow; index < lastVisible; index++) {
|
||||
const cell = layout.cell(index - this.scrollRow);
|
||||
@@ -557,10 +705,11 @@ export class ShellChromeLayer implements Layer {
|
||||
}
|
||||
|
||||
/**
|
||||
* Draw the switcher strip or row. Given `statusImage`, a bottom row shares
|
||||
* its right end with the status bar, drawn there (into that image, which
|
||||
* may be this one) first, and the window icons take what it leaves.
|
||||
* Returns the status bar's left edge, or null without one.
|
||||
* Draw the switcher strip or row. Given `statusImage`, a bottom switcher
|
||||
* shares its right end with the status bar, drawn there (into that image,
|
||||
* which may be this one) first, and the window icons take what it leaves
|
||||
* (see planBottomBar). Returns the status bar's left edge, or null without
|
||||
* one.
|
||||
*/
|
||||
private drawSidebar(image: GrayImage, state: ShellChromeState, statusImage?: GrayImage): number | null {
|
||||
// A side strip aligns with the app's preferred band (legacy tall
|
||||
@@ -573,18 +722,17 @@ export class ShellChromeLayer implements Layer {
|
||||
// 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.
|
||||
// window; a bottom switcher's two rows likewise fill the top one first.
|
||||
const count = state.windows.length;
|
||||
const statusLeft = statusImage && switcherPosition() === "bottom"
|
||||
? this.drawRowStatus(statusImage, state, strip, count) : null;
|
||||
const bar = this.bottomBar;
|
||||
const statusLeft = statusImage && bar?.statusRows.length ? this.drawRowStatus(statusImage, strip, bar) : null;
|
||||
const windowsRight = statusLeft === null ? strip.x + strip.width : statusLeft - ROW_STATUS_GAP;
|
||||
this.rowWindowsRight = windowsRight;
|
||||
const visibleCount = switcherLayout(count, state.foregroundHeightMode, state.foregroundAppId, windowsRight).visibleCount;
|
||||
const visibleCount = switcherLayout(count, state.foregroundHeightMode, state.foregroundAppId, bar).visibleCount;
|
||||
// With the selection out on a notification, the windows stay scrolled as they were.
|
||||
this.scrollRow = state.selectedIndex >= 0
|
||||
? scrollToKeepSelectionVisible(this.scrollRow, state.selectedIndex, visibleCount, count)
|
||||
: Math.min(this.scrollRow, Math.max(0, count - visibleCount));
|
||||
const layout = switcherLayout(count, state.foregroundHeightMode, state.foregroundAppId, windowsRight, this.scrollRow);
|
||||
const layout = switcherLayout(count, state.foregroundHeightMode, state.foregroundAppId, bar, this.scrollRow);
|
||||
const { iconSize, position } = layout;
|
||||
const lastVisible = Math.min(count, this.scrollRow + layout.visibleCount);
|
||||
const cellOf = (index: number) => layout.cell(index - this.scrollRow);
|
||||
@@ -600,7 +748,7 @@ export class ShellChromeLayer implements Layer {
|
||||
const selCell = selVisible ? cellOf(state.selectedIndex) : null;
|
||||
drawSeparator(image, state, strip, selCell?.atSeparator ? selCell : null);
|
||||
const frame = position === "bottom" ? windowFrameRect(state) : null;
|
||||
this.frameCornerSquare = !!frame && selCell?.x === frame.x;
|
||||
this.frameCornerSquare = !!frame && !!selCell?.atSeparator && selCell.x === frame.x;
|
||||
|
||||
for (let index = this.scrollRow; index < lastVisible; index++) {
|
||||
const window = state.windows[index]!;
|
||||
@@ -630,13 +778,14 @@ export class ShellChromeLayer implements Layer {
|
||||
}
|
||||
|
||||
if (position === "bottom") {
|
||||
// Chevrons sit in the margins at either end of the icons, pointing off them.
|
||||
const chevronY = strip.y + ((strip.height / 2) | 0);
|
||||
// Chevrons sit in the margins at either end of the icons, pointing off
|
||||
// them: before the first row's, and after the last row's.
|
||||
const rowMiddle = (line: number) => strip.y + line * SWITCHER_ROW_HEIGHT + (SWITCHER_ROW_HEIGHT >> 1);
|
||||
if (this.scrollRow > 0) {
|
||||
drawChevron(image, strip.x + 6, chevronY, "left");
|
||||
drawChevron(image, strip.x + 6, rowMiddle(0), "left");
|
||||
}
|
||||
if (lastVisible < count) {
|
||||
drawChevron(image, windowsRight - 6, chevronY, "right");
|
||||
drawChevron(image, windowsRight - 6, rowMiddle((bar?.windowRows ?? 1) - 1), "right");
|
||||
}
|
||||
return statusLeft;
|
||||
}
|
||||
@@ -654,39 +803,75 @@ export class ShellChromeLayer implements Layer {
|
||||
}
|
||||
|
||||
/**
|
||||
* The status bar at the right end of the switcher row, right to left:
|
||||
* date and time, batteries, app widgets, then notification icons, each as
|
||||
* it sits in the top bar (see ROW_STATUS_TOP). Notification icons stop
|
||||
* short of room for a few window slots; the windows get the rest, and
|
||||
* whatever they leave over is free space between the two. Returns the
|
||||
* left edge of what it drew.
|
||||
* Lay out the bottom switcher for this paint (planBottomBar) under the
|
||||
* foreground window, with the status bar's items when it shares the
|
||||
* switcher, and record its height in geometry.ts, telling the shell when
|
||||
* that moves or resizes windows. Null for the other switcher positions.
|
||||
*/
|
||||
private drawRowStatus(image: GrayImage, state: ShellChromeState, row: Rect, windowCount: number): number {
|
||||
image.fillRect(row.x, row.y + 1, row.width, row.height - 1, SHELL_OPAQUE_BLACK);
|
||||
const top = row.y + ROW_STATUS_TOP;
|
||||
const font = getDefaultMediumFont();
|
||||
const clock = clockText();
|
||||
// A TTF face measures fractionally; the status surface's crop edges need whole pixels.
|
||||
const clockX = row.x + row.width - Math.ceil(font.measureText(clock));
|
||||
image.drawText(font, clockX, top + Math.max(0, ((TOP_BAR_HEIGHT - font.lineHeight) / 2) | 0), clock, 210);
|
||||
// The battery block keeps its usual right margin inside the edge it's given.
|
||||
const batteryLeft = this.drawTopBarBatteries(image, state, top, clockX - ROW_CLOCK_GAP + BATTERY_BLOCK_RIGHT_MARGIN);
|
||||
const trayLeft = drawTrayIcons(image, state.trayIcons, batteryLeft, top);
|
||||
private layoutBottomBar(state: ShellChromeState): BottomBarPlan<RowStatusItem> | null {
|
||||
if (switcherPosition() !== "bottom") return null;
|
||||
const appId = state.foregroundAppId;
|
||||
const status = statusInSwitcherRow(appId) ? this.rowStatusItems(state) : [];
|
||||
const plan = planBottomBar(switcherRect(state.foregroundHeightMode, appId).width, state.windows.length, status);
|
||||
if (setSwitcherBarHeight(plan.height, appId)) this.onBottomBarHeightChanged();
|
||||
return plan;
|
||||
}
|
||||
|
||||
// Right-aligned against the widgets, with the top bar's spacing.
|
||||
const slots = Math.min(windowCount, ROW_MIN_WINDOW_SLOTS);
|
||||
const windowsFloor = row.x + 2 * LIST_MARGIN + Math.max(0, slots * ROW_STEP - ICON_SPACING) + ROW_STATUS_GAP;
|
||||
const iconsRight = trayLeft - 8, step = NOTIFICATION_ICON_STEP;
|
||||
const maxIcons = Math.max(0, ((iconsRight - windowsFloor + 4) / step) | 0);
|
||||
if (maxIcons === 0) return trayLeft;
|
||||
const { icons, keys, stale } = readActiveNotificationIcons(maxIcons, renderPassAllowsStaleData());
|
||||
/**
|
||||
* The status bar's items for the bottom switcher, left to right: every
|
||||
* notification icon, the app widgets, the battery block, and the date and
|
||||
* time, each to draw as it sits in the top bar.
|
||||
*/
|
||||
private rowStatusItems(state: ShellChromeState): RowStatusItem[] {
|
||||
const items: RowStatusItem[] = [];
|
||||
const { icons, keys, stale } = readActiveNotificationIcons(ALL_NOTIFICATIONS, renderPassAllowsStaleData());
|
||||
if (stale) {
|
||||
noteStaleDataUsed();
|
||||
}
|
||||
if (!icons.length) return trayLeft;
|
||||
const iconsLeft = iconsRight - icons.length * step + 4;
|
||||
this.drawNotificationIcons(image, state, icons, keys, iconsLeft, top + (((TOP_BAR_HEIGHT - NOTIFICATION_ICON_SIZE) / 2) | 0));
|
||||
return iconsLeft;
|
||||
icons.forEach((icon, index) => items.push({
|
||||
kind: "notification", width: NOTIFICATION_ICON_SIZE,
|
||||
draw: (image, x, top) => this.drawNotificationIcon(image, state, icon, keys[index], x, top + NOTIFICATION_ICON_TOP),
|
||||
}));
|
||||
for (const icon of state.trayIcons) {
|
||||
items.push({ kind: "tray", width: icon.width, draw: (image, x, top) => drawTrayIcon(image, icon, x, top) });
|
||||
}
|
||||
const batteries = batteryItems(state);
|
||||
if (batteries.length) {
|
||||
// Measured by drawing it: each battery style lays itself out as it draws.
|
||||
const scratch = new GrayImage(G2_LENS_WIDTH, TOP_BAR_HEIGHT, 0);
|
||||
const width = G2_LENS_WIDTH - BATTERY_BLOCK_RIGHT_MARGIN - drawBatteryBlock(scratch, batteries, 0, G2_LENS_WIDTH);
|
||||
// The block keeps its usual right margin inside the edge it's given.
|
||||
items.push({ kind: "batteries", width,
|
||||
draw: (image, x, top) => drawBatteryBlock(image, batteries, top, x + width + BATTERY_BLOCK_RIGHT_MARGIN) });
|
||||
}
|
||||
const font = getDefaultMediumFont();
|
||||
const clock = clockText();
|
||||
// A TTF face measures fractionally; the status surface's crop edges need whole pixels.
|
||||
items.push({ kind: "clock", width: Math.ceil(font.measureText(clock)),
|
||||
draw: (image, x, top) => image.drawText(font, x, top + Math.max(0, ((TOP_BAR_HEIGHT - font.lineHeight) / 2) | 0), clock, 210) });
|
||||
return items;
|
||||
}
|
||||
|
||||
/**
|
||||
* The status bar at the right end of the bottom switcher: its rows as
|
||||
* planned (planBottomBar), each right-aligned against the switcher's end,
|
||||
* the first row ROW_STATUS_TOP under its top. Whatever the windows leave
|
||||
* over is free space between the two. Returns the left edge of the widest
|
||||
* row.
|
||||
*/
|
||||
private drawRowStatus(image: GrayImage, row: Rect, bar: BottomBarPlan<RowStatusItem>): number {
|
||||
image.fillRect(row.x, row.y + 1, row.width, row.height - 1, SHELL_OPAQUE_BLACK);
|
||||
const right = row.x + row.width;
|
||||
bar.statusRows.forEach((items, line) => {
|
||||
const top = row.y + ROW_STATUS_TOP + line * bar.statusPitch;
|
||||
let x = right - statusRowWidth(items);
|
||||
items.forEach((item, index) => {
|
||||
if (index > 0) x += statusGap(items[index - 1]!, item);
|
||||
item.draw(image, x, top);
|
||||
x += item.width;
|
||||
});
|
||||
});
|
||||
return right - bar.statusWidth;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -759,118 +944,124 @@ 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, barRight);
|
||||
const batteryLeft = drawBatteryBlock(image, batteryItems(state), barTop, barRight);
|
||||
const trayLeft = drawTrayIcons(image, state.trayIcons, batteryLeft, barTop);
|
||||
|
||||
const iconsX = clockX + Math.ceil(font.measureText(clock)) + 16;
|
||||
const maxIcons = Math.max(0, ((trayLeft - 8 - iconsX) / NOTIFICATION_ICON_STEP) | 0);
|
||||
const maxIcons = Math.max(0, ((trayLeft - NOTIFICATIONS_GAP - iconsX) / NOTIFICATION_ICON_STEP) | 0);
|
||||
if (maxIcons > 0) {
|
||||
const { icons, keys, stale } = readActiveNotificationIcons(maxIcons, renderPassAllowsStaleData());
|
||||
if (stale) {
|
||||
noteStaleDataUsed();
|
||||
}
|
||||
this.drawNotificationIcons(image, state, icons, keys, iconsX, barTop + (((TOP_BAR_HEIGHT - NOTIFICATION_ICON_SIZE) / 2) | 0));
|
||||
for (let index = 0; index < icons.length; index++) {
|
||||
this.drawNotificationIcon(image, state, icons[index]!, keys[index], iconsX + index * NOTIFICATION_ICON_STEP, barTop + NOTIFICATION_ICON_TOP);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Draw the notification icons left to right from `left`, noting each as a
|
||||
* notification entry. The one the switcher's selection is on
|
||||
* Draw a notification icon at (x, iconY), noting it as a notification
|
||||
* entry. The one the switcher's selection is on
|
||||
* (state.selectedNotificationKey) sits in a rounded box like a sidebar
|
||||
* overflow icon's: filled, with the icon inverted, while the switcher has
|
||||
* focus, and outlined while its detail view in the foreground window has.
|
||||
*/
|
||||
private drawNotificationIcons(image: GrayImage, state: ShellChromeState, icons: GrayImage[], keys: string[], left: number, iconY: number): void {
|
||||
for (let index = 0; index < icons.length; index++) {
|
||||
const x = left + index * NOTIFICATION_ICON_STEP;
|
||||
const key = keys[index];
|
||||
const box = {
|
||||
x: x - NOTIFICATION_BOX_MARGIN_X, y: iconY - NOTIFICATION_BOX_MARGIN_Y,
|
||||
width: NOTIFICATION_ICON_SIZE + 2 * NOTIFICATION_BOX_MARGIN_X, height: NOTIFICATION_ICON_SIZE + 2 * NOTIFICATION_BOX_MARGIN_Y,
|
||||
};
|
||||
if (key) this.notificationEntries.push({ key, ...box });
|
||||
const selected = !!key && key === state.selectedNotificationKey;
|
||||
const focused = selected && state.focus === "sidebar";
|
||||
if (selected) drawSelectionBox(image, box.x, box.y, box.width, box.height, focused);
|
||||
image.drawImage(focused ? invertedIcon(icons[index]!) : icons[index]!, x, iconY);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Labelled battery indicators for the phone, Wear OS watch, G2, and R1,
|
||||
* right-aligned in the top bar. The watch one exists only while a watch
|
||||
* 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, stacked above either, or
|
||||
* dense: device icons beside gauges, two per column) and, per device,
|
||||
* whether the indicator shows always, only below 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, barRight: number): number {
|
||||
const mode = batteryDisplayModeSetting.get();
|
||||
const items: BatteryItem[] = [];
|
||||
const phone = readPhoneBatteryState();
|
||||
if (phone.battery !== null && Number.isFinite(phone.battery)) {
|
||||
pushBatteryItem(items, phoneBatteryVisibilitySetting.get(), "Phone", "phone", phone.battery, Boolean(phone.charging));
|
||||
}
|
||||
if (state.battery.watch !== null && Number.isFinite(state.battery.watch)) {
|
||||
pushBatteryItem(items, watchBatteryVisibilitySetting.get(), "Watch", "watch", state.battery.watch,
|
||||
Boolean(state.battery.watchCharging));
|
||||
}
|
||||
if (state.battery.headset !== null && Number.isFinite(state.battery.headset)) {
|
||||
pushBatteryItem(items, glassesBatteryVisibilitySetting.get(), "G2", "glasses", state.battery.headset,
|
||||
Boolean(state.battery.headsetCharging));
|
||||
}
|
||||
if (state.battery.ring !== null && Number.isInteger(state.battery.ring)
|
||||
&& state.battery.ring >= 0 && state.battery.ring <= 100) {
|
||||
pushBatteryItem(items, ringBatteryVisibilitySetting.get(), "R1", "ring", state.battery.ring,
|
||||
Boolean(state.battery.ringCharging));
|
||||
}
|
||||
if (!items.length) return barRight;
|
||||
if (mode === "stacked" || mode === "stacked-percentage") {
|
||||
return drawStackedBatteries(image, items, barTop, barRight, mode === "stacked-percentage");
|
||||
}
|
||||
if (mode === "dense") {
|
||||
return drawDenseBatteries(image, items, barRight - BATTERY_BLOCK_RIGHT_MARGIN, barTop + DENSE_TOP);
|
||||
}
|
||||
|
||||
const font = getDefaultSmallFont();
|
||||
const percentageMode = mode === "percentage";
|
||||
const labelGap = 5;
|
||||
const itemGap = 12;
|
||||
const textY = barTop + Math.max(0, ((TOP_BAR_HEIGHT - font.lineHeight) / 2) | 0);
|
||||
let x = barRight - BATTERY_BLOCK_RIGHT_MARGIN;
|
||||
for (let index = items.length - 1; index >= 0; index--) {
|
||||
const item = items[index]!;
|
||||
const percentText = `${item.percent}%`;
|
||||
const valueWidth = percentageMode ? Math.ceil(font.measureText(percentText)) : BATTERY_ICON_WIDTH;
|
||||
const labelWidth = Math.ceil(font.measureText(item.label));
|
||||
x -= labelWidth + labelGap + valueWidth;
|
||||
image.drawText(font, x, textY, item.label, BATTERY_LABEL_VALUE);
|
||||
const valueX = x + labelWidth + labelGap;
|
||||
if (percentageMode) {
|
||||
if (item.charging) {
|
||||
// Inverted text marks charging, matching the dashboard card.
|
||||
image.fillRect(valueX - 2, textY - 1, valueWidth + 4, font.lineHeight + 2, 255);
|
||||
image.drawText(font, valueX, textY, percentText, 1);
|
||||
} else {
|
||||
image.drawText(font, valueX, textY, percentText, 200);
|
||||
}
|
||||
} else {
|
||||
const icon = drawBattery(item.percent, item.charging);
|
||||
image.bitBlt(icon, valueX, barTop + Math.max(0, ((TOP_BAR_HEIGHT - icon.height) / 2) | 0), {
|
||||
transparentZero: true,
|
||||
});
|
||||
}
|
||||
x -= itemGap;
|
||||
}
|
||||
return x + itemGap;
|
||||
private drawNotificationIcon(image: GrayImage, state: ShellChromeState, icon: GrayImage, key: string | undefined, x: number, iconY: number): void {
|
||||
const box = {
|
||||
x: x - NOTIFICATION_BOX_MARGIN_X, y: iconY - NOTIFICATION_BOX_MARGIN_Y,
|
||||
width: NOTIFICATION_ICON_SIZE + 2 * NOTIFICATION_BOX_MARGIN_X, height: NOTIFICATION_ICON_SIZE + 2 * NOTIFICATION_BOX_MARGIN_Y,
|
||||
};
|
||||
if (key) this.notificationEntries.push({ key, ...box });
|
||||
const selected = !!key && key === state.selectedNotificationKey;
|
||||
const focused = selected && state.focus === "sidebar";
|
||||
if (selected) drawSelectionBox(image, box.x, box.y, box.width, box.height, focused);
|
||||
image.drawImage(focused ? invertedIcon(icon) : icon, x, iconY);
|
||||
}
|
||||
}
|
||||
|
||||
type BatteryItem = { label: string; device: BatteryDevice; percent: number; charging: boolean };
|
||||
|
||||
/**
|
||||
* Labelled battery indicators for the phone, Wear OS watch, G2, and R1. The
|
||||
* watch one exists only while a watch running the Faceclaw watch app is
|
||||
* reachable (no placeholder otherwise). The Settings > Customization >
|
||||
* Battery indicators submenu picks, per device, whether the indicator shows
|
||||
* always, only below 50%, or never.
|
||||
*/
|
||||
function batteryItems(state: ShellChromeState): BatteryItem[] {
|
||||
const items: BatteryItem[] = [];
|
||||
const phone = readPhoneBatteryState();
|
||||
if (phone.battery !== null && Number.isFinite(phone.battery)) {
|
||||
pushBatteryItem(items, phoneBatteryVisibilitySetting.get(), "Phone", "phone", phone.battery, Boolean(phone.charging));
|
||||
}
|
||||
if (state.battery.watch !== null && Number.isFinite(state.battery.watch)) {
|
||||
pushBatteryItem(items, watchBatteryVisibilitySetting.get(), "Watch", "watch", state.battery.watch,
|
||||
Boolean(state.battery.watchCharging));
|
||||
}
|
||||
if (state.battery.headset !== null && Number.isFinite(state.battery.headset)) {
|
||||
pushBatteryItem(items, glassesBatteryVisibilitySetting.get(), "G2", "glasses", state.battery.headset,
|
||||
Boolean(state.battery.headsetCharging));
|
||||
}
|
||||
if (state.battery.ring !== null && Number.isInteger(state.battery.ring)
|
||||
&& state.battery.ring >= 0 && state.battery.ring <= 100) {
|
||||
pushBatteryItem(items, ringBatteryVisibilitySetting.get(), "R1", "ring", state.battery.ring,
|
||||
Boolean(state.battery.ringCharging));
|
||||
}
|
||||
return items;
|
||||
}
|
||||
|
||||
/**
|
||||
* The battery indicators (batteryItems), right-aligned in the top bar's
|
||||
* layout from `barTop`, in the style the Battery indicators submenu picks:
|
||||
* label beside a gauge icon or percentage, stacked above either, or dense
|
||||
* (device icons beside gauges, two per column). `barRight` is the bar's
|
||||
* right edge (short of a right-hand sidebar). Returns the left edge of the
|
||||
* battery block, or `barRight` with no indicators.
|
||||
*/
|
||||
function drawBatteryBlock(image: GrayImage, items: BatteryItem[], barTop: number, barRight: number): number {
|
||||
const mode = batteryDisplayModeSetting.get();
|
||||
if (!items.length) return barRight;
|
||||
if (mode === "stacked" || mode === "stacked-percentage") {
|
||||
return drawStackedBatteries(image, items, barTop, barRight, mode === "stacked-percentage");
|
||||
}
|
||||
if (mode === "dense") {
|
||||
return drawDenseBatteries(image, items, barRight - BATTERY_BLOCK_RIGHT_MARGIN, barTop + DENSE_TOP);
|
||||
}
|
||||
|
||||
const font = getDefaultSmallFont();
|
||||
const percentageMode = mode === "percentage";
|
||||
const labelGap = 5;
|
||||
const itemGap = 12;
|
||||
const textY = barTop + Math.max(0, ((TOP_BAR_HEIGHT - font.lineHeight) / 2) | 0);
|
||||
let x = barRight - BATTERY_BLOCK_RIGHT_MARGIN;
|
||||
for (let index = items.length - 1; index >= 0; index--) {
|
||||
const item = items[index]!;
|
||||
const percentText = `${item.percent}%`;
|
||||
const valueWidth = percentageMode ? Math.ceil(font.measureText(percentText)) : BATTERY_ICON_WIDTH;
|
||||
const labelWidth = Math.ceil(font.measureText(item.label));
|
||||
x -= labelWidth + labelGap + valueWidth;
|
||||
image.drawText(font, x, textY, item.label, BATTERY_LABEL_VALUE);
|
||||
const valueX = x + labelWidth + labelGap;
|
||||
if (percentageMode) {
|
||||
if (item.charging) {
|
||||
// Inverted text marks charging, matching the dashboard card.
|
||||
image.fillRect(valueX - 2, textY - 1, valueWidth + 4, font.lineHeight + 2, 255);
|
||||
image.drawText(font, valueX, textY, percentText, 1);
|
||||
} else {
|
||||
image.drawText(font, valueX, textY, percentText, 200);
|
||||
}
|
||||
} else {
|
||||
const icon = drawBattery(item.percent, item.charging);
|
||||
image.bitBlt(icon, valueX, barTop + Math.max(0, ((TOP_BAR_HEIGHT - icon.height) / 2) | 0), {
|
||||
transparentZero: true,
|
||||
});
|
||||
}
|
||||
x -= itemGap;
|
||||
}
|
||||
return x + itemGap;
|
||||
}
|
||||
|
||||
/** The status bar's date and time. */
|
||||
function clockText(): string {
|
||||
const now = new Date();
|
||||
@@ -1009,12 +1200,17 @@ function drawTrayIcons(image: GrayImage, trayIcons: GrayImage[], rightEdge: numb
|
||||
let x = rightEdge;
|
||||
for (let index = trayIcons.length - 1; index >= 0; index--) {
|
||||
const icon = trayIcons[index]!;
|
||||
x -= icon.width + 10;
|
||||
image.drawImage(icon, x, barTop + Math.max(0, ((TOP_BAR_HEIGHT - icon.height) / 2) | 0));
|
||||
x -= icon.width + TRAY_ICON_GAP;
|
||||
drawTrayIcon(image, icon, x, barTop);
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
/** An app tray icon with its left edge at x, centred in the top bar's layout from `barTop`. */
|
||||
function drawTrayIcon(image: GrayImage, icon: GrayImage, x: number, barTop: number): void {
|
||||
image.drawImage(icon, x, barTop + Math.max(0, ((TOP_BAR_HEIGHT - icon.height) / 2) | 0));
|
||||
}
|
||||
|
||||
/** The sidebar attention marker, cached per fill value (deferred-image source). */
|
||||
const attentionDots = new Map<number, GrayImage>();
|
||||
function attentionDot(value: number): GrayImage {
|
||||
|
||||
+49
-20
@@ -26,17 +26,38 @@ export const TOP_BAR_HEIGHT = 28;
|
||||
export const SIDEBAR_WIDTH = 64;
|
||||
|
||||
/**
|
||||
* Height of the app switcher as a row under the window: one tall tab, the
|
||||
* Height of one row of the app switcher 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: one
|
||||
* pixel for the side of the window's frame (windowFramed), the rest for the
|
||||
* whole display's stereo shift (uiDepth). Full Screen windows take those
|
||||
* margins too, giving up both.
|
||||
* margins too, giving up both. When the row's contents don't fit, the
|
||||
* switcher grows a second row (see setSwitcherBarHeight).
|
||||
*/
|
||||
export const SWITCHER_ROW_HEIGHT = 36;
|
||||
|
||||
/**
|
||||
* Height of the bottom switcher as its contents last laid out (chrome-layer.ts
|
||||
* planBottomBar): SWITCHER_ROW_HEIGHT, or more once the status bar's items
|
||||
* or the window icons take a second row. One for the switcher reserved
|
||||
* under windows, one for the switcher overlaying an immersive window.
|
||||
*/
|
||||
const switcherBarHeights = { reserved: SWITCHER_ROW_HEIGHT, overlay: SWITCHER_ROW_HEIGHT };
|
||||
|
||||
/**
|
||||
* Set the bottom switcher's height for its current layout under the given
|
||||
* (foreground) app's window: the overlay's over an immersive window, else
|
||||
* the row reserved under windows. True if that moves or resizes windows.
|
||||
*/
|
||||
export function setSwitcherBarHeight(height: number, appId?: string): boolean {
|
||||
const which = isImmersive(appId) ? "overlay" : "reserved";
|
||||
if (switcherBarHeights[which] === height) return false;
|
||||
switcherBarHeights[which] = height;
|
||||
return which === "reserved";
|
||||
}
|
||||
|
||||
/** Which edge the app switcher is on, or a popup (Settings > Customization). */
|
||||
export function switcherPosition(): AppSwitcherPosition {
|
||||
return appSwitcherPositionSetting.get();
|
||||
@@ -116,13 +137,13 @@ export function sidebarWidth(appId?: string): number {
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 under an immersive
|
||||
* window (where the row overlays the window's bottom edge while it has
|
||||
* focus).
|
||||
* How much of the screen's height a bottom switcher takes away from app
|
||||
* windows: its rows (one, or two when the layout needs them), or nothing
|
||||
* beside a side strip or under an immersive window (where the switcher
|
||||
* overlays the window's bottom edge while it has focus).
|
||||
*/
|
||||
export function switcherRowHeight(appId?: string): number {
|
||||
return !isImmersive(appId) && switcherPosition() === "bottom" ? SWITCHER_ROW_HEIGHT : 0;
|
||||
return !isImmersive(appId) && switcherPosition() === "bottom" ? switcherBarHeights.reserved : 0;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -139,23 +160,25 @@ export function sidebarStripVisible(focus: "sidebar" | "window", appId?: string)
|
||||
* (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. Over an immersive window
|
||||
* the row overlays the bottom edge of the screen. A popup's is the area it
|
||||
* centres in, the foreground window's content (the chrome layer sizes the
|
||||
* box itself).
|
||||
* the row overlays the bottom edge of the screen. Either way it is as tall
|
||||
* as its layout (setSwitcherBarHeight). A popup's is the area it centres
|
||||
* in, the foreground window's content (the chrome layer sizes the box
|
||||
* itself).
|
||||
*/
|
||||
export function switcherRect(heightMode: WindowHeightMode, appId?: string): { x: number; y: number; width: number; height: number } {
|
||||
switch (switcherPosition()) {
|
||||
case "popup":
|
||||
return appViewportRect(heightMode, appId);
|
||||
case "bottom":
|
||||
case "bottom": {
|
||||
const reserved = switcherRowHeight(appId);
|
||||
const height = reserved || switcherBarHeights.overlay;
|
||||
return {
|
||||
x: appViewportLeft(appId),
|
||||
y: switcherRowHeight(appId) > 0
|
||||
? windowTop(heightMode, appId) + windowBandHeight(heightMode, appId)
|
||||
: G2_LENS_HEIGHT - SWITCHER_ROW_HEIGHT,
|
||||
y: reserved > 0 ? windowTop(heightMode, appId) + windowBandHeight(heightMode, appId) : G2_LENS_HEIGHT - height,
|
||||
width: appViewportWidth(appId),
|
||||
height: SWITCHER_ROW_HEIGHT,
|
||||
height,
|
||||
};
|
||||
}
|
||||
case "right":
|
||||
return { x: G2_LENS_WIDTH - SIDEBAR_WIDTH, y: minWindowTop(appId), width: SIDEBAR_WIDTH, height: MIN_WINDOW_HEIGHT };
|
||||
default:
|
||||
@@ -345,7 +368,7 @@ export const SHELL_OPAQUE_BLACK = 1;
|
||||
* firmware uses, leaving most of the field of view clear; "medium" is one
|
||||
* header (and footer) taller, so the content area between them is a full
|
||||
* 288px (the EvenHub app surface height); "max" uses the whole 480px screen
|
||||
* (terminal views), less a bottom switcher row. All include the header the
|
||||
* (terminal views), less a bottom switcher's rows. All include the header the
|
||||
* shell draws at the window's top edge (windowHeaderHeight) and any footer
|
||||
* at its bottom (windowFooterHeight).
|
||||
*/
|
||||
@@ -356,7 +379,7 @@ export const MIN_WINDOW_HEIGHT = 288;
|
||||
|
||||
/**
|
||||
* Height of the screen area windows are placed in: the whole screen, less
|
||||
* a bottom switcher row's height.
|
||||
* a bottom switcher's height.
|
||||
*/
|
||||
function windowAreaHeight(appId?: string): number {
|
||||
return G2_LENS_HEIGHT - switcherRowHeight(appId);
|
||||
@@ -394,11 +417,17 @@ export function minWindowTop(appId?: string): number {
|
||||
|
||||
/**
|
||||
* Top edge (y) of a window's header; 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.
|
||||
* top. A bottom switcher row hangs under the band, so the band and a
|
||||
* one-row switcher together distribute the screen's slack. A switcher of
|
||||
* more rows takes its extra height out of the slack under it, pushing the
|
||||
* band up only as far as there is too little, so the band doesn't move as
|
||||
* the switcher's layout changes unless it has to.
|
||||
*/
|
||||
export function windowTop(mode: WindowHeightMode, appId?: string): number {
|
||||
return Math.round((windowAreaHeight(appId) - windowBandHeight(mode, appId)) * verticalPositionFraction(appId));
|
||||
const band = windowBandHeight(mode, appId);
|
||||
const oneRowArea = G2_LENS_HEIGHT - (switcherRowHeight(appId) > 0 ? SWITCHER_ROW_HEIGHT : 0);
|
||||
const top = Math.round((oneRowArea - band) * verticalPositionFraction(appId));
|
||||
return Math.min(top, windowAreaHeight(appId) - band);
|
||||
}
|
||||
|
||||
/** App-content viewport size for a height mode (independent of vertical position). */
|
||||
|
||||
+27
-4
@@ -143,9 +143,10 @@ export type ShellWindow = {
|
||||
/** Repaint and resubmit this window's surface. */
|
||||
requestRender: () => void;
|
||||
/**
|
||||
* Re-measure against the current display mode (viewport size / band) and
|
||||
* repaint. Windows without it (workers with a canvas fixed at open) are
|
||||
* closed and relaunched by the controller instead.
|
||||
* Re-measure against the current display mode and app switcher (viewport
|
||||
* size / band) and repaint. Windows without it are closed and relaunched
|
||||
* by the controller instead on a display mode change, and left at the size
|
||||
* they opened with when the bottom switcher changes height.
|
||||
*/
|
||||
relayout?: () => void;
|
||||
/**
|
||||
@@ -201,6 +202,12 @@ export type ShellConfig = {
|
||||
onScreenStateChanged: (on: boolean) => void;
|
||||
/** Window registered/removed or foreground changed (persists the open-app list). */
|
||||
onWindowsChanged?: () => void;
|
||||
/**
|
||||
* The bottom switcher's layout changed its height (geometry.ts
|
||||
* setSwitcherBarHeight): windows have to move, or resize, to suit. Called
|
||||
* after the shell paint that found it.
|
||||
*/
|
||||
onSwitcherBarHeightChanged?: () => void;
|
||||
/**
|
||||
* The Notifications app's window, opened in the background (neither
|
||||
* foregrounded nor focused) unless it is open already, for the switcher
|
||||
@@ -445,8 +452,9 @@ class Shell {
|
||||
requestShellRender: () => {},
|
||||
onScreenStateChanged: () => {},
|
||||
};
|
||||
private readonly chrome = new ShellChromeLayer(() => this.chromeState());
|
||||
private readonly chrome = new ShellChromeLayer(() => this.chromeState(), () => this.switcherBarHeightChanged());
|
||||
private readonly stack = new LayerStack(this.chrome, this.actions);
|
||||
private switcherBarChangePending = false;
|
||||
|
||||
// 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.
|
||||
@@ -494,6 +502,21 @@ class Shell {
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* The chrome found, mid-paint, that the bottom switcher's height changed.
|
||||
* The controller moves or resizes windows once the paint is over: a
|
||||
* window's relayout repaints it, which mustn't happen inside the shell's
|
||||
* own paint.
|
||||
*/
|
||||
private switcherBarHeightChanged(): void {
|
||||
if (this.switcherBarChangePending) return;
|
||||
this.switcherBarChangePending = true;
|
||||
setTimeout(() => {
|
||||
this.switcherBarChangePending = false;
|
||||
this.config.onSwitcherBarHeightChanged?.();
|
||||
}, 0);
|
||||
}
|
||||
|
||||
/** Add a window (or replace one with the same windowId, keeping its slot). */
|
||||
registerWindow(window: ShellWindow): void {
|
||||
const existing = this.windows.findIndex((w) => w.windowId === window.windowId);
|
||||
|
||||
@@ -460,10 +460,10 @@ export class WorkerAppHost {
|
||||
closeable: true,
|
||||
acceptsDirectional: spec.acceptsDirectional,
|
||||
heightMode,
|
||||
// These apps can resize their live content without losing route/session state.
|
||||
relayout: this.options.appId === "navigate" || this.options.appId === "terminal"
|
||||
? () => this.post({ type: "resize-window", windowId: spec.windowId, viewport: appViewportSize(heightMode, this.options.appId) })
|
||||
: undefined,
|
||||
// Every app worker resizes its live content in place, keeping its state
|
||||
// (a game in progress, a route): the bottom switcher's height changes
|
||||
// with what it holds, and full-height windows give way to it.
|
||||
relayout: () => this.post({ type: "resize-window", windowId: spec.windowId, viewport: appViewportSize(heightMode, this.options.appId) }),
|
||||
hasAppMenu: () => this.windowGestures.get(spec.windowId)?.hasAppMenu ?? false,
|
||||
claimsLongPress: () => this.windowGestures.get(spec.windowId)?.claimsLongPress ?? false,
|
||||
close: () => {
|
||||
|
||||
+167
-28
@@ -282,7 +282,7 @@ function chromeLayer(g, { notifications = 0, phoneBattery = null, windows = 1, t
|
||||
'../../graphics/textwrap': require('../.test-build/app/graphics/textwrap.js'),
|
||||
'../../graphics/battery': require('../.test-build/app/graphics/battery.js'),
|
||||
'./ambient-cards': { activeAmbientCards: () => [] },
|
||||
'../../native/notification-icons': { readActiveNotificationIcons: (max) => {
|
||||
'../../native/notification-icons': { ALL_NOTIFICATIONS: 0x7fffffff, readActiveNotificationIcons: (max) => {
|
||||
requested.push(max);
|
||||
const count = Math.min(max, notifications);
|
||||
return { icons: Array.from({ length: count }, () => new graphics.GrayImage(24, 24, 200)),
|
||||
@@ -307,7 +307,9 @@ function chromeLayer(g, { notifications = 0, phoneBattery = null, windows = 1, t
|
||||
selectedIndex: 0, focus: 'window', foregroundHeightMode: 'min',
|
||||
battery: { headset: null, ring: null, watch: null }, trayIcons,
|
||||
};
|
||||
return { chrome: new context.exports.ShellChromeLayer(() => state), state, requested };
|
||||
let heightChanges = 0;
|
||||
const chrome = new context.exports.ShellChromeLayer(() => state, () => heightChanges++);
|
||||
return { chrome, state, requested, planBottomBar: context.exports.planBottomBar, heightChanges: () => heightChanges };
|
||||
}
|
||||
|
||||
test('a bottom app switcher frames the foreground window\'s content in a rounded border', () => {
|
||||
@@ -405,12 +407,13 @@ test('the launcher\'s tab lines up with the window frame, whose corner squares t
|
||||
({ px, at } = paint(chrome));
|
||||
assert.deepEqual([px(31, 365), px(32, 365), at(35, 366), at(36, 366)], [0, 0, 1, 40]);
|
||||
assert.equal(chrome.windowIndexAt(31, 380, 3), 0);
|
||||
// Scrolled past the launcher, the cells keep the left chevron's margin.
|
||||
const scrolled = chromeLayer(g, { windows: 20 });
|
||||
scrolled.state.selectedIndex = 19;
|
||||
// Scrolled past the launcher (more windows than two rows of 14 hold), the
|
||||
// cells keep the left chevron's margin.
|
||||
const scrolled = chromeLayer(g, { windows: 40 });
|
||||
scrolled.state.selectedIndex = 39;
|
||||
({ px } = paint(scrolled.chrome));
|
||||
assert.equal(scrolled.chrome.windowIndexAt(35, 380, 20), null);
|
||||
assert.notEqual(scrolled.chrome.windowIndexAt(41, 380, 20), null);
|
||||
assert.equal(scrolled.chrome.windowIndexAt(35, 380, 40), null);
|
||||
assert.notEqual(scrolled.chrome.windowIndexAt(41, 380, 40), null);
|
||||
assert.equal(px(31, 365), 0);
|
||||
});
|
||||
|
||||
@@ -459,35 +462,144 @@ test('the switcher row lays out windows, free space, notifications, widgets, bat
|
||||
assert.equal(at(row, 40 + 2, 366 + 2), 120, 'first window icon');
|
||||
assert.equal(chrome.windowIndexAt(45, 380, 1), 0);
|
||||
assert.equal(chrome.windowIndexAt(iconsLeft + 2, 380, 1), null);
|
||||
// Notification icons stop short of the one window slot's room (with the
|
||||
// row's margins and the gap to the status bar).
|
||||
assert.equal(requested.at(-1), Math.floor((trayLeft - 8 - (32 + 20 + 40 - 8 + 8) + 4) / 28));
|
||||
// The row asks for every notification icon, to lay itself out round them all.
|
||||
assert.equal(requested.at(-1), 0x7fffffff);
|
||||
// No top bar, but the frame is still there, its top one row above the content.
|
||||
const [frame] = row.image.draws.filter((d) => d.presentation?.displayList);
|
||||
assert.deepEqual([row.x + frame.x, row.y + frame.y, frame.source.height], [31, 78, 289]);
|
||||
shellScene.encodeShellScene(parts, g.uiDepth());
|
||||
});
|
||||
|
||||
test('many windows scroll in what the notification icons leave them', () => {
|
||||
test('past two rows of windows, they scroll, and notification icons give way to a few slots a row', () => {
|
||||
const g = geometry();
|
||||
g.settings.appSwitcherPositionSetting.value = 'bottom';
|
||||
g.settings.statusBarPositionSetting.value = 'bottom';
|
||||
const { chrome, requested } = chromeLayer(g, { notifications: 40, windows: 12 });
|
||||
const { chrome, requested, heightChanges } = chromeLayer(g, { notifications: 40, windows: 12 });
|
||||
const [row, status] = chrome.paintParts();
|
||||
// Clock only (no batteries or widgets): notifications end 8px before its
|
||||
// 8px lead-in, and stop where three window slots plus margins remain.
|
||||
const trayLeft = 608 - 56 - 8, floor = 32 + 20 + 3 * 40 - 8 + 8;
|
||||
const max = Math.floor((trayLeft - 8 - floor + 4) / 28);
|
||||
assert.equal(requested.at(-1), max);
|
||||
const iconsLeft = trayLeft - 8 - max * 28 + 4;
|
||||
assert.equal(status.x, iconsLeft - 2);
|
||||
// Three windows fit before the status bar's gap; the rest scroll, with the
|
||||
// chevron at the end of the windows rather than of the row.
|
||||
assert.equal(requested.at(-1), 0x7fffffff);
|
||||
// The last layout: two rows of each, 72px tall, under the unmoved band.
|
||||
assert.equal(g.switcherRowHeight(), 72);
|
||||
assert.equal(heightChanges(), 1);
|
||||
assert.deepEqual([row.y, row.image.height], [366, 72]);
|
||||
// Notification icons drop from the end until the two status rows leave
|
||||
// three window slots a row (32 + 20 + 3 * 40 - 8, and the gap): 28 stay,
|
||||
// 15 in the first row (416px) and 13 with the clock in the second (432px).
|
||||
assert.equal(chrome.notificationKeys().length, 28);
|
||||
assert.deepEqual([status.x, status.y, status.image.height], [608 - 432 - 2, 367, 71]);
|
||||
const at = (p, x, y) => p.image.withDrawsBaked().pixels[(y - p.y) * p.image.width + x - p.x];
|
||||
assert.deepEqual([at(status, 608 - 416, 366 + 5 + 2), at(status, 608 - 432, 366 + 36 + 5 + 2)], [200, 200]);
|
||||
// Three windows a row; the rest scroll, with the chevron after the second
|
||||
// row's, at the end of the windows rather than of the row.
|
||||
assert.equal(chrome.windowIndexAt(32 + 10 + 2 * 40 + 4, 380, 12), 2);
|
||||
assert.equal(chrome.windowIndexAt(32 + 10 + 3 * 40 + 4, 380, 12), null);
|
||||
const windowsRight = iconsLeft - 8;
|
||||
const chevron = row.image.pixels.findIndex((v, i) => v === 140);
|
||||
assert.equal(chevron % row.image.width + row.x, windowsRight - 6);
|
||||
assert.equal(chrome.windowIndexAt(32 + 10 + 2 * 40 + 4, 420, 12), 5);
|
||||
const windowsRight = 608 - 432 - 8;
|
||||
const chevron = row.image.pixels.findIndex((v) => v === 140);
|
||||
assert.deepEqual([chevron % row.image.width + row.x, Math.floor(chevron / row.image.width) + row.y], [windowsRight - 6, 366 + 36 + 18 - 5]);
|
||||
});
|
||||
|
||||
test('the bottom switcher falls back to denser layouts as what it holds outgrows it', () => {
|
||||
const { planBottomBar } = chromeLayer(geometry());
|
||||
const notifications = (count) => Array.from({ length: count }, () => ({ kind: 'notification', width: 24 }));
|
||||
const clock = { kind: 'clock', width: 56 };
|
||||
const summary = (plan) => [plan.level, plan.height, plan.windowRows, plan.windowColumns,
|
||||
Array.from(plan.statusRows, (items) => items.length), plan.statusWidth, plan.statusPitch];
|
||||
// Three windows (132px with margins) and five icons and the clock fit one row.
|
||||
assert.deepEqual(summary(planBottomBar(576, 3, [...notifications(5), clock])), [1, 36, 1, 8, [6], 208, 28]);
|
||||
// Fourteen icons don't (28 * 14 - 4 + 16 + 56 > 576 - 132 - 8), so the
|
||||
// status bar takes two rows, broken where they come nearest the same
|
||||
// width: 8 icons (220px) over 6 and the clock (236px), a top bar apart.
|
||||
const many = [...notifications(14), clock];
|
||||
assert.deepEqual(summary(planBottomBar(576, 3, many)), [2, 64, 1, 8, [8, 7], 236, 28]);
|
||||
// Nine windows don't fit the one row of 8 slots that leaves: two rows of
|
||||
// windows, the status rows level with them.
|
||||
assert.deepEqual(summary(planBottomBar(576, 9, many)), [3, 72, 2, 8, [8, 7], 236, 36]);
|
||||
// Seventeen don't fit those 16 slots: the last layout scrolls them.
|
||||
assert.deepEqual(summary(planBottomBar(576, 17, many)), [4, 72, 2, 8, [8, 7], 236, 36]);
|
||||
// Without the status bar, the windows alone: 14 a row.
|
||||
assert.deepEqual(summary(planBottomBar(576, 14, [])), [1, 36, 1, 14, [], 0, 28]);
|
||||
assert.deepEqual(summary(planBottomBar(576, 15, [])), [3, 72, 2, 14, [], 0, 36]);
|
||||
assert.deepEqual(summary(planBottomBar(576, 29, [])), [4, 72, 2, 14, [], 0, 36]);
|
||||
// A full-width (640) row has room for more.
|
||||
assert.equal(planBottomBar(640, 3, many).level, 1);
|
||||
});
|
||||
|
||||
test('a taller bottom switcher takes its room from the slack under a band, or from full-height windows', () => {
|
||||
const g = geometry();
|
||||
g.settings.appSwitcherPositionSetting.value = 'bottom';
|
||||
g.settings.statusBarPositionSetting.value = 'bottom';
|
||||
const before = g.rect('min');
|
||||
assert.equal(g.setSwitcherBarHeight(64), true);
|
||||
assert.equal(g.setSwitcherBarHeight(64), false);
|
||||
// The band stays put, the switcher growing down into the slack under it...
|
||||
assert.deepEqual(g.rect('min'), before);
|
||||
assert.deepEqual({ ...g.switcherRect('min') }, { x: 32, y: 366, width: 576, height: 64 });
|
||||
assert.equal(g.isOnSwitcherEdge(10, 420, 'min'), true);
|
||||
// ...pushing it up only where there's too little.
|
||||
g.settings.displayLayoutSetting.value = 'band-low';
|
||||
assert.equal(g.windowTop('min'), 117);
|
||||
g.settings.displayLayoutSetting.value = 'band-bottom';
|
||||
assert.equal(g.windowTop('min'), 480 - 64 - 288);
|
||||
assert.equal(g.switcherRect('min').y + 64, 480);
|
||||
// Tall windows give up the height.
|
||||
g.settings.displayLayoutSetting.value = 'tall';
|
||||
assert.deepEqual(g.rect('max'), { x: 32, y: 1, width: 576, height: 415 });
|
||||
g.settings.displayLayoutSetting.value = 'band-middle';
|
||||
assert.deepEqual(g.rect('max', 'terminal'), { x: 32, y: 1, width: 576, height: 415 });
|
||||
// Over an immersive window the switcher is an overlay of its own height,
|
||||
// which moves no window.
|
||||
g.setAppImmersive('onboarding', true);
|
||||
assert.equal(g.setSwitcherBarHeight(72, 'onboarding'), false);
|
||||
assert.deepEqual({ ...g.switcherRect('min', 'onboarding') }, { x: 0, y: 408, width: 640, height: 72 });
|
||||
assert.equal(g.switcherRowHeight(), 64);
|
||||
// Beside a side strip it takes nothing.
|
||||
g.settings.appSwitcherPositionSetting.value = 'left';
|
||||
assert.equal(g.switcherRowHeight(), 0);
|
||||
});
|
||||
|
||||
test('the status bar takes a second row of its own before the windows do', () => {
|
||||
const g = geometry();
|
||||
g.settings.appSwitcherPositionSetting.value = 'bottom';
|
||||
g.settings.statusBarPositionSetting.value = 'bottom';
|
||||
const { chrome, heightChanges } = chromeLayer(g, { notifications: 14, windows: 3 });
|
||||
const before = g.rect('min');
|
||||
const [row, status] = chrome.paintParts();
|
||||
assert.equal(g.switcherRowHeight(), 64);
|
||||
assert.equal(heightChanges(), 1);
|
||||
chrome.paintParts();
|
||||
assert.equal(heightChanges(), 1, 'reported once');
|
||||
assert.deepEqual(g.rect('min'), before);
|
||||
// Both rows right-aligned against the row's end: 8 icons (220px) over 6
|
||||
// and the clock (236px), a top bar's height apart.
|
||||
assert.deepEqual([status.x, status.y, status.image.height], [608 - 236 - 2, 367, 63]);
|
||||
const at = (p, x, y) => p.image.withDrawsBaked().pixels[(y - p.y) * p.image.width + x - p.x];
|
||||
assert.deepEqual([at(status, 608 - 220, 371 + 2), at(status, 608 - 236, 371 + 28 + 2), at(status, 608 - 56, 371 + 28 + 8 + 2)],
|
||||
[200, 200, 210]);
|
||||
assert.deepEqual(Array.from(chrome.notificationKeys()), Array.from({ length: 14 }, (_, i) => `n${i}`));
|
||||
// The windows keep one row, against the window.
|
||||
assert.equal(chrome.windowIndexAt(45, 380, 3), 0);
|
||||
assert.equal(chrome.windowIndexAt(45, 410, 3), null);
|
||||
assert.equal(row.image.height, 64);
|
||||
});
|
||||
|
||||
test('windows past one row take a second, where a selected one sits in a box', () => {
|
||||
const g = geometry();
|
||||
g.settings.appSwitcherPositionSetting.value = 'bottom';
|
||||
g.settings.statusBarPositionSetting.value = 'bottom';
|
||||
const { chrome, state } = chromeLayer(g, { notifications: 14, windows: 9 });
|
||||
state.selectedIndex = 8;
|
||||
const [row, status] = chrome.paintParts();
|
||||
assert.equal(g.switcherRowHeight(), 72);
|
||||
// Eight slots a row (what the 236px status rows leave); the ninth window
|
||||
// starts the second row, under the first.
|
||||
assert.deepEqual([chrome.windowIndexAt(31 + 7 * 40, 380, 9), chrome.windowIndexAt(31, 410, 9), chrome.windowIndexAt(71, 410, 9)], [7, 8, null]);
|
||||
const at = (p, x, y) => p.image.pixels[(y - p.y) * p.image.width + x - p.x];
|
||||
// Its selection is a box (as for a sidebar overflow column), and the
|
||||
// separator runs unbroken over the first row.
|
||||
assert.deepEqual([at(row, 31, 402 + 18), at(row, 31 + 5, 402 + 7)], [150, 120]);
|
||||
assert.equal(at(row, 50, 366), 40);
|
||||
// The status rows line up with the window rows.
|
||||
assert.equal(status.image.withDrawsBaked().pixels[(366 + 36 + 5 + 2 - status.y) * status.image.width + 608 - 236 - status.x], 200);
|
||||
});
|
||||
|
||||
test('a popup app switcher shows a box of window icons over the dimmed window while focused', () => {
|
||||
@@ -613,15 +725,15 @@ test('a notification the switcher selects sits in a box, filled with its icon in
|
||||
test('with the selection out on a notification, the windows stay scrolled as they were', () => {
|
||||
const g = geometry();
|
||||
g.settings.appSwitcherPositionSetting.value = 'bottom';
|
||||
const { chrome, state } = chromeLayer(g, { notifications: 2, windows: 20 });
|
||||
state.selectedIndex = 19;
|
||||
const { chrome, state } = chromeLayer(g, { notifications: 2, windows: 40 });
|
||||
state.selectedIndex = 39;
|
||||
chrome.paintParts();
|
||||
const last = 32 + 10 + 2 * 40 + 4;
|
||||
const before = chrome.windowIndexAt(last, 380, 20);
|
||||
const before = chrome.windowIndexAt(last, 380, 40);
|
||||
assert.ok(before > 2);
|
||||
Object.assign(state, { selectedIndex: -1, selectedNotificationKey: 'n0' });
|
||||
chrome.paintParts();
|
||||
assert.equal(chrome.windowIndexAt(last, 380, 20), before);
|
||||
assert.equal(chrome.windowIndexAt(last, 380, 40), before);
|
||||
});
|
||||
|
||||
// Exercise the real worker message handler with platform work stubbed out.
|
||||
@@ -677,6 +789,33 @@ test('Terminal resize keeps the view identity, negotiates its grid and skips pos
|
||||
assert.equal(calls.length, 6);
|
||||
});
|
||||
|
||||
test('the games and Roam resize in place, keeping their state, and repaint when in front', () => {
|
||||
for (const app of ['blocks', 'freecell', 'minesweeper', 'pinball']) {
|
||||
let paints = 0, menuSize;
|
||||
const window = { windowId: 'test', viewportWidth: 576, viewportHeight: 443, foreground: true, phase: 'playing',
|
||||
menu: { resize: (size) => { menuSize = size; } }, lastSubmittedFingerprint: 'old' };
|
||||
const resize = resizeHandler(`app/apps/${app}/${app}-app.worker.ts`, {
|
||||
windows: new Map([['test', window]]), renderAndSubmit: () => paints++,
|
||||
});
|
||||
resize({ width: 576, height: 415 });
|
||||
assert.deepEqual([window.viewportWidth, window.viewportHeight, window.phase, window.lastSubmittedFingerprint, paints],
|
||||
[576, 415, 'playing', '', 1], app);
|
||||
assert.deepEqual({ ...menuSize }, { width: 576, height: 415 }, app);
|
||||
window.foreground = false;
|
||||
resize({ width: 576, height: 443 });
|
||||
assert.deepEqual([window.viewportHeight, paints], [443, 1], app);
|
||||
}
|
||||
let paints = 0, viewSize;
|
||||
const window = { windowId: 'test', viewportWidth: 576, viewportHeight: 443, menu: null, lastSubmittedFingerprint: 'old',
|
||||
view: { resize: (...size) => { viewSize = size; } } };
|
||||
const resize = resizeHandler('app/apps/roam/roam-app.worker.ts', {
|
||||
window, render: () => paints++, DOC_MARGIN: 6, HEADER_HEIGHT: 30, BOTTOM_MARGIN: 6,
|
||||
});
|
||||
resize({ width: 576, height: 415 });
|
||||
// The document re-wraps for the region under its header.
|
||||
assert.deepEqual([window.viewportHeight, viewSize, window.lastSubmittedFingerprint, paints], [415, [564, 379], '', 1]);
|
||||
});
|
||||
|
||||
test('resizing a terminal reconnects with the new grid and ignores callbacks from the old socket', () => {
|
||||
const sockets = [];
|
||||
const context = {
|
||||
|
||||
Reference in new issue
Block a user