Struct arkham::prelude::ViewContext

source ·

pub struct ViewContext {
    pub view: View,
    pub container: Rc<RefCell<Container>>,
    /* private fields */
}

Expand description

ViewContext represents the display context for a given area. it maintains the drawing state for the region internally and is used to generate a final view that is eventually rendered.

Fields§

§view: View§container: Rc<RefCell<Container>>

Implementations§

source §

impl ViewContext

source

pub fn new(container: Rc<RefCell<Container>>, size: Size) -> Self

Constructs a new ViewConext for a given area. A container reference must also be passedo, so that component functions called from the context are injectable.

source

pub fn render(&mut self)

Notify the application to rerender the view. This is useful after a state change that might affect other views.

Examples found in repository ?

examples/navigation.rs (line 34)

fn main_route(ctx: &mut ViewContext, kb: Res<Keyboard>, route: State<Route>) {
    ctx.insert(
        0,
        "Welcome to the main screen, press 2 to goto the secondary screen",
    );
    if kb.char() == Some('2') {
        *route.get_mut() = Route::Secondary;
        ctx.render();
    }
}

fn secondary_route(ctx: &mut ViewContext, kb: Res<Keyboard>, route: State<Route>) {
    ctx.insert(
        0,
        "Welcome to the secondary screen, press 1 to goto the main screen",
    );

    if kb.char() == Some('1') {
        *route.get_mut() = Route::Main;
        ctx.render();
    }
}

source

pub fn vertical_stack<S>(&self, size: S) -> Stack
where S: Into<Size>,

Examples found in repository ?

examples/stack.rs (line 8)

fn root(ctx: &mut ViewContext) {
    let mut stack = ctx.vertical_stack((100, 100));
    for _ in 0..10 {
        stack.component((ctx.size().width, 1), list_item);
    }
    ctx.component((0, (100, 100)), stack);
}

source

pub fn horizontal_stack<S>(&self, size: S) -> Stack
where S: Into<Size>,

Examples found in repository ?

examples/stack.rs (line 17)

fn list_item(ctx: &mut ViewContext) {
    let size = ctx.size();
    let mut hstack = ctx.horizontal_stack((ctx.size().width, 1));
    hstack.insert("> ");
    hstack.insert("line 1");
    ctx.component(size, hstack);
}

source

pub fn component<F, Args, R>(&mut self, rect: R, f: F)
where F: Callable<Args>, Args: FromContainer, R: Into<Rect>,

Execute a component function. The passed function will receive a new ViewContext for its size and can be injected with arguments. The context given to the component function will then be applied to the parent ViewContext at a given position.

Examples found in repository ?

examples/stack.rs (line 12)

fn root(ctx: &mut ViewContext) {
    let mut stack = ctx.vertical_stack((100, 100));
    for _ in 0..10 {
        stack.component((ctx.size().width, 1), list_item);
    }
    ctx.component((0, (100, 100)), stack);
}

fn list_item(ctx: &mut ViewContext) {
    let size = ctx.size();
    let mut hstack = ctx.horizontal_stack((ctx.size().width, 1));
    hstack.insert("> ");
    hstack.insert("line 1");
    ctx.component(size, hstack);
}

More examples

Hide additional examples

examples/component_functions.rs (line 10)

fn root(ctx: &mut ViewContext) {
    let size = ctx.size();
    ctx.fill(size, Rune::new().bg(Color::DarkGrey));
    ctx.component(Rect::new((10, 10), (20, 1)), hello_world);
    ctx.component(Rect::new(0, (size.width, 1)), quit_nag);
}

examples/component_params.rs (line 10)

fn root(ctx: &mut ViewContext) {
    let size = ctx.size();
    ctx.fill(size, Rune::new().bg(Color::DarkGrey));
    ctx.component(Rect::new((10, 10), (20, 1)), say_hello("Alice"));
    ctx.component(Rect::new(0, (size.width, 1)), quit_nag);
}

examples/keyboard.rs (line 10)

fn root(ctx: &mut ViewContext) {
    let size = ctx.size();
    ctx.fill(size, Rune::new().bg(Color::DarkGrey));
    ctx.component(((10, 10), (30, 1)), hello_world);
    ctx.component(((10, 11), (20, 1)), show_key_press);
    ctx.component((0, (size.width, 1)), quit_nag);
}

examples/navigation.rs (line 19)

fn root(ctx: &mut ViewContext, route: State<Route>) {
    let size = ctx.size();
    let r = *route.get();
    ctx.insert((0, 0), "Press Q to quit");
    match r {
        Route::Main => {
            ctx.component(Rect::new((0, 1), size), main_route);
        }
        Route::Secondary => {
            ctx.component(Rect::new((0, 1), size), secondary_route);
        }
    }
}

source

pub fn set_rune(&mut self, pos: P, rune: Rune)
where P: Into<Pos>,

Set a specific rune to a specific position. This function can be used to set a signle character. To set multiple runes at a time see the View::insert function.