ltrender 0.1.3

a diff based terminal rendering engine
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

use std::sync::mpsc::{self, Receiver};

use common_stdx::Point;

use crate::{
    error::DrawObjectBuilderError,
    terminal_buffer::{
        Drawable,
        standard_drawables::{VideoStreamDrawable, videostream_drawable::StreamFrame},
    },
};

use crate::handle_pointed_field;

#[derive(Default)]
pub struct VideoStreamDrawableBuilder {
    position: Option<Point<i32>>,
    receiver: Option<Receiver<StreamFrame>>,
    size: Option<(u16, u16)>,
}

impl VideoStreamDrawableBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    handle_pointed_field!(position, position);
    pub fn size(mut self, size: (u16, u16)) -> Self {
        self.size = Some(size);
        self
    }
    pub fn recv(mut self, receiver: Receiver<StreamFrame>) -> Self {
        self.receiver = Some(receiver);
        self
    }

    pub fn build(self) -> Result<Box<dyn Drawable>, DrawObjectBuilderError> {
        Ok(Box::new(VideoStreamDrawable {
            position: self.position.unwrap_or(Point { x: 0, y: 0 }),
            receiver: self
                .receiver
                .ok_or(DrawObjectBuilderError::FailedToBuildVideoStream())?,
            size: self.size.unwrap_or((0, 0)),
            last_frame: StreamFrame {
                size: (0, 0),
                data: Vec::new(),
            },
        }))
    }
}

pub fn make_videostream_drawable(
    position: impl Into<Point<i32>>,
    max_bounds: usize,
) -> Result<
    (
        mpsc::SyncSender<StreamFrame>,
        Box<dyn crate::terminal_buffer::Drawable>,
    ),
    crate::error::DrawObjectBuilderError,
> {
    let (sender, receiver) = mpsc::sync_channel::<StreamFrame>(max_bounds);

    let drawable = VideoStreamDrawableBuilder::new()
        .recv(receiver)
        .position(position)
        .build()?;

    Ok((sender, drawable))
}