Hopefully fix read not triggering draw

The terminal mutex is no longer released between event processing and
doing a draw. This may fix the race condition with data arriving but not
being displayed until a subsequent event.

cc #29

src/event.rs

@@ -2,14 +2,15 @@
 use std::borrow::Cow;
 use std::fs::File;
 use std::io::Write;
-use std::sync::{Arc, mpsc};
+use std::sync::mpsc;
-use serde_json as json;
 
+use serde_json as json;
+use parking_lot::MutexGuard;
 use glutin::{self, ElementState};
-use index::{Line, Column, Side};
 
 use config::Config;
 use display::OnResize;
+use index::{Line, Column, Side};
 use input::{self, ActionContext, MouseBinding, KeyBinding};
 use selection::Selection;
 use sync::FairMutex;
@@ -58,7 +59,6 @@ pub struct Processor<N> {
     mouse_bindings: Vec<MouseBinding>,
     notifier: N,
     mouse: Mouse,
-    terminal: Arc<FairMutex<Term>>,
     resize_tx: mpsc::Sender<(u32, u32)>,
     ref_test: bool,
     size_info: SizeInfo,
@@ -81,21 +81,15 @@ impl<N: Notify> Processor<N> {
     /// pty.
     pub fn new(
         notifier: N,
-        terminal: Arc<FairMutex<Term>>,
         resize_tx: mpsc::Sender<(u32, u32)>,
         config: &Config,
         ref_test: bool,
+        size_info: SizeInfo,
     ) -> Processor<N> {
-        let size_info = {
-            let terminal = terminal.lock();
-            terminal.size_info().to_owned()
-        };
-
         Processor {
             key_bindings: config.key_bindings().to_vec(),
             mouse_bindings: config.mouse_bindings().to_vec(),
             notifier: notifier,
-            terminal: terminal,
             resize_tx: resize_tx,
             ref_test: ref_test,
             mouse: Default::default(),
@@ -176,13 +170,20 @@ impl<N: Notify> Processor<N> {
     }
 
     /// Process at least one event and handle any additional queued events.
-    pub fn process_events(&mut self, window: &Window) -> bool {
+    pub fn process_events<'a>(
+        &mut self,
+        term: &'a FairMutex<Term>,
+        window: &Window
+    ) -> (MutexGuard<'a, Term>, bool) {
         let mut wakeup_request = false;
 
-        // These are lazily initialized the first time an event is returned
+        // Terminal is lazily initialized the first time an event is returned
-        // from the blocking WaitEventsIterator. Otherwise, the pty reader
+        // from the blocking WaitEventsIterator. Otherwise, the pty reader would
-        // would be blocked the entire time we wait for input!
+        // be blocked the entire time we wait for input!
         let terminal;
+
+        {
+            // Ditto on lazy initialization for context and processor.
             let context;
             let mut processor: input::Processor<N>;
 
@@ -201,7 +202,7 @@ impl<N: Notify> Processor<N> {
 
             match window.wait_events().next() {
                 Some(event) => {
-                terminal = self.terminal.lock();
+                    terminal = term.lock();
                     context = ActionContext {
                         terminal: &terminal,
                         notifier: &mut self.notifier,
@@ -225,8 +226,9 @@ impl<N: Notify> Processor<N> {
             for event in window.poll_events() {
                 process!(event);
             }
+        }
 
-        wakeup_request
+        (terminal, wakeup_request)
     }
 
     pub fn update_config(&mut self, config: &Config) {

src/main.rs

@@ -104,10 +104,10 @@ fn run(mut config: Config, options: cli::Options) -> Result<(), Box<Error>> {
     // Need the Rc<RefCell<_>> here since a ref is shared in the resize callback
     let mut processor = event::Processor::new(
         event_loop::Notifier(loop_tx),
-        terminal.clone(),
         display.resize_channel(),
         &config,
         options.ref_test,
+        display.size().to_owned(),
     );
 
     // Create a config monitor when config was loaded from path
@@ -123,7 +123,7 @@ fn run(mut config: Config, options: cli::Options) -> Result<(), Box<Error>> {
     // Main display loop
     loop {
         // Process input and window events
-        let wakeup_request = processor.process_events(display.window());
+        let (mut terminal, wakeup_request) = processor.process_events(&terminal, display.window());
 
         // Handle config reloads
         let config_updated = config_monitor.as_ref()
@@ -136,7 +136,6 @@ fn run(mut config: Config, options: cli::Options) -> Result<(), Box<Error>> {
             }).unwrap_or(false);
 
         // Maybe draw the terminal
-        let mut terminal = terminal.lock();
         if wakeup_request || config_updated {
             // Handle pending resize events
             //