Major refactoring in Sodium

cursor.rs

-use super::*;
+use editor::Editor;
+use mode::{Mode, CommandMode, PrimitiveMode};
 
 #[derive(Clone)]
 /// A cursor, i.e. a state defining a mode, and a position. The cursor does not define the content

delete.rs

-use super::*;
+use editor::Editor;
+use redraw::RedrawTask;
 
 impl Editor {
     /// Delete a character

editor.rs

-use super::*;
-use orbital::*;
+use cursor::Cursor;
+use std::collections::VecDeque;
+use orbital::Window;
+use graphics::StatusBar;
+use options::Options;
+use key_state::KeyState;
+use redraw::RedrawTask;
 
 /// The current state of the editor, including the file, the cursor, the scrolling info, etc.
 pub struct Editor {

exec.rs

-use super::*;
+use editor::Editor;
+use parse::{Inst, Parameter};
+use key::Key;
+use mode::{Mode, CommandMode, PrimitiveMode};
+use insert::{InsertOptions, InsertMode};
+use redraw::RedrawTask;
+
+use std::collections::VecDeque;
 use std::iter::FromIterator;
 
 // TODO: Move the command definitions outta here
 impl Editor {
     /// Execute an instruction
     pub fn exec(&mut self, Inst(para, cmd): Inst) {
-        use super::Key::*;
-        use super::Mode::*;
-        use super::PrimitiveMode::*;
-        use super::CommandMode::*;
+        use key::Key::*;
+        use mode::Mode::*;
+        use mode::PrimitiveMode::*;
+        use mode::CommandMode::*;
 
         let n = para.d();
         let bef = self.pos();

graphics.rs

-use super::*;
-use orbital::*;
+use editor::Editor;
+use orbital::Color;
+use redraw::RedrawTask;
+use mode::Mode;
+use mode::PrimitiveMode;
+use mode::CommandMode;
 
 impl Editor {
     /// Redraw the window

insert.rs

-use super::*;
+use editor::Editor;
+use mode::{Mode, PrimitiveMode, CommandMode};
+use redraw::RedrawTask;
+use key::Key;
+
+use std::collections::VecDeque;
 use std::iter::FromIterator;
 
 #[derive(Clone, PartialEq, Copy)]

invert.rs

-use super::*;
+use editor::Editor;
 
 impl Editor {
     pub fn invert_chars(&mut self, n: usize) {
@@ -7,7 +7,7 @@ impl Editor {
             let current = self.current();
             if let Some(c) = self.text[y].get_mut(x) {
                 if let Some(cur) = current {
-                    *c = invert::invert(cur);
+                    *c = invert(cur);
                 }
             }
             if let Some(m) = self.next(1) {

key_state.rs

-use super::*;
-use orbital::*;
+use key::Key;
+use orbital::{
+    KeyEvent,
+    K_ALT,
+    K_CTRL,
+    K_LEFT_SHIFT,
+    K_RIGHT_SHIFT
+};
 
 /// Key state
 pub struct KeyState {

main.rs

 extern crate orbital;
 
-pub use std::collections::VecDeque;
-
-mod editor;
-pub use self::editor::*;
-
-mod parse;
-pub use self::parse::*;
-
-mod key_state;
-pub use self::key_state::*;
-
-mod key;
-pub use self::key::*;
-
-mod prompt;
-pub use self::prompt::*;
-
-mod open;
-pub use self::open::*;
-
-mod redraw;
-pub use self::redraw::*;
-
-mod options;
-pub use self::options::*;
-
-mod position;
-pub use self::position::*;
-
-mod graphics;
-pub use self::graphics::*;
-
-mod selection;
-pub use self::selection::*;
-
-mod mode;
-pub use self::mode::*;
-
-mod movement;
-pub use self::movement::*;
-
-mod motion;
-pub use self::motion::*;
-
-mod cursor;
-pub use self::cursor::*;
-
-mod insert;
-pub use self::insert::*;
-
-mod delete;
-pub use self::delete::*;
-
-mod exec;
-pub use self::exec::*;
-
+pub mod editor;
+pub mod parse;
+pub mod key_state;
+pub mod key;
+pub mod prompt;
+pub mod open;
+pub mod redraw;
+pub mod options;
+pub mod position;
+pub mod graphics;
+pub mod selection;
+pub mod mode;
+pub mod movement;
+pub mod motion;
+pub mod cursor;
+pub mod insert;
+pub mod delete;
+pub mod exec;
 pub mod invert;
 
-#[no_mangle] pub fn main() {
-    Editor::init();
+#[no_mangle]
+pub fn main() {
+    editor::Editor::init();
 }

mode.rs

-use super::*;
+use insert::InsertOptions;
+use editor::Editor;
 
 #[derive(Clone, PartialEq, Copy)]
 /// A mode. Modes determine which set of commands that will be used. Modes comes in two flavors:

motion.rs

-use super::*;
+use editor::Editor;
+use parse::Inst;
+use position::to_signed_pos;
 
 impl Editor {
     /// Convert an instruction to a motion (new coordinate). Returns None if the instructions given
@@ -9,7 +11,7 @@ impl Editor {
     /// d deletes the text given by the motion following. Other commands can make use of motions,
     /// using this method.
     pub fn to_motion(&mut self, Inst(n, cmd): Inst) -> Option<(usize, usize)> {
-        use super::Key::*;
+        use key::Key::*;
         match cmd.key {
             Char('h') => Some(self.left(n.d())),
             Char('l') => Some(self.right(n.d())),
@@ -54,7 +56,7 @@ impl Editor {
     /// cases it's a position which is out of bounds. This is useful when commands want to mesure
     /// the relative movement over the movement.
     pub fn to_motion_unbounded(&mut self, Inst(n, cmd): Inst) -> Option<(isize, isize)> {
-        use super::Key::*;
+        use key::Key::*;
         match cmd.key {
             Char('h') => Some(self.left_unbounded(n.d())),
             Char('l') => Some(self.right_unbounded(n.d())),

movement.rs

-use super::*;
+use editor::Editor;
 
 impl Editor {
     /// Goto a given position. Does not automatically bound.

open.rs

-use super::*;
+use editor::Editor;
 use std::fs::File;
 use std::io::Read;
+use std::collections::VecDeque;
 
 pub enum OpenStatus {
     Ok,

parse.rs

-use super::*;
-use orbital::*;
+use key::{Cmd, Key};
+use editor::Editor;
+use orbital::{EventOption, Event};
+use redraw::RedrawTask;
+use mode::Mode;
 
 #[derive(Copy, Clone)]
 /// An instruction, i.e. a command and a numeral parameter

position.rs

-use super::*;
+use editor::Editor;
 
 /// Convert a usize tuple to isize
 pub fn to_signed_pos((x, y): (usize, usize)) -> (isize, isize) {

prompt.rs

-use super::*;
+use editor::Editor;
+use open::OpenStatus;
 
 impl Editor {
     /// Invoke a command in the prompt

redraw.rs

 use std::ops::Range;
 
 #[derive(Clone)]
+/// A task for the renderer for redrawing
 pub enum RedrawTask {
     Null,
     Lines(Range<usize>),

selection.rs

-use super::*;
+use editor::Editor;
+use std::collections::VecDeque;
 
 impl Editor {
     /// Remove from a given motion (row based), i.e. if the motion given is to another line, all