Small refactoring

src/backend/curses/mod.rs

@@ -1,6 +1,6 @@
-use theme::{BaseColor, Color};
 use event::{Event, Key};
 use std::collections::HashMap;
+use theme::{BaseColor, Color};
 
 #[cfg(feature = "ncurses")]
 mod n;
@@ -58,7 +58,6 @@ where
         };
         target.insert(code, event);
     }
-
 }
 
 fn find_closest(color: &Color) -> i16 {

src/view/any.rs

@@ -0,0 +1,46 @@
+use std::any::Any;
+use view::View;
+
+/// A view that can be downcasted to its concrete type.
+///
+/// This trait is automatically implemented for any `T: View`.
+pub trait AnyView {
+    /// Downcast self to a `Any`.
+    fn as_any(&self) -> &Any;
+
+    /// Downcast self to a mutable `Any`.
+    fn as_any_mut(&mut self) -> &mut Any;
+
+    /// Returns a boxed any from a boxed self.
+    ///
+    /// Can be used before `Box::downcast()`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use cursive::views::TextView;
+    /// # use cursive::view::View;
+    /// # fn main() {
+    /// let boxed: Box<View> = Box::new(TextView::new("text"));
+    /// let text: Box<TextView> = boxed.as_boxed_any().downcast().unwrap();
+    /// # }
+    /// ```
+    fn as_boxed_any(self: Box<Self>) -> Box<Any>;
+}
+
+impl<T: View> AnyView for T {
+    /// Downcast self to a `Any`.
+    fn as_any(&self) -> &Any {
+        self
+    }
+
+    /// Downcast self to a mutable `Any`.
+    fn as_any_mut(&mut self) -> &mut Any {
+        self
+    }
+
+    fn as_boxed_any(self: Box<Self>) -> Box<Any> {
+        self
+    }
+}
+

src/view/finder.rs

@@ -0,0 +1,66 @@
+use std::any::Any;
+use view::{View, ViewPath, ViewWrapper};
+use views::IdView;
+
+/// Provides `call_on<V: View>` to views.
+///
+/// This trait is mostly a wrapper around [`View::call_on_any`].
+///
+/// It provides a nicer interface to find a view when you know its type.
+///
+/// [`View::call_on_any`]: ./trait.View.html#method.call_on_any
+pub trait Finder {
+    /// Tries to find the view pointed to by the given selector.
+    ///
+    /// If the view is not found, or if it is not of the asked type,
+    /// it returns None.
+    fn call_on<V, F, R>(&mut self, sel: &Selector, callback: F) -> Option<R>
+    where
+        V: View + Any,
+        F: FnOnce(&mut V) -> R;
+
+    /// Convenient method to use `call_on` with a `view::Selector::Id`.
+    fn find_id<V, F, R>(&mut self, id: &str, callback: F) -> Option<R>
+    where
+        V: View + Any,
+        F: FnOnce(&mut V) -> R,
+    {
+        self.call_on(&Selector::Id(id), callback)
+    }
+}
+
+impl<T: View> Finder for T {
+    fn call_on<V, F, R>(&mut self, sel: &Selector, callback: F) -> Option<R>
+    where
+        V: View + Any,
+        F: FnOnce(&mut V) -> R,
+    {
+        let mut result = None;
+        {
+            let result_ref = &mut result;
+
+            let mut callback = Some(callback);
+            let callback = |v: &mut Any| {
+                if let Some(callback) = callback.take() {
+                    if v.is::<V>() {
+                        *result_ref =
+                            v.downcast_mut::<V>().map(|v| callback(v));
+                    } else if v.is::<IdView<V>>() {
+                        *result_ref = v.downcast_mut::<IdView<V>>()
+                            .and_then(|v| v.with_view_mut(callback));
+                    }
+                }
+            };
+            self.call_on_any(sel, Box::new(callback));
+        }
+        result
+    }
+}
+
+/// Selects a single view (if any) in the tree.
+pub enum Selector<'a> {
+    /// Selects a view from its ID.
+    Id(&'a str),
+    /// Selects a view from its path.
+    Path(&'a ViewPath),
+}

src/view/internal.rs

@@ -1,23 +0,0 @@
-//! Internal module for some implementation details.
-//!
-//! You probable are not interested in anything here. These elements are
-//! required to be public, but you should never need to use them directly.
-
-use view::{View, AnyView};
-
-/// A trait for elements that can be converted to `AnyView`.
-///
-/// You should never need to implement this yourself; it is automatically
-/// implemented for any `T: View`.
-///
-/// Just ignore this trait entirely.
-pub trait ToAny {
-    /// Converts a boxed `Self` to a boxed `AnyView`.
-    fn to_any(self: Box<Self>) -> Box<AnyView>;
-}
-
-impl <T: View> ToAny for T {
-    fn to_any(self: Box<Self>) -> Box<AnyView> {
-        self
-    }
-}

src/view/into_boxed_view.rs

@@ -1,8 +1,8 @@
-use view::{View};
+use view::View;
 
-/// Represents a type that can be made into a `Box<AnyView>`.
+/// Represents a type that can be made into a `Box<View>`.
 pub trait IntoBoxedView {
-    /// Returns a `Box<AnyView>`.
+    /// Returns a `Box<View>`.
     fn as_boxed_view(self) -> Box<View>;
 }
 

src/view/mod.rs

@@ -39,10 +39,13 @@
 mod view_wrapper;
 
 // Essentials components
+mod any;
+mod finder;
 mod position;
 mod size_cache;
 mod size_constraint;
 mod view_path;
+mod view;
 
 // Helper bases
 mod scroll;
@@ -51,205 +54,15 @@ mod boxable;
 
 mod into_boxed_view;
 
-pub use self::into_boxed_view::IntoBoxedView;
+pub use self::any::AnyView;
 pub use self::boxable::Boxable;
+pub use self::finder::{Finder, Selector};
 pub use self::identifiable::Identifiable;
+pub use self::into_boxed_view::IntoBoxedView;
 pub use self::position::{Offset, Position};
 pub use self::scroll::{ScrollBase, ScrollStrategy};
 pub use self::size_cache::SizeCache;
 pub use self::size_constraint::SizeConstraint;
 pub use self::view_path::ViewPath;
 pub use self::view_wrapper::ViewWrapper;
-use Printer;
+pub use self::view::View;
-use direction::Direction;
-use event::{Event, EventResult};
-use std::any::Any;
-use vec::Vec2;
-use views::IdView;
-
-/// A view that can be downcasted to its concrete type.
-///
-/// This trait is automatically implemented for any `T: View`.
-pub trait AnyView {
-    /// Downcast self to a `Any`.
-    fn as_any(&self) -> &Any;
-
-    /// Downcast self to a mutable `Any`.
-    fn as_any_mut(&mut self) -> &mut Any;
-
-    /// Returns a boxed any from a boxed self.
-    ///
-    /// Can be used before `Box::downcast()`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use cursive::views::TextView;
-    /// # use cursive::view::AnyView;
-    /// # fn main() {
-    /// let boxed: Box<AnyView> = Box::new(TextView::new("text"));
-    /// let text: Box<TextView> = boxed.as_boxed_any().downcast().unwrap();
-    /// # }
-    /// ```
-    fn as_boxed_any(self: Box<Self>) -> Box<Any>;
-}
-
-impl<T: View> AnyView for T {
-    /// Downcast self to a `Any`.
-    fn as_any(&self) -> &Any {
-        self
-    }
-
-    /// Downcast self to a mutable `Any`.
-    fn as_any_mut(&mut self) -> &mut Any {
-        self
-    }
-
-    fn as_boxed_any(self: Box<Self>) -> Box<Any> {
-        self
-    }
-}
-
-/// Main trait defining a view behaviour.
-///
-/// This is what you should implement to define a custom View.
-pub trait View: Any + AnyView {
-    /// Called when a key was pressed.
-    ///
-    /// Default implementation just ignores it.
-    fn on_event(&mut self, Event) -> EventResult {
-        EventResult::Ignored
-    }
-
-    /// Returns the minimum size the view requires with the given restrictions.
-    ///
-    /// If the view is flexible (it has multiple size options), it can try
-    /// to return one that fits the given `constraint`.
-    /// It's also fine to ignore it and return a fixed value.
-    ///
-    /// Default implementation always return `(1,1)`.
-    fn required_size(&mut self, constraint: Vec2) -> Vec2 {
-        let _ = constraint;
-        Vec2::new(1, 1)
-    }
-
-    /// Returns `true` if the view content changed since last layout phase.
-    ///
-    /// This is mostly an optimisation for views where the layout phase is
-    /// expensive.
-    ///
-    /// * Views can ignore it and always return true (default implementation).
-    ///   They will always be assumed to have changed.
-    /// * View Groups can ignore it and always re-layout their children.
-    ///     * If they call `required_size` or `layout` with stable parameters,
-    ///       the children may cache the result themselves and speed up the
-    ///       process anyway.
-    fn needs_relayout(&self) -> bool {
-        true
-    }
-
-    /// Called once the size for this view has been decided,
-    ///
-    /// View groups should propagate the information to their children.
-    fn layout(&mut self, Vec2) {}
-
-    /// Draws the view with the given printer (includes bounds) and focus.
-    fn draw(&self, printer: &Printer);
-
-    /// Runs a closure on the view identified by the given selector.
-    ///
-    /// See [`Finder::call_on`] for a nicer interface, implemented for all
-    /// views.
-    ///
-    /// [`Finder::call_on`]: trait.Finder.html#method.call_on
-    ///
-    /// If the selector doesn't find a match, the closure will not be run.
-    ///
-    /// Default implementation is a no-op.
-    fn call_on_any<'a>(&mut self, _: &Selector, _: Box<FnMut(&mut Any) + 'a>) {
-        // TODO: FnMut -> FnOnce once it works
-    }
-
-    /// Moves the focus to the view identified by the given selector.
-    ///
-    /// Returns `Ok(())` if the view was found and selected.
-    ///
-    /// Default implementation simply returns `Err(())`.
-    fn focus_view(&mut self, &Selector) -> Result<(), ()> {
-        Err(())
-    }
-
-    /// This view is offered focus. Will it take it?
-    ///
-    /// `source` indicates where the focus comes from.
-    /// When the source is unclear, `Front` is usually used.
-    ///
-    /// Default implementation always return `false`.
-    fn take_focus(&mut self, source: Direction) -> bool {
-        let _ = source;
-        false
-    }
-}
-
-/// Provides `call_on<V: View>` to views.
-///
-/// This trait is mostly a wrapper around [`View::call_on_any`].
-///
-/// It provides a nicer interface to find a view when you know its type.
-///
-/// [`View::call_on_any`]: ./trait.View.html#method.call_on_any
-pub trait Finder {
-    /// Tries to find the view pointed to by the given selector.
-    ///
-    /// If the view is not found, or if it is not of the asked type,
-    /// it returns None.
-    fn call_on<V, F, R>(&mut self, sel: &Selector, callback: F) -> Option<R>
-    where
-        V: View + Any,
-        F: FnOnce(&mut V) -> R;
-
-    /// Convenient method to use `call_on` with a `view::Selector::Id`.
-    fn find_id<V, F, R>(&mut self, id: &str, callback: F) -> Option<R>
-    where
-        V: View + Any,
-        F: FnOnce(&mut V) -> R,
-    {
-        self.call_on(&Selector::Id(id), callback)
-    }
-}
-
-impl<T: View> Finder for T {
-    fn call_on<V, F, R>(&mut self, sel: &Selector, callback: F) -> Option<R>
-    where
-        V: View + Any,
-        F: FnOnce(&mut V) -> R,
-    {
-        let mut result = None;
-        {
-            let result_ref = &mut result;
-
-            let mut callback = Some(callback);
-            let callback = |v: &mut Any| {
-                if let Some(callback) = callback.take() {
-                    if v.is::<V>() {
-                        *result_ref =
-                            v.downcast_mut::<V>().map(|v| callback(v));
-                    } else if v.is::<IdView<V>>() {
-                        *result_ref = v.downcast_mut::<IdView<V>>()
-                            .and_then(|v| v.with_view_mut(callback));
-                    }
-                }
-            };
-            self.call_on_any(sel, Box::new(callback));
-        }
-        result
-    }
-}
-
-/// Selects a single view (if any) in the tree.
-pub enum Selector<'a> {
-    /// Selects a view from its ID.
-    Id(&'a str),
-    /// Selects a view from its path.
-    Path(&'a ViewPath),
-}

src/view/view.rs

@@ -0,0 +1,89 @@
+use Printer;
+use direction::Direction;
+use event::{Event, EventResult};
+use std::any::Any;
+use vec::Vec2;
+use view::{AnyView, Selector};
+
+
+/// Main trait defining a view behaviour.
+///
+/// This is what you should implement to define a custom View.
+pub trait View: Any + AnyView {
+    /// Called when a key was pressed.
+    ///
+    /// Default implementation just ignores it.
+    fn on_event(&mut self, Event) -> EventResult {
+        EventResult::Ignored
+    }
+
+    /// Returns the minimum size the view requires with the given restrictions.
+    ///
+    /// If the view is flexible (it has multiple size options), it can try
+    /// to return one that fits the given `constraint`.
+    /// It's also fine to ignore it and return a fixed value.
+    ///
+    /// Default implementation always return `(1,1)`.
+    fn required_size(&mut self, constraint: Vec2) -> Vec2 {
+        let _ = constraint;
+        Vec2::new(1, 1)
+    }
+
+    /// Returns `true` if the view content changed since last layout phase.
+    ///
+    /// This is mostly an optimisation for views where the layout phase is
+    /// expensive.
+    ///
+    /// * Views can ignore it and always return true (default implementation).
+    ///   They will always be assumed to have changed.
+    /// * View Groups can ignore it and always re-layout their children.
+    ///     * If they call `required_size` or `layout` with stable parameters,
+    ///       the children may cache the result themselves and speed up the
+    ///       process anyway.
+    fn needs_relayout(&self) -> bool {
+        true
+    }
+
+    /// Called once the size for this view has been decided,
+    ///
+    /// View groups should propagate the information to their children.
+    fn layout(&mut self, Vec2) {}
+
+    /// Draws the view with the given printer (includes bounds) and focus.
+    fn draw(&self, printer: &Printer);
+
+    /// Runs a closure on the view identified by the given selector.
+    ///
+    /// See [`Finder::call_on`] for a nicer interface, implemented for all
+    /// views.
+    ///
+    /// [`Finder::call_on`]: trait.Finder.html#method.call_on
+    ///
+    /// If the selector doesn't find a match, the closure will not be run.
+    ///
+    /// Default implementation is a no-op.
+    fn call_on_any<'a>(&mut self, _: &Selector, _: Box<FnMut(&mut Any) + 'a>) {
+        // TODO: FnMut -> FnOnce once it works
+    }
+
+    /// Moves the focus to the view identified by the given selector.
+    ///
+    /// Returns `Ok(())` if the view was found and selected.
+    ///
+    /// Default implementation simply returns `Err(())`.
+    fn focus_view(&mut self, &Selector) -> Result<(), ()> {
+        Err(())
+    }
+
+    /// This view is offered focus. Will it take it?
+    ///
+    /// `source` indicates where the focus comes from.
+    /// When the source is unclear, `Front` is usually used.
+    ///
+    /// Default implementation always return `false`.
+    fn take_focus(&mut self, source: Direction) -> bool {
+        let _ = source;
+        false
+    }
+}
+

src/view/view_wrapper.rs

@@ -176,7 +176,8 @@ macro_rules! wrap_impl {
     };
 }
 
-/// Convenient macro to implement the getters for inner [`View`] in [`ViewWrapper`].
+/// Convenient macro to implement the getters for inner [`View`] in
+/// [`ViewWrapper`].
 ///
 /// It defines the `get_inner` and `get_inner_mut` implementations.
 ///

src/views/dialog.rs

@@ -10,8 +10,8 @@ use std::cmp::max;
 use theme::ColorStyle;
 use unicode_width::UnicodeWidthStr;
 use vec::{Vec2, Vec4};
-use view::{View, Selector};
+use view::{Selector, View};
-use views::{ViewBox, Button, DummyView, SizedView, TextView};
+use views::{Button, DummyView, SizedView, TextView, ViewBox};
 
 /// Identifies currently focused element in [`Dialog`].
 ///

src/views/mod.rs

@@ -62,7 +62,6 @@ mod text_area;
 mod text_view;
 mod tracked_view;
 
-pub use self::view_box::ViewBox;
 pub use self::box_view::BoxView;
 pub use self::button::Button;
 pub use self::canvas::Canvas;
@@ -88,3 +87,4 @@ pub use self::stack_view::{LayerPosition, StackView};
 pub use self::text_area::TextArea;
 pub use self::text_view::{TextContent, TextContentRef, TextView};
 pub use self::tracked_view::TrackedView;
+pub use self::view_box::ViewBox;

src/views/stack_view.rs

@@ -7,9 +7,8 @@ use std::cell;
 use std::ops::Deref;
 use theme::ColorStyle;
 use vec::Vec2;
-use view::{View, Offset, Position, Selector,
+use view::{IntoBoxedView, Offset, Position, Selector, View, ViewWrapper};
-           ViewWrapper, IntoBoxedView};
+use views::{Layer, ShadowView, ViewBox};
-use views::{ViewBox, Layer, ShadowView};
 
 /// Simple stack of views.
 /// Only the top-most view is active and can receive input.

src/views/view_box.rs

@@ -1,5 +1,5 @@
 use std::ops::{Deref, DerefMut};
-use view::{View, ViewWrapper, IntoBoxedView};
+use view::{IntoBoxedView, View, ViewWrapper};
 
 /// A boxed `View`.
 ///
@@ -15,8 +15,10 @@ impl ViewBox {
     }
 
     /// Box the given view
-    pub fn boxed<T>(view: T) -> Self 
+    pub fn boxed<T>(view: T) -> Self
-    where T: IntoBoxedView {
+    where
+        T: IntoBoxedView,
+    {
         ViewBox::new(view.as_boxed_view())
     }