yuno 0.1.0

A declarative UI layout and rendering framework powered by Skia.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

use crate::drawing::{Drawable, Plan};
use crate::layouts::{HasPlanner, Layout};
use skia_safe::{Canvas, Font, Paint, Point};
use std::cell::RefCell;
use std::rc::Rc;

fn format_time(ms: i64) -> String {
    if ms < 0 {
        return "00:00".to_string();
    }
    let total_secs = ms / 1000;
    format!("{:02}:{:02}", total_secs / 60, total_secs % 60)
}

pub struct TimeText {
    pub current_time: RefCell<i64>,
    pub video_length: RefCell<i64>,
    pub(crate) font: Font,
    pub(crate) text_paint: Paint,
    pub(crate) shadow_paint: Paint,
    pub(crate) planner: RefCell<Option<Rc<dyn Layout>>>,
}

impl HasPlanner for TimeText {
    fn planner(&self) -> &RefCell<Option<Rc<dyn Layout>>> {
        &self.planner
    }
    fn set_planner(&self, p: Option<Rc<dyn Layout>>) {
        *self.planner.borrow_mut() = p;
    }
}

impl Drawable for TimeText {
    fn draw(&self, canvas: &Canvas) -> anyhow::Result<()> {
        let area = self.get_planned_drawing_area(canvas);
        let time_text = format!(
            "{} / {}",
            format_time(*self.current_time.borrow()),
            format_time(*self.video_length.borrow())
        );

        let (text_width, _) = self.font.measure_str(&time_text, None);
        // Align to the right edge and bottom of the allocated rect
        let text_x = area.right - text_width;
        let text_y = area.bottom;

        canvas.draw_str(
            &time_text,
            Point::new(text_x + 1.5, text_y + 1.5),
            &self.font,
            &self.shadow_paint,
        );
        canvas.draw_str(
            &time_text,
            Point::new(text_x, text_y),
            &self.font,
            &self.text_paint,
        );

        Ok(())
    }
    fn get_horizontal_plan(&self) -> Plan {
        Plan::Fill
    }
    fn get_vertical_plan(&self) -> Plan {
        Plan::Fill
    }
}