rgx 0.9.0

A 2D graphics toolkit for rust
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

use super::*;

/// Widget layout context.
#[derive(Debug, Copy, Clone)]
pub struct LayoutCtx<'a> {
    pub fonts: &'a HashMap<text::FontId, text::Font>,
}

impl<'a> LayoutCtx<'a> {
    pub fn new(fonts: &'a HashMap<text::FontId, text::Font>) -> Self {
        Self { fonts }
    }
}

/// Widget general context.
#[derive(Debug, Copy, Clone)]
pub struct Context<'a> {
    /// Widget transform.
    pub transform: Transform,
    /// Cursor position relative to widget.
    pub cursor: Point,
    /// Loaded textures.
    pub surfaces: &'a HashMap<TextureId, Image>,
    /// Whether this widget is hot.
    pub hot: bool,
    /// Whether this widget is active.
    pub active: bool,
}

impl<'a> Context<'a> {
    pub fn new(cursor: Point, surfaces: &'a HashMap<TextureId, Image>) -> Self {
        Self {
            transform: Transform::identity(),
            cursor,
            surfaces,
            hot: false,
            active: false,
        }
    }

    /// Offset this context.
    pub fn offset(self, offset: Offset) -> Self {
        self.transform(Transform::translate(offset))
    }

    /// Set widget "hot" state.
    pub fn hot(self, hot: bool) -> Self {
        Self { hot, ..self }
    }

    /// Set widget "active" state.
    pub fn active(self, active: bool) -> Self {
        Self { active, ..self }
    }

    /// Transform context.
    pub fn transform(self, t: impl Into<Transform>) -> Self {
        let t = t.into();
        let transform = self.transform * t;

        Self {
            transform,
            cursor: self.cursor.untransform(t),
            ..self
        }
    }

    /// Check hot state.
    pub fn is_hot(&self) -> bool {
        self.hot
    }
}