Struct Border

pub struct Border<V: View + ViewSize> {
    pub child: V,
    pub title: Option<String>,
    pub padding: BorderPadding,
    pub chars: BorderChars,
    pub foreground_colour: Colour,
    pub background_colour: Colour,
    pub title_colour: Colour,
    pub bold_title: bool,
    pub underline_title: bool,
    pub bold_border: bool,
}

Decorate another element with a border. The child element must implement View and ViewSize, and can be accessed via the child field. It’s possible to give the border a title, in which case the text appears in the top-left corner.

Fields

child: V

title: Option<String>

padding: BorderPadding

chars: BorderChars

foreground_colour: Colour

background_colour: Colour

title_colour: Colour

bold_title: bool

underline_title: bool

bold_border: bool

Implementations

impl<V: View + ViewSize> Border<V>

pub fn new(child: V) -> Self

Examples found in repository

examples/tetris.rs (line 379)

    fn new(width: u16, height: u16) -> Self {
        let context = Context::new().unwrap();
        let mut model = Model {
            game_canvas: Border::new(Canvas::new((width, height))),
            piece_canvas: Border::new(Canvas::new((6, 4))),
        };

        model.piece_canvas.title = Some("next".to_string());
        model.piece_canvas.foreground_colour = BORDER_COLOUR;
        model.piece_canvas.background_colour = BORDER_BACKGROUND;
        model.game_canvas.foreground_colour = BORDER_COLOUR;
        model.game_canvas.background_colour = BORDER_BACKGROUND;

        Self {
            context,
            model,
        }
    }
    fn display_end_text(&mut self) {
        self.context.render(&RichText::one_line(
                vec![("YOU DIED", TextInfo::default().bold().foreground_colour(colours::RED))])).unwrap();
    }
    fn render(&mut self, game: &Game) {
        game.render(&mut self.model.game_canvas.child);
        game.render_next(&mut self.model.piece_canvas.child);
        self.context.render(&self.model).unwrap();
    }
    fn main_menu(&mut self) -> MainMenuChoice {
        let mut menu = Border::new(MenuInstance::new(Menu::smallest(vec![
            ("Play", MainMenuChoice::Play),
            ("Quit", MainMenuChoice::Quit),
        ])).unwrap());

        match self.context.run_menu(&mut menu, |b| &mut b.child).unwrap() {
            MenuChoice::Finalise(x) => x,
            _ => MainMenuChoice::Quit,
        }
    }

examples/menu.rs (line 25)

fn main() {
    let mut ctx = Context::new().unwrap();

    let mut menu = Menu::new(vec![
        ("One", 1),
        ("Two", 2),
        ("Three", 3),
        ("Four", 4),
    ], (6, 4));

    menu.selected_info.foreground_colour = colours::RED;

    let mut menu_instance = Border::new(MenuInstance::new(menu).unwrap());

    let choice = loop {
        match ctx.run_menu(&mut menu_instance, |v| &mut v.child).unwrap() {
            MenuChoice::Quit => return,
            MenuChoice::Cancel => break None,
            MenuChoice::Finalise(x) => break Some(x),
        }
    };

    if let Some(x) = choice {
        ctx.render(&Text::one_line(format!("You chose: {}", x))).unwrap();
    } else {
        ctx.render(&Text::one_line("You chose nothing!")).unwrap();
    }

    thread::sleep(Duration::from_millis(1000));
}

examples/border.rs (line 33)

fn main() {
    let mut context = Context::new().unwrap();

    let mut app = App {
        a: Border::new(Text::new("abcdefghijklmnopqrstuvwxyz", (5, 5))),
        b: Border::with_title(Text::new("abcdefghijklmnopqrstuvwxyz", (5, 5)), "Foo"),
    };

    app.b.title_colour = colours::DARK_GREY;
    app.b.foreground_colour = colours::RED;
    app.b.background_colour = colours::BLUE;

    app.a.bold_border = true;
    app.b.bold_title = true;

    app.a.chars.top_left = '#';
    app.a.chars.bottom_left = '#';
    app.a.chars.top_right = '#';
    app.a.chars.bottom_right = '#';
    app.a.chars.left = '#';
    app.a.chars.right = '#';
    app.a.chars.top = '#';
    app.a.chars.bottom = '#';

    app.a.padding.top = 1;
    app.a.padding.left = 2;
    app.a.padding.right = 2;
    app.a.padding.bottom = 4;

    let mut app = Border::with_title(app, "Hello, World!");
    app.underline_title = true;

    context.render(&app).unwrap();
    context.wait_input().unwrap();
}

pub fn with_title<S: Into<String>>(child: V, title: S) -> Self

Examples found in repository

examples/border.rs (line 34)

fn main() {
    let mut context = Context::new().unwrap();

    let mut app = App {
        a: Border::new(Text::new("abcdefghijklmnopqrstuvwxyz", (5, 5))),
        b: Border::with_title(Text::new("abcdefghijklmnopqrstuvwxyz", (5, 5)), "Foo"),
    };

    app.b.title_colour = colours::DARK_GREY;
    app.b.foreground_colour = colours::RED;
    app.b.background_colour = colours::BLUE;

    app.a.bold_border = true;
    app.b.bold_title = true;

    app.a.chars.top_left = '#';
    app.a.chars.bottom_left = '#';
    app.a.chars.top_right = '#';
    app.a.chars.bottom_right = '#';
    app.a.chars.left = '#';
    app.a.chars.right = '#';
    app.a.chars.top = '#';
    app.a.chars.bottom = '#';

    app.a.padding.top = 1;
    app.a.padding.left = 2;
    app.a.padding.right = 2;
    app.a.padding.bottom = 4;

    let mut app = Border::with_title(app, "Hello, World!");
    app.underline_title = true;

    context.render(&app).unwrap();
    context.wait_input().unwrap();
}

Trait Implementations

impl<V: Clone + View + ViewSize> Clone for Border<V>

fn clone(&self) -> Border<V>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V: Debug + View + ViewSize> Debug for Border<V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, V> Deserialize<'de> for Border<V>

where V: Deserialize<'de> + View + ViewSize,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<V> Serialize for Border<V>

where V: Serialize + View + ViewSize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<V: View + ViewSize> View for Border<V>

fn view<G: ViewGrid>(&self, offset: Vector2<i16>, depth: i16, grid: &mut G)

Update the cells in grid to describe how a type should be rendered. Implementations of view for low level ui components will typically involve updating cells directly. Implementations for higer level components, such as an entire application’s ui, will typically call the view methed of lower level components which make up the ui.

impl<V: View + ViewSize> ViewSize for Border<V>

fn size(&self) -> Vector2<u16>

Returns the size in cells of the rectangle containing a ui element. This allows for the implementation of decorator ui components that render a border around some inner element.