1use iced::mouse;
32use iced::widget::canvas;
33use iced::{Element, Length, Point, Rectangle, Renderer, Theme};
34
35#[derive(Debug, Clone, Copy, PartialEq, Eq)]
37pub enum Nav {
38 Back,
39 Forward,
40 Up,
41}
42
43const STROKE_FRACTION: f32 = 1.75 / 26.0;
49
50const EXTENT_FRACTION: f32 = 0.22;
61
62pub fn nav<'a, Message: 'a>(kind: Nav, side: f32, color: iced::Color) -> Element<'a, Message> {
64 canvas(NavGlyph { kind, color })
65 .width(Length::Fixed(side))
66 .height(Length::Fixed(side))
67 .into()
68}
69
70struct NavGlyph {
71 kind: Nav,
72 color: iced::Color,
73}
74
75impl<Message> canvas::Program<Message, Theme, Renderer> for NavGlyph {
76 type State = ();
77
78 fn draw(
79 &self,
80 _state: &Self::State,
81 renderer: &Renderer,
82 _theme: &Theme,
83 bounds: Rectangle,
84 _cursor: mouse::Cursor,
85 ) -> Vec<canvas::Geometry> {
86 let mut frame = canvas::Frame::new(renderer, bounds.size());
87 let side = bounds.width.min(bounds.height);
88 let mid = Point::new(bounds.width / 2.0, bounds.height / 2.0);
89 let extent = side * EXTENT_FRACTION;
90
91 let path = canvas::Path::new(|b| match self.kind {
92 Nav::Back => {
97 b.move_to(Point::new(mid.x + extent * 0.5, mid.y - extent));
98 b.line_to(Point::new(mid.x - extent * 0.5, mid.y));
99 b.line_to(Point::new(mid.x + extent * 0.5, mid.y + extent));
100 }
101 Nav::Forward => {
102 b.move_to(Point::new(mid.x - extent * 0.5, mid.y - extent));
103 b.line_to(Point::new(mid.x + extent * 0.5, mid.y));
104 b.line_to(Point::new(mid.x - extent * 0.5, mid.y + extent));
105 }
106 Nav::Up => {
110 let head = extent * 0.72;
111 b.move_to(Point::new(mid.x, mid.y + extent));
112 b.line_to(Point::new(mid.x, mid.y - extent));
113 b.move_to(Point::new(mid.x - head, mid.y - extent + head));
114 b.line_to(Point::new(mid.x, mid.y - extent));
115 b.line_to(Point::new(mid.x + head, mid.y - extent + head));
116 }
117 });
118
119 frame.stroke(
120 &path,
121 canvas::Stroke {
122 style: canvas::Style::Solid(self.color),
123 width: side * STROKE_FRACTION,
124 line_cap: canvas::LineCap::Round,
128 line_join: canvas::LineJoin::Round,
129 ..canvas::Stroke::default()
130 },
131 );
132
133 vec![frame.into_geometry()]
134 }
135}
136
137pub fn sidebar<'a, Message: 'a>(side: f32, color: iced::Color) -> Element<'a, Message> {
145 canvas(SidebarGlyph { color, right: false }).width(Length::Fixed(side)).height(Length::Fixed(side)).into()
146}
147
148pub fn side_panel<'a, Message: 'a>(side: f32, color: iced::Color) -> Element<'a, Message> {
153 canvas(SidebarGlyph { color, right: true }).width(Length::Fixed(side)).height(Length::Fixed(side)).into()
154}
155
156struct SidebarGlyph {
157 color: iced::Color,
158 right: bool,
160}
161
162impl<Message> canvas::Program<Message, Theme, Renderer> for SidebarGlyph {
163 type State = ();
164
165 fn draw(
166 &self,
167 _state: &Self::State,
168 renderer: &Renderer,
169 _theme: &Theme,
170 bounds: Rectangle,
171 _cursor: mouse::Cursor,
172 ) -> Vec<canvas::Geometry> {
173 let mut frame = canvas::Frame::new(renderer, bounds.size());
174 let side = bounds.width.min(bounds.height);
175 let extent = side * VIEW_EXTENT_FRACTION;
176 let left = bounds.width / 2.0 - extent / 2.0;
177 let top = bounds.height / 2.0 - extent / 2.0;
178 let stroke = (extent * 0.12).max(1.0);
179 let fill = canvas::Fill::from(self.color);
180
181 let mirror = |x: f32, width: f32| if self.right { 2.0 * left + extent - x - width } else { x };
185 let mut rect = |x: f32, y: f32, w: f32, h: f32| {
186 frame.fill_rectangle(Point::new(mirror(x, w), y), iced::Size::new(w, h), fill);
187 };
188
189 let rail = extent * 0.34;
191 rect(left, top, rail, extent);
192
193 let right = left + extent;
197 let bottom = top + extent;
198 let body_left = left + rail;
199 rect(body_left, top, right - body_left, stroke);
200 rect(body_left, bottom - stroke, right - body_left, stroke);
201 rect(right - stroke, top, stroke, extent);
202
203 vec![frame.into_geometry()]
204 }
205}
206
207#[derive(Debug, Clone, Copy, PartialEq, Eq)]
214pub enum View {
215 List,
216 Grid,
217 Columns,
218}
219
220pub fn view<'a, Message: 'a>(kind: View, side: f32, color: iced::Color) -> Element<'a, Message> {
222 canvas(ViewGlyph { kind, color }).width(Length::Fixed(side)).height(Length::Fixed(side)).into()
223}
224
225struct ViewGlyph {
226 kind: View,
227 color: iced::Color,
228}
229
230impl<Message> canvas::Program<Message, Theme, Renderer> for ViewGlyph {
231 type State = ();
232
233 fn draw(
234 &self,
235 _state: &Self::State,
236 renderer: &Renderer,
237 _theme: &Theme,
238 bounds: Rectangle,
239 _cursor: mouse::Cursor,
240 ) -> Vec<canvas::Geometry> {
241 let mut frame = canvas::Frame::new(renderer, bounds.size());
242 let side = bounds.width.min(bounds.height);
243 let extent = side * VIEW_EXTENT_FRACTION;
246 let left = bounds.width / 2.0 - extent / 2.0;
247 let top = bounds.height / 2.0 - extent / 2.0;
248 let bar = (extent * 0.16).max(1.0);
249
250 let fill = canvas::Fill::from(self.color);
251 match self.kind {
252 View::List => {
254 for i in 0..3 {
255 let gap = (extent - bar * 3.0) / 2.0;
256 let y = top + i as f32 * (bar + gap);
257 frame.fill_rectangle(Point::new(left, y), iced::Size::new(extent, bar), fill);
258 }
259 }
260 View::Grid => {
262 let cell = extent * 0.42;
263 let gap = extent - cell * 2.0;
264 for (cx, cy) in [(0.0, 0.0), (1.0, 0.0), (0.0, 1.0), (1.0, 1.0)] {
265 frame.fill_rectangle(
266 Point::new(left + cx * (cell + gap), top + cy * (cell + gap)),
267 iced::Size::new(cell, cell),
268 fill,
269 );
270 }
271 }
272 View::Columns => {
274 let w = extent * 0.30;
275 let gap = extent - w * 2.0;
276 for i in 0..2 {
277 frame.fill_rectangle(
278 Point::new(left + i as f32 * (w + gap), top),
279 iced::Size::new(w, extent),
280 fill,
281 );
282 }
283 }
284 }
285
286 vec![frame.into_geometry()]
287 }
288}
289
290const VIEW_EXTENT_FRACTION: f32 = 0.55;
292
293#[derive(Debug, Clone, Copy, PartialEq, Eq)]
305pub enum Page {
306 Display,
307 Power,
308 Keyboard,
309 Network,
310 Bluetooth,
311 Windows,
312 WindowRules,
313 Keybinds,
314 Animation,
315 Idle,
316 Session,
317 Advanced,
318 Apps,
319 Appearance,
320 Wallpaper,
321 NightLight,
322 ScreenSharing,
323 Tray,
324}
325
326pub fn page<'a, Message: 'a>(kind: Page, side: f32, color: iced::Color) -> Element<'a, Message> {
328 canvas(PageGlyph { kind, color }).width(Length::Fixed(side)).height(Length::Fixed(side)).into()
329}
330
331struct PageGlyph {
332 kind: Page,
333 color: iced::Color,
334}
335
336const PAGE_EXTENT_FRACTION: f32 = 0.78;
340
341impl<Message> canvas::Program<Message, Theme, Renderer> for PageGlyph {
342 type State = ();
343
344 fn draw(
345 &self,
346 _state: &Self::State,
347 renderer: &Renderer,
348 _theme: &Theme,
349 bounds: Rectangle,
350 _cursor: mouse::Cursor,
351 ) -> Vec<canvas::Geometry> {
352 use iced::{Radians, Size};
353 use std::f32::consts::PI;
354
355 let mut frame = canvas::Frame::new(renderer, bounds.size());
356 let side = bounds.width.min(bounds.height);
357 let extent = side * PAGE_EXTENT_FRACTION;
358 let left = bounds.width / 2.0 - extent / 2.0;
359 let top = bounds.height / 2.0 - extent / 2.0;
360 let at = |x: f32, y: f32| Point::new(left + x * extent, top + y * extent);
363 let len = |v: f32| v * extent;
364 let rect = |b: &mut canvas::path::Builder, x: f32, y: f32, w: f32, h: f32, r: f32| {
365 b.rounded_rectangle(at(x, y), Size::new(len(w), len(h)), len(r).into());
366 };
367 let arc = |b: &mut canvas::path::Builder, x: f32, y: f32, r: f32, from: f32, to: f32| {
368 let start = at(x, y) + iced::Vector::new(len(r) * from.cos(), len(r) * from.sin());
369 b.move_to(start);
370 b.arc(canvas::path::Arc {
371 center: at(x, y),
372 radius: len(r),
373 start_angle: Radians(from),
374 end_angle: Radians(to),
375 });
376 };
377 let line = |b: &mut canvas::path::Builder, x0: f32, y0: f32, x1: f32, y1: f32| {
378 b.move_to(at(x0, y0));
379 b.line_to(at(x1, y1));
380 };
381
382 let path = canvas::Path::new(|b| match self.kind {
383 Page::Display => {
385 rect(b, 0.05, 0.14, 0.9, 0.58, 0.08);
386 line(b, 0.5, 0.72, 0.5, 0.86);
387 line(b, 0.3, 0.86, 0.7, 0.86);
388 }
389 Page::Power => {
391 rect(b, 0.04, 0.26, 0.8, 0.48, 0.08);
392 line(b, 0.92, 0.42, 0.92, 0.58);
393 }
394 Page::Keyboard => {
396 rect(b, 0.02, 0.22, 0.96, 0.56, 0.08);
397 for i in 0..4 {
398 let x = 0.2 + i as f32 * 0.2;
399 line(b, x, 0.42, x + 0.02, 0.42);
400 }
401 line(b, 0.28, 0.6, 0.72, 0.6);
402 }
403 Page::Network => {
405 for r in [0.44, 0.3, 0.16] {
406 arc(b, 0.5, 0.82, r, PI * 1.25, PI * 1.75);
407 }
408 line(b, 0.5, 0.8, 0.5, 0.82);
409 }
410 Page::Bluetooth => {
412 b.move_to(at(0.26, 0.3));
413 b.line_to(at(0.72, 0.7));
414 b.line_to(at(0.5, 0.9));
415 b.line_to(at(0.5, 0.1));
416 b.line_to(at(0.72, 0.3));
417 b.line_to(at(0.26, 0.7));
418 }
419 Page::Windows => {
421 rect(b, 0.04, 0.12, 0.5, 0.76, 0.07);
422 rect(b, 0.62, 0.12, 0.34, 0.34, 0.07);
423 rect(b, 0.62, 0.54, 0.34, 0.34, 0.07);
424 }
425 Page::WindowRules => {
427 rect(b, 0.04, 0.12, 0.92, 0.76, 0.07);
428 line(b, 0.04, 0.32, 0.96, 0.32);
429 line(b, 0.2, 0.52, 0.8, 0.52);
430 line(b, 0.2, 0.68, 0.6, 0.68);
431 }
432 Page::Keybinds => {
434 rect(b, 0.12, 0.12, 0.76, 0.76, 0.14);
435 rect(b, 0.24, 0.2, 0.52, 0.46, 0.08);
436 }
437 Page::Animation => {
439 b.circle(at(0.64, 0.5), len(0.26));
440 line(b, 0.04, 0.34, 0.26, 0.34);
441 line(b, 0.0, 0.5, 0.28, 0.5);
442 line(b, 0.04, 0.66, 0.26, 0.66);
443 }
444 Page::Idle => {
446 arc(b, 0.5, 0.5, 0.4, PI * 0.35, PI * 1.65);
447 let tip_top = at(0.5, 0.5)
448 + iced::Vector::new(len(0.4) * (PI * 1.65).cos(), len(0.4) * (PI * 1.65).sin());
449 let tip_bottom = at(0.5, 0.5)
450 + iced::Vector::new(len(0.4) * (PI * 0.35).cos(), len(0.4) * (PI * 0.35).sin());
451 b.move_to(tip_top);
452 b.quadratic_curve_to(at(0.34, 0.5), tip_bottom);
453 }
454 Page::Session => {
456 b.move_to(at(0.28, 0.14));
457 b.line_to(at(0.82, 0.5));
458 b.line_to(at(0.28, 0.86));
459 b.close();
460 }
461 Page::Advanced => {
463 line(b, 0.04, 0.32, 0.96, 0.32);
464 line(b, 0.04, 0.68, 0.96, 0.68);
465 b.circle(at(0.34, 0.32), len(0.11));
466 b.circle(at(0.66, 0.68), len(0.11));
467 }
468 Page::Apps => {
470 for (x, y) in [(0.08, 0.08), (0.56, 0.08), (0.08, 0.56), (0.56, 0.56)] {
471 rect(b, x, y, 0.36, 0.36, 0.08);
472 }
473 }
474 Page::Appearance => {
476 b.circle(at(0.5, 0.5), len(0.42));
477 line(b, 0.5, 0.08, 0.5, 0.92);
478 }
479 Page::Wallpaper => {
481 rect(b, 0.04, 0.14, 0.92, 0.72, 0.07);
482 b.move_to(at(0.14, 0.76));
483 b.line_to(at(0.4, 0.44));
484 b.line_to(at(0.58, 0.64));
485 b.line_to(at(0.7, 0.52));
486 b.line_to(at(0.86, 0.76));
487 }
488 Page::NightLight => {
490 arc(b, 0.5, 0.7, 0.26, PI, PI * 2.0);
491 line(b, 0.04, 0.7, 0.96, 0.7);
492 line(b, 0.5, 0.14, 0.5, 0.28);
493 line(b, 0.16, 0.34, 0.25, 0.43);
494 line(b, 0.84, 0.34, 0.75, 0.43);
495 }
496 Page::ScreenSharing => {
498 rect(b, 0.04, 0.14, 0.92, 0.64, 0.07);
499 line(b, 0.5, 0.64, 0.5, 0.32);
500 line(b, 0.36, 0.44, 0.5, 0.3);
501 line(b, 0.64, 0.44, 0.5, 0.3);
502 }
503 Page::Tray => {
505 rect(b, 0.04, 0.16, 0.92, 0.68, 0.07);
506 line(b, 0.04, 0.38, 0.96, 0.38);
507 line(b, 0.62, 0.27, 0.64, 0.27);
508 line(b, 0.76, 0.27, 0.78, 0.27);
509 }
510 });
511
512 frame.stroke(
513 &path,
514 canvas::Stroke {
515 style: canvas::Style::Solid(self.color),
516 width: (side * STROKE_FRACTION * 0.85).max(1.0),
521 line_cap: canvas::LineCap::Round,
522 line_join: canvas::LineJoin::Round,
523 ..canvas::Stroke::default()
524 },
525 );
526
527 vec![frame.into_geometry()]
528 }
529}
530
531pub fn signal<'a, Message: 'a>(
537 strength: u8,
538 side: f32,
539 on: iced::Color,
540 off: iced::Color,
541) -> Element<'a, Message> {
542 canvas(SignalGlyph { lit: signal_bars(strength), on, off })
543 .width(Length::Fixed(side))
544 .height(Length::Fixed(side))
545 .into()
546}
547
548pub fn signal_bars(strength: u8) -> u8 {
551 match strength {
552 0 => 0,
553 1..=29 => 1,
554 30..=54 => 2,
555 55..=79 => 3,
556 _ => 4,
557 }
558}
559
560struct SignalGlyph {
561 lit: u8,
562 on: iced::Color,
563 off: iced::Color,
564}
565
566impl<Message> canvas::Program<Message, Theme, Renderer> for SignalGlyph {
567 type State = ();
568
569 fn draw(
570 &self,
571 _state: &Self::State,
572 renderer: &Renderer,
573 _theme: &Theme,
574 bounds: Rectangle,
575 _cursor: mouse::Cursor,
576 ) -> Vec<canvas::Geometry> {
577 let mut frame = canvas::Frame::new(renderer, bounds.size());
578 let side = bounds.width.min(bounds.height);
579 let extent = side * PAGE_EXTENT_FRACTION;
580 let left = bounds.width / 2.0 - extent / 2.0;
581 let bottom = bounds.height / 2.0 + extent / 2.0;
582 let bar = extent / 5.5;
583 let gap = (extent - bar * 4.0) / 3.0;
584 for i in 0..4u8 {
585 let height = extent * (0.25 + 0.25 * i as f32);
586 let colour = if i < self.lit { self.on } else { self.off };
587 frame.fill_rectangle(
588 Point::new(left + i as f32 * (bar + gap), bottom - height),
589 iced::Size::new(bar, height),
590 canvas::Fill::from(colour),
591 );
592 }
593 vec![frame.into_geometry()]
594 }
595}
596
597pub fn battery<'a, Message: 'a>(
603 fraction: f32,
604 side: f32,
605 outline: iced::Color,
606 fill: iced::Color,
607) -> Element<'a, Message> {
608 canvas(BatteryGlyph { fraction: fraction.clamp(0.0, 1.0), outline, fill })
609 .width(Length::Fixed(side * 2.0))
610 .height(Length::Fixed(side))
611 .into()
612}
613
614struct BatteryGlyph {
615 fraction: f32,
616 outline: iced::Color,
617 fill: iced::Color,
618}
619
620impl<Message> canvas::Program<Message, Theme, Renderer> for BatteryGlyph {
621 type State = ();
622
623 fn draw(
624 &self,
625 _state: &Self::State,
626 renderer: &Renderer,
627 _theme: &Theme,
628 bounds: Rectangle,
629 _cursor: mouse::Cursor,
630 ) -> Vec<canvas::Geometry> {
631 let mut frame = canvas::Frame::new(renderer, bounds.size());
632 let h = bounds.height;
633 let stroke = (h * 0.08).max(1.5);
634 let nub = h * 0.12;
635 let body_w = bounds.width - nub - stroke;
636 let body = canvas::Path::rounded_rectangle(
637 Point::new(stroke / 2.0, stroke / 2.0),
638 iced::Size::new(body_w, h - stroke),
639 (h * 0.18).into(),
640 );
641 frame.stroke(
642 &body,
643 canvas::Stroke::default().with_width(stroke).with_color(self.outline),
644 );
645 frame.fill_rectangle(
647 Point::new(body_w + stroke / 2.0, h * 0.32),
648 iced::Size::new(nub, h * 0.36),
649 canvas::Fill::from(self.outline),
650 );
651 let inset = stroke * 2.0;
653 let full = body_w - inset * 2.0 + stroke;
654 if self.fraction > 0.0 {
655 frame.fill(
656 &canvas::Path::rounded_rectangle(
657 Point::new(inset, inset),
658 iced::Size::new(full * self.fraction, h - inset * 2.0),
659 (h * 0.08).into(),
660 ),
661 self.fill,
662 );
663 }
664 vec![frame.into_geometry()]
665 }
666}
667
668pub fn eject<'a, Message: 'a>(side: f32, color: iced::Color) -> Element<'a, Message> {
676 canvas(EjectGlyph { color }).width(Length::Fixed(side)).height(Length::Fixed(side)).into()
677}
678
679struct EjectGlyph {
680 color: iced::Color,
681}
682
683impl<Message> canvas::Program<Message, Theme, Renderer> for EjectGlyph {
684 type State = ();
685
686 fn draw(
687 &self,
688 _state: &Self::State,
689 renderer: &Renderer,
690 _theme: &Theme,
691 bounds: Rectangle,
692 _cursor: mouse::Cursor,
693 ) -> Vec<canvas::Geometry> {
694 let mut frame = canvas::Frame::new(renderer, bounds.size());
695 let side = bounds.width.min(bounds.height);
696 let extent = side * VIEW_EXTENT_FRACTION;
697 let left = bounds.width / 2.0 - extent / 2.0;
698 let top = bounds.height / 2.0 - extent / 2.0;
699 let fill = canvas::Fill::from(self.color);
700 let triangle = canvas::Path::new(|b| {
704 b.move_to(Point::new(left + extent / 2.0, top));
705 b.line_to(Point::new(left + extent, top + extent * 0.6));
706 b.line_to(Point::new(left, top + extent * 0.6));
707 b.close();
708 });
709 frame.fill(&triangle, fill);
710 frame.fill_rectangle(
711 Point::new(left, top + extent * 0.78),
712 iced::Size::new(extent, extent * 0.22),
713 fill,
714 );
715 vec![frame.into_geometry()]
716 }
717}
718
719#[cfg(test)]
737mod tests {
738 use super::*;
739
740 #[test]
743 fn any_signal_lights_a_bar_and_only_a_strong_one_lights_four() {
744 assert_eq!(signal_bars(0), 0);
745 assert_eq!(signal_bars(1), 1);
746 assert_eq!(signal_bars(54), 2);
747 assert_eq!(signal_bars(79), 3);
748 assert_eq!(signal_bars(97), 4);
749 assert_eq!(signal_bars(100), 4);
750 }
751}