fp_tui 0.2.2

A very basic tui library
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use std::rc::Rc;
use std::cell::RefCell;

use crate::Widget;
use crate::common::{BoundingBox, Dimensions, Position};

/// #### Description
/// A widget for drawing on a 2d canvas
/// 
/// Currently there is minimal functionality for this, it might be expanded upon
/// in the future
/// 
pub struct CanvasWidget {
    /// #### Description
    /// The bounds of the canvas
    /// 
    bounding_box: BoundingBox,

    /// #### Description
    /// A buffer of characters to draw to
    /// 
    buffer: Box<[Box<[char]>]>
}

impl CanvasWidget {
    /// #### Description
    /// Creates a new canvas widget
    /// 
    /// #### Arguments
    /// * `x`: [i32] - The x position of the widget
    /// * `y`: [i32] - The y position of the widget
    /// * `width`: [u32] - The width of the widget
    /// * `height`: [u32] - The height of the widget
    /// 
    pub fn new(x: i32, y: i32, width: u32, height: u32) -> Rc<RefCell<Self>> {
        let bounding_box = BoundingBox::new(
            Position::new(x, y),
            Dimensions::new(width, height)
        );

        let mut buffer_vec = vec![];
        let row_vec = vec![' '; width as usize];

        for _ in 0..height {
            buffer_vec.push(
                row_vec.clone().into_boxed_slice()
            );
        }

        return Rc::new(RefCell::new(Self {
            bounding_box,
            buffer: buffer_vec.into_boxed_slice()
        }));
    }

    /// #### Description
    /// Retrieves the width of the canvas
    ///
    /// #### Returns
    /// [u32] - The width of the canvas
    ///
    pub fn get_width(&self) -> u32 {
        return self.get_bounding_box().get_width();
    }

    /// #### Description
    /// Retrieves the height of the display buffer
    ///
    /// #### Returns
    /// [u32] - The height of the display buffer
    ///
    pub fn get_height(&self) -> u32 {
        return self.get_bounding_box().get_height();
    }

    /// #### Description
    /// Draws a character to the canvas
    ///
    /// If the coordinates are out of the bounds of the canvas it ignores the 
    /// write
    ///
    /// #### Arguments
    /// * `c`: [char] - The character to insert
    /// * `x`: [u32] - The x position to write to
    /// * `y`: [u32] - The y position to write to
    ///
    pub fn set_char(&mut self, c: char, x: i32, y: i32) {
        // Guard for detecting if the coordinates are in bounds
        if self.get_bounding_box().get_width() <= x as u32 || 
           self.get_bounding_box().get_height() <= y as u32 ||
           x < 0 ||
           y < 0
        {
            return;
        }
        else {
            self.buffer[y as usize][x as usize] = c;
        }
    }

    /// #### Description
    /// Clears the canvas to a specified character
    ///
    /// #### Arguments
    /// * `c`: [char] - The character to clear with
    ///
    pub fn clear(&mut self, c: char) {
        for y in 0..self.get_bounding_box().get_height() {
            for x in 0..self.get_bounding_box().get_width() {
                self.buffer[y as usize][x as usize] = c;
            }
        }
    }
}

impl Widget for CanvasWidget {
    fn draw(
            &mut self,
            positioning_algorithm: &Box<dyn crate::PositioningAlgorithm>,
            display_buffer: &mut crate::DisplayBuffer
        ) {
        let abs_pos = positioning_algorithm.calculate_position(
            self.bounding_box.get_position()
        );

        for y in 0..self.get_bounding_box().get_height() {
            for x in 0..self.get_bounding_box().get_width() {
                display_buffer.set_char(
                    self.buffer[y as usize][x as usize],
                    x as i32 + abs_pos.get_x(),
                    y as i32 + abs_pos.get_y()
                );
            }
        }
    }

    fn get_bounding_box(&self) -> crate::common::BoundingBox {
        return self.bounding_box;
    }
}