cursive 0.1.1

A TUI library based on ncurses-rs.
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

use std::cmp;

use XY;
use vec::Vec2;
use super::{View, ViewWrapper};

/// Wrapper around another view, with a fixed size.
///
/// Each axis can be enabled independantly.
///
/// * If both axis are fixed, the view always asks for this size.
/// * If both axis are left free, the wrapper has no effect and the underlying
///   view is directly queried.
/// * If only one axis is fixed, it will override the size request when
///   querying the wrapped view.
///
/// # Examples
///
/// ```
/// # use cursive::view::{BoxView,TextView};
/// // Creates a 20x4 BoxView with a TextView content.
/// let view = BoxView::fixed_size((20,4), TextView::new("Hello!"));
/// ```
pub struct BoxView<T: View> {
    size: XY<Option<usize>>,
    view: T,
}

impl<T: View> BoxView<T> {
    /// Wraps `view` in a new `BoxView` with the given size.
    pub fn fixed_size<S: Into<Vec2>>(size: S, view: T) -> Self {
        let size = size.into();

        BoxView::new(Some(size.x), Some(size.y), view)
    }

    /// Creates a new `BoxView` with the given width and height requirements.
    ///
    /// `None` values will use the wrapped view's preferences.
    pub fn new(width: Option<usize>, height: Option<usize>, view: T) -> Self {
        BoxView {
            size: (width, height).into(),
            view: view,
        }
    }

    /// Wraps `view` in a new `BoxView` with fixed width.
    pub fn fixed_width(width: usize, view: T) -> Self {
        BoxView::new(Some(width), None, view)
    }

    /// Wraps `view` in a new `BoxView` with fixed height.
    pub fn fixed_height(height: usize, view: T) -> Self {
        BoxView::new(None, Some(height), view)
    }
}

fn min<T: Ord>(a: T, b: Option<T>) -> T {
    match b {
        Some(b) => cmp::min(a, b),
        None => a,
    }
}

impl<T: View> ViewWrapper for BoxView<T> {
    wrap_impl!(&self.view);

    fn wrap_get_min_size(&mut self, req: Vec2) -> Vec2 {

        if let (Some(w), Some(h)) = self.size.pair() {
            // If we know everything already, no need to ask
            Vec2::new(w, h)
        } else {
            // If req < self.size in any axis, we're screwed.
            // TODO: handle insufficient space
            // (should probably show an error message or a blank canvas)

            // From now on, we assume req >= self.size.

            // Override the request on the restricted axis
            let req = req.zip_map(self.size, min);

            // Back in my time, we didn't ask kids for their opinions!
            let child_size = self.view.get_min_size(req);

            // This calls unwrap_or on each axis
            self.size.unwrap_or(child_size)
        }
    }
}