LG webOS TV launcher: a fast, remote-first home screen with live video wallpapers, widgets, Jellyfin, Moonlight game streaming and Home Assistant. Native Rust + OpenGL ES.
//! Home widgets on screen: the blocks and the text line right of the
//! headline, the full-screen pages they open, and edit mode. Geometry follows
//! the approved mockup (Home widgets v32): 322 px blocks on the Home grid,
//! one 28 px plate radius, nested plates concentric (outer − padding).
use super::*;
use crate::{
smart_home::Entity,
weather::Reading,
weather_sky::Mood,
widgets::{self as w, Block, Detail, Kind, RADIUS, Size},
widgets_state::{
hdmi_inputs, input_live, input_name, smart_camera, smart_devices, smart_sensor,
},
};
const GREEN: u32 = 0x8fe3a8;
const RED: u32 = 0xffa98f;
/// Block top before scroll: 2 px under the old weather card, same bottom edge.
const BLOCK_TOP: f32 = WEATHER_TOP + 2.;
/// Index for previews: never focused, never a real block.
pub(super) const PREVIEW: usize = usize::MAX;
fn ts(assets: &Assets, size: f32, weight: u16) -> TextStyle {
weather_type(assets, size, weight, false)
}
fn td(assets: &Assets, size: f32) -> TextStyle {
weather_type(assets, size, 700, true)
}
fn trend(pct: f64) -> Color {
c(if pct >= 0. { GREEN } else { RED }, 1.)
}
/// Text with a soft dark copy under it, so light type reads on any sky.
fn lifted(out: &mut Scene, value: &str, r: Rect, style: TextStyle, color: Color, center: bool) {
out.text(
value,
Rect::new(r.x, r.y + 2., r.w, r.h),
style,
c(0x071325, 0.3 * color[3]),
center,
);
out.text(value, r, style, color, center);
}
fn width(assets: &Assets, value: &str, style: TextStyle) -> f32 {
// ▲ and ▼ render from a fallback font the metrics table does not know.
let arrows = value.chars().filter(|c| matches!(c, '▲' | '▼')).count() as f32;
assets.width(value, style).ceil() + 2. + arrows * style.size * 0.7
}
// ------------------------------------------------------------------ layout
pub(super) fn available(state: &State, kind: Kind) -> bool {
match kind {
Kind::Weather => state.preferences.show_weather,
Kind::Crypto => true,
Kind::Hdmi => !state.inventory.inputs.is_empty(),
Kind::Smart => !state.preferences.smart_home.server_url.is_empty(),
}
}
pub(super) struct Zone {
/// (index in preferences, block, screen rect).
pub blocks: Vec<(usize, Block, Rect)>,
pub text: Vec<(usize, Kind)>,
pub left: f32,
pub top: f32,
}
pub(super) fn zone(state: &State) -> Zone {
let prefs = &state.preferences.widgets;
let blocks: Vec<(usize, Block)> = prefs
.blocks
.iter()
.copied()
.enumerate()
.filter(|(_, b)| available(state, b.kind))
.collect();
let text: Vec<(usize, Kind)> = prefs
.text
.iter()
.copied()
.enumerate()
.filter(|(_, k)| available(state, *k))
.collect();
let only: Vec<Block> = blocks.iter().map(|b| b.1).collect();
let layout = w::layout(
&only,
!text.is_empty(),
HOME_TILE_PITCH,
HOME_TILE_WIDTH,
crate::state::HOME_STRIP_RIGHT,
);
let top =
BLOCK_TOP + HOME_DROP - state.scroll - state.bounce_at(crate::state::BounceAxis::Page);
Zone {
blocks: blocks
.into_iter()
.zip(layout.blocks)
.map(|((i, b), (x, wd))| (i, b, Rect::new(x, top, wd, w::BLOCK_H)))
.collect(),
text,
left: layout.left,
top,
}
}
/// Headline wrap width: it stops 44 px before the widgets.
pub(super) fn phrase_width(state: &State) -> f32 {
(zone(state).left - 44. - crate::state::HOME_STRIP_LEFT).clamp(520., PHRASE_W)
}
/// Bottom of the blocks before scroll, for the Favorites offset.
pub(super) fn bottom() -> f32 {
BLOCK_TOP + w::BLOCK_H
}
// --------------------------------------------------------------- Home zone
pub(super) fn home(out: &mut Scene, state: &State, assets: &Assets) {
let z = zone(state);
let edit = state.widget_edit;
if edit.is_some() {
// Edit mode: everything but the widgets steps back.
out.shape(Rect::new(0., 0., 1920., 1080.), 0., c(0x000000, 0.5));
}
if !z.text.is_empty() {
let start = out.draw.len();
text_line(out, state, assets, &z);
out.enter(start, state, 0.21, 29.);
}
let grab = edit.and_then(|e| e.grab);
for (n, (i, b, r)) in z.blocks.iter().enumerate() {
if grab.is_some_and(|g| g.index == *i) {
// Where the carried widget lands.
out.shape(*r, RADIUS, c(0xffffff, 0.05));
out.border(*r, RADIUS, 3., c(0xffffff, 0.45));
continue;
}
let start = out.draw.len();
block(out, state, assets, *i, *b, *r);
out.enter(start, state, 0.21 + n as f32 * motion::STAGGER, 29.);
}
if edit.is_some() {
edit_chrome(out, state, assets, &z);
}
if let Some(g) = grab
&& let Some((i, b, r)) = z.blocks.iter().find(|(i, _, _)| *i == g.index)
{
let at = Rect::new(g.at.0 - g.offset.0, g.at.1 - g.offset.1, r.w, r.h);
let start = out.draw.len();
out.shadow(at, RADIUS, 80., 34., 0.6);
block(out, state, assets, *i, *b, at);
out.focus_ring(at, RADIUS, 1., state);
let (cx, cy) = at.center();
scale_group(&mut out.draw[start..], cx, cy, 1.03);
// The carried widget has no hit box of its own.
out.controls.retain(|c| c.target != Target::Widget(*i));
out.control(Target::Widget(*i), *r, true);
}
}
/// One block at `r`. `index` is its place in preferences; PREVIEW draws it
/// without focus or controls.
pub(super) fn block(
out: &mut Scene,
state: &State,
assets: &Assets,
index: usize,
b: Block,
r: Rect,
) {
let target = Target::Widget(index);
let level = if index == PREVIEW {
0.
} else {
state.focus_level(&target)
};
let controls = out.controls.len();
let whole = match b.kind {
Kind::Weather => {
weather_block(out, state, assets, b.size, r);
true
}
Kind::Crypto => {
crypto_block(out, state, assets, b.size, r);
true
}
Kind::Hdmi => hdmi_block(out, state, assets, index, b.size, r),
Kind::Smart => smart_block(out, state, assets, index, b.size, r),
};
if whole {
out.focus_ring(r, RADIUS, level, state);
}
if index == PREVIEW {
out.controls.truncate(controls);
} else if whole {
out.controls.insert(
controls,
Control {
target,
rect: r,
scrollable: true,
},
);
}
}
// ----------------------------------------------------------------- weather
fn synthetic(code: u8, is_day: bool, temperature: f64) -> Reading {
Reading {
temperature,
code,
is_day,
wind_speed: 0.,
temperature_3h_ago: None,
hours: [None; 5],
}
}
/// The sky mood and reading Home shows; desktop QA can force a mood with
/// LUMA_WEATHER_PREVIEW_MOOD.
pub(super) fn weather_now(state: &State) -> (Mood, Option<Reading>) {
let real = state
.preferences
.weather_location
.as_ref()
.and_then(|place| state.weather.reading(place));
#[cfg(debug_assertions)]
let preview = std::env::var("LUMA_WEATHER_PREVIEW_MOOD")
.ok()
.and_then(|name| Mood::from_name(&name));
#[cfg(not(debug_assertions))]
let preview: Option<Mood> = None;
let mood = preview
.or_else(|| real.map(Mood::from_reading))
.unwrap_or(Mood::Clear);
let fallback = preview.map(|m| {
let code = match m {
Mood::Clear | Mood::Wind | Mood::Night => 0,
Mood::Partly | Mood::NightCloudy => 2,
Mood::Cloudy => 3,
Mood::Fog => 45,
Mood::Rain => 61,
Mood::Storm => 95,
Mood::Snow => 71,
};
let mut r = synthetic(code, !matches!(m, Mood::Night | Mood::NightCloudy), 22.);
for (i, h) in r.hours.iter_mut().enumerate() {
*h = Some(crate::weather::HourForecast {
hour: (14 + i as u8) % 24,
temperature: 23. + i as f64,
code,
is_day: true,
});
}
r
});
(mood, real.or(fallback))
}
fn forecast(state: &State) -> Option<&w::Forecast> {
let key = state.preferences.weather_location.as_ref()?.key();
state.widget_data.forecast.as_ref().filter(|f| f.key == key)
}
fn temp(state: &State, value: f64) -> String {
weather::format_temperature(value, state.preferences.temperature_unit)
}
/// Compact temperature for rows and columns: "14°".
fn deg(state: &State, value: f64) -> String {
temp(state, value).trim_end_matches(['C', 'F']).to_owned()
}
fn condition_text(state: &State, r: Reading) -> String {
state
.preferences
.language
.t(weather::condition(r).key)
.to_owned()
}
fn high_low(state: &State) -> Option<String> {
let d = forecast(state)?.days.first()?;
Some(format!("H {} L {}", deg(state, d.max), deg(state, d.min)))
}
fn city(state: &State) -> String {
state
.preferences
.weather_location
.as_ref()
.map_or_else(|| "Set weather location".to_owned(), |l| l.name.clone())
}
fn hero_icon(mood: Mood, r: Reading) -> &'static str {
match mood {
Mood::Night => "weather-moon",
Mood::NightCloudy | Mood::Wind => "weather-cloud",
_ => condition_icon(weather::condition(r).icon),
}
}
/// The condition icon with the pulsing sun glow, centered on (cx, cy).
fn hero(
out: &mut Scene,
state: &State,
assets: &Assets,
mood: Mood,
r: Reading,
at: (f32, f32),
d: f32,
) {
if matches!(mood, Mood::Clear | Mood::Partly) {
let pulse = 1.
+ if state.preferences.reduced_motion {
0.
} else {
0.06 * (state.page_started.elapsed().as_secs_f32() * 1.2).sin()
};
let g = d * 1.45 * pulse;
out.draw.push(Draw::TintedImage(
assets.path("weather-sky/glow.png"),
Rect::new(at.0 - g / 2., at.1 - g / 2., g, g),
0.,
false,
[1., 1., 1., 0.7],
));
}
out.icon(
assets,
hero_icon(mood, r),
Rect::new(at.0 - d / 2., at.1 - d / 2., d, d),
c(0xfff8ef, 1.),
);
}
fn city_line(out: &mut Scene, state: &State, assets: &Assets, x: f32, y: f32, max: f32, size: f32) {
let style = ts(assets, size, 500);
let icon = size;
out.icon(
assets,
"location",
Rect::new(x, y + (size * 1.36 - icon) / 2., icon, icon),
c(0xffffff, 0.92),
);
lifted(
out,
&clip_weather_line(&city(state), max - icon - 8., style, assets),
Rect::new(x + icon + 8., y, max - icon - 8., size * 1.4),
style,
c(0xffffff, 0.92),
false,
);
}
fn sky_plate(out: &mut Scene, state: &State, assets: &Assets, r: Rect, radius: f32, mood: Mood) {
out.shadow(r, radius, 24., 8., 0.16);
// The sky is translucent: frost under it so the wallpaper never shows through sharp.
out.frost(r, radius);
crate::weather_sky::draw(
&mut out.draw,
&assets.root,
r,
radius,
mood,
state.page_started.elapsed().as_secs_f32(),
state.preferences.reduced_motion,
);
out.border(r, radius, 1., c(0xffffff, 0.14));
}
fn weather_block(out: &mut Scene, state: &State, assets: &Assets, size: Size, r: Rect) {
let (mood, reading) = weather_now(state);
sky_plate(out, state, assets, r, RADIUS, mood);
let Some(now) = reading else {
let message = if state.weather.loading {
"Updating forecast"
} else if state.preferences.weather_location.is_none() {
"Choose a city in Settings"
} else {
"Forecast unavailable"
};
let style = ts(assets, 22., 600);
out.text(
clip_weather_line(message, r.w - 44., style, assets),
Rect::new(r.x + 22., r.y + r.h / 2. - 16., r.w - 44., 32.),
style,
WHITE,
size != Size::L,
);
return;
};
match size {
Size::S => weather_s(out, state, assets, r, mood, now),
Size::L => weather_l(out, state, assets, r, mood, now),
_ => weather_m(out, state, assets, r, mood, now),
}
}
fn weather_s(out: &mut Scene, state: &State, assets: &Assets, r: Rect, mood: Mood, now: Reading) {
// Under the temperature, right: a wide reading never runs into it.
hero(
out,
state,
assets,
mood,
now,
(r.x + r.w - 66., r.y + 186.),
84.,
);
city_line(out, state, assets, r.x + 22., r.y + 20., 150., 18.);
lifted(
out,
&temp(state, now.temperature),
Rect::new(r.x + 22., r.y + 49., r.w - 44., 80.),
td(assets, 68.),
WHITE,
false,
);
let mut y = r.y + r.h - 20.;
if let Some(hl) = high_low(state) {
y -= 25.;
lifted(
out,
&hl,
Rect::new(r.x + 22., y, r.w - 44., 25.),
ts(assets, 18., 500),
c(0xffffff, 0.85),
false,
);
}
let style = ts(assets, 20., 500);
lifted(
out,
&clip_weather_line(&condition_text(state, now), r.w - 44., style, assets),
Rect::new(r.x + 22., y - 28., r.w - 44., 28.),
style,
WHITE,
false,
);
}
fn weather_m(out: &mut Scene, state: &State, assets: &Assets, r: Rect, mood: Mood, now: Reading) {
hero(
out,
state,
assets,
mood,
now,
(r.x + r.w - 92., r.y + 92.),
108.,
);
city_line(out, state, assets, r.x + 20., r.y + 22., r.w - 200., 20.);
let t = temp(state, now.temperature);
let big = td(assets, 72.);
lifted(
out,
&t,
Rect::new(r.x + 20., r.y + 50., 300., 86.),
big,
WHITE,
false,
);
let x = r.x + 20. + width(assets, &t, big) + 16.;
let side = (r.x + r.w - 170. - x).max(80.);
let style = ts(assets, 22., 500);
lifted(
out,
&clip_weather_line(&condition_text(state, now), side, style, assets),
Rect::new(x, r.y + 63., side, 30.),
style,
WHITE,
false,
);
if let Some(hl) = high_low(state) {
lifted(
out,
&hl,
Rect::new(x, r.y + 95., side, 25.),
ts(assets, 18., 500),
c(0xffffff, 0.85),
false,
);
}
// Six-hour strip, concentric with the plate: inset 20, radius 28 − 20.
let strip = Rect::new(r.x + 20., r.y + r.h - 20. - 76., r.w - 40., 76.);
out.shape(strip, w::inner_radius(RADIUS, 20.), c(0xffffff, 0.14));
let cell = (strip.w - 12.) / 6.;
for i in 0..6usize {
let x = strip.x + 6. + i as f32 * cell;
let (label, value) = if i == 0 {
("Now".to_owned(), deg(state, now.temperature))
} else if let Some(h) = now.hours[i - 1] {
(format!("{:02}:00", h.hour), deg(state, h.temperature))
} else {
("--".into(), "--".into())
};
let delay = 0.1 + i as f32 * 0.05;
let alpha = if state.preferences.reduced_motion {
1.
} else {
motion::progress(state.page_started.elapsed().as_secs_f32() - delay, 0.4)
};
out.text(
label,
Rect::new(x, strip.y + 10., cell, 25.),
ts(assets, 18., 500),
c(0xffffff, 0.85 * alpha),
true,
);
out.text(
value,
Rect::new(x, strip.y + 36., cell, 30.),
ts(assets, 22., 600),
c(0xffffff, alpha),
true,
);
}
}
fn weather_l(out: &mut Scene, state: &State, assets: &Assets, r: Rect, mood: Mood, now: Reading) {
let left = Rect::new(r.x + 26., r.y + 22., 330., r.h - 44.);
city_line(out, state, assets, left.x, left.y, left.w, 20.);
lifted(
out,
&temp(state, now.temperature),
Rect::new(left.x, left.y + 31., left.w, 86.),
td(assets, 72.),
WHITE,
false,
);
let style = ts(assets, 22., 500);
lifted(
out,
&clip_weather_line(&condition_text(state, now), left.w, style, assets),
Rect::new(left.x, left.y + 113., left.w, 30.),
style,
WHITE,
false,
);
if let Some(hl) = high_low(state) {
lifted(
out,
&hl,
Rect::new(left.x, left.y + 143., left.w, 25.),
ts(assets, 18., 500),
c(0xffffff, 0.85),
false,
);
}
if let Some(f) = forecast(state) {
let line = format!(
"Wind {:.0} m/s · Humidity {:.0}% · UV {:.0}",
f.wind_ms, f.humidity, f.uv
);
let style = ts(assets, 18., 500);
lifted(
out,
&clip_weather_line(&line, left.w, style, assets),
Rect::new(left.x, left.y + left.h - 25., left.w, 25.),
style,
c(0xffffff, 0.85),
false,
);
}
// Five days on a panel inset 16, radius 28 − 16.
let panel = Rect::new(left.x + left.w + 28., r.y + 16., 0., r.h - 32.);
let panel = Rect::new(panel.x, panel.y, r.x + r.w - 16. - panel.x, panel.h);
out.shape(panel, w::inner_radius(RADIUS, 16.), c(0xffffff, 0.14));
let Some(f) = forecast(state) else {
hero(out, state, assets, mood, now, panel.center(), 108.);
return;
};
days(
out,
state,
assets,
&f.days,
5,
Rect::new(panel.x + 20., panel.y + 12., panel.w - 40., panel.h - 24.),
DayScale {
size: 20.,
icon: 28.,
},
);
}
/// Text size and icon side of the day rows.
struct DayScale {
size: f32,
icon: f32,
}
/// Day rows: label, icon, low, range bar, high. Rows share `r` evenly.
fn days(
out: &mut Scene,
state: &State,
assets: &Assets,
list: &[w::Day],
n: usize,
r: Rect,
scale: DayScale,
) {
let DayScale { size, icon } = scale;
let shown = &list[..list.len().min(n)];
if shown.is_empty() {
return;
}
let lo = shown.iter().map(|d| d.min).fold(f64::MAX, f64::min);
let hi = shown.iter().map(|d| d.max).fold(f64::MIN, f64::max);
let span = (hi - lo).max(1.);
let row = r.h / n as f32;
let style = ts(assets, size, 500);
let label_w = size * 3.6;
let num_w = size * 2.6;
for (i, d) in shown.iter().enumerate() {
let y = r.y + i as f32 * row;
let mid = y + row / 2.;
if i > 0 && size > 20. {
out.shape(Rect::new(r.x, y, r.w, 1.), 0., c(0xffffff, 0.10));
}
let label = if i == 0 {
"Today"
} else {
w::WEEKDAYS[d.weekday as usize % 7]
};
let th = size * 1.4;
out.text(
label,
Rect::new(r.x, mid - th / 2., label_w, th),
style,
WHITE,
false,
);
let ix = r.x + label_w + 4.;
out.icon(
assets,
condition_icon(weather::condition(synthetic(d.code, true, d.max)).icon),
Rect::new(ix, mid - icon / 2., icon, icon),
WHITE,
);
let low_x = ix + icon + 14.;
out.text(
deg(state, d.min),
Rect::new(low_x, mid - th / 2., num_w, th),
style.right(),
c(0xffffff, 0.72),
false,
);
let bar_x = low_x + num_w + 14.;
let bar_w = r.x + r.w - num_w - 14. - bar_x;
let bar = Rect::new(bar_x, mid - 3., bar_w.max(20.), 6.);
out.shape(bar, 3., c(0xffffff, 0.18));
let a = ((d.min - lo) / span) as f32;
let b = ((d.max - lo) / span) as f32;
let seg = Rect::new(bar.x + bar.w * a, bar.y, (bar.w * (b - a)).max(6.), 6.);
out.draw
.push(Draw::HGradient(seg, 3., c(0x9fe3f5, 1.), c(0xffd36b, 1.)));
out.text(
deg(state, d.max),
Rect::new(r.x + r.w - num_w, mid - th / 2., num_w, th),
style.right(),
WHITE,
false,
);
}
}
// ------------------------------------------------------------------ crypto
fn coin_disc(out: &mut Scene, assets: &Assets, symbol: &str, x: f32, y: f32, d: f32) {
let (_, color, glyph) = w::coin(symbol);
let r = Rect::new(x, y, d, d);
out.shape(r, d / 2., c(color, 1.));
// Never under the 18 px TV minimum, even in the 26 px text-line disc.
let g = (d * 0.6).max(18.);
let style = ts(assets, g, 600);
out.text(
glyph,
Rect::new(x, y + (d - g * 1.36) / 2., d, g * 1.36),
style,
WHITE,
true,
);
}
fn pair_quote(prefs: &w::WidgetPrefs) -> &str {
match (prefs.exchange, prefs.quote.as_str()) {
(w::Exchange::Binance | w::Exchange::Bybit | w::Exchange::Okx, "USD") => "USDT",
(_, q) => q,
}
}
fn price(state: &State, value: f64) -> String {
w::format_price(value, &state.preferences.widgets.quote)
}
/// A line through `series` (oldest first) with an optional soft area below.
/// The renderer has no line primitive: the line is a chain of small discs,
/// the area a run of 2 px vertical gradients.
pub(super) fn sparkline(
out: &mut Scene,
series: &[f64],
r: Rect,
color: u32,
line: f32,
area: bool,
) {
if series.len() < 2 || r.w < 4. {
return;
}
let lo = series.iter().copied().fold(f64::MAX, f64::min);
let hi = series.iter().copied().fold(f64::MIN, f64::max);
let span = (hi - lo).max(hi.abs() * 1e-6).max(1e-12);
let value = |u: f32| {
let p = u * (series.len() - 1) as f32;
let i = (p.floor() as usize).min(series.len() - 2);
let k = (p - i as f32) as f64;
series[i] * (1. - k) + series[i + 1] * k
};
let y_of = |v: f64| r.y + r.h - ((v - lo) / span) as f32 * r.h;
let steps = (r.w / 2.).ceil() as usize;
if area {
for k in 0..steps {
let x = r.x + k as f32 * 2.;
let y = y_of(value((k as f32 * 2. / r.w).min(1.)));
out.draw.push(Draw::RoundedGradient(
Rect::new(x, y, 2.4, r.y + r.h - y),
0.,
c(color, 0.26),
c(color, 0.),
));
}
}
let half = line / 2.;
let mut prev: Option<(f32, f32)> = None;
for k in 0..=steps {
let u = (k as f32 * 2. / r.w).min(1.);
let p = (r.x + u * r.w, y_of(value(u)));
let from = prev.unwrap_or(p);
let dist = ((p.0 - from.0).powi(2) + (p.1 - from.1).powi(2)).sqrt();
let n = (dist / (line * 0.45)).ceil().max(1.) as usize;
for j in 1..=n {
let t = j as f32 / n as f32;
let (x, y) = (from.0 + (p.0 - from.0) * t, from.1 + (p.1 - from.1) * t);
out.shape(
Rect::new(x - half, y - half, line, line),
half,
c(color, 1.),
);
}
prev = Some(p);
}
}
fn crypto_status(state: &State) -> &'static str {
if state.widget_data.quotes_failed {
"Prices unavailable"
} else {
"Loading prices"
}
}
fn crypto_block(out: &mut Scene, state: &State, assets: &Assets, size: Size, r: Rect) {
out.glass(r, RADIUS);
let prefs = &state.preferences.widgets;
let coins = prefs.ordered_coins();
match size {
Size::S => {
let symbol = &coins[0];
coin_disc(out, assets, symbol, r.x + 22., r.y + 22., 34.);
out.text(
symbol,
Rect::new(r.x + 66., r.y + 24., 100., 30.),
ts(assets, 22., 600),
WHITE,
false,
);
out.text(
prefs.exchange.short(),
Rect::new(r.x + r.w - 22. - 120., r.y + 26., 120., 26.),
ts(assets, 18., 500).right(),
c(0xffffff, 0.7),
false,
);
let Some(q) = state.widget_data.quote(symbol) else {
out.text(
crypto_status(state),
Rect::new(r.x + 22., r.y + 80., r.w - 44., 30.),
ts(assets, 20., 500),
c(0xffffff, 0.7),
false,
);
return;
};
let style = td(assets, 40.);
out.text(
clip_weather_line(&price(state, q.price), r.w - 44., style, assets),
Rect::new(r.x + 22., r.y + 68., r.w - 44., 48.),
style,
WHITE,
false,
);
out.text(
format!(
"{} · {}",
w::format_change(q.change_pct),
prefs.period.label().to_lowercase()
),
Rect::new(r.x + 22., r.y + 118., r.w - 44., 28.),
ts(assets, 20., 500),
trend(q.change_pct),
false,
);
sparkline(
out,
&q.series,
Rect::new(r.x + 22., r.y + r.h - 18. - 110., r.w - 44., 104.),
if q.change_pct >= 0. { GREEN } else { RED },
3.,
true,
);
}
Size::M => {
let inner = Rect::new(r.x + 24., r.y + 18., r.w - 48., r.h - 36.);
let row = 70.;
let gap = (inner.h - 3. * row) / 2.;
for (i, symbol) in coins.iter().take(3).enumerate() {
let y = inner.y + i as f32 * (row + gap);
if i > 0 {
out.shape(
Rect::new(inner.x, y - gap / 2., inner.w, 1.),
0.,
c(0xffffff, 0.08),
);
}
coin_row(
out,
state,
assets,
symbol,
Rect::new(inner.x, y, inner.w, row),
true,
);
}
}
_ => {
let symbol = &coins[0];
let left = Rect::new(r.x + 24., r.y + 22., 520., r.h - 44.);
coin_disc(out, assets, symbol, left.x, left.y, 36.);
let name = w::coin(symbol).0;
let ns = ts(assets, 22., 600);
let name = if name.is_empty() {
symbol.as_str()
} else {
name
};
out.text(
name,
Rect::new(left.x + 48., left.y + 3., 200., 30.),
ns,
WHITE,
false,
);
out.text(
format!(
"{symbol}/{} · {}",
pair_quote(prefs),
prefs.exchange.short()
),
Rect::new(
left.x + 48. + width(assets, name, ns) + 12.,
left.y + 6.,
300.,
26.,
),
ts(assets, 18., 500),
c(0xffffff, 0.7),
false,
);
if let Some(q) = state.widget_data.quote(symbol) {
let big = td(assets, 48.);
let p = price(state, q.price);
out.text(
&p,
Rect::new(left.x, left.y + 44., 360., 60.),
big,
WHITE,
false,
);
out.text(
format!(
"{} · {}",
w::format_change(q.change_pct),
prefs.period.label().to_lowercase()
),
Rect::new(
left.x + width(assets, &p, big) + 14.,
left.y + 66.,
220.,
28.,
),
ts(assets, 20., 500),
trend(q.change_pct),
false,
);
sparkline(
out,
&q.series,
Rect::new(left.x, left.y + 124., left.w, left.h - 128.),
if q.change_pct >= 0. { GREEN } else { RED },
3.,
true,
);
} else {
out.text(
crypto_status(state),
Rect::new(left.x, left.y + 60., left.w, 30.),
ts(assets, 20., 500),
c(0xffffff, 0.7),
false,
);
}
let x = left.x + left.w + 24.;
out.shape(
Rect::new(x, r.y + 22., 1., r.h - 44.),
0.,
c(0xffffff, 0.08),
);
let list = Rect::new(x + 24., r.y + 22., r.x + r.w - 24. - x - 24., r.h - 44.);
let rest: Vec<&String> = coins.iter().skip(1).take(3).collect();
let row = 56.;
let gap = (list.h - 3. * row) / 2.;
for (i, symbol) in rest.into_iter().enumerate() {
let y = list.y + i as f32 * (row + gap);
coin_row(
out,
state,
assets,
symbol,
Rect::new(list.x, y, list.w, row),
false,
);
}
}
}
}
/// Coin row of the M and L widgets: disc, symbol (and name), price and change.
fn coin_row(out: &mut Scene, state: &State, assets: &Assets, symbol: &str, r: Rect, full: bool) {
let d = if full { 40. } else { 32. };
let mid = r.y + r.h / 2.;
coin_disc(out, assets, symbol, r.x, mid - d / 2., d);
let x = r.x + d + if full { 14. } else { 12. };
if full {
out.text(
symbol,
Rect::new(x, mid - 29., 120., 30.),
ts(assets, 22., 600),
WHITE,
false,
);
out.text(
w::coin(symbol).0,
Rect::new(x, mid + 1., 120., 25.),
ts(assets, 18., 500),
c(0xffffff, 0.65),
false,
);
} else {
out.text(
symbol,
Rect::new(x, mid - 15., 100., 30.),
ts(assets, 22., 600),
WHITE,
false,
);
}
let Some(q) = state.widget_data.quote(symbol) else {
out.text(
"—",
Rect::new(r.x + r.w - 140., mid - 15., 140., 30.),
ts(assets, 22., 600).right(),
c(0xffffff, 0.5),
false,
);
return;
};
let ps = ts(assets, if full { 24. } else { 22. }, 600);
out.text(
price(state, q.price),
Rect::new(r.x + r.w - 160., mid - 30., 160., 32.),
ps.right(),
WHITE,
false,
);
out.text(
w::format_change(q.change_pct),
Rect::new(r.x + r.w - 160., mid + 2., 160., 25.),
ts(assets, 18., 500).right(),
trend(q.change_pct),
false,
);
if full {
let spark = Rect::new(x + 130., mid - 18., r.w - (x + 130. - r.x) - 180., 36.);
sparkline(
out,
&q.series,
spark,
if q.change_pct >= 0. { GREEN } else { RED },
2.5,
false,
);
}
}
// -------------------------------------------------------------------- HDMI
fn device_colors(icon: &str) -> (u32, u32) {
match icon {
"playstation" => (0x2a4cae, 0x1c2f6a),
"computer" => (0x4f3496, 0x2f205e),
"console" => (0x2f7d4a, 0x1d4b2e),
"streamer" => (0x8a3b2c, 0x52231a),
_ => (0x41464f, 0x2c3037),
}
}
fn input_tile(
out: &mut Scene,
state: &State,
assets: &Assets,
input: &Input,
r: Rect,
radius: f32,
big: bool,
) {
let custom = state
.preferences
.input_names
.get(&input.id)
.map(String::as_str);
let icon = input_icon(input, custom);
let (a, b) = device_colors(icon);
out.draw
.push(Draw::RoundedGradient(r, radius, c(a, 1.), c(b, 1.)));
let live = input_live(input);
let d = if big { 132. } else { 104. };
out.icon(
assets,
&format!("input-{icon}"),
Rect::new(
r.x + (r.w - d) / 2.,
r.y + (r.h - d) / 2. - if big { 6. } else { 18. },
d,
d,
),
c(0xffffff, if live { 1. } else { 0.55 }),
);
let name = input_name(state, input);
let style = ts(assets, 26., 600);
out.text(
clip_weather_line(&name, r.w - 36., style, assets),
Rect::new(r.x + 18., r.y + r.h - 16. - 36., r.w - 36., 36.),
style,
WHITE,
false,
);
if big {
// Port and signal chips, top left.
let mut x = r.x + 26.;
for label in [
input.port.clone(),
if live {
"Signal".to_owned()
} else {
"No signal".to_owned()
},
] {
if label.is_empty() {
continue;
}
let cs = ts(assets, 18., 500);
let cw = width(assets, &label, cs) + 28.;
let chip = Rect::new(x, r.y + 24., cw, 36.);
out.shape(chip, 18., c(0x000000, 0.45));
out.text(
label,
Rect::new(chip.x, chip.y + 5., chip.w, 26.),
cs,
WHITE,
true,
);
x += cw + 8.;
}
}
}
/// Returns whether the whole block is one control (M) or tiles (L).
fn hdmi_block(
out: &mut Scene,
state: &State,
assets: &Assets,
index: usize,
size: Size,
r: Rect,
) -> bool {
let inputs = hdmi_inputs(state);
if size != Size::L {
out.shadow(r, RADIUS, 24., 8., 0.16);
match inputs.first() {
Some(input) => input_tile(out, state, assets, input, r, RADIUS, true),
None => out.glass(r, RADIUS),
}
out.border(r, RADIUS, 1., c(0xffffff, 0.08));
return true;
}
out.glass(r, RADIUS);
let pad = 16.;
let gap = 14.;
let tw = (r.w - 2. * pad - 2. * gap) / 3.;
for (k, input) in inputs.iter().take(3).enumerate() {
let t = Rect::new(
r.x + pad + k as f32 * (tw + gap),
r.y + pad,
tw,
r.h - 2. * pad,
);
let radius = w::inner_radius(RADIUS, pad);
input_tile(out, state, assets, input, t, radius, false);
if index != PREVIEW {
let target = Target::WidgetTile(index, k);
out.focus_ring(t, radius, state.focus_level(&target), state);
out.control(target, t, true);
}
}
false
}
// -------------------------------------------------------------- Smart Home
fn entity_icon(e: &Entity) -> &'static str {
match e.domain.as_str() {
"light" => "smart-light",
"lock" => "smart-lock",
"fan" => "smart-fan",
"cover" => "smart-door",
"sensor" | "climate" => "thermometer",
"binary_sensor" => "eye",
_ => "power",
}
}
fn camera_picture(
out: &mut Scene,
state: &State,
assets: &Assets,
cam: Option<&Entity>,
r: Rect,
radius: f32,
big: bool,
) {
out.shape(r, radius, c(0x1b1f25, 1.));
let snapshot = cam.and_then(|e| state.ha_snapshots.get(&e.id));
if let Some(path) = snapshot {
out.image(path.clone(), r, radius, false);
} else {
out.text(
if cam.is_some() {
"Waiting for the camera"
} else {
"No camera selected"
},
Rect::new(r.x + 16., r.y + r.h / 2. - 14., r.w - 32., 28.),
ts(assets, 18., 500),
c(0xffffff, 0.45),
true,
);
}
// LIVE chip.
let inset = if big { 20. } else { 14. };
let chip = Rect::new(r.x + inset, r.y + inset, 92., if big { 36. } else { 32. });
out.shape(chip, chip.h / 2., c(0x181a1e, 0.6));
out.shape(
Rect::new(chip.x + 14., chip.y + chip.h / 2. - 5., 10., 10.),
5.,
c(0xff6b5e, 1.),
);
out.text(
"LIVE",
Rect::new(chip.x + 32., chip.y + (chip.h - 25.) / 2., 56., 25.),
ts(assets, 18., 600),
WHITE,
false,
);
if let Some(e) = cam {
if big {
out.draw.push(Draw::RoundedGradient(
Rect::new(r.x, r.y + r.h - 110., r.w, 110.),
radius,
c(0x000000, 0.),
c(0x000000, 0.7),
));
}
let style = ts(assets, if big { 26. } else { 22. }, 600);
let bottom = if big { 20. } else { 14. };
let detail = if big && !e.area.is_empty() { 25. } else { 0. };
lifted(
out,
&clip_weather_line(&e.name, r.w - 2. * inset, style, assets),
Rect::new(
r.x + inset + 4.,
r.y + r.h - bottom - detail - style.size * 1.36,
r.w - 2. * inset,
style.size * 1.4,
),
style,
WHITE,
false,
);
if detail > 0. {
out.text(
&e.area,
Rect::new(
r.x + inset + 4.,
r.y + r.h - bottom - 25.,
r.w - 2. * inset,
25.,
),
ts(assets, 18., 500),
c(0xffffff, 0.75),
false,
);
}
}
}
fn device_tile(out: &mut Scene, state: &State, assets: &Assets, e: &Entity, r: Rect, radius: f32) {
let on = e.on();
// A device that is on is "chosen": accent outline; the fill is only focus.
out.shape(r, radius, c(0xffffff, 0.10));
choice(out, state, r, radius, on, 0.);
let ink = WHITE;
out.icon(
assets,
entity_icon(e),
Rect::new(r.x + 16., r.y + 14., 30., 30.),
ink,
);
let style = ts(assets, 18., 500);
out.text(
clip_weather_line(&e.name, r.w - 32., style, assets),
Rect::new(r.x + 16., r.y + r.h - 14. - 28. - 25., r.w - 32., 25.),
style,
[ink[0], ink[1], ink[2], if on { 1. } else { 0.75 }],
false,
);
out.text(
smart_value(e),
Rect::new(r.x + 16., r.y + r.h - 14. - 28., r.w - 32., 28.),
ts(assets, 20., 600),
ink,
false,
);
}
fn smart_block(
out: &mut Scene,
state: &State,
assets: &Assets,
index: usize,
size: Size,
r: Rect,
) -> bool {
match size {
Size::S => {
out.glass(r, RADIUS);
let Some(e) = smart_devices(state).first().copied() else {
out.text(
"No devices yet",
Rect::new(r.x + 22., r.y + r.h / 2. - 14., r.w - 44., 28.),
ts(assets, 20., 500),
c(0xffffff, 0.7),
false,
);
return true;
};
let disc = Rect::new(r.x + 22., r.y + 22., 64., 64.);
out.shape(disc, 32., c(0xffffff, 0.14));
choice(out, state, disc, 32., e.on(), 0.);
let ink = WHITE;
out.icon(
assets,
entity_icon(e),
Rect::new(disc.x + 16., disc.y + 16., 32., 32.),
ink,
);
let x = r.x + 22.;
let inner = r.w - 44.;
out.text(
&e.area,
Rect::new(x, r.y + r.h - 22. - 28. - 36. - 25., inner, 25.),
ts(assets, 18., 500),
c(0xffffff, 0.7),
false,
);
let ns = ts(assets, 26., 600);
out.text(
clip_weather_line(&e.name, inner, ns, assets),
Rect::new(x, r.y + r.h - 22. - 28. - 36., inner, 36.),
ns,
WHITE,
false,
);
out.text(
smart_value(e),
Rect::new(x, r.y + r.h - 22. - 28., inner, 28.),
ts(assets, 20., 500),
c(0xffffff, 0.9),
false,
);
true
}
Size::M => {
out.shadow(r, RADIUS, 24., 8., 0.16);
camera_picture(out, state, assets, smart_camera(state), r, RADIUS, true);
out.border(r, RADIUS, 1., c(0xffffff, 0.08));
true
}
_ => {
out.glass(r, RADIUS);
let pad = 16.;
let radius = w::inner_radius(RADIUS, pad);
let cam = Rect::new(r.x + pad, r.y + pad, 400., r.h - 2. * pad);
camera_picture(out, state, assets, smart_camera(state), cam, radius, false);
if index != PREVIEW {
let target = Target::Widget(index);
out.focus_ring(cam, radius, state.focus_level(&target), state);
out.control(target, cam, true);
}
let grid = Rect::new(
cam.x + cam.w + 16.,
r.y + pad,
r.x + r.w - pad - cam.x - cam.w - 16.,
r.h - 2. * pad,
);
let gap = 12.;
let tw = (grid.w - gap) / 2.;
let th = (grid.h - gap) / 2.;
for (k, e) in smart_devices(state).into_iter().take(4).enumerate() {
let t = Rect::new(
grid.x + (k % 2) as f32 * (tw + gap),
grid.y + (k / 2) as f32 * (th + gap),
tw,
th,
);
device_tile(out, state, assets, e, t, radius);
if index != PREVIEW {
let target = Target::WidgetTile(index, k);
out.focus_ring(t, radius, state.focus_level(&target), state);
out.control(target, t, true);
}
}
false
}
}
}
// --------------------------------------------------------------- text line
/// The parts of one text item: icon (or coin), text runs with colours.
fn text_item(state: &State, kind: Kind) -> (Option<String>, Option<String>, Vec<(String, Color)>) {
match kind {
Kind::Weather => {
let (mood, reading) = weather_now(state);
let Some(r) = reading else {
return (
Some("weather-sun".into()),
None,
vec![("Weather".into(), WHITE)],
);
};
let wind = forecast(state).map_or(r.wind_speed / 3.6, |f| f.wind_ms);
(
Some(hero_icon(mood, r).into()),
None,
vec![(
format!("{} · Wind {:.0} m/s", temp(state, r.temperature), wind),
WHITE,
)],
)
}
Kind::Crypto => {
let symbol = state.preferences.widgets.main_coin.clone();
match state.widget_data.quote(&symbol) {
Some(q) => (
None,
Some(symbol),
vec![
(price(state, q.price), WHITE),
(
format!(
"{} {:.1}%",
if q.change_pct >= 0. { "▲" } else { "▼" },
q.change_pct.abs()
),
trend(q.change_pct),
),
],
),
None => (
None,
Some(symbol),
vec![(crypto_status(state).into(), c(0xffffff, 0.72))],
),
}
}
Kind::Smart => {
let lights = state
.ha_entities
.iter()
.filter(|e| e.domain == "light" && e.on() && !e.hidden)
.count();
let mut line = smart_sensor(state)
.map(|e| match e.state.parse::<f64>() {
Ok(v) if e.unit.contains('°') || e.device_class == "temperature" => {
format!("{} {v:.1}°", e.name)
}
_ => format!("{} {}", e.name, smart_value(e)),
})
.unwrap_or_default();
if !line.is_empty() {
line.push_str(" · ");
}
line.push_str(&match lights {
0 => "Lights off".to_owned(),
1 => "1 light on".to_owned(),
n => format!("{n} lights on"),
});
(Some("thermometer".into()), None, vec![(line, WHITE)])
}
Kind::Hdmi => (None, None, vec![]),
}
}
/// Width of a text item, for layout and hit boxes.
pub(super) fn text_item_width(assets: &Assets, state: &State, kind: Kind) -> f32 {
let (icon, coin, runs) = text_item(state, kind);
let style = ts(assets, 22., 500);
let lead = if icon.is_some() || coin.is_some() {
36.
} else {
0.
};
lead + runs
.iter()
.map(|(t, _)| width(assets, t, style))
.sum::<f32>()
+ 10. * (runs.len().saturating_sub(1)) as f32
}
/// Text items that fit the line: (index, kind, content rect).
fn text_rects(state: &State, assets: &Assets, z: &Zone) -> Vec<(usize, Kind, Rect)> {
let mut x = z.left;
let mut out = Vec::new();
for (i, kind) in &z.text {
let wd = text_item_width(assets, state, *kind);
if x + wd > crate::state::HOME_STRIP_RIGHT + 1. {
break;
}
out.push((*i, *kind, Rect::new(x, z.top - 60., wd, 44.)));
x += wd + 40.;
}
out
}
/// The pill a text item is focused and edited in: one shape for both.
fn text_pill(r: Rect) -> Rect {
Rect::new(r.x - 14., r.y - 8., r.w + 28., r.h + 16.)
}
pub(super) fn text_line(out: &mut Scene, state: &State, assets: &Assets, z: &Zone) {
let style = ts(assets, 22., 500);
for (i, kind, r) in text_rects(state, assets, z) {
let (x, y) = (r.x, r.y);
let target = Target::WidgetText(i);
let level = state.focus_level(&target);
let pill = text_pill(r);
if level > 0. {
out.focus_ring(pill, pill.h / 2., level, state);
}
let (icon, coin, runs) = text_item(state, kind);
let mut cx = x;
if let Some(icon) = icon {
out.icon(assets, &icon, Rect::new(cx, y + 9., 26., 26.), WHITE);
cx += 36.;
}
if let Some(symbol) = coin {
coin_disc(out, assets, &symbol, cx, y + 9., 26.);
cx += 36.;
}
for (t, color) in runs {
let tw = width(assets, &t, style);
// Spare width: symbols such as ▲ may come from a fallback font.
lifted(
out,
&t,
Rect::new(cx, y + 7., tw + 40., 30.),
style,
color,
false,
);
cx += tw + 10.;
}
out.control(target, pill, true);
}
}
// --------------------------------------------------------------- edit mode
fn round_button(out: &mut Scene, state: &State, r: Rect, target: &Target) -> Color {
let level = state.focus_level(target);
out.shape(r, r.h / 2., c(0x3c3e44, 0.92));
out.border(r, r.h / 2., 1., c(0xffffff, 0.18));
if level > 0. {
let at = out.draw.len();
accent_fill(out, r, r.h / 2., state);
motion::transform_group(&mut out.draw[at..], 0., 0., level);
}
blend(WHITE, accent_ink(state), level)
}
fn edit_chrome(out: &mut Scene, state: &State, assets: &Assets, z: &Zone) {
let right = crate::state::HOME_STRIP_RIGHT;
// Every widget, text or block, gets its own outline and its own «−» on
// its top-left corner, so a button never sits closer to a neighbour.
for (i, _, r) in text_rects(state, assets, z) {
let pill = text_pill(r);
out.border(pill, pill.h / 2., 1.5, c(0xffffff, 0.35));
let b = Rect::new(pill.x - 16., pill.y - 16., 36., 36.);
let target = Target::WidgetTextRemove(i);
let ink = round_button(out, state, b, &target);
out.shape(Rect::new(b.x + 11., b.y + 16.5, 14., 3.), 1.5, ink);
out.control(target, b, true);
}
for (i, _, r) in &z.blocks {
let lift = state.focus_level(&Target::Widget(*i));
if lift > 0. {
out.shadow(*r, RADIUS, 80., 34., 0.5 * lift);
}
let b = Rect::new(r.x - 18., r.y - 18., 44., 44.);
let target = Target::WidgetRemove(*i);
let ink = round_button(out, state, b, &target);
out.shape(Rect::new(b.x + 14., b.y + 20.5, 16., 3.), 1.5, ink);
out.control(target, b, true);
}
// Add widget and the hint, right-aligned under the blocks.
let y = z.top + w::BLOCK_H + 22.;
let hint = "Hold the wheel and drag · Arrows move it · Back finishes";
let hs = ts(assets, 22., 500);
let hw = width(assets, hint, hs) + 48.;
let hint_r = Rect::new(right - hw, y, hw, 56.);
out.glass(hint_r, 28.);
out.text(hint, Rect::new(hint_r.x, y + 12., hw, 32.), hs, WHITE, true);
let label = "Add widget";
let ls = ts(assets, 22., 600);
let aw = 18. + 20. + 8. + width(assets, label, ls) + 24.;
let add = Rect::new(hint_r.x - 16. - aw, y, aw, 56.);
let target = Target::WidgetAdd;
let level = state.focus_level(&target);
out.shape(add, 28., c(0xffffff, 0.14));
if level > 0. {
let at = out.draw.len();
accent_fill(out, add, 28., state);
motion::transform_group(&mut out.draw[at..], 0., 0., level);
}
let ink = blend(WHITE, accent_ink(state), level);
out.shape(Rect::new(add.x + 18., add.y + 26.5, 20., 3.), 1.5, ink);
out.shape(Rect::new(add.x + 26.5, add.y + 18., 3., 20.), 1.5, ink);
out.text(
label,
Rect::new(add.x + 46., y + 12., aw - 46., 32.),
ls,
ink,
false,
);
out.control(target, add, true);
}
/// Scale a composed group about (ox, oy): rects, radii, strokes, blurs and type.
pub(super) fn scale_group(draw: &mut [Draw], ox: f32, oy: f32, k: f32) {
let sr = |r: &mut Rect| {
r.x = ox + (r.x - ox) * k;
r.y = oy + (r.y - oy) * k;
r.w *= k;
r.h *= k;
};
for d in draw {
match d {
Draw::Shape(r, radius, stroke, _)
| Draw::DiagonalGradientBorder(r, radius, stroke, _, _) => {
sr(r);
*radius *= k;
*stroke *= k;
}
Draw::RoundedGradient(r, radius, _, _)
| Draw::DiagonalGradient(r, radius, _, _)
| Draw::HGradient(r, radius, _, _)
| Draw::Sheen(r, radius, _, _)
| Draw::Image(_, r, radius, _)
| Draw::TintedImage(_, r, radius, _, _) => {
sr(r);
*radius *= k;
}
Draw::Shadow(r, radius, blur, _) => {
sr(r);
*radius *= k;
*blur *= k;
}
Draw::Text(_, r, style, _, _) => {
sr(r);
style.size *= k;
}
Draw::AppImage(_, r, _) => sr(r),
Draw::Clip(Some(r)) => sr(r),
Draw::RoundClip(Some((r, radius))) => {
sr(r);
*radius *= k;
}
_ => {}
}
}
}
// ---------------------------------------------------------- detail pages
pub(super) fn detail(out: &mut Scene, state: &State, assets: &Assets) {
let Some(d) = state.widget_detail else {
return;
};
out.controls.clear();
out.draw.push(Draw::Clip(None));
let start = out.draw.len();
out.shape(Rect::new(0., 0., 1920., 1080.), 0., c(0x050608, 0.62));
match d {
Detail::Weather { tab } => weather_detail(out, state, assets, tab),
Detail::Crypto { coin } => crypto_detail(out, state, assets, coin),
}
if let Some(opened) = state.widget_detail_started
&& !state.preferences.reduced_motion
{
let t = motion::progress(opened.elapsed().as_secs_f32(), motion::PANEL_IN);
motion::transform_group(&mut out.draw[start..], 0., 16. * (1. - t), t);
}
}
/// One filled element per screen: focus fills with the accent, the chosen
/// item without focus keeps only an accent outline (like `view::sub_tab`).
/// Returns the ink level: 1 on the fill, 0 on the outline.
pub(super) fn choice(
out: &mut Scene,
state: &State,
r: Rect,
radius: f32,
selected: bool,
focus: f32,
) -> f32 {
if selected && focus < 1. {
const W: f32 = 2.5;
let (a, b) = state.accent_colors();
let b = if state.preferences.accent.kind == "gradient" {
b
} else {
a
};
let alpha = 1. - focus;
out.draw.push(Draw::DiagonalGradientBorder(
r.inset(W / 2.),
radius - W / 2.,
W,
c(a, alpha),
c(b, alpha),
));
}
if focus > 0. {
let at = out.draw.len();
accent_fill(out, r, radius, state);
motion::transform_group(&mut out.draw[at..], 0., 0., focus);
}
focus
}
fn tabs(
out: &mut Scene,
state: &State,
assets: &Assets,
labels: &[&str],
selected: usize,
x: f32,
y: f32,
) {
let style = ts(assets, 22., 500);
let mut x = x;
for (i, label) in labels.iter().enumerate() {
let wd = width(assets, label, style) + 60.;
let r = Rect::new(x, y, wd, 64.);
let target = Target::WidgetTab(i);
out.shape(r, 32., c(0xffffff, 0.14));
let on = choice(
out,
state,
r,
32.,
i == selected,
state.focus_level(&target),
);
out.text(
*label,
Rect::new(r.x, y + 16., wd, 32.),
style,
blend(WHITE, accent_ink(state), on),
true,
);
out.control(target, r, false);
x += wd + 16.;
}
}
fn close(out: &mut Scene, state: &State, assets: &Assets, x: f32, y: f32) {
let r = Rect::new(x, y, 64., 64.);
movie_view::close_button(
out,
state,
assets,
r,
"close",
state.focus_level(&Target::WidgetClose),
);
out.control(Target::WidgetClose, r, false);
}
fn tile_head(out: &mut Scene, assets: &Assets, icon: &str, label: &str, x: f32, y: f32) {
out.icon(
assets,
icon,
Rect::new(x, y + 2., 20., 20.),
c(0xffffff, 0.72),
);
out.text(
label,
Rect::new(x + 28., y, 400., 25.),
ts(assets, 18., 500).tracking(0.03),
c(0xffffff, 0.72),
false,
);
}
fn compass(deg: f64) -> &'static str {
const NAMES: [&str; 8] = [
"north",
"northeast",
"east",
"southeast",
"south",
"southwest",
"west",
"northwest",
];
NAMES[(((deg % 360. + 360.) % 360. + 22.5) / 45.) as usize % 8]
}
fn uv_word(uv: f64) -> &'static str {
match uv {
u if u < 3. => "Low",
u if u < 6. => "Moderate",
u if u < 8. => "High",
u if u < 11. => "Very high",
_ => "Extreme",
}
}
fn weather_detail(out: &mut Scene, state: &State, assets: &Assets, tab: usize) {
let (mood, reading) = weather_now(state);
let panel = Rect::new(48., 48., 1824., 984.);
out.shadow(panel, 40., 80., 30., 0.5);
sky_plate(out, state, assets, panel, 40., mood);
out.draw.push(Draw::RoundedGradient(
Rect::new(panel.x, panel.y + panel.h * 0.3, panel.w, panel.h * 0.7),
40.,
c(0x0a0e18, 0.),
c(0x0a0e18, 0.55),
));
close(out, state, assets, 1744., 112.);
tabs(
out,
state,
assets,
&["Today", "Tomorrow", "10 days"],
tab,
112.,
420.,
);
let f = forecast(state);
city_line(out, state, assets, 112., 104., 560., 24.);
let Some(now) = reading else {
out.text(
"Forecast unavailable",
Rect::new(112., 200., 560., 46.),
ts(assets, 34., 500),
WHITE,
false,
);
return;
};
lifted(
out,
&temp(state, now.temperature),
Rect::new(112., 140., 560., 170.),
td(assets, 150.),
WHITE,
false,
);
lifted(
out,
&condition_text(state, now),
Rect::new(112., 305., 560., 46.),
ts(assets, 34., 500),
WHITE,
false,
);
let mut line = high_low(state).unwrap_or_default();
if let Some(f) = f
&& f.feels_like.is_finite()
{
line = format!("{line} · Feels like {}", temp(state, f.feels_like));
}
lifted(
out,
&line,
Rect::new(112., 357., 560., 30.),
ts(assets, 22., 500),
c(0xffffff, 0.85),
false,
);
let plate = |out: &mut Scene, r: Rect| {
out.shape(r, RADIUS, c(0xffffff, 0.13));
out.border(r, RADIUS, 1., c(0xffffff, 0.10));
};
// Hourly (or ten days) across the top right.
let hourly = Rect::new(712., 196., 1096., 292.);
plate(out, hourly);
let Some(f) = f else {
out.text(
"Updating forecast",
Rect::new(hourly.x + 28., hourly.y + 120., 600., 34.),
ts(assets, 24., 500),
c(0xffffff, 0.8),
false,
);
return;
};
tile_head(
out,
assets,
"clock",
if tab == 2 {
"10-DAY FORECAST"
} else {
"HOURLY FORECAST"
},
hourly.x + 28.,
hourly.y + 20.,
);
let summary = {
let rainy = f
.hours
.iter()
.find(|h| h.day == if tab == 1 { 1 } else { 0 } && h.rain_chance >= 50.);
match rainy {
Some(h) => format!("Rain likely from {:02}:00", h.hour),
None => "No rain expected".to_owned(),
}
};
if tab != 2 {
out.text(
&summary,
Rect::new(hourly.x + hourly.w - 28. - 600., hourly.y + 18., 600., 28.),
ts(assets, 20., 500).right(),
c(0xffffff, 0.8),
false,
);
}
// (label, icon, extra, value, highlighted)
let cols: Vec<(String, &str, String, String, bool)> = match tab {
2 => f
.days
.iter()
.take(10)
.enumerate()
.map(|(i, d)| {
(
if i == 0 {
"Today".into()
} else {
w::WEEKDAYS[d.weekday as usize % 7].into()
},
condition_icon(weather::condition(synthetic(d.code, true, d.max)).icon),
if d.rain_chance >= 20. {
format!("{:.0}%", d.rain_chance)
} else {
String::new()
},
deg(state, d.max),
i == 0,
)
})
.collect(),
_ => {
let list: Vec<&w::Hour> = if tab == 1 {
f.hours
.iter()
.filter(|h| h.day == 1 && h.hour >= 8)
.take(12)
.collect()
} else {
f.hours.iter().take(12).collect()
};
list.iter()
.enumerate()
.map(|(i, h)| {
(
if i == 0 && tab == 0 {
"Now".into()
} else {
format!("{:02}", h.hour)
},
condition_icon(
weather::condition(synthetic(h.code, h.is_day, h.temperature)).icon,
),
if h.rain_chance >= 20. {
format!("{:.0}%", h.rain_chance)
} else {
String::new()
},
deg(state, h.temperature),
i == 0 && tab == 0,
)
})
.collect()
}
};
let n = if tab == 2 { 10 } else { 12 };
let grid = Rect::new(
hourly.x + 28.,
hourly.y + 60.,
hourly.w - 56.,
hourly.h - 80.,
);
let cw = grid.w / n as f32;
for (i, (label, icon, extra, value, hi)) in cols.iter().enumerate() {
let x = grid.x + i as f32 * cw;
if *hi {
out.shape(Rect::new(x, grid.y, cw, grid.h), 16., c(0xffffff, 0.14));
}
out.text(
label,
Rect::new(x, grid.y + 14., cw, 30.),
ts(assets, 22., 500),
c(0xffffff, if *hi { 1. } else { 0.78 }),
true,
);
out.icon(
assets,
icon,
Rect::new(x + cw / 2. - 18., grid.y + 62., 36., 36.),
WHITE,
);
out.text(
extra,
Rect::new(x, grid.y + 102., cw, 25.),
ts(assets, 18., 500),
c(0x9fdcff, 1.),
true,
);
out.text(
value,
Rect::new(x, grid.y + grid.h - 14. - 41., cw, 41.),
ts(assets, 30., 600),
WHITE,
true,
);
}
// Seven days, left.
let week = Rect::new(112., 504., 560., 464.);
plate(out, week);
tile_head(
out,
assets,
"list",
"7-DAY FORECAST",
week.x + 26.,
week.y + 22.,
);
days(
out,
state,
assets,
&f.days,
7,
Rect::new(week.x + 26., week.y + 58., week.w - 52., 7. * 52.),
DayScale {
size: 22.,
icon: 30.,
},
);
// Six conditions tiles.
let today = f.days.first();
let tiles: [(&str, &str, String, String); 6] = [
(
"WIND",
"weather-cloud",
format!("{:.0} m/s", f.wind_ms),
format!(
"Gusts up to {:.0} m/s\nfrom the {}",
f.gust_ms,
compass(f.wind_dir)
),
),
(
"HUMIDITY",
"weather-drizzle",
format!("{:.0}%", f.humidity),
if f.dew_point.is_finite() {
format!("Dew point {}", temp(state, f.dew_point))
} else {
String::new()
},
),
(
"UV INDEX",
"weather-sun",
format!("{:.0}", f.uv),
uv_word(f.uv).to_owned(),
),
(
"SUNSET",
"weather-moon",
f.sunset.clone(),
format!("Sunrise {}", f.sunrise),
),
(
"RAIN",
"weather-rain",
format!("{:.0} mm", today.map_or(0., |d| d.rain_mm)),
format!("Chance today {:.0}%", today.map_or(0., |d| d.rain_chance)),
),
(
"PRESSURE",
"clock",
if f.pressure.is_finite() {
format!("{:.0} hPa", f.pressure)
} else {
"—".into()
},
if f.visibility_km.is_finite() {
format!("Visibility {:.0} km", f.visibility_km)
} else {
String::new()
},
),
];
for (k, (label, icon, value, sub)) in tiles.iter().enumerate() {
let r = Rect::new(
712. + (k % 3) as f32 * 373.,
504. + (k / 3) as f32 * 242.,
349.,
222.,
);
plate(out, r);
tile_head(out, assets, icon, label, r.x + 24., r.y + 22.);
out.text(
value,
Rect::new(r.x + 24., r.y + 54., r.w - 48., 56.),
td(assets, 44.),
WHITE,
false,
);
if k == 2 {
let bar = Rect::new(r.x + 24., r.y + 122., r.w - 48., 8.);
let stops = [0x6fdc8c, 0xf5e050, 0xffa04d, 0xff5d5d, 0xb46bff];
let seg = bar.w / 4.;
for s in 0..4 {
let sr = Rect::new(
bar.x + s as f32 * seg,
bar.y,
seg + if s < 3 { 1. } else { 0. },
bar.h,
);
out.draw.push(Draw::HGradient(
sr,
if s == 0 || s == 3 { 4. } else { 0. },
c(stops[s], 1.),
c(stops[s + 1], 1.),
));
}
let mx = bar.x + bar.w * (f.uv / 11.).clamp(0., 1.) as f32;
out.shape(
Rect::new(mx - 10., bar.y - 6., 20., 20.),
10.,
c(0x000000, 0.25),
);
out.shape(Rect::new(mx - 7., bar.y - 3., 14., 14.), 7., WHITE);
}
let lines: Vec<&str> = sub.lines().collect();
for (j, l) in lines.iter().enumerate() {
let y = r.y + r.h - 22. - (lines.len() - j) as f32 * 27.;
out.text(
*l,
Rect::new(r.x + 24., y, r.w - 48., 27.),
ts(assets, 20., 500),
c(0xffffff, 0.8),
false,
);
}
}
}
fn crypto_detail(out: &mut Scene, state: &State, assets: &Assets, coin: usize) {
let prefs = &state.preferences.widgets;
let coins = prefs.ordered_coins();
let symbol = coins.get(coin).unwrap_or(&coins[0]).clone();
let panel = Rect::new(48., 48., 1824., 984.);
out.shadow(panel, 40., 80., 30., 0.5);
out.glass(panel, 40.);
close(out, state, assets, 1744., 96.);
let period = period_index(prefs.period);
tabs(
out,
state,
assets,
&["1H", "24H", "7D", "1Y"],
period,
1392.,
196.,
);
coin_disc(out, assets, &symbol, 112., 104., 56.);
let name = w::coin(&symbol).0;
let name = if name.is_empty() {
symbol.as_str()
} else {
name
};
let ns = ts(assets, 32., 600);
out.text(name, Rect::new(184., 110., 400., 44.), ns, WHITE, false);
out.text(
format!(
"{symbol} / {} · {}",
pair_quote(prefs),
prefs.exchange.short()
),
Rect::new(184. + width(assets, name, ns) + 16., 118., 500., 30.),
ts(assets, 22., 500),
c(0xffffff, 0.65),
false,
);
let chart = Rect::new(152., 320., 1080., 350.);
if let Some(q) = state.widget_data.quote(&symbol) {
let big = td(assets, 96.);
let p = price(state, q.price);
out.text(&p, Rect::new(112., 168., 1100., 110.), big, WHITE, false);
let first = q.series.first().copied().unwrap_or(q.price);
out.text(
format!(
"{} {} · {:.2}%",
if q.change_pct >= 0. { "▲" } else { "▼" },
price(state, (q.price - first).abs()),
q.change_pct.abs()
),
Rect::new(112. + width(assets, &p, big) + 22., 214., 520., 40.),
ts(assets, 28., 500),
trend(q.change_pct),
false,
);
// Grid lines and labels, then the line.
for k in 0..4 {
let v = q.high - (q.high - q.low) * k as f64 / 3.;
let y = chart.y + chart.h * k as f32 / 3.;
out.shape(Rect::new(chart.x, y, chart.w, 1.), 0., c(0xffffff, 0.08));
out.text(
price(state, v),
Rect::new(chart.x + chart.w + 20., y - 13., 160., 26.),
ts(assets, 18., 500),
c(0xffffff, 0.6),
false,
);
}
let marks = match prefs.period {
w::Period::Hour => ["−60 min", "−45 min", "−30 min", "−15 min", "Now"],
w::Period::Day => ["−24 h", "−18 h", "−12 h", "−6 h", "Now"],
w::Period::Week => ["−7 d", "−5 d", "−3 d", "−1 d", "Now"],
w::Period::Year => ["−12 mo", "−9 mo", "−6 mo", "−3 mo", "Now"],
};
for (k, m) in marks.iter().enumerate() {
let x = chart.x + chart.w * k as f32 / 4.;
out.text(
*m,
Rect::new(x - 60., chart.y + chart.h + 22., 120., 26.),
ts(assets, 18., 500),
c(0xffffff, 0.6),
true,
);
}
sparkline(
out,
&q.series,
chart,
if q.change_pct >= 0. { GREEN } else { RED },
4.,
true,
);
let label = prefs.period.label();
let stats = [
(format!("{label} HIGH"), price(state, q.high)),
(format!("{label} LOW"), price(state, q.low)),
(format!("{label} OPEN"), price(state, first)),
("PRICES FROM".to_owned(), prefs.exchange.short().to_owned()),
];
for (k, (l, v)) in stats.iter().enumerate() {
let r = Rect::new(112. + k as f32 * 274., 818., 250., 150.);
out.shape(r, RADIUS, c(0xffffff, 0.07));
out.border(r, RADIUS, 1., c(0xffffff, 0.08));
out.text(
l,
Rect::new(r.x + 24., r.y + 22., r.w - 48., 25.),
ts(assets, 18., 500).tracking(0.03),
c(0xffffff, 0.65),
false,
);
out.text(
v,
Rect::new(r.x + 24., r.y + 56., r.w - 48., 44.),
ts(assets, 32., 600),
WHITE,
false,
);
}
} else {
out.text(
crypto_status(state),
Rect::new(112., 190., 1000., 60.),
ts(assets, 40., 600),
c(0xffffff, 0.8),
false,
);
}
for (k, s) in coins.iter().take(4).enumerate() {
let r = Rect::new(1392., 300. + k as f32 * 112., 416., 96.);
let target = Target::WidgetCoin(k);
out.shape(r, 48., c(0xffffff, 0.07));
let t = choice(out, state, r, 48., k == coin, state.focus_level(&target));
let ink = blend(WHITE, accent_ink(state), t);
coin_disc(out, assets, s, r.x + 18., r.y + 20., 56.);
out.text(
s,
Rect::new(r.x + 90., r.y + 16., 140., 32.),
ts(assets, 24., 600),
ink,
false,
);
out.text(
w::coin(s).0,
Rect::new(r.x + 90., r.y + 50., 160., 25.),
ts(assets, 18., 500),
[ink[0], ink[1], ink[2], 0.7],
false,
);
if let Some(q) = state.widget_data.quote(s) {
out.text(
price(state, q.price),
Rect::new(r.x + r.w - 28. - 180., r.y + 16., 180., 32.),
ts(assets, 24., 600).right(),
ink,
false,
);
let up = q.change_pct >= 0.;
let tc = blend(
trend(q.change_pct),
c(if up { 0x1d5a2f } else { 0x7a2a1a }, 1.),
t,
);
out.text(
w::format_change(q.change_pct),
Rect::new(r.x + r.w - 28. - 180., r.y + 50., 180., 25.),
ts(assets, 18., 500).right(),
tc,
false,
);
}
out.control(target, r, false);
}
out.text(
"Up and down switch the coin.\nPick coins in Settings › Widgets.",
Rect::new(1392., 760., 416., 64.),
ts(assets, 20., 500).leading(1.4),
c(0xffffff, 0.65),
false,
);
}
fn period_index(p: w::Period) -> usize {
w::Period::ALL.iter().position(|x| *x == p).unwrap_or(1)
}