From afc681bcf455d31f0d0782df71fb497d6fa7fa78 Mon Sep 17 00:00:00 2001
From: Alexandre Bury <alexandre.bury@gmail.com>
Date: Tue, 24 Jan 2017 10:48:00 -0800
Subject: [PATCH] Add `Canvas::state_mut(&mut self)`

And missing Canvas::needs_relayout closure.
---
 src/views/canvas.rs | 46 ++++++++++++++++++++++++++++++++++-----------
 1 file changed, 35 insertions(+), 11 deletions(-)

diff --git a/src/views/canvas.rs b/src/views/canvas.rs
index b24e2f8..fab5346 100644
--- a/src/views/canvas.rs
+++ b/src/views/canvas.rs
@@ -16,6 +16,7 @@ pub struct Canvas<T> {
     required_size: Box<FnMut(Vec2, &mut T) -> Vec2>,
     layout: Box<FnMut(Vec2, &mut T)>,
     take_focus: Box<FnMut(Direction, &mut T) -> bool>,
+    needs_relayout: Box<Fn(&T) -> bool>,
 }
 
 impl<T> Canvas<T> {
@@ -38,17 +39,23 @@ impl<T> Canvas<T> {
             required_size: Box::new(|_, _| Vec2::new(1, 1)),
             layout: Box::new(|_, _| ()),
             take_focus: Box::new(|_, _| false),
+            needs_relayout: Box::new(|_| true),
         }
     }
 
-    /// Sets the closure for `draw(&Printer)`
+    /// Gets a mutable reference to the inner state.
+    pub fn state_mut(&mut self) -> &mut T {
+        &mut self.state
+    }
+
+    /// Sets the closure for `draw(&Printer)`.
     pub fn set_draw<F>(&mut self, f: F)
         where F: 'static + Fn(&Printer, &T)
     {
         self.draw = Box::new(f);
     }
 
-    /// Sets the closure for `draw(&Printer)`
+    /// Sets the closure for `draw(&Printer)`.
     ///
     /// Chainable variant.
     pub fn with_draw<F>(self, f: F) -> Self
@@ -57,14 +64,14 @@ impl<T> Canvas<T> {
         self.with(|s| s.set_draw(f))
     }
 
-    /// Sets the closure for `on_event(Event)`
+    /// Sets the closure for `on_event(Event)`.
     pub fn set_on_event<F>(&mut self, f: F)
         where F: 'static + FnMut(Event, &mut T) -> EventResult
     {
         self.on_event = Box::new(f);
     }
 
-    /// Sets the closure for `on_event(Event)`
+    /// Sets the closure for `on_event(Event)`.
     ///
     /// Chainable variant.
     pub fn with_on_event<F>(self, f: F) -> Self
@@ -73,14 +80,14 @@ impl<T> Canvas<T> {
         self.with(|s| s.set_on_event(f))
     }
 
-    /// Sets the closure for `required_size(Vec2)`
+    /// Sets the closure for `required_size(Vec2)`.
     pub fn set_required_size<F>(&mut self, f: F)
         where F: 'static + FnMut(Vec2, &mut T) -> Vec2
     {
         self.required_size = Box::new(f);
     }
 
-    /// Sets the closure for `required_size(Vec2)`
+    /// Sets the closure for `required_size(Vec2)`.
     ///
     /// Chainable variant.
     pub fn with_required_size<F>(self, f: F) -> Self
@@ -89,14 +96,14 @@ impl<T> Canvas<T> {
         self.with(|s| s.set_required_size(f))
     }
 
-    /// Sets the closure for `layout(Vec2)`
+    /// Sets the closure for `layout(Vec2)`.
     pub fn set_layout<F>(&mut self, f: F)
         where F: 'static + FnMut(Vec2, &mut T)
     {
         self.layout = Box::new(f);
     }
 
-    /// Sets the closure for `layout(Vec2)`
+    /// Sets the closure for `layout(Vec2)`.
     ///
     /// Chainable variant.
     pub fn with_layout<F>(self, f: F) -> Self
@@ -105,14 +112,14 @@ impl<T> Canvas<T> {
         self.with(|s| s.set_layout(f))
     }
 
-    /// Sets the closure for `take_focus(Direction)`
+    /// Sets the closure for `take_focus(Direction)`.
     pub fn set_take_focus<F>(&mut self, f: F)
         where F: 'static + FnMut(Direction, &mut T) -> bool
     {
         self.take_focus = Box::new(f);
     }
 
-    /// Sets the closure for `take_focus(Direction)`
+    /// Sets the closure for `take_focus(Direction)`.
     ///
     /// Chainable variant.
     pub fn with_take_focus<F>(self, f: F) -> Self
@@ -120,9 +127,26 @@ impl<T> Canvas<T> {
     {
         self.with(|s| s.set_take_focus(f))
     }
+
+    /// Sets the closure for `needs_relayout()`.
+    pub fn set_needs_relayout<F>(&mut self, f: F)
+        where F: 'static + Fn(&T) -> bool
+    {
+        self.needs_relayout = Box::new(f);
+    }
+
+
+    /// Sets the closure for `needs_relayout()`.
+    ///
+    /// Chainable variant.
+    pub fn with_needs_relayout<F>(self, f: F) -> Self
+        where F: 'static + Fn(&T) -> bool
+    {
+        self.with(|s| s.set_needs_relayout(f))
+    }
 }
 
-impl <T> View for Canvas<T> {
+impl<T> View for Canvas<T> {
     fn draw(&self, printer: &Printer) {
         (self.draw)(printer, &self.state);
     }