use iced::mouse;
use iced::widget::canvas;
use iced::{Element, Length, Point, Rectangle, Renderer, Theme};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Nav {
Back,
Forward,
Up,
}
const STROKE_FRACTION: f32 = 1.75 / 26.0;
const EXTENT_FRACTION: f32 = 0.22;
pub fn nav<'a, Message: 'a>(kind: Nav, side: f32, color: iced::Color) -> Element<'a, Message> {
canvas(NavGlyph { kind, color })
.width(Length::Fixed(side))
.height(Length::Fixed(side))
.into()
}
struct NavGlyph {
kind: Nav,
color: iced::Color,
}
impl<Message> canvas::Program<Message, Theme, Renderer> for NavGlyph {
type State = ();
fn draw(
&self,
_state: &Self::State,
renderer: &Renderer,
_theme: &Theme,
bounds: Rectangle,
_cursor: mouse::Cursor,
) -> Vec<canvas::Geometry> {
let mut frame = canvas::Frame::new(renderer, bounds.size());
let side = bounds.width.min(bounds.height);
let mid = Point::new(bounds.width / 2.0, bounds.height / 2.0);
let extent = side * EXTENT_FRACTION;
let path = canvas::Path::new(|b| match self.kind {
Nav::Back => {
b.move_to(Point::new(mid.x + extent * 0.5, mid.y - extent));
b.line_to(Point::new(mid.x - extent * 0.5, mid.y));
b.line_to(Point::new(mid.x + extent * 0.5, mid.y + extent));
}
Nav::Forward => {
b.move_to(Point::new(mid.x - extent * 0.5, mid.y - extent));
b.line_to(Point::new(mid.x + extent * 0.5, mid.y));
b.line_to(Point::new(mid.x - extent * 0.5, mid.y + extent));
}
Nav::Up => {
let head = extent * 0.72;
b.move_to(Point::new(mid.x, mid.y + extent));
b.line_to(Point::new(mid.x, mid.y - extent));
b.move_to(Point::new(mid.x - head, mid.y - extent + head));
b.line_to(Point::new(mid.x, mid.y - extent));
b.line_to(Point::new(mid.x + head, mid.y - extent + head));
}
});
frame.stroke(
&path,
canvas::Stroke {
style: canvas::Style::Solid(self.color),
width: side * STROKE_FRACTION,
line_cap: canvas::LineCap::Round,
line_join: canvas::LineJoin::Round,
..canvas::Stroke::default()
},
);
vec![frame.into_geometry()]
}
}
pub fn sidebar<'a, Message: 'a>(side: f32, color: iced::Color) -> Element<'a, Message> {
canvas(SidebarGlyph { color, right: false }).width(Length::Fixed(side)).height(Length::Fixed(side)).into()
}
pub fn side_panel<'a, Message: 'a>(side: f32, color: iced::Color) -> Element<'a, Message> {
canvas(SidebarGlyph { color, right: true }).width(Length::Fixed(side)).height(Length::Fixed(side)).into()
}
struct SidebarGlyph {
color: iced::Color,
right: bool,
}
impl<Message> canvas::Program<Message, Theme, Renderer> for SidebarGlyph {
type State = ();
fn draw(
&self,
_state: &Self::State,
renderer: &Renderer,
_theme: &Theme,
bounds: Rectangle,
_cursor: mouse::Cursor,
) -> Vec<canvas::Geometry> {
let mut frame = canvas::Frame::new(renderer, bounds.size());
let side = bounds.width.min(bounds.height);
let extent = side * VIEW_EXTENT_FRACTION;
let left = bounds.width / 2.0 - extent / 2.0;
let top = bounds.height / 2.0 - extent / 2.0;
let stroke = (extent * 0.12).max(1.0);
let fill = canvas::Fill::from(self.color);
let mirror = |x: f32, width: f32| if self.right { 2.0 * left + extent - x - width } else { x };
let mut rect = |x: f32, y: f32, w: f32, h: f32| {
frame.fill_rectangle(Point::new(mirror(x, w), y), iced::Size::new(w, h), fill);
};
let rail = extent * 0.34;
rect(left, top, rail, extent);
let right = left + extent;
let bottom = top + extent;
let body_left = left + rail;
rect(body_left, top, right - body_left, stroke);
rect(body_left, bottom - stroke, right - body_left, stroke);
rect(right - stroke, top, stroke, extent);
vec![frame.into_geometry()]
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum View {
List,
Grid,
Columns,
}
pub fn view<'a, Message: 'a>(kind: View, side: f32, color: iced::Color) -> Element<'a, Message> {
canvas(ViewGlyph { kind, color }).width(Length::Fixed(side)).height(Length::Fixed(side)).into()
}
struct ViewGlyph {
kind: View,
color: iced::Color,
}
impl<Message> canvas::Program<Message, Theme, Renderer> for ViewGlyph {
type State = ();
fn draw(
&self,
_state: &Self::State,
renderer: &Renderer,
_theme: &Theme,
bounds: Rectangle,
_cursor: mouse::Cursor,
) -> Vec<canvas::Geometry> {
let mut frame = canvas::Frame::new(renderer, bounds.size());
let side = bounds.width.min(bounds.height);
let extent = side * VIEW_EXTENT_FRACTION;
let left = bounds.width / 2.0 - extent / 2.0;
let top = bounds.height / 2.0 - extent / 2.0;
let bar = (extent * 0.16).max(1.0);
let fill = canvas::Fill::from(self.color);
match self.kind {
View::List => {
for i in 0..3 {
let gap = (extent - bar * 3.0) / 2.0;
let y = top + i as f32 * (bar + gap);
frame.fill_rectangle(Point::new(left, y), iced::Size::new(extent, bar), fill);
}
}
View::Grid => {
let cell = extent * 0.42;
let gap = extent - cell * 2.0;
for (cx, cy) in [(0.0, 0.0), (1.0, 0.0), (0.0, 1.0), (1.0, 1.0)] {
frame.fill_rectangle(
Point::new(left + cx * (cell + gap), top + cy * (cell + gap)),
iced::Size::new(cell, cell),
fill,
);
}
}
View::Columns => {
let w = extent * 0.30;
let gap = extent - w * 2.0;
for i in 0..2 {
frame.fill_rectangle(
Point::new(left + i as f32 * (w + gap), top),
iced::Size::new(w, extent),
fill,
);
}
}
}
vec![frame.into_geometry()]
}
}
const VIEW_EXTENT_FRACTION: f32 = 0.55;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Page {
Display,
Power,
Keyboard,
Network,
Bluetooth,
Windows,
WindowRules,
Keybinds,
Animation,
Idle,
Session,
Advanced,
Apps,
Appearance,
Wallpaper,
NightLight,
ScreenSharing,
Tray,
}
pub fn page<'a, Message: 'a>(kind: Page, side: f32, color: iced::Color) -> Element<'a, Message> {
canvas(PageGlyph { kind, color }).width(Length::Fixed(side)).height(Length::Fixed(side)).into()
}
struct PageGlyph {
kind: Page,
color: iced::Color,
}
const PAGE_EXTENT_FRACTION: f32 = 0.78;
impl<Message> canvas::Program<Message, Theme, Renderer> for PageGlyph {
type State = ();
fn draw(
&self,
_state: &Self::State,
renderer: &Renderer,
_theme: &Theme,
bounds: Rectangle,
_cursor: mouse::Cursor,
) -> Vec<canvas::Geometry> {
use iced::{Radians, Size};
use std::f32::consts::PI;
let mut frame = canvas::Frame::new(renderer, bounds.size());
let side = bounds.width.min(bounds.height);
let extent = side * PAGE_EXTENT_FRACTION;
let left = bounds.width / 2.0 - extent / 2.0;
let top = bounds.height / 2.0 - extent / 2.0;
let at = |x: f32, y: f32| Point::new(left + x * extent, top + y * extent);
let len = |v: f32| v * extent;
let rect = |b: &mut canvas::path::Builder, x: f32, y: f32, w: f32, h: f32, r: f32| {
b.rounded_rectangle(at(x, y), Size::new(len(w), len(h)), len(r).into());
};
let arc = |b: &mut canvas::path::Builder, x: f32, y: f32, r: f32, from: f32, to: f32| {
let start = at(x, y) + iced::Vector::new(len(r) * from.cos(), len(r) * from.sin());
b.move_to(start);
b.arc(canvas::path::Arc {
center: at(x, y),
radius: len(r),
start_angle: Radians(from),
end_angle: Radians(to),
});
};
let line = |b: &mut canvas::path::Builder, x0: f32, y0: f32, x1: f32, y1: f32| {
b.move_to(at(x0, y0));
b.line_to(at(x1, y1));
};
let path = canvas::Path::new(|b| match self.kind {
Page::Display => {
rect(b, 0.05, 0.14, 0.9, 0.58, 0.08);
line(b, 0.5, 0.72, 0.5, 0.86);
line(b, 0.3, 0.86, 0.7, 0.86);
}
Page::Power => {
rect(b, 0.04, 0.26, 0.8, 0.48, 0.08);
line(b, 0.92, 0.42, 0.92, 0.58);
}
Page::Keyboard => {
rect(b, 0.02, 0.22, 0.96, 0.56, 0.08);
for i in 0..4 {
let x = 0.2 + i as f32 * 0.2;
line(b, x, 0.42, x + 0.02, 0.42);
}
line(b, 0.28, 0.6, 0.72, 0.6);
}
Page::Network => {
for r in [0.44, 0.3, 0.16] {
arc(b, 0.5, 0.82, r, PI * 1.25, PI * 1.75);
}
line(b, 0.5, 0.8, 0.5, 0.82);
}
Page::Bluetooth => {
b.move_to(at(0.26, 0.3));
b.line_to(at(0.72, 0.7));
b.line_to(at(0.5, 0.9));
b.line_to(at(0.5, 0.1));
b.line_to(at(0.72, 0.3));
b.line_to(at(0.26, 0.7));
}
Page::Windows => {
rect(b, 0.04, 0.12, 0.5, 0.76, 0.07);
rect(b, 0.62, 0.12, 0.34, 0.34, 0.07);
rect(b, 0.62, 0.54, 0.34, 0.34, 0.07);
}
Page::WindowRules => {
rect(b, 0.04, 0.12, 0.92, 0.76, 0.07);
line(b, 0.04, 0.32, 0.96, 0.32);
line(b, 0.2, 0.52, 0.8, 0.52);
line(b, 0.2, 0.68, 0.6, 0.68);
}
Page::Keybinds => {
rect(b, 0.12, 0.12, 0.76, 0.76, 0.14);
rect(b, 0.24, 0.2, 0.52, 0.46, 0.08);
}
Page::Animation => {
b.circle(at(0.64, 0.5), len(0.26));
line(b, 0.04, 0.34, 0.26, 0.34);
line(b, 0.0, 0.5, 0.28, 0.5);
line(b, 0.04, 0.66, 0.26, 0.66);
}
Page::Idle => {
arc(b, 0.5, 0.5, 0.4, PI * 0.35, PI * 1.65);
let tip_top = at(0.5, 0.5)
+ iced::Vector::new(len(0.4) * (PI * 1.65).cos(), len(0.4) * (PI * 1.65).sin());
let tip_bottom = at(0.5, 0.5)
+ iced::Vector::new(len(0.4) * (PI * 0.35).cos(), len(0.4) * (PI * 0.35).sin());
b.move_to(tip_top);
b.quadratic_curve_to(at(0.34, 0.5), tip_bottom);
}
Page::Session => {
b.move_to(at(0.28, 0.14));
b.line_to(at(0.82, 0.5));
b.line_to(at(0.28, 0.86));
b.close();
}
Page::Advanced => {
line(b, 0.04, 0.32, 0.96, 0.32);
line(b, 0.04, 0.68, 0.96, 0.68);
b.circle(at(0.34, 0.32), len(0.11));
b.circle(at(0.66, 0.68), len(0.11));
}
Page::Apps => {
for (x, y) in [(0.08, 0.08), (0.56, 0.08), (0.08, 0.56), (0.56, 0.56)] {
rect(b, x, y, 0.36, 0.36, 0.08);
}
}
Page::Appearance => {
b.circle(at(0.5, 0.5), len(0.42));
line(b, 0.5, 0.08, 0.5, 0.92);
}
Page::Wallpaper => {
rect(b, 0.04, 0.14, 0.92, 0.72, 0.07);
b.move_to(at(0.14, 0.76));
b.line_to(at(0.4, 0.44));
b.line_to(at(0.58, 0.64));
b.line_to(at(0.7, 0.52));
b.line_to(at(0.86, 0.76));
}
Page::NightLight => {
arc(b, 0.5, 0.7, 0.26, PI, PI * 2.0);
line(b, 0.04, 0.7, 0.96, 0.7);
line(b, 0.5, 0.14, 0.5, 0.28);
line(b, 0.16, 0.34, 0.25, 0.43);
line(b, 0.84, 0.34, 0.75, 0.43);
}
Page::ScreenSharing => {
rect(b, 0.04, 0.14, 0.92, 0.64, 0.07);
line(b, 0.5, 0.64, 0.5, 0.32);
line(b, 0.36, 0.44, 0.5, 0.3);
line(b, 0.64, 0.44, 0.5, 0.3);
}
Page::Tray => {
rect(b, 0.04, 0.16, 0.92, 0.68, 0.07);
line(b, 0.04, 0.38, 0.96, 0.38);
line(b, 0.62, 0.27, 0.64, 0.27);
line(b, 0.76, 0.27, 0.78, 0.27);
}
});
frame.stroke(
&path,
canvas::Stroke {
style: canvas::Style::Solid(self.color),
width: (side * STROKE_FRACTION * 0.85).max(1.0),
line_cap: canvas::LineCap::Round,
line_join: canvas::LineJoin::Round,
..canvas::Stroke::default()
},
);
vec![frame.into_geometry()]
}
}
pub fn signal<'a, Message: 'a>(
strength: u8,
side: f32,
on: iced::Color,
off: iced::Color,
) -> Element<'a, Message> {
canvas(SignalGlyph { lit: signal_bars(strength), on, off })
.width(Length::Fixed(side))
.height(Length::Fixed(side))
.into()
}
pub fn signal_bars(strength: u8) -> u8 {
match strength {
0 => 0,
1..=29 => 1,
30..=54 => 2,
55..=79 => 3,
_ => 4,
}
}
struct SignalGlyph {
lit: u8,
on: iced::Color,
off: iced::Color,
}
impl<Message> canvas::Program<Message, Theme, Renderer> for SignalGlyph {
type State = ();
fn draw(
&self,
_state: &Self::State,
renderer: &Renderer,
_theme: &Theme,
bounds: Rectangle,
_cursor: mouse::Cursor,
) -> Vec<canvas::Geometry> {
let mut frame = canvas::Frame::new(renderer, bounds.size());
let side = bounds.width.min(bounds.height);
let extent = side * PAGE_EXTENT_FRACTION;
let left = bounds.width / 2.0 - extent / 2.0;
let bottom = bounds.height / 2.0 + extent / 2.0;
let bar = extent / 5.5;
let gap = (extent - bar * 4.0) / 3.0;
for i in 0..4u8 {
let height = extent * (0.25 + 0.25 * i as f32);
let colour = if i < self.lit { self.on } else { self.off };
frame.fill_rectangle(
Point::new(left + i as f32 * (bar + gap), bottom - height),
iced::Size::new(bar, height),
canvas::Fill::from(colour),
);
}
vec![frame.into_geometry()]
}
}
pub fn battery<'a, Message: 'a>(
fraction: f32,
side: f32,
outline: iced::Color,
fill: iced::Color,
) -> Element<'a, Message> {
canvas(BatteryGlyph { fraction: fraction.clamp(0.0, 1.0), outline, fill })
.width(Length::Fixed(side * 2.0))
.height(Length::Fixed(side))
.into()
}
struct BatteryGlyph {
fraction: f32,
outline: iced::Color,
fill: iced::Color,
}
impl<Message> canvas::Program<Message, Theme, Renderer> for BatteryGlyph {
type State = ();
fn draw(
&self,
_state: &Self::State,
renderer: &Renderer,
_theme: &Theme,
bounds: Rectangle,
_cursor: mouse::Cursor,
) -> Vec<canvas::Geometry> {
let mut frame = canvas::Frame::new(renderer, bounds.size());
let h = bounds.height;
let stroke = (h * 0.08).max(1.5);
let nub = h * 0.12;
let body_w = bounds.width - nub - stroke;
let body = canvas::Path::rounded_rectangle(
Point::new(stroke / 2.0, stroke / 2.0),
iced::Size::new(body_w, h - stroke),
(h * 0.18).into(),
);
frame.stroke(
&body,
canvas::Stroke::default().with_width(stroke).with_color(self.outline),
);
frame.fill_rectangle(
Point::new(body_w + stroke / 2.0, h * 0.32),
iced::Size::new(nub, h * 0.36),
canvas::Fill::from(self.outline),
);
let inset = stroke * 2.0;
let full = body_w - inset * 2.0 + stroke;
if self.fraction > 0.0 {
frame.fill(
&canvas::Path::rounded_rectangle(
Point::new(inset, inset),
iced::Size::new(full * self.fraction, h - inset * 2.0),
(h * 0.08).into(),
),
self.fill,
);
}
vec![frame.into_geometry()]
}
}
pub fn eject<'a, Message: 'a>(side: f32, color: iced::Color) -> Element<'a, Message> {
canvas(EjectGlyph { color }).width(Length::Fixed(side)).height(Length::Fixed(side)).into()
}
struct EjectGlyph {
color: iced::Color,
}
impl<Message> canvas::Program<Message, Theme, Renderer> for EjectGlyph {
type State = ();
fn draw(
&self,
_state: &Self::State,
renderer: &Renderer,
_theme: &Theme,
bounds: Rectangle,
_cursor: mouse::Cursor,
) -> Vec<canvas::Geometry> {
let mut frame = canvas::Frame::new(renderer, bounds.size());
let side = bounds.width.min(bounds.height);
let extent = side * VIEW_EXTENT_FRACTION;
let left = bounds.width / 2.0 - extent / 2.0;
let top = bounds.height / 2.0 - extent / 2.0;
let fill = canvas::Fill::from(self.color);
let triangle = canvas::Path::new(|b| {
b.move_to(Point::new(left + extent / 2.0, top));
b.line_to(Point::new(left + extent, top + extent * 0.6));
b.line_to(Point::new(left, top + extent * 0.6));
b.close();
});
frame.fill(&triangle, fill);
frame.fill_rectangle(
Point::new(left, top + extent * 0.78),
iced::Size::new(extent, extent * 0.22),
fill,
);
vec![frame.into_geometry()]
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn any_signal_lights_a_bar_and_only_a_strong_one_lights_four() {
assert_eq!(signal_bars(0), 0);
assert_eq!(signal_bars(1), 1);
assert_eq!(signal_bars(54), 2);
assert_eq!(signal_bars(79), 3);
assert_eq!(signal_bars(97), 4);
assert_eq!(signal_bars(100), 4);
}
}