Fix Viewport update bug (#45)

* Add pending notifications queue

The viewport isn't being properly updated, which partially is
caused by notifications being dropped when the view-id isn't known.
- Added a queue of pending notifications to the EditView struct
- Drain the queue and send to core once the view-id is received.
- Update the viewport with the calculated size in `Widget`::layout

* Zorch viewport on new view

Also moving invalidation around. The invalidation changes were included
as they affect the UX in a similar way.

Author: LiHRaM

src/edit_view.rs

@@ -18,6 +18,7 @@ use std::cmp::min;
 use std::ops::Range;
 use std::any::Any;
 use std::sync::{Mutex, Weak};
+use std::mem;
 
 use serde_json::Value;
 
@@ -59,16 +60,20 @@ pub enum EditViewCommands {
     SelectAll,
 }
 
+type Method = String;
+type Params = Value;
+
 /// State and behavior for one editor view.
 pub struct EditView {
-    view_id: String,
+    view_id: Option<String>,
     line_cache: LineCache,
     dwrite_factory: directwrite::Factory,
     resources: Option<Resources>,
     scroll_offset: f32,
     size: (f32, f32),  // in px units
     viewport: Range<usize>,
     core: Weak<Mutex<Core>>,
+    pending: Vec<(Method, Params)>,
 }
 
 struct Resources {
@@ -116,7 +121,10 @@ impl Widget for EditView {
     fn layout(&mut self, bc: &BoxConstraints, _children: &[Id], _size: Option<(f32, f32)>,
         _ctx: &mut LayoutCtx) -> LayoutResult
     {
-        LayoutResult::Size(bc.constrain((0.0, 0.0)))
+        let size = bc.constrain((0.0, 0.0));
+        self.size = size;
+        self.update_viewport();
+        LayoutResult::Size(size)
     }
 
     fn mouse(&mut self, event: &MouseEvent, _ctx: &mut HandlerCtx) -> bool { 
@@ -137,13 +145,24 @@ impl Widget for EditView {
         if let Some(cmd) = payload.downcast_ref::<EditViewCommands>() {
             match cmd {
                 EditViewCommands::ViewId(view_id) => {
-                    self.view_id = view_id.to_string();
+                    self.view_id = Some(view_id.to_string());
+                    self.viewport = 0..0; // zorch viewport
+                    self.update_viewport();
+
+                    // Fire off the pending notifications
+                    let pending = mem::replace(&mut self.pending, Vec::new());
+                    for notification in pending {
+                        let (method, params) = notification;
+                        self.send_edit_cmd(&method, &params);
+                    }
                 }
                 EditViewCommands::ApplyUpdate(update) => {
                     self.apply_update(&update);
+                    ctx.invalidate();
                 }
                 EditViewCommands::ScrollTo(line) => {
                     self.scroll_to(*line);
+                    ctx.invalidate();
                 }
                 EditViewCommands::Core(core) => {
                     self.core = core.clone();
@@ -164,48 +183,55 @@ impl Widget for EditView {
                     self.send_action("transpose");
                 }
                 EditViewCommands::AddCursorAbove => {
-                    self.add_cursor_above();
+                    // Note: some subtlety around find, the escape key cancels it, but the menu
+                    // shouldn't.
+                    self.send_action("add_selection_above");
                 }
                 EditViewCommands::AddCursorBelow => {
-                    self.add_cursor_below();
+                    // Note: some subtlety around find, the escape key cancels it, but the menu
+                    // shouldn't.
+                    self.send_action("add_selection_below");
                 }
                 EditViewCommands::SingleSelection => {
-                    self.single_selection();
+                    // Note: some subtlety around find, the escape key cancels it, but the menu
+                    // shouldn't.
+                    self.send_action("cancel_operation");
                 }
                 EditViewCommands::SelectAll => {
-                    self.select_all();
+                    // Note: some subtlety around find, the escape key cancels it, but the menu
+                    // shouldn't.
+                    self.send_action("select_all");
                 }
             }
-            // TODO: Finer grained invalidation
-            ctx.invalidate();
         }
         true
     }
 
-    fn key(&mut self, event: &KeyEvent, _ctx: &mut HandlerCtx) -> bool {
+    fn key(&mut self, event: &KeyEvent, ctx: &mut HandlerCtx) -> bool {
         match event.key {
             KeyVariant::Vkey(vk) => {
-                self.keydown(vk, event.mods);
+                return self.keydown(vk, event.mods, ctx)
             }
             KeyVariant::Char(ch) => {
                 self.char(ch as u32, event.mods);
             }
-        } 
+        }
         true
     }
 }
 
 impl EditView {
     pub fn new() -> EditView {
         EditView {
-            view_id: "".into(),
+            view_id: Default::default(),
             line_cache: LineCache::new(),
             dwrite_factory: directwrite::Factory::new().unwrap(),
             resources: None,
             scroll_offset: 0.0,
             size: (0.0, 0.0),
             viewport: 0..0,
             core: Default::default(),
+            pending: Default::default(),
         }
     }
 
@@ -232,11 +258,6 @@ impl EditView {
         self.resources = None;
     }
 
-    pub fn size(&mut self, x: f32, y: f32) {
-        self.size = (x, y);
-        self.constrain_scroll();
-    }
-
     pub fn clear_line_cache(&mut self) {
         self.line_cache = LineCache::new();
     }
@@ -254,7 +275,7 @@ impl EditView {
         self.constrain_scroll();
     }
 
-    pub fn char(&self, ch: u32, _mods: u32) {
+    pub fn char(&mut self, ch: u32, _mods: u32) {
         if let Some(c) = ::std::char::from_u32(ch) {
             if ch >= 0x20 {
                 // Don't insert control characters
@@ -264,34 +285,35 @@ impl EditView {
         }
     }
 
-    fn send_edit_cmd(&self, method: &str, params: &Value) {
-        let edit_params = json!({
-            "method": method,
-            "params": params,
-            "view_id": &self.view_id,
-        });
-        self.send_notification("edit", &edit_params);
-    }
+    fn send_edit_cmd(&mut self, method: &str, params: &Value) {
+        // TODO: When let_chains lands, this will be easier.
+        let core = self.core.upgrade();
+        if core.is_some() && self.view_id.is_some() {
+            let view_id = &self.view_id.clone().unwrap();
+            let edit_params = json!({
+                "method": method,
+                "params": params,
+                "view_id": view_id,
+            });
 
-    fn send_notification(&self, method: &str, params: &Value) {
-        if let Some(ref core) = self.core.upgrade() {
-            core.lock().unwrap().send_notification(method, params);
+            let core = core.unwrap();
+            core.lock().unwrap().send_notification("edit", &edit_params);
             // NOTE: For debugging, could be replaced by trace logging
             // println!("fe->core: {}", json!({
             //     "method": method,
             //     "params": params,
             // }));
         } else {
-            // TODO: queue pending
+            self.pending.push((method.to_owned(), params.clone()));
         }
     }
 
     /// Sends a simple action with no parameters
-    fn send_action(&self, method: &str) {
+    fn send_action(&mut self, method: &str) {
         self.send_edit_cmd(method, &json!([]));
     }
 
-    pub fn keydown(&mut self, vk_code: i32, mods: u32) -> bool {
+    pub fn keydown(&mut self, vk_code: i32, mods: u32, ctx: &mut HandlerCtx) -> bool {
         // Handle special keys here
         match vk_code {
             VK_RETURN => {
@@ -307,6 +329,7 @@ impl EditView {
                     self.scroll_offset -= LINE_SPACE;
                     self.constrain_scroll();
                     self.update_viewport();
+                    ctx.invalidate();
                 } else {
                     let action = if mods == M_CTRL | M_ALT {
                         "add_selection_above"
@@ -322,6 +345,7 @@ impl EditView {
                     self.scroll_offset += LINE_SPACE;
                     self.constrain_scroll();
                     self.update_viewport();
+                    ctx.invalidate();
                 } else {
                     let action = if mods == M_CTRL | M_ALT {
                         "add_selection_below"
@@ -421,31 +445,6 @@ impl EditView {
         true
     }
 
-    // Commands
-    pub fn add_cursor_above(&mut self) {
-        // Note: some subtlety around find, the escape key cancels it, but the menu
-        // shouldn't.
-        self.send_action("add_selection_above");
-    }
-
-    pub fn add_cursor_below(&mut self) {
-        // Note: some subtlety around find, the escape key cancels it, but the menu
-        // shouldn't.
-        self.send_action("add_selection_below");
-    }
-
-    pub fn single_selection(&mut self) {
-        // Note: some subtlety around find, the escape key cancels it, but the menu
-        // shouldn't.
-        self.send_action("cancel_operation");
-    }
-
-    pub fn select_all(&mut self) {
-        // Note: some subtlety around find, the escape key cancels it, but the menu
-        // shouldn't.
-        self.send_action("select_all");
-    }
-
     pub fn mouse_wheel(&mut self, delta: i32, _mods: u32) {
         // TODO: scale properly, taking SPI_GETWHEELSCROLLLINES into account
         let scroll_scaling = 0.5;