widgem 0.0.1

A lightweight cross-platform desktop widget toolkit
Documentation 
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use {
    super::{Widget, WidgetBaseOf},
    crate::{
        draw::DrawEvent,
        impl_widget_base,
        layout::SizeHints,
        types::{PhysicalPixels, Point},
    },
    anyhow::Result,
    png::DecodingError,
    std::{path::Path, rc::Rc},
    tiny_skia::Pixmap,
    usvg::Transform,
    widgem_macros::impl_with,
};

pub struct Image {
    pixmap: Option<Rc<Pixmap>>,
    // TODO: finite f32
    scale: Option<f32>,
    base: WidgetBaseOf<Self>,
    is_prescaled: bool,
}

#[impl_with]
impl Image {
    pub fn set_prescaled(&mut self, value: bool) {
        self.is_prescaled = value;
        self.base.size_hint_changed();
        self.base.update();
    }

    pub fn is_prescaled(&self) -> bool {
        self.is_prescaled
    }

    pub fn set_pixmap(&mut self, pixmap: Option<Rc<Pixmap>>) {
        if self.pixmap.as_ref().map(Rc::as_ptr) == pixmap.as_ref().map(Rc::as_ptr) {
            return;
        }
        self.pixmap = pixmap;
        self.base.size_hint_changed();
        self.base.update();
    }

    pub fn load_png<P: AsRef<Path>>(&mut self, path: P) -> Result<(), DecodingError> {
        self.set_pixmap(Some(Rc::new(Pixmap::load_png(path)?)));
        Ok(())
    }

    pub fn set_scale(&mut self, scale: Option<f32>) {
        if self.scale == scale {
            return;
        }
        self.scale = scale;
        self.base.size_hint_changed();
        self.base.update();
    }

    fn total_scale(&self) -> f32 {
        let extra_scale = if self.is_prescaled {
            1.0
        } else {
            self.base.scale()
        };
        self.scale.unwrap_or(1.0) * extra_scale
    }

    pub fn map_widget_pos_to_content_pos(&self, pos: Point) -> Point {
        let scale = self.total_scale();
        Point::new(pos.x().div_f32_round(scale), pos.y().div_f32_round(scale))
    }
}

impl Widget for Image {
    impl_widget_base!();

    fn new(base: WidgetBaseOf<Self>) -> Self {
        Self {
            base,
            pixmap: None,
            is_prescaled: false,
            scale: None,
        }
    }

    fn handle_draw(&mut self, event: DrawEvent) -> Result<()> {
        let scale = self.total_scale();
        if let Some(pixmap) = &self.pixmap {
            event.draw_pixmap(
                Point::default(),
                (**pixmap).as_ref(),
                Transform::from_scale(scale, scale),
            );
        }
        Ok(())
    }

    fn handle_size_hint_x_request(&mut self) -> Result<SizeHints> {
        let scale = self.total_scale();
        let size = (self.pixmap.as_ref().map_or(0.0, |p| p.width() as f32) * scale).ceil() as i32;

        Ok(SizeHints {
            min: PhysicalPixels::from_i32(size),
            preferred: PhysicalPixels::from_i32(size),
            is_fixed: true,
        })
    }

    fn handle_size_hint_y_request(&mut self, _size_x: PhysicalPixels) -> Result<SizeHints> {
        let scale = self.total_scale();
        let size = (self.pixmap.as_ref().map_or(0.0, |p| p.height() as f32) * scale).ceil() as i32;

        Ok(SizeHints {
            min: PhysicalPixels::from_i32(size),
            preferred: PhysicalPixels::from_i32(size),
            is_fixed: true,
        })
    }

    fn handle_layout(&mut self, _event: crate::event::LayoutEvent) -> Result<()> {
        Ok(())
    }
}