Most of the builtin apps had some padding between the window edge and their content, because they expect to be displayed with a line border on their edge. We added a customization option to remove the border, so, that padding is not always necessary. Make the layouts dynamically adjust, to omit the padding when it isn't needed.
584 lines
23 KiB
TypeScript
584 lines
23 KiB
TypeScript
import { screenHeight, screenWidth } from "../../graphics/screen-size";
|
|
import {
|
|
appSwitcherPositionSetting,
|
|
type AppSwitcherPosition,
|
|
displayLayoutSetting,
|
|
type DisplayLayout,
|
|
navigateDisplayLayoutSetting,
|
|
terminalDisplayLayoutSetting,
|
|
statusBarPositionSetting,
|
|
statusBarVisibilitySetting,
|
|
uiDepthSetting,
|
|
type WindowBorder,
|
|
windowBorderSetting,
|
|
} from "../dashboard-settings";
|
|
import { type EdgeKind, type Edges, uniformEdges, type Viewport, viewportWith } from "../viewport";
|
|
|
|
/** The paired glasses' screen, which the shell lays out in (graphics/screen-size.ts). */
|
|
export { screenHeight, screenWidth };
|
|
|
|
/** Top bar: 24px notification icons plus a little padding. */
|
|
export const TOP_BAR_HEIGHT = 28;
|
|
/**
|
|
* 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 or a
|
|
* popup too, except in the Full Screen display mode (640 wide; never beside
|
|
* a strip) and immersive windows, which the switcher overlays (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 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. 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();
|
|
}
|
|
|
|
/** Whether the app switcher is a strip down the left or right edge. */
|
|
function sideStrip(): boolean {
|
|
const position = switcherPosition();
|
|
return position === "left" || position === "right";
|
|
}
|
|
|
|
/** An app's own Display mode setting (Navigate, Terminal); "default" for the rest. */
|
|
function appDisplayLayout(appId?: string) {
|
|
return appId === "navigate" ? navigateDisplayLayoutSetting.get()
|
|
: appId === "terminal" ? terminalDisplayLayoutSetting.get() : "default";
|
|
}
|
|
|
|
/**
|
|
* The display mode an app's windows use (see dashboard-settings.ts
|
|
* DisplayLayout): its own, or the global one. Full Screen needs the width a
|
|
* side strip takes, so beside one it is Tall.
|
|
*/
|
|
export function displayLayout(appId?: string): DisplayLayout {
|
|
const own = appDisplayLayout(appId);
|
|
const layout = own === "global" || own === "default" ? displayLayoutSetting.get() : own;
|
|
return layout === "fullscreen" && sideStrip() ? "tall" : layout;
|
|
}
|
|
|
|
/** Fraction of the slack above a window band in each band display mode. */
|
|
const BAND_FRACTIONS: Partial<Record<DisplayLayout, number>> = {
|
|
"band-top": 0,
|
|
"band-high": 0.25,
|
|
"band-middle": 0.5,
|
|
"band-low": 0.75,
|
|
"band-bottom": 1,
|
|
};
|
|
|
|
/** A band display mode's fraction of the slack above the band; undefined for Tall and Full Screen. */
|
|
function bandFraction(layout: DisplayLayout): number | undefined {
|
|
return BAND_FRACTIONS[layout];
|
|
}
|
|
|
|
/**
|
|
* Apps whose windows are immersive right now: the whole panel, with no
|
|
* status bar, window frame or room kept for the switcher (which overlays
|
|
* them only while it has focus), at depth 0. An app switches it at runtime
|
|
* (InProcessWindow.setImmersive; the onboarding's first pages), so it is
|
|
* per app, like the per-app display modes.
|
|
*/
|
|
const immersiveApps = new Set<string>();
|
|
|
|
/** Mark an app's windows immersive or not; true if that changed anything. */
|
|
export function setAppImmersive(appId: string, immersive: boolean): boolean {
|
|
if (immersiveApps.has(appId) === immersive) return false;
|
|
if (immersive) immersiveApps.add(appId);
|
|
else immersiveApps.delete(appId);
|
|
return true;
|
|
}
|
|
|
|
export function isImmersive(appId?: string): boolean {
|
|
return appId !== undefined && immersiveApps.has(appId);
|
|
}
|
|
|
|
/** Whether an app's windows span the panel's whole width: Full Screen, or immersive. */
|
|
function fullWidth(appId?: string): boolean {
|
|
return isImmersive(appId) || displayLayout(appId) === "fullscreen";
|
|
}
|
|
|
|
/**
|
|
* 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 a popup or the
|
|
* window is immersive (where the chrome paints the strip over the window
|
|
* while the sidebar has focus).
|
|
*/
|
|
export function sidebarWidth(appId?: string): number {
|
|
return !isImmersive(appId) && sideStrip() ? SIDEBAR_WIDTH : 0;
|
|
}
|
|
|
|
/**
|
|
* 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" ? switcherBarHeights.reserved : 0;
|
|
}
|
|
|
|
/**
|
|
* Whether the switcher is on screen: always when it reserves room; as a
|
|
* popup, or over an immersive window, only while it has focus.
|
|
*/
|
|
export function sidebarStripVisible(focus: "sidebar" | "window", appId?: string): boolean {
|
|
return (!isImmersive(appId) && switcherPosition() !== "popup") || 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. Over an immersive window
|
|
* 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": {
|
|
const reserved = switcherRowHeight(appId);
|
|
const height = reserved || switcherBarHeights.overlay;
|
|
return {
|
|
x: appViewportLeft(appId),
|
|
y: reserved > 0 ? windowTop(heightMode, appId) + windowBandHeight(heightMode, appId) : screenHeight() - height,
|
|
width: appViewportWidth(appId),
|
|
height,
|
|
};
|
|
}
|
|
case "right":
|
|
return { x: screenWidth() - SIDEBAR_WIDTH, y: minWindowTop(appId), width: SIDEBAR_WIDTH, height: minWindowHeight(appId) };
|
|
default:
|
|
return { x: 0, y: minWindowTop(appId), width: SIDEBAR_WIDTH, height: minWindowHeight(appId) };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Which lines the chrome draws round the foreground window (Settings >
|
|
* Customization > Border): all of them, only the one between the window and
|
|
* the status bar, or none. The choice is a bottom or popup switcher's; a
|
|
* side strip always has its lines.
|
|
*/
|
|
export function windowBorder(): WindowBorder {
|
|
return sideStrip() ? "all" : windowBorderSetting.get();
|
|
}
|
|
|
|
/**
|
|
* Whether the foreground window's content gets a rounded frame (drawn by
|
|
* the chrome layer): with every border line on (windowBorder), where
|
|
* there's room. Its left and right sides take the pixel just outside the
|
|
* 576-wide window; there's no room around a Full Screen or immersive
|
|
* window, nor need beside a side strip. With a reserved bottom switcher
|
|
* row, the row's top edge is the frame's bottom side, as the window
|
|
* header's last row is its top. With a popup switcher, its top and bottom
|
|
* take a header or footer row of their own, except where the status bar's
|
|
* row next to the window serves.
|
|
*/
|
|
export function windowFramed(appId?: string): boolean {
|
|
if (fullWidth(appId) || windowBorder() !== "all") return false;
|
|
switch (switcherPosition()) {
|
|
case "bottom":
|
|
return switcherRowHeight(appId) > 0;
|
|
case "popup":
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Whether a line divides a status bar with rows of its own (the top bar, or
|
|
* a popup switcher's at the bottom) from the window. A window frame's side
|
|
* is that line where there is one (chrome-layer.ts statusBarPlacement).
|
|
*/
|
|
export function statusBarDivider(): boolean {
|
|
return windowBorder() !== "none";
|
|
}
|
|
|
|
/**
|
|
* Whether a line runs along a bottom switcher's top edge, between it and
|
|
* the window: a window frame's bottom side, or straight across where the
|
|
* window has no room for a frame. As the status line alone, only where the
|
|
* status bar shares the row.
|
|
*/
|
|
export function switcherRowDivider(appId?: string): boolean {
|
|
const border = windowBorder();
|
|
return border === "all" || (border === "status" && statusInSwitcherRow(appId));
|
|
}
|
|
|
|
/**
|
|
* Whether the status bar shares the bottom switcher row instead of topping
|
|
* each window (Settings > Customization > Status bar position): only beside
|
|
* a reserved row, as the row over an immersive window shows just while it
|
|
* has focus.
|
|
*/
|
|
export function statusInSwitcherRow(appId?: string): boolean {
|
|
return switcherRowHeight(appId) > 0 && statusBarPositionSetting.get() === "bottom";
|
|
}
|
|
|
|
/**
|
|
* Which edge of the foreground window's band the status bar runs along
|
|
* (outside the switcher row): the top, or, with a popup switcher, the
|
|
* bottom too (Settings > Customization > Status bar position).
|
|
*/
|
|
export function statusBarEdge(): "top" | "bottom" {
|
|
return switcherPosition() === "popup" && statusBarPositionSetting.get() === "bottom" ? "bottom" : "top";
|
|
}
|
|
|
|
/**
|
|
* Whether the status bar shows only while a popup switcher is up, over the
|
|
* edge of the window's content, rather than always in rows of the band's
|
|
* own (Settings > Customization > Status bar visibility).
|
|
*/
|
|
export function statusBarOverlays(): boolean {
|
|
return switcherPosition() === "popup" && statusBarVisibilitySetting.get() === "switcher";
|
|
}
|
|
|
|
/**
|
|
* Rows the shell draws along one edge of each window's content: the status
|
|
* bar's (the top bar, as a header), the frame's side, or none. A bottom
|
|
* switcher row's band has no footer: the frame's bottom side is the row's
|
|
* top edge. An immersive window has neither.
|
|
*/
|
|
function windowEdgeHeight(edge: "top" | "bottom", appId?: string): number {
|
|
if (isImmersive(appId)) return 0;
|
|
if (switcherPosition() !== "popup") {
|
|
if (edge === "bottom") return 0;
|
|
return !statusInSwitcherRow(appId) ? TOP_BAR_HEIGHT : windowFramed(appId) ? 1 : 0;
|
|
}
|
|
if (!statusBarOverlays() && statusBarEdge() === edge) return TOP_BAR_HEIGHT;
|
|
return windowFramed(appId) ? 1 : 0;
|
|
}
|
|
|
|
/**
|
|
* Height of the header the shell draws over each window's content: the top
|
|
* bar; with the status bar elsewhere, just the row the window frame's top
|
|
* runs along, or nothing without a frame.
|
|
*/
|
|
export function windowHeaderHeight(appId?: string): number {
|
|
return windowEdgeHeight("top", appId);
|
|
}
|
|
|
|
/**
|
|
* Height of the footer the shell draws under each window's content, within
|
|
* its band: with a popup switcher, the status bar at the bottom, or the row
|
|
* the window frame's bottom runs along; else nothing.
|
|
*/
|
|
export function windowFooterHeight(appId?: string): number {
|
|
return windowEdgeHeight("bottom", appId);
|
|
}
|
|
|
|
/**
|
|
* Top edge (y) of the status bar's TOP_BAR_HEIGHT rows for a window: the
|
|
* band's first rows, or its last with the status bar at the bottom. Over
|
|
* the content when the status bar overlays (statusBarOverlays).
|
|
*/
|
|
export function statusBarTop(heightMode: WindowHeightMode, appId?: string): number {
|
|
const top = windowTop(heightMode, appId);
|
|
return statusBarEdge() === "bottom" ? top + windowBandHeight(heightMode, appId) - TOP_BAR_HEIGHT : top;
|
|
}
|
|
|
|
/**
|
|
* 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. A popup
|
|
* is modal: while it shows, the whole screen is the switcher's.
|
|
*/
|
|
export function isOnSwitcherEdge(x: number, y: number, heightMode: WindowHeightMode, appId?: string): boolean {
|
|
switch (switcherPosition()) {
|
|
case "popup":
|
|
return true;
|
|
case "bottom":
|
|
return y >= switcherRect(heightMode, appId).y;
|
|
case "right":
|
|
return x >= screenWidth() - SIDEBAR_WIDTH;
|
|
default:
|
|
return x < SIDEBAR_WIDTH;
|
|
}
|
|
}
|
|
|
|
/** Width of app windows: the screen's when Full Screen or immersive, else SIDEBAR_WIDTH less (576 on the G2). */
|
|
function appViewportWidth(appId?: string): number {
|
|
return fullWidth(appId) ? screenWidth() : screenWidth() - SIDEBAR_WIDTH;
|
|
}
|
|
|
|
/**
|
|
* Left edge (x) of app windows: past a left strip, centred above a bottom
|
|
* row (see SWITCHER_ROW_HEIGHT) or under a popup switcher, else the screen
|
|
* edge.
|
|
*/
|
|
export function appViewportLeft(appId?: string): number {
|
|
if (fullWidth(appId)) return 0;
|
|
switch (switcherPosition()) {
|
|
case "left":
|
|
return SIDEBAR_WIDTH;
|
|
case "bottom":
|
|
case "popup":
|
|
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 or a popup, where the windows' side margins,
|
|
* less the window frame's pixel, leave room for the shift; not while the
|
|
* given (foreground) app's windows are Full Screen or immersive, which have
|
|
* no margins.
|
|
*/
|
|
export function uiDepth(appId?: string): number {
|
|
return sideStrip() || fullWidth(appId) ? 0 : Number(uiDepthSetting.get());
|
|
}
|
|
|
|
/**
|
|
* In a band display mode, explicit app modes (including Use global) replace
|
|
* the requested height; the default keeps legacy per-window heights, such
|
|
* as tall terminal sessions. Tall, Full Screen and immersive windows are
|
|
* always the whole height.
|
|
*/
|
|
export function effectiveHeightMode(mode: WindowHeightMode, appId?: string): WindowHeightMode {
|
|
if (isImmersive(appId) || bandFraction(displayLayout(appId)) === undefined) return "max";
|
|
return appDisplayLayout(appId) === "default" ? mode : "min";
|
|
}
|
|
|
|
/**
|
|
* 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(screenWidth() / 2) - appViewportLeft();
|
|
}
|
|
|
|
/**
|
|
* On the color-key shell surface, pixel value 0 is transparent; 1 is the
|
|
* darkest opaque shade (identical to 0 after 4bpp quantization). Shell
|
|
* painting must use this for intentional black.
|
|
*/
|
|
export const SHELL_OPAQUE_BLACK = 1;
|
|
|
|
/**
|
|
* Windows come in three heights. "min" covers the same 288px band the stock
|
|
* 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's rows. All include the header the
|
|
* shell draws at the window's top edge (windowHeaderHeight) and any footer
|
|
* at its bottom (windowFooterHeight).
|
|
*/
|
|
export type WindowHeightMode = "min" | "medium" | "max";
|
|
|
|
/** Total height (header + content) of a min-height window on a screen with room for it: the G2's stock band. */
|
|
export const MIN_WINDOW_HEIGHT = 288;
|
|
|
|
/**
|
|
* Total height of a min-height window here: the stock 288px band, or the
|
|
* whole window area on a screen too short for it (the RayNeo iO's 220 rows).
|
|
*/
|
|
export function minWindowHeight(appId?: string): number {
|
|
return Math.min(MIN_WINDOW_HEIGHT, windowAreaHeight(appId));
|
|
}
|
|
|
|
/**
|
|
* Height of the screen area windows are placed in: the whole screen, less
|
|
* a bottom switcher's height.
|
|
*/
|
|
function windowAreaHeight(appId?: string): number {
|
|
return screenHeight() - switcherRowHeight(appId);
|
|
}
|
|
|
|
/** Total height (header + content + footer) of a window's band in the given mode. */
|
|
export function windowBandHeight(mode: WindowHeightMode, appId?: string): number {
|
|
switch (effectiveHeightMode(mode, appId)) {
|
|
case "max":
|
|
return windowAreaHeight(appId);
|
|
case "medium":
|
|
return Math.min(windowAreaHeight(appId), minWindowHeight(appId) + windowHeaderHeight(appId) + windowFooterHeight(appId));
|
|
default:
|
|
return minWindowHeight(appId);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fraction of the slack above a window band, from the band display mode's
|
|
* position: each band height distributes its own free space by the same
|
|
* fraction, so all heights sit consistently within the screen. Tall and
|
|
* Full Screen windows leave no slack.
|
|
*/
|
|
function verticalPositionFraction(appId?: string): number {
|
|
return bandFraction(displayLayout(appId)) ?? 0.5;
|
|
}
|
|
|
|
/**
|
|
* Top edge (y) of a min-height window. The sidebar and shell overlays always
|
|
* align to this band, even while a taller window is foreground.
|
|
*/
|
|
export function minWindowTop(appId?: string): number {
|
|
return windowTop("min", appId);
|
|
}
|
|
|
|
/**
|
|
* 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 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 {
|
|
const band = windowBandHeight(mode, appId);
|
|
const oneRowArea = screenHeight() - (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). */
|
|
export function appViewportSize(mode: WindowHeightMode, appId?: string): { width: number; height: number } {
|
|
return {
|
|
width: appViewportWidth(appId),
|
|
height: windowBandHeight(mode, appId) - windowHeaderHeight(appId) - windowFooterHeight(appId),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* What each edge of an app's windows touches (see viewport.ts EdgeKind): a
|
|
* line the chrome draws right outside it, or nothing. A framed window has a
|
|
* line on every side. Otherwise the top or bottom has one where a status bar
|
|
* with rows of its own, or a bottom switcher row, lies past it and the
|
|
* Border setting divides the two; a side has one only beside a side strip,
|
|
* whose separator it is. An immersive window has the whole panel, and so
|
|
* none.
|
|
*/
|
|
export function windowEdges(appId?: string): Edges<EdgeKind> {
|
|
if (isImmersive(appId)) return uniformEdges("offscreen");
|
|
if (windowFramed(appId)) return uniformEdges("border");
|
|
const position = switcherPosition();
|
|
const line = (drawn: boolean): EdgeKind => (drawn ? "border" : "offscreen");
|
|
const statusLine = (edge: "top" | "bottom") => windowEdgeHeight(edge, appId) === TOP_BAR_HEIGHT && statusBarDivider();
|
|
return {
|
|
top: line(statusLine("top")),
|
|
right: line(position === "right"),
|
|
bottom: line(position === "bottom" ? switcherRowHeight(appId) > 0 && switcherRowDivider(appId) : statusLine("bottom")),
|
|
left: line(position === "left"),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* A window's viewport as its layouts get it: the app-content size for its
|
|
* height mode, what its edges touch, and the padding suggested for them.
|
|
*/
|
|
export function appViewport(mode: WindowHeightMode, appId?: string): Viewport {
|
|
return viewportWith(appViewportSize(mode, appId), windowEdges(appId));
|
|
}
|
|
|
|
/** Screen rect of a window's app-content viewport (between its header and footer). */
|
|
export function appViewportRect(mode: WindowHeightMode, appId?: string): {
|
|
x: number;
|
|
y: number;
|
|
width: number;
|
|
height: number;
|
|
} {
|
|
return {
|
|
x: appViewportLeft(appId),
|
|
y: windowTop(mode, appId) + windowHeaderHeight(appId),
|
|
...appViewportSize(mode, appId),
|
|
};
|
|
}
|
|
|
|
export type ScreenRect = { x: number; y: number; width: number; height: number };
|
|
|
|
function unionRect(a: ScreenRect, b: ScreenRect): ScreenRect {
|
|
const x = Math.min(a.x, b.x);
|
|
const y = Math.min(a.y, b.y);
|
|
return {
|
|
x,
|
|
y,
|
|
width: Math.max(a.x + a.width, b.x + b.width) - x,
|
|
height: Math.max(a.y + a.height, b.y + b.height) - y,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* The part of the screen the shell draws in while the given (foreground)
|
|
* window is up: the window's band, plus the frame's side pixels; the
|
|
* min-height band the shell overlays align to; and a side strip or bottom
|
|
* row (a popup shows within the window's content). An immersive window has
|
|
* the whole panel. The phone mirror's Scaled preview zooms to this.
|
|
*/
|
|
export function usedScreenRect(heightMode: WindowHeightMode, appId?: string): ScreenRect {
|
|
if (isImmersive(appId)) return { x: 0, y: 0, width: screenWidth(), height: screenHeight() };
|
|
const frame = windowFramed(appId) ? 1 : 0;
|
|
const x = appViewportLeft(appId) - frame;
|
|
const width = appViewportWidth(appId) + 2 * frame;
|
|
let used = unionRect(
|
|
{ x, y: windowTop(heightMode, appId), width, height: windowBandHeight(heightMode, appId) },
|
|
{ x, y: minWindowTop(appId), width, height: minWindowHeight(appId) },
|
|
);
|
|
if (switcherPosition() !== "popup") used = unionRect(used, switcherRect(heightMode, appId));
|
|
return used;
|
|
}
|
|
|
|
/**
|
|
* The screen area the phone mirror shows to present `used` as large as it
|
|
* fits, centred, at the screen's own aspect (4:3 on the G2, 27:11 on the iO),
|
|
* so the mirror keeps its shape whatever the display mode: `used` grown along
|
|
* one axis, past the screen's edges if need be (the mirror shows black there).
|
|
*/
|
|
export function phonePreviewRect(used: ScreenRect): ScreenRect {
|
|
// Whole aspect units, so the aspect is exact.
|
|
const gcd = (a: number, b: number): number => (b ? gcd(b, a % b) : a);
|
|
const unit = gcd(screenWidth(), screenHeight());
|
|
const aspectW = screenWidth() / unit, aspectH = screenHeight() / unit;
|
|
const units = Math.ceil(Math.max(used.width / aspectW, used.height / aspectH));
|
|
const width = units * aspectW;
|
|
const height = units * aspectH;
|
|
return {
|
|
x: Math.round(used.x + (used.width - width) / 2),
|
|
y: Math.round(used.y + (used.height - height) / 2),
|
|
width,
|
|
height,
|
|
};
|
|
}
|