Struct EventHandler 

pub struct EventHandler { /* private fields */ }

Implementations

impl EventHandler

pub fn new( input_manager_state: Arc<Mutex<EventManagerState>>, ) -> (Self, Receiver<EventManagerCommand>)

pub fn create_hook(&self) -> EventHook

Examples found in repository

examples/input_handler.rs (line 52)

fn main() {
    init_terminal!();
    init_logger("./input_handler_test.log").unwrap();
    let (_input_manager, input_handler, screen_select_h) =
        CrosstermEventManager::new_with_select_sub(TargetScreen::None);
    let handle = thread::spawn(move || {
        macro_rules! try_send {
            ($message: expr) => {
                if let Err(e) = screen_select_h.send($message) {
                    info!("error sending select {:?}", e);
                    break;
                } else {
                };
            };
        }
        loop {
            if let Ok(sshm) = screen_select_h.recv() {
                match sshm {
                    ScreenSelectHMsg::Event(sm) => {
                        if let SubscriptionMessage::Mouse {
                            msg,
                            screen: _screen,
                        } = sm
                            && let MouseMessage::Pressed(_) = msg
                        {
                            try_send!(Some(TargetScreen::Screen(1)));
                        } else {
                            try_send!(None);
                        };
                    }
                    // accept incoming selection requests
                    ScreenSelectHMsg::Selection(s) => {
                        try_send!(Some(s));
                    }
                }
            }
        }
    });
    let mut hook = input_handler.create_hook();

    hook.on_key_press(KeyCode::Char('q'), |_| exit(0)).unwrap();
    hook.on_key_press(KeyCode::Char('n'), |_| eprintln!("n"))
        .unwrap();

    hook.on_mouse_button_press(MouseButtons::Left, |m| eprintln!("{:?}", m))
        .unwrap();

    while !hook.is_pressed(InputButton::Mouse(MouseButton::Right)) {}
    while hook.is_pressed(InputButton::Mouse(MouseButton::Right)) {}
    handle.join().unwrap();
    restore_terminal().unwrap();
}

examples/menu_drawable.rs (line 33)

fn main() -> Result<(), AppError> {
    init_terminal!();
    init_logger("./menu_drawable_example.log")?;
    let (cols, rows) = size()?;
    let renderer = Renderer::<DefaultScreenBuffer<CrosstermCellDrawer>, Instant>::create_renderer(
        (cols, rows),
    );
    let (r, ev_handler, _ev_manager) = start_renderer_with_input(renderer);
    r.set_update_interval(1)?;

    let hook = ev_handler.create_hook();

    let inside_rect1 = RectDrawableBuilder::new()
        .border_style(BorderStyle::Basic)
        .fill_style(' ')
        .rect(Rect::from_coords(0, 0, 3, 3))
        .build()?;
    let inside_rect2 = RectDrawableBuilder::new()
        .border_style(BorderStyle::AllRound(TerminalChar::from_char('~')))
        .fill_style(' ')
        .rect(Rect::from_coords(0, 0, 3, 3))
        .build()?;
    let inside_circle = CircleDrawableBuilder::new()
        .border_style(TerminalChar::from_char('O').set_bg(Color::Maroon))
        .radius(4)
        .build()?;
    let border_rect = RectDrawable {
        rect: Rect::from_coords(0, 0, 0, 0),
        border_thickness: 1,
        border_style: BorderStyle::AllRound(TerminalChar::from_char('+').set_fg(Color::Fuchsia)),
        fill_style: Some(TerminalChar::from_char(' ')),
        screen_fit: None,
    };

    let menu_screen = r.create_screen(AreaRect::FullScreen, 0)?;

    let menu_drawable = SelectMenuDrawable::new(
        vec![inside_rect1, inside_rect2, inside_circle],
        border_rect,
        SelectMenuFitting::FitToContents,
        menu_screen,
        hook,
        r.clone(),
    )?;

    let drawable_id = r.register_drawable(
        menu_screen,
        DrawObject {
            creation_time: std::time::Instant::now(),
            drawable: Box::new(menu_drawable),
            layer: 0,
            lifetime: ObjectLifetime::ExplicitRemove,
            shaders: Vec::new(),
        },
    )?;
    r.render_drawable(drawable_id)?;
    let hook = ev_handler.create_hook();
    loop {
        if hook.is_pressed(InputButton::Mouse(MouseButton::Right)) {
            break;
        }
    }
    let _ = restore_terminal();
    Ok(())
}

examples/screens.rs (line 124)

pub fn main() -> Result<(), AppError> {
    init_terminal!();
    init_logger("./screens_showcase.log")?;

    let (cols, rows) = size()?;
    let renderer = Renderer::<DefaultScreenBuffer<CrosstermCellDrawer>, Instant>::create_renderer(
        (cols, rows),
    );
    let (mut r, ev_handler, _ev_manager) = start_renderer_with_input(renderer);
    r.set_update_interval(1)?;

    let mut hook = ev_handler.create_hook();

    let mut ad_screens = AdjustableScreens::new_uniform_grid(WIDTH, HEIGHT, &mut r)?;

    for screen in &mut ad_screens {
        let builder = DrawObjectBuilder::default();
        let d_key = builder
            .layer(100)
            .rect_drawable(|r| {
                r.border_style(
                ltrender::terminal_buffer::standard_drawables::rect_drawable::BorderStyle::Custom {
                    top: TerminalChar::from_char('T'),
                    bottom: TerminalChar::from_char('B'),
                    left: TerminalChar::from_char('L'),
                    right: TerminalChar::from_char('R'),
                },
            )
            .border_thickness(1)
            .fill_style(' ')
            .rect(Rect::from_coords(0, 0, 2, 2))
            .screen_fit(ScreenFitType::Full)
            })?
            .add_lifetime(ObjectLifetime::ExplicitRemove)
            .screen(screen)
            .build_and_register(&mut r)?;
        info!("manually rendering drawable: {:?}", d_key);
        r.render_drawable(d_key)?;
    }

    let (s, recv) = mpsc::channel();
    let builder = DrawObjectBuilder::default();
    let text_stream = builder
        .layer(200)
        .videostream_drawable(|b| b.position((0, 0)).recv(recv))?
        .add_lifetime(ObjectLifetime::ExplicitRemove)
        .screen(0)
        .build_and_register(&mut r)?;
    let callback_hook = ev_handler.create_hook();
    let callback_renderh: RenderHandle<Instant> = r.clone();
    hook.on_mouse_button_press(MouseButtons::Left, move |_| {
        if let TargetScreen::Screen(id) = callback_hook.current_selected_screen() {
            let msg = format!("selected_screen: {}", id);
            info!("{}", msg);
            let mut data = Vec::new();
            for chr in msg.chars() {
                data.push(Some(TerminalChar::from_char(chr)));
            }
            let _ = s.send(StreamFrame {
                size: (data.len() as u16, 1),
                data,
            });
            let _ = callback_renderh.render_drawable(text_stream);
        }
    })?;
    loop {
        if hook.is_pressed(InputButton::Key(KeyCode::Char('c'))) {
            info!("breaking out of the loop");
            break;
        }

        let cur_size = size()?;
        let rendered_size = r.get_terminal_size()?;
        if cur_size != rendered_size {
            info!(
                "redrawing with cur_size: {:?}, rendered: {:?}",
                cur_size, rendered_size
            );
            r.handle_resize(cur_size)?;
            ad_screens.place_screens_uniformly(&mut r)?;
        }
    }
    restore_terminal()?;
    info!("returning with ok");
    Ok(())
}

Trait Implementations

impl Clone for EventHandler

fn clone(&self) -> EventHandler

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventHandler

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

Formats the value using the given formatter.