pub async fn next_event(&mut self) -> Option<Event> {
        while let Some(ev) = self.source.next_event().await {
            #[cfg(feature = "event-cache")]
            self.cache.process_event(&ev);
            // If there is an event, it might not be something Quicksilver can process.
            // If it's not, skip this and get the next event
            if let Some(ev) = conv(ev) {
                return Some(ev);
            }
        }

        // We didn't have any Some events before we hit a None
        None
    }
/// Retrieve the next event from the environment, or wait until there is one
///
/// If an event has occured since this method was last called, it will be return as
/// `Some(event)`. Once all events have been handled, `None` will be returned. At this point you
/// should run any update or drawing logic in your app. When this method is called after it
/// returns `None`, it will yield control back to the environment until your app should run
/// again.
Retrieve the next event from the environment, or wait until there is one
If an event has occured since this method was last called, it will be return as
`Some(event)`. Once all events have been handled, `None` will be returned. At this point you
should run any update or drawing logic in your app. When this method is called after it
returns `None`, it will yield control back to the environment until your app should run
again.
Retrieve the next event from the environment or wait until there is one If an event has occured since this method was last called it will be return as ` Some ( event ) ` . Once all events have been handled ` None ` will be returned . At this point you should run any update or drawing logic in your app . When this method is called after it returns ` None ` it will yield control back to the environment until your app should run again .
pub async fn next_event(&mut self) -> Option<Event> {
        while let Some(ev) = self.source.next_event().await {
            #[cfg(feature = "event-cache")]
            self.cache.process_event(&ev);
            // If there is an event, it might not be something Quicksilver can process.
            // If it's not, skip this and get the next event
            if let Some(ev) = conv(ev) {
                return Some(ev);
            }
        }
        // We didn't have any Some events before we hit a None
        None
    }
pub async fn next_event ( & mut self ) -> Option < Event > { while let Some ( ev ) = self . source . next_event ( ) . await { # [ cfg ( feature " " ) ] self . cache . process_event ( & ev ) ; // If there is an event, it might not be something Quicksilver can process. // If it's not, skip this and get the next event if let Some ( ev ) = conv ( ev ) { return Some ( ev ) ; } } // We didn't have any Some events before we hit a None None }
Retrieve the next event from the environment, or wait until there is one
If an event has occured since this method was last called, it will be return as
`Some(event)`.
Retrieve the next event from the environment or wait until there is one If an event has occured since this method was last called it will be return as ` Some ( event ) ` .
&mut self
&mut self