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.
//! What the remote and the pointer do with Home widgets: focus routes, OK,
//! Back, edit mode, the full-screen pages and Settings › Widgets.
use crate::{
model::Input,
smart_home::Entity,
state::{Control, Direction, Effect, Page, SettingsLevel, State, Target, WEATHER_SECTION},
widgets::{
Block, COINS, Detail, Edit, Exchange, Grab, Kind, Period, QUOTES, REFRESH_CHOICES,
SettingsPage, Size, TEXT_MAX, ZONE_COLUMNS,
},
};
use std::time::Instant;
/// One row of a Settings › Widgets page.
pub struct Row {
pub label: String,
pub value: Option<String>,
pub chevron: bool,
pub checked: bool,
/// Shown but cannot be chosen now (does not fit, not available).
pub dim: bool,
}
fn row(label: impl Into<String>, value: Option<String>, chevron: bool, checked: bool) -> Row {
Row {
label: label.into(),
value,
chevron,
checked,
dim: false,
}
}
/// The Root page shows a WIDGET SETTINGS heading before this row.
pub const ROOT_SETTINGS_FROM: usize = 3;
pub fn input_live(input: &Input) -> bool {
input.signal.unwrap_or(input.connected.unwrap_or(false))
}
/// Inputs the HDMI widget shows: the chosen one first, then connected ones.
pub fn hdmi_inputs(state: &State) -> Vec<&Input> {
let prefs = &state.preferences.widgets;
let mut list: Vec<&Input> = state.inventory.inputs.iter().collect();
list.sort_by_key(|i| {
(
i.id != prefs.hdmi_input,
!i.connected.unwrap_or(false),
!input_live(i),
)
});
if prefs.hdmi_hide_no_signal {
let live: Vec<&Input> = list.iter().copied().filter(|i| input_live(i)).collect();
if !live.is_empty() {
return live;
}
}
list
}
pub fn input_name(state: &State, input: &Input) -> String {
state
.preferences
.input_names
.get(&input.id)
.cloned()
.filter(|n| !n.trim().is_empty())
.unwrap_or_else(|| input.title.clone())
}
pub fn smart_camera(state: &State) -> Option<&Entity> {
let want = &state.preferences.widgets.smart_camera;
let cams = state.ha_tab(1);
cams.iter()
.copied()
.find(|e| !want.is_empty() && e.id == *want)
.or_else(|| cams.first().copied())
}
pub fn smart_devices(state: &State) -> Vec<&Entity> {
let want = &state.preferences.widgets.smart_devices;
if !want.is_empty() {
return want
.iter()
.filter_map(|id| state.ha_entities.iter().find(|e| &e.id == id))
.collect();
}
let all = state.ha_tab(0);
let mut list: Vec<&Entity> = all.iter().copied().filter(|e| e.actionable()).collect();
list.extend(all.iter().copied().filter(|e| !e.actionable()));
list.truncate(4);
list
}
fn is_temperature(e: &Entity) -> bool {
e.domain == "sensor" && (e.device_class == "temperature" || e.unit.contains('°'))
}
/// What the Smart Home text widget can show: sensors and states, temperature first.
pub fn text_candidates(state: &State) -> Vec<&Entity> {
let mut list: Vec<&Entity> = state
.ha_entities
.iter()
.filter(|e| {
!e.hidden
&& matches!(
e.domain.as_str(),
"sensor" | "binary_sensor" | "climate" | "lock" | "alarm_control_panel"
)
})
.collect();
list.sort_by_key(|e| !is_temperature(e));
list
}
/// The chosen entity; without a choice, only a room temperature (never an
/// appliance such as a kettle), otherwise nothing and the line shows lights.
pub fn smart_sensor(state: &State) -> Option<&Entity> {
let want = &state.preferences.widgets.smart_sensor;
if !want.is_empty() {
return state.ha_entities.iter().find(|e| e.id == *want);
}
const ROOM: [&str; 14] = [
"room",
"living",
"bedroom",
"indoor",
"home",
"house",
"hall",
"комнат",
"гостин",
"спальн",
"дом",
"квартир",
"зал",
"детск",
];
const APPLIANCE: [&str; 12] = [
"kettle",
"чайник",
"boiler",
"бойлер",
"water",
"вод",
"cpu",
"battery",
"fridge",
"холодил",
"oven",
"плит",
];
state.ha_entities.iter().find(|e| {
let text = format!("{} {} {}", e.name, e.area, e.id).to_lowercase();
!e.hidden
&& is_temperature(e)
&& e.state.parse::<f64>().is_ok()
&& ROOM.iter().any(|w| text.contains(w))
&& !APPLIANCE.iter().any(|w| text.contains(w))
})
}
/// Nearest control in a direction, the same score as the generic route but
/// without the header rule (full-screen pages put Close at the top).
fn nearest(controls: &[Control], from: &Target, direction: Direction) -> Option<Target> {
nearest_where(controls, from, direction, |_| true)
}
/// `nearest` among the controls `keep` accepts.
fn nearest_where(
controls: &[Control],
from: &Target,
direction: Direction,
keep: impl Fn(&Target) -> bool,
) -> Option<Target> {
let current = controls.iter().find(|c| &c.target == from)?;
let (x, y) = current.rect.center();
controls
.iter()
.filter(|c| &c.target != from && keep(&c.target))
.filter_map(|c| {
let (cx, cy) = c.rect.center();
let (primary, cross, overlap) = match direction {
Direction::Up => (y - cy, (x - cx).abs(), (current.rect.w + c.rect.w) / 2.),
Direction::Down => (cy - y, (x - cx).abs(), (current.rect.w + c.rect.w) / 2.),
Direction::Left => (x - cx, (y - cy).abs(), (current.rect.h + c.rect.h) / 2.),
Direction::Right => (cx - x, (y - cy).abs(), (current.rect.h + c.rect.h) / 2.),
};
(primary > 1.).then_some((
c.target.clone(),
primary + cross * 2. + if cross >= overlap { 10000. } else { 0. },
))
})
.min_by(|a, b| a.1.total_cmp(&b.1))
.map(|(t, _)| t)
}
fn is_widget(t: &Target) -> bool {
matches!(
t,
Target::Widget(_) | Target::WidgetText(_) | Target::WidgetTile(..)
)
}
fn rect_of(controls: &[Control], t: &Target) -> Option<crate::state::Rect> {
controls.iter().find(|c| &c.target == t).map(|c| c.rect)
}
impl State {
fn widget_save(&mut self) -> Vec<Effect> {
self.preferences.widgets.normalize();
self.dirty = true;
vec![Effect::Save]
}
pub fn weather_widget_shown(&self) -> bool {
self.preferences.show_weather && self.preferences.widgets.uses(Kind::Weather)
}
/// Put a weather widget back: the largest block that fits, else the text line.
pub fn restore_weather_widget(&mut self) {
if self.preferences.widgets.uses(Kind::Weather) {
return;
}
let size = [Size::M, Size::S]
.into_iter()
.find(|s| self.widget_add_allowed(Kind::Weather, *s));
let prefs = &mut self.preferences.widgets;
match size {
Some(size) => prefs.blocks.insert(
0,
Block {
kind: Kind::Weather,
size,
},
),
None if prefs.text.len() < TEXT_MAX => prefs.text.insert(0, Kind::Weather),
None => prefs.text[0] = Kind::Weather,
}
prefs.normalize();
}
pub fn widget_page(&self) -> Option<SettingsPage> {
match self.settings_level {
SettingsLevel::Widgets(p) if self.page == Page::Settings => Some(p),
_ => None,
}
}
// ------------------------------------------------------------ remote
/// Arrow keys for widgets, their pages and Settings › Widgets. None hands
/// the key to the generic route.
pub fn widget_direction(
&mut self,
direction: Direction,
controls: &[Control],
) -> Option<Vec<Effect>> {
if self.widget_detail.is_some() {
if let Some(next) = nearest(controls, &self.focus, direction) {
self.focus(next, controls);
} else if matches!(direction, Direction::Up)
&& controls.iter().any(|c| c.target == Target::WidgetClose)
{
self.focus(Target::WidgetClose, controls);
}
return Some(vec![]);
}
if let Some(page) = self.widget_page()
&& self.subpage.is_none()
{
return Some(self.widget_settings_direction(page, direction, controls));
}
if self.page != Page::Home || self.overlay.is_some() {
return None;
}
if self.widget_edit.is_some() {
return Some(self.widget_edit_direction(direction, controls));
}
// Up from a Favorites card reaches the widget above it.
if let Target::App(_) = &self.focus
&& matches!(direction, Direction::Up)
&& let Some(app) = rect_of(controls, &self.focus)
{
let cx = app.center().0;
let above = controls
.iter()
.filter(|c| matches!(c.target, Target::Widget(_) | Target::WidgetTile(..)))
.filter(|c| c.rect.y < app.y && c.rect.x <= cx && cx <= c.rect.x + c.rect.w)
.max_by(|a, b| a.rect.y.total_cmp(&b.rect.y))
.map(|c| c.target.clone());
if let Some(t) = above {
self.focus(t, controls);
return Some(vec![]);
}
return None;
}
if !is_widget(&self.focus) {
return None;
}
match direction {
Direction::Up => {
let up = nearest_where(controls, &self.focus, Direction::Up, is_widget);
let next = up.unwrap_or(Target::Nav(self.page_index()));
self.focus(next, controls);
Some(vec![])
}
_ => None,
}
}
fn widget_edit_direction(&mut self, direction: Direction, controls: &[Control]) -> Vec<Effect> {
let horizontal = matches!(direction, Direction::Left | Direction::Right);
let step = |at: usize, len: usize| -> Option<usize> {
match direction {
Direction::Left => at.checked_sub(1),
_ => (at + 1 < len).then_some(at + 1),
}
};
match self.focus.clone() {
Target::Widget(i) if horizontal => {
let len = self.preferences.widgets.blocks.len();
if let Some(j) = step(i, len) {
self.preferences.widgets.blocks.swap(i, j);
self.change_focus(Target::Widget(j));
return self.widget_save();
}
return vec![];
}
Target::WidgetText(i) if horizontal => {
let len = self.preferences.widgets.text.len();
if let Some(j) = step(i, len) {
self.preferences.widgets.text.swap(i, j);
self.change_focus(Target::WidgetText(j));
return self.widget_save();
}
return vec![];
}
Target::Widget(i) if matches!(direction, Direction::Up) => {
self.focus(Target::WidgetRemove(i), controls);
return vec![];
}
Target::Widget(_) if matches!(direction, Direction::Down) => {
self.focus(Target::WidgetAdd, controls);
return vec![];
}
Target::WidgetRemove(i) if matches!(direction, Direction::Down) => {
self.focus(Target::Widget(i), controls);
return vec![];
}
Target::WidgetText(i) if matches!(direction, Direction::Up) => {
self.focus(Target::WidgetTextRemove(i), controls);
return vec![];
}
Target::WidgetTextRemove(i) if matches!(direction, Direction::Down) => {
self.focus(Target::WidgetText(i), controls);
return vec![];
}
_ => {}
}
// Edit mode keeps focus on the widgets and their buttons.
if let Some(next) = nearest_where(controls, &self.focus, direction, |t| {
is_widget(t)
|| matches!(
t,
Target::WidgetRemove(_) | Target::WidgetTextRemove(_) | Target::WidgetAdd
)
}) {
self.focus(next, controls);
}
vec![]
}
// ---------------------------------------------------------------- OK
pub fn widget_activate(&mut self) -> Option<Vec<Effect>> {
if self.page == Page::Settings
&& self.settings_level == SettingsLevel::Root
&& self.focus == Target::Sidebar(WEATHER_SECTION)
{
self.section = WEATHER_SECTION;
self.settings_push(
SettingsLevel::Widgets(SettingsPage::Root),
Target::WidgetRow(0),
);
return Some(vec![]);
}
let editing = self.widget_edit.is_some();
Some(match self.focus.clone() {
Target::Widget(i) => {
let b = *self.preferences.widgets.blocks.get(i)?;
if editing {
return Some(vec![]);
}
self.open_widget(b.kind, b.size)
}
Target::WidgetText(i) => {
let k = *self.preferences.widgets.text.get(i)?;
if editing {
return Some(vec![]);
}
self.open_widget(k, Size::Text)
}
Target::WidgetTile(i, k) => {
let b = *self.preferences.widgets.blocks.get(i)?;
match b.kind {
Kind::Hdmi => {
let id = hdmi_inputs(self).get(k).map(|i| i.id.clone());
match id {
Some(id) if !self.launching => vec![Effect::Launch(id)],
_ => vec![],
}
}
Kind::Smart => {
let id = smart_devices(self).get(k).map(|e| e.id.clone());
id.map_or_else(Vec::new, |id| self.smart_toggle(&id))
}
_ => vec![],
}
}
Target::WidgetRemove(i) => {
if i < self.preferences.widgets.blocks.len() {
self.preferences.widgets.blocks.remove(i);
}
let n = self.preferences.widgets.blocks.len();
self.change_focus(if n == 0 {
Target::WidgetAdd
} else {
Target::Widget(i.min(n - 1))
});
self.widget_save()
}
Target::WidgetTextRemove(i) => {
if i < self.preferences.widgets.text.len() {
self.preferences.widgets.text.remove(i);
}
let n = self.preferences.widgets.text.len();
self.change_focus(if n > 0 {
Target::WidgetText(i.min(n - 1))
} else if self.preferences.widgets.blocks.is_empty() {
Target::WidgetAdd
} else {
Target::Widget(0)
});
self.widget_save()
}
Target::WidgetAdd => {
self.widget_edit = None;
self.open_settings();
self.section = WEATHER_SECTION;
self.settings_level = SettingsLevel::Widgets(SettingsPage::Add);
self.change_focus(Target::WidgetRow(0));
vec![]
}
Target::WidgetTab(i) => {
match self.widget_detail.as_mut()? {
Detail::Weather { tab } => *tab = i,
Detail::Crypto { .. } => {
if let Some(p) = Period::ALL.get(i) {
self.preferences.widgets.period = *p;
return Some(self.widget_save());
}
}
}
vec![]
}
Target::WidgetCoin(k) => {
if let Some(Detail::Crypto { coin }) = self.widget_detail.as_mut() {
*coin = k;
}
vec![]
}
Target::WidgetClose => {
self.close_widget_detail();
vec![]
}
Target::WidgetRow(i) => {
let page = self.widget_page()?;
self.widget_settings_row(page, i)
}
Target::WidgetSize(k) => {
if let Some(size) = Size::ALL.get(k)
&& self.widget_add_allowed(self.widget_add.0, *size)
{
self.widget_add.1 = *size;
}
vec![]
}
_ => return None,
})
}
fn smart_toggle(&mut self, id: &str) -> Vec<Effect> {
if !self.ha_online {
return vec![];
}
let Some(entity) = self.ha_entities.iter_mut().find(|e| e.id == id) else {
return vec![];
};
if !entity.actionable() {
return vec![];
}
let turn_on = !entity.on();
let service = if entity.domain == "cover" {
if turn_on { "open_cover" } else { "close_cover" }
} else if turn_on {
"turn_on"
} else {
"turn_off"
};
entity.state = if turn_on { "on".into() } else { "off".into() };
self.dirty = true;
vec![Effect::HomeAssistant(crate::smart_home::Command::Call {
entity_id: id.to_owned(),
service: service.into(),
data: serde_json::json!({ "entity_id": id }),
})]
}
fn open_widget(&mut self, kind: Kind, size: Size) -> Vec<Effect> {
let back = self.focus.clone();
match kind {
Kind::Weather => {
if self.preferences.weather_location.is_none() {
self.open_settings();
self.section = WEATHER_SECTION;
self.settings_level = SettingsLevel::Section;
self.change_focus(Target::WeatherLocation);
return vec![];
}
self.widget_detail = Some(Detail::Weather { tab: 0 });
self.change_focus(Target::WidgetTab(0));
}
Kind::Crypto => {
self.widget_detail = Some(Detail::Crypto { coin: 0 });
self.change_focus(Target::WidgetCoin(0));
}
Kind::Hdmi => {
let id = hdmi_inputs(self).first().map(|i| i.id.clone());
return match id {
Some(id) if !self.launching => vec![Effect::Launch(id)],
_ => vec![],
};
}
Kind::Smart => match size {
Size::Text => {
self.open(2);
return vec![];
}
Size::S => {
let id = smart_devices(self).first().map(|e| e.id.clone());
return id.map_or_else(Vec::new, |id| self.smart_toggle(&id));
}
_ => {
let Some(id) = smart_camera(self).map(|e| e.id.clone()) else {
return vec![];
};
self.ha_camera = Some(id);
self.widget_return = Some(back);
self.change_focus(Target::SmartClose);
self.dirty = true;
return vec![];
}
},
}
self.widget_return = Some(back);
self.widget_detail_started = Some(Instant::now());
self.dirty = true;
vec![]
}
pub fn close_widget_detail(&mut self) {
self.widget_detail = None;
self.widget_detail_started = None;
let back = self
.widget_return
.take()
.unwrap_or_else(|| self.first_content());
self.change_focus(back);
self.dirty = true;
}
/// After the camera opened from a widget closes, focus returns to it.
pub fn widget_camera_closed(&mut self) -> bool {
if let Some(back) = self.widget_return.take() {
self.change_focus(back);
return true;
}
false
}
// -------------------------------------------------------------- Back
pub fn widget_back(&mut self) -> Option<Vec<Effect>> {
if self.widget_detail.is_some() {
self.close_widget_detail();
return Some(vec![]);
}
if self.widget_edit.take().is_some() {
self.dirty = true;
if !is_widget(&self.focus) {
self.change_focus(if self.preferences.widgets.blocks.is_empty() {
self.first_content()
} else {
Target::Widget(0)
});
}
return Some(self.widget_save());
}
if self.page != Page::Settings || self.subpage.is_some() {
return None;
}
if self.settings_level == SettingsLevel::Section && self.section == WEATHER_SECTION {
self.settings_pop(
SettingsLevel::Widgets(SettingsPage::Root),
Target::WidgetRow(ROOT_SETTINGS_FROM),
);
return Some(vec![]);
}
let page = self.widget_page()?;
use SettingsPage as P;
let (level, row) = match page {
P::Root => {
self.settings_pop(SettingsLevel::Root, Target::Sidebar(WEATHER_SECTION));
return Some(vec![]);
}
P::Text => (P::Root, 1),
P::Add => (P::Root, 2),
P::Crypto => (P::Root, 4),
P::Hdmi => (P::Root, 5),
P::Smart => (P::Root, 6),
P::Exchange => (P::Crypto, 0),
P::Coins => (P::Crypto, 1),
P::MainCoin => (P::Crypto, 2),
P::Quote => (P::Crypto, 3),
P::Period => (P::Crypto, 4),
P::Refresh => (P::Crypto, 5),
P::HdmiInput => (P::Hdmi, 0),
P::SmartCamera => (P::Smart, 0),
P::SmartDevices => (P::Smart, 1),
P::SmartSensor => (P::Smart, 2),
};
self.settings_pop(SettingsLevel::Widgets(level), Target::WidgetRow(row));
Some(vec![])
}
// -------------------------------------------------------------- hold
/// Holding OK on a widget starts edit mode; the pointer may then carry it.
pub fn widget_hold(&mut self) -> bool {
if self.page != Page::Home || self.overlay.is_some() || !is_widget(&self.focus) {
return false;
}
if let Target::WidgetTile(i, _) = self.focus {
self.change_focus(Target::Widget(i));
}
if self.widget_edit.is_none() {
self.widget_edit = Some(Edit { grab: None });
}
self.notice = None;
self.dirty = true;
true
}
pub fn widget_enter_edit(&mut self) {
self.open(0);
self.widget_edit = Some(Edit { grab: None });
self.change_focus(if self.preferences.widgets.blocks.is_empty() {
Target::WidgetAdd
} else {
Target::Widget(0)
});
}
/// Pick a block up with the pointer at (x, y) inside `rect`.
pub fn widget_grab(&mut self, index: usize, rect: crate::state::Rect, x: f32, y: f32) {
if let Some(edit) = self.widget_edit.as_mut() {
edit.grab = Some(Grab {
index,
offset: (x - rect.x, y - rect.y),
at: (x, y),
});
self.change_focus(Target::Widget(index));
self.dirty = true;
}
}
pub fn widget_grabbed(&self) -> bool {
self.widget_edit.is_some_and(|e| e.grab.is_some())
}
/// Move the carried block; it swaps places as it passes a neighbour's centre.
pub fn widget_drag_to(&mut self, x: f32, y: f32, controls: &[Control]) -> bool {
let Some(mut grab) = self.widget_edit.and_then(|e| e.grab) else {
return false;
};
grab.at = (x, y);
let centre = x - grab.offset.0
+ controls
.iter()
.find(|c| c.target == Target::Widget(grab.index))
.map_or(0., |c| c.rect.w / 2.);
let slots: Vec<(usize, f32)> = controls
.iter()
.filter_map(|c| match c.target {
Target::Widget(i) => Some((i, c.rect.center().0)),
_ => None,
})
.collect();
let mut target = grab.index;
for (i, cx) in &slots {
if *i < grab.index && centre < *cx {
target = target.min(*i);
}
if *i > grab.index && centre > *cx {
target = target.max(*i);
}
}
let mut changed = false;
if target != grab.index && target < self.preferences.widgets.blocks.len() {
let b = self.preferences.widgets.blocks.remove(grab.index);
self.preferences.widgets.blocks.insert(target, b);
grab.index = target;
self.focus = Target::Widget(target);
changed = true;
}
if let Some(edit) = self.widget_edit.as_mut() {
edit.grab = Some(grab);
}
self.dirty = true;
changed
}
/// Drop the carried block; returns true when one was carried.
pub fn widget_drop(&mut self) -> Vec<Effect> {
let carried = self
.widget_edit
.as_mut()
.and_then(|e| e.grab.take())
.is_some();
if carried {
return self.widget_save();
}
vec![]
}
// ---------------------------------------------- Settings › Widgets
pub fn widget_add_allowed(&self, kind: Kind, size: Size) -> bool {
let prefs = &self.preferences.widgets;
if !kind.sizes().contains(&size) {
return false;
}
if size == Size::Text {
return prefs.text.contains(&kind) || prefs.text.len() < TEXT_MAX;
}
prefs.columns_used() + size.columns() <= ZONE_COLUMNS
}
pub fn widget_settings_rows(&self, page: SettingsPage) -> Vec<Row> {
use SettingsPage as P;
let prefs = &self.preferences.widgets;
let check = |label: &str, on: bool| row(label, None, false, on);
match page {
P::Root => {
let layout = if prefs.blocks.is_empty() {
"Text only".to_owned()
} else {
prefs
.blocks
.iter()
.map(|b| b.size.label())
.collect::<Vec<_>>()
.join(" + ")
};
let city = self
.preferences
.weather_location
.as_ref()
.map_or("Set location".to_owned(), |l| l.name.clone());
let hdmi = hdmi_inputs(self)
.first()
.map_or("No inputs".to_owned(), |i| input_name(self, i));
let smart = if self.preferences.smart_home.server_url.is_empty() {
"Not connected".to_owned()
} else {
format!(
"{} · {} devices",
smart_camera(self).map_or("No camera".to_owned(), |e| e.name.clone()),
smart_devices(self).len()
)
};
vec![
row("Edit layout on Home", Some(layout), true, false),
row(
"Text line",
Some(match prefs.text.len() {
0 => "Off".to_owned(),
1 => "1 widget".to_owned(),
n => format!("{n} widgets"),
}),
true,
false,
),
row("Add widget", None, true, false),
row("Weather", Some(city), true, false),
row(
"Crypto",
Some(format!(
"{} · {}",
prefs.exchange.short(),
prefs.coins.join(", ")
)),
true,
false,
),
row("HDMI input", Some(hdmi), true, false),
row("Smart Home", Some(smart), true, false),
]
}
P::Add => {
let mut rows: Vec<Row> = Kind::ALL
.iter()
.map(|k| check(k.title(), self.widget_add.0 == *k))
.collect();
rows.push(row("Add to Home", None, false, false));
rows
}
P::Text => [Kind::Weather, Kind::Crypto, Kind::Smart]
.iter()
.map(|k| {
let mut r = check(k.title(), prefs.text.contains(k));
r.dim = !prefs.text.contains(k) && prefs.text.len() >= TEXT_MAX;
r
})
.collect(),
P::Crypto => vec![
row("Exchange", Some(prefs.exchange.short().into()), true, false),
row("Coins", Some(prefs.coins.join(", ")), true, false),
row("Main coin", Some(prefs.main_coin.clone()), true, false),
row("Quote currency", Some(prefs.quote.clone()), true, false),
row(
"Change period",
Some(prefs.period.long().into()),
true,
false,
),
row(
"Refresh",
Some(refresh_label(prefs.refresh_seconds)),
true,
false,
),
],
P::Exchange => Exchange::ALL
.iter()
.map(|e| check(e.title(), prefs.exchange == *e))
.collect(),
P::Coins => COINS
.iter()
.map(|c| {
check(
&format!("{} · {}", c.0, c.1),
prefs.coins.iter().any(|s| s == c.0),
)
})
.collect(),
P::MainCoin => prefs
.coins
.iter()
.map(|s| check(s, prefs.main_coin == *s))
.collect(),
P::Quote => QUOTES.iter().map(|q| check(q, prefs.quote == *q)).collect(),
P::Period => Period::ALL
.iter()
.map(|p| check(p.long(), prefs.period == *p))
.collect(),
P::Refresh => REFRESH_CHOICES
.iter()
.map(|s| check(&refresh_label(*s), prefs.refresh_seconds == *s))
.collect(),
P::Hdmi => vec![
row(
"Input on M widget",
Some(
hdmi_inputs(self)
.first()
.map_or("None".to_owned(), |i| input_name(self, i)),
),
true,
false,
),
row(
"Hide inputs without signal",
Some(
if prefs.hdmi_hide_no_signal {
"On"
} else {
"Off"
}
.into(),
),
false,
false,
),
row(
"Names and logos",
Some("In Settings › Inputs".into()),
true,
false,
),
],
P::HdmiInput => {
let mut rows = vec![check("First connected", prefs.hdmi_input.is_empty())];
rows.extend(
self.inventory
.inputs
.iter()
.map(|i| check(&input_name(self, i), prefs.hdmi_input == i.id)),
);
rows
}
P::Smart => vec![
row(
"Camera",
Some(smart_camera(self).map_or("None".to_owned(), |e| e.name.clone())),
true,
false,
),
row(
"Devices (S and L widgets)",
Some(if prefs.smart_devices.is_empty() {
"Recommended".to_owned()
} else {
format!("{} selected", prefs.smart_devices.len())
}),
true,
false,
),
row(
"Text widget shows",
Some(smart_sensor(self).map_or("Lights only".to_owned(), |e| e.name.clone())),
true,
false,
),
row(
"Home Assistant",
Some(
if self.ha_online {
"Connected"
} else {
"Offline"
}
.into(),
),
true,
false,
),
],
P::SmartCamera => {
let mut rows = vec![check("First camera", prefs.smart_camera.is_empty())];
rows.extend(
self.ha_tab(1)
.iter()
.map(|e| check(&e.name, prefs.smart_camera == e.id)),
);
rows
}
P::SmartDevices => {
let mut rows = vec![check("Recommended", prefs.smart_devices.is_empty())];
rows.extend(
self.ha_listed(0)
.into_iter()
.filter(|e| e.actionable() || e.domain == "lock" || e.domain == "sensor")
.map(|e| {
let on = prefs.smart_devices.contains(&e.id);
let mut r = check(&e.name, on);
r.dim = !on && prefs.smart_devices.len() >= 4;
r
}),
);
rows
}
P::SmartSensor => {
let mut rows = vec![check("Lights only", prefs.smart_sensor.is_empty())];
rows.extend(
text_candidates(self)
.into_iter()
.map(|e| check(&e.name, prefs.smart_sensor == e.id)),
);
rows
}
}
}
fn widget_settings_direction(
&mut self,
page: SettingsPage,
direction: Direction,
controls: &[Control],
) -> Vec<Effect> {
let n = self.widget_settings_rows(page).len();
let sizes = page == SettingsPage::Add;
let next = match (&self.focus, direction) {
(Target::SettingsBack, Direction::Right | Direction::Down) => {
Some(Target::WidgetRow(0))
}
(Target::SettingsBack, Direction::Up) => Some(Target::Nav(self.settings_nav_index())),
(Target::SettingsBack, _) => None,
(Target::WidgetRow(_), Direction::Left) | (Target::WidgetSize(0), Direction::Left) => {
Some(Target::SettingsBack)
}
(Target::WidgetRow(0), Direction::Up) => Some(Target::SettingsBack),
(Target::WidgetRow(i), Direction::Up) if sizes && *i + 1 == n => {
Some(Target::WidgetSize(
Size::ALL
.iter()
.position(|s| *s == self.widget_add.1)
.unwrap_or(0),
))
}
(Target::WidgetRow(i), Direction::Up) => Some(Target::WidgetRow(i - 1)),
(Target::WidgetRow(i), Direction::Down) if sizes && *i + 2 == n => {
Some(Target::WidgetSize(
Size::ALL
.iter()
.position(|s| *s == self.widget_add.1)
.unwrap_or(0),
))
}
(Target::WidgetRow(i), Direction::Down) => {
Some(Target::WidgetRow((i + 1).min(n.saturating_sub(1))))
}
(Target::WidgetRow(_), Direction::Right) => {
return self.widget_activate().unwrap_or_default();
}
(Target::WidgetSize(_), Direction::Up) => Some(Target::WidgetRow(n.saturating_sub(2))),
(Target::WidgetSize(_), Direction::Down) => {
Some(Target::WidgetRow(n.saturating_sub(1)))
}
(Target::WidgetSize(k), Direction::Left) => Some(Target::WidgetSize(k - 1)),
(Target::WidgetSize(k), Direction::Right) => Some(Target::WidgetSize((k + 1).min(3))),
(Target::Nav(_), Direction::Down) => Some(Target::WidgetRow(0)),
_ => None,
};
if let Some(next) = next {
self.focus(next, controls);
}
vec![]
}
fn widget_settings_row(&mut self, page: SettingsPage, i: usize) -> Vec<Effect> {
use SettingsPage as P;
let push = |s: &mut Self, p: SettingsPage, row: usize| {
s.settings_push(SettingsLevel::Widgets(p), Target::WidgetRow(row));
vec![]
};
let prefs = &mut self.preferences.widgets;
match page {
P::Root => match i {
0 => {
self.widget_enter_edit();
vec![]
}
1 => push(self, P::Text, 0),
2 => {
let first = Kind::ALL
.iter()
.copied()
.find(|k| k.sizes().iter().any(|s| self.widget_add_allowed(*k, *s)))
.unwrap_or(Kind::Weather);
let size = first
.sizes()
.iter()
.copied()
.find(|s| *s != Size::Text && self.widget_add_allowed(first, *s))
.unwrap_or(Size::Text);
self.widget_add = (first, size);
push(self, P::Add, 0)
}
3 => {
self.section = WEATHER_SECTION;
self.settings_push(SettingsLevel::Section, Target::WeatherToggle);
vec![]
}
4 => push(self, P::Crypto, 0),
5 => push(self, P::Hdmi, 0),
6 => push(self, P::Smart, 0),
_ => vec![],
},
P::Add => {
if let Some(kind) = Kind::ALL.get(i) {
self.widget_add.0 = *kind;
if !self.widget_add_allowed(*kind, self.widget_add.1) {
self.widget_add.1 = kind
.sizes()
.iter()
.copied()
.find(|s| self.widget_add_allowed(*kind, *s))
.unwrap_or(kind.sizes()[0]);
}
self.dirty = true;
return vec![];
}
let (kind, size) = self.widget_add;
if !self.widget_add_allowed(kind, size) {
self.notify("No room: remove a widget or choose a smaller size");
return vec![];
}
let prefs = &mut self.preferences.widgets;
if size == Size::Text {
if !prefs.text.contains(&kind) {
prefs.text.push(kind);
}
} else {
prefs.blocks.push(Block { kind, size });
}
self.notify(format!("{} {} added to Home", kind.title(), size.label()));
// Smart Home: straight to choosing what it shows.
match (kind, size) {
(Kind::Smart, Size::Text) => self.settings_push(
SettingsLevel::Widgets(P::SmartSensor),
Target::WidgetRow(0),
),
(Kind::Smart, Size::S | Size::L) => self.settings_push(
SettingsLevel::Widgets(P::SmartDevices),
Target::WidgetRow(0),
),
(Kind::Smart, _) => self.settings_push(
SettingsLevel::Widgets(P::SmartCamera),
Target::WidgetRow(0),
),
_ => self.settings_pop(SettingsLevel::Widgets(P::Root), Target::WidgetRow(2)),
}
self.widget_save()
}
P::Text => {
let kind = [Kind::Weather, Kind::Crypto, Kind::Smart][i.min(2)];
if let Some(at) = prefs.text.iter().position(|k| *k == kind) {
prefs.text.remove(at);
} else if prefs.text.len() < TEXT_MAX {
prefs.text.push(kind);
}
self.widget_save()
}
P::Crypto => push(
self,
[
P::Exchange,
P::Coins,
P::MainCoin,
P::Quote,
P::Period,
P::Refresh,
][i.min(5)],
0,
),
P::Exchange => {
prefs.exchange = Exchange::ALL[i.min(Exchange::ALL.len() - 1)];
self.widget_save()
}
P::Coins => {
let symbol = COINS[i.min(COINS.len() - 1)].0.to_owned();
if let Some(at) = prefs.coins.iter().position(|s| *s == symbol) {
if prefs.coins.len() > 1 {
prefs.coins.remove(at);
}
} else if prefs.coins.len() < 8 {
prefs.coins.push(symbol);
}
self.widget_save()
}
P::MainCoin => {
if let Some(s) = prefs.coins.get(i) {
prefs.main_coin = s.clone();
}
self.widget_save()
}
P::Quote => {
prefs.quote = QUOTES[i.min(QUOTES.len() - 1)].into();
self.widget_save()
}
P::Period => {
prefs.period = Period::ALL[i.min(3)];
self.widget_save()
}
P::Refresh => {
prefs.refresh_seconds = REFRESH_CHOICES[i.min(REFRESH_CHOICES.len() - 1)];
self.widget_save()
}
P::Hdmi => match i {
0 => push(self, P::HdmiInput, 0),
1 => {
prefs.hdmi_hide_no_signal = !prefs.hdmi_hide_no_signal;
self.widget_save()
}
_ => {
self.section = crate::state::INPUTS_SECTION;
let target = self
.inventory
.inputs
.first()
.map(|input| Target::InputMode(input.id.clone()))
.unwrap_or(Target::Setting(3));
self.settings_push(SettingsLevel::Section, target);
vec![]
}
},
P::HdmiInput => {
prefs.hdmi_input = if i == 0 {
String::new()
} else {
self.inventory
.inputs
.get(i - 1)
.map(|x| x.id.clone())
.unwrap_or_default()
};
self.widget_save()
}
P::Smart => match i {
0 => push(self, P::SmartCamera, 0),
1 => push(self, P::SmartDevices, 0),
2 => push(self, P::SmartSensor, 0),
_ => {
self.section = crate::state::SMARTHOME_SECTION;
let target = if self.preferences.smart_home.server_url.is_empty() {
Target::SmartConnect
} else {
Target::SmartShowTab
};
self.settings_push(SettingsLevel::Section, target);
vec![]
}
},
P::SmartCamera => {
let id = if i == 0 {
String::new()
} else {
self.ha_tab(1)
.get(i - 1)
.map(|e| e.id.clone())
.unwrap_or_default()
};
self.preferences.widgets.smart_camera = id;
self.widget_save()
}
P::SmartDevices => {
if i == 0 {
self.preferences.widgets.smart_devices.clear();
return self.widget_save();
}
let id = self
.ha_listed(0)
.into_iter()
.filter(|e| e.actionable() || e.domain == "lock" || e.domain == "sensor")
.nth(i - 1)
.map(|e| e.id.clone());
if let Some(id) = id {
let list = &mut self.preferences.widgets.smart_devices;
if let Some(at) = list.iter().position(|x| *x == id) {
list.remove(at);
} else if list.len() < 4 {
list.push(id);
}
}
self.widget_save()
}
P::SmartSensor => {
let id = if i == 0 {
String::new()
} else {
text_candidates(self)
.get(i - 1)
.map(|e| e.id.clone())
.unwrap_or_default()
};
self.preferences.widgets.smart_sensor = id;
self.widget_save()
}
}
}
}
pub fn refresh_label(seconds: u32) -> String {
match seconds {
s if s < 60 => format!("Every {s} s"),
60 => "Every minute".into(),
s => format!("Every {} minutes", s / 60),
}
}