Struct cursive::Cursive [] [src]

pub struct Cursive {
    // some fields omitted
}

Central part of the cursive library.

It initializes ncurses on creation and cleans up on drop. To use it, you should populate it with views, layouts and callbacks, then start the event loop with run().

It uses a list of screen, with one screen active at a time.

Methods

impl Cursive
[src]

fn new() -> Self

Creates a new Cursive root, and initialize ncurses.

fn cb_sink(&self) -> &Sender<Box<Fn(&mut Cursive) + Send>>

Returns a sink for asynchronous callbacks.

Returns the sender part of a channel, that allows to send callbacks to self from other threads.

Callbacks will be executed in the order of arrival on the next event cycle.

fn select_menubar(&mut self)

Selects the menubar

fn set_autohide_menu(&mut self, autohide: bool)

Sets the menubar autohide_menubar feature.

  • When enabled, the menu is only visible when selected.
  • When disabled, the menu is always visible and reserves the top row.

fn menubar(&mut self) -> &mut Menubar

Retrieve the menu tree used by the menubar.

This allows to add menu items to the menubar.

Examples

let mut siv = Cursive::new();

siv.menubar()
   .add("File",
        MenuTree::new()
            .leaf("New", |s| s.add_layer(Dialog::info("New file!")))
            .subtree("Recent", MenuTree::new().with(|tree| {
                for i in 1..100 {
                    tree.add_leaf(&format!("Item {}", i), |_| ())
                }
            }))
            .delimiter()
            .with(|tree| {
                for i in 1..10 {
                    tree.add_leaf(&format!("Option {}", i), |_| ());
                }
            })
            .delimiter()
            .leaf("Quit", |s| s.quit()))
   .add("Help",
        MenuTree::new()
            .subtree("Help",
                     MenuTree::new()
                         .leaf("General", |s| {
                             s.add_layer(Dialog::info("Help message!"))
                         })
                         .leaf("Online", |s| {
                             s.add_layer(Dialog::info("Online help?"))
                         }))
            .leaf("About",
                  |s| s.add_layer(Dialog::info("Cursive v0.0.0"))));

siv.add_global_callback(Key::Esc, |s| s.select_menubar());

fn current_theme(&self) -> &Theme

Returns the currently used theme

fn set_theme(&mut self, theme: Theme)

Sets the current theme.

fn load_theme_file<P: AsRef<Path>>(&mut self, filename: P) -> Result<()Error>

Loads a theme from the given file.

filename must point to a valid toml file.

fn load_theme(&mut self, content: &str) -> Result<()Error>

Loads a theme from the given string content.

Content must be valid toml.

fn set_fps(&self, fps: u32)

Sets the refresh rate, in frames per second.

Regularly redraws everything, even when no input is given. Between 0 and 1000. Call with fps=0 to disable (default value).

fn screen(&self) -> &StackView

Returns a reference to the currently active screen.

fn screen_mut(&mut self) -> &mut StackView

Returns a mutable reference to the currently active screen.

fn add_screen(&mut self) -> ScreenId

Adds a new screen, and returns its ID.

fn add_active_screen(&mut self) -> ScreenId

Convenient method to create a new screen, and set it as active.

fn set_screen(&mut self, screen_id: ScreenId)

Sets the active screen. Panics if no such screen exist.

fn find<V: View + Any>(&mut self, sel: &Selector) -> Option<&mut V>

Tries to find the view pointed to by the given path.

If the view is not found, or if it is not of the asked type, it returns None.

Examples

let mut siv = Cursive::new();

siv.add_layer(IdView::new("text", TextView::new("Text #1")));

siv.add_global_callback('p', |s| {
    s.find::<TextView>(&Selector::Id("text"))
     .unwrap()
     .set_content("Text #2");
});

fn find_id<V: View + Any>(&mut self, id: &str) -> Option<&mut V>

Convenient method to use find with a view::Selector::Id.

Examples

let mut siv = Cursive::new();

siv.add_layer(IdView::new("text", TextView::new("Text #1")));

siv.add_global_callback('p', |s| {
    s.find_id::<TextView>("text")
     .unwrap()
     .set_content("Text #2");
});

fn add_global_callback<F, E: Into<Event>>(&mut self, event: E, cb: F) where F: Fn(&mut Cursive) + 'static

Adds a global callback.

Will be triggered on the given key press when no view catches it.

Examples

let mut siv = Cursive::new();

siv.add_global_callback('q', |s| s.quit());

fn add_layer<T: 'static + View>(&mut self, view: T)

Convenient method to add a layer to the current screen.

Examples

let mut siv = Cursive::new();

siv.add_layer(TextView::new("Hello world!"));

fn pop_layer(&mut self)

Convenient method to remove a layer from the current screen.

fn screen_size(&self) -> Vec2

Returns the size of the screen, in characters.

fn run(&mut self)

Runs the event loop.

It will wait for user input (key presses) and trigger callbacks accordingly.

Blocks until quit() is called.

fn quit(&mut self)

Stops the event loop.

Trait Implementations

impl Default for Cursive
[src]

fn default() -> Self

Returns the "default value" for a type. Read more

impl Drop for Cursive
[src]

fn drop(&mut self)

A method called when the value goes out of scope. Read more