termrs_core 0.3.0

The core library of termrs
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

use std::{io::Error, marker::PhantomData};

use crate::{
    input::{Event, EventStatus},
    render::{Margin, Position, RenderContext, Size},
    widget::{EventContext, LayoutInfo, RenderInfo, Widget},
};

/// Adds to a [`Widget`] padding and border.
pub struct Wrapper<Message, Content, L, R>
where
    Content: Widget<Message, LayoutInfo = L, RenderInfo = R>,
    L: LayoutInfo,
    R: RenderInfo,
{
    content: Content,
    phantom_message: PhantomData<Message>,

    padding: Margin,
}

pub struct WrapperLayout<L: LayoutInfo> {
    padding: Margin,
    child_layout: L,
}

impl<L: LayoutInfo> LayoutInfo for WrapperLayout<L> {
    fn bounds(&self) -> Size {
        self.child_layout.bounds().add_margin(&self.padding)
    }
}

impl<Message, Content, L, R> Wrapper<Message, Content, L, R>
where
    Content: Widget<Message, LayoutInfo = L, RenderInfo = R>,
    L: LayoutInfo,
    R: RenderInfo,
{
    pub fn new(content: Content) -> Self {
        Self {
            content,
            phantom_message: PhantomData,
            padding: Margin::default(),
        }
    }

    pub fn with_padding(mut self, padding: Margin) -> Self {
        self.padding = padding;
        self
    }
}

impl<Message, Content, L, R> Widget<Message> for Wrapper<Message, Content, L, R>
where
    Content: Widget<Message, LayoutInfo = L, RenderInfo = R>,
    L: LayoutInfo,
    R: RenderInfo,
{
    type LayoutInfo = WrapperLayout<L>;
    type RenderInfo = R;

    fn render(
        &self,
        position: Position,
        layout: &Self::LayoutInfo,
        context: &mut dyn RenderContext,
    ) -> std::io::Result<Self::RenderInfo> {
        let position = position.offset_u16(self.padding.left(), self.padding.top());

        if let Some(position) = position {
            self.content.render(position, &layout.child_layout, context)
        } else {
            Err(Error::other("Invalid position"))
        }
    }

    fn layout(&self, available_size: Size) -> Self::LayoutInfo {
        let available_size = available_size.sub_margin(&self.padding);

        let child_layout = self.content.layout(available_size);

        WrapperLayout {
            child_layout,
            padding: self.padding.clone(),
        }
    }

    fn on_event(
        &mut self,
        event: &Event,
        render_info: &Self::RenderInfo,
        event_context: &mut dyn EventContext<Message>,
    ) -> EventStatus {
        // Wrapper is not a container, so it shares keyboard
        // and mouse focus with it's content widget.

        self.content.on_event(event, render_info, event_context)
    }
}