Method handle_keys

src/lib.rs:147–186

handle an update to the event stream This returns OK(()) if all keys are handled by the handlers and an Err(()) otherwise. that way the down stream can decide what to do (tests: panic. Firmare/MatrixToStream -> drop unhandled events)

(&mut self)

    /// that way the down stream can decide what to do
    /// (tests: panic. Firmare/MatrixToStream -> drop unhandled events)
    pub fn handle_keys(&mut self) -> Result<(), ()> {
        for (_e, status) in self.events.iter_mut() {
            *status = EventStatus::Unhandled;
        }
        //skip the modifiers
        for (ii, h) in self.handlers.iter_mut().enumerate() {
            if self.output.state().modifiers_and_enabled_handlers[ii + KEYBOARD_STATE_RESERVED_BITS]
            {
                match h.process_keys(&mut self.events, &mut self.output) {
                    HandlerResult::NoOp => {}
                    HandlerResult::Disable => {
                        self.output
                            .state()
                            .disable_handler((ii + KEYBOARD_STATE_RESERVED_BITS) as HandlerID);
                    }
                }
                if self.output.state()._aborted() {
                    self.output.state()._clear_abort();
                    self.events.clear();
                    break; // no more handlers being done
                }
            }
        }
        // remove handled & timeout events.
        self.events.drain_filter(|(event, status)| {
            (EventStatus::Handled == *status)
                || (match event {
                    Event::TimeOut(_) => true,
                    _ => false,
                })
        });
        if self
            .events
            .iter()
            .any(|(_e, status)| EventStatus::Unhandled == *status)
        {
            return Err(());
        }
        Ok(())
    }
    //throw away unhandled key events
    pub fn clear_unhandled(&mut self) {
        self.events