9 files changed, 445 insertions, 316 deletions

diff --git a/src/app.rs b/src/app.rs
index 82096e1..f8797fc 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -9,26 +9,13 @@ use cursive::{Printer, Vec2};
 
 use chrono::{Local, NaiveDate};
 
-use crate::habit::{Bit, Count, Habit, HabitWrapper};
+use crate::habit::{Bit, Count, Habit, HabitWrapper, ViewMode};
 use crate::utils;
 use crate::Command;
 use crate::CONFIGURATION;
 
 use serde::{Deserialize, Serialize};
 
-#[derive(PartialEq, Serialize, Deserialize)]
-pub enum ViewMode {
-    Day,
-    Month,
-    Year,
-}
-
-impl std::default::Default for ViewMode {
-    fn default() -> Self {
-        ViewMode::Month
-    }
-}
-
 struct StatusLine(String, String);
 
 #[derive(Serialize, Deserialize)]
@@ -41,9 +28,6 @@ pub struct App {
     focus: usize,
 
     #[serde(skip)]
-    view_mode: ViewMode,
-
-    #[serde(skip)]
     view_month_offset: u32,
 }
 
@@ -51,7 +35,6 @@ impl App {
     pub fn new() -> Self {
         return App {
             habits: vec![],
-            view_mode: ViewMode::Day,
             focus: 0,
             view_month_offset: 0,
         };
@@ -65,9 +48,9 @@ impl App {
         self.habits.retain(|h| h.get_name() != name);
     }
 
-    pub fn set_mode(&mut self, set_mode: ViewMode) {
-        if set_mode != self.view_mode {
-            self.view_mode = set_mode;
+    pub fn set_mode(&mut self, mode: ViewMode) {
+        if !self.habits.is_empty() {
+            self.habits[self.focus].set_view_mode(mode);
         }
     }
 
@@ -128,7 +111,7 @@ impl App {
     fn status(&self) -> StatusLine {
         let today = chrono::Local::now().naive_utc().date();
         let remaining = self.habits.iter().map(|h| h.remaining(today)).sum::<u32>();
-        let total = self.habits.iter().map(|h| h.total()).sum::<u32>();
+        let total = self.habits.iter().map(|h| h.goal()).sum::<u32>();
         let completed = total - remaining;
 
         let timestamp = if self.view_month_offset == 0 {
@@ -141,7 +124,7 @@ impl App {
             let months = self.view_month_offset;
             format!(
                 "{:>width$}",
-                format!("{} months ago", self.view_month_offset),
+                format!("{} months ago", months),
                 width = CONFIGURATION.view_width * CONFIGURATION.grid_width
             )
         };
@@ -233,8 +216,8 @@ impl View for App {
         }
 
         offset = offset.map_x(|_| 0).map_y(|_| self.max_size().y - 2);
-        printer.print(offset, &self.status().1); // right
-        printer.print(offset, &self.status().0); // left
+        printer.print(offset, &self.status().1); // right status
+        printer.print(offset, &self.status().0); // left status
     }
 
     fn required_size(&mut self, _: Vec2) -> Vec2 {
@@ -243,7 +226,7 @@ impl View for App {
         let view_height = CONFIGURATION.view_height;
         let width = {
             if self.habits.len() > 0 {
-                grid_width * view_width
+                grid_width * (view_width + 2)
             } else {
                 0
             }
@@ -300,6 +283,29 @@ impl View for App {
                 self.save_state();
                 return EventResult::with_cb(|s| s.quit());
             }
+            Event::Char('v') => {
+                if self.habits.is_empty() {
+                    return EventResult::Consumed(None);
+                }
+                if self.habits[self.focus].view_mode() == ViewMode::Week {
+                    self.set_mode(ViewMode::Day)
+                } else {
+                    self.set_mode(ViewMode::Week)
+                }
+                return EventResult::Consumed(None);
+            }
+            Event::Char('V') => {
+                for habit in self.habits.iter_mut() {
+                    habit.set_view_mode(ViewMode::Week);
+                }
+                return EventResult::Consumed(None);
+            }
+            Event::Key(Key::Esc) => {
+                for habit in self.habits.iter_mut() {
+                    habit.set_view_mode(ViewMode::Day);
+                }
+                return EventResult::Consumed(None);
+            }
 
             /* We want sifting to be an app level function,
              * that later trickles down into each habit
diff --git a/src/habit.rs b/src/habit.rs
deleted file mode 100644
index 48dd363..0000000
--- a/src/habit.rs
+++ /dev/null
@@ -1,271 +0,0 @@
-use std::collections::HashMap;
-
-use chrono::NaiveDate;
-use serde::{Deserialize, Serialize};
-
-use cursive::direction::Direction;
-use cursive::event::{Event, EventResult};
-use cursive::{Printer, Vec2};
-
-use crate::views::ShadowView;
-use crate::CONFIGURATION;
-
-pub enum TrackEvent {
-    Increment,
-    Decrement,
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-pub struct CustomBool(bool);
-
-use std::fmt;
-impl fmt::Display for CustomBool {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{:^3}",
-            if self.0 {
-                CONFIGURATION.true_chr
-            } else {
-                CONFIGURATION.false_chr
-            }
-        )
-    }
-}
-
-impl From<bool> for CustomBool {
-    fn from(b: bool) -> Self {
-        CustomBool(b)
-    }
-}
-
-pub trait Habit {
-    type HabitType;
-
-    fn set_name(&mut self, name: impl AsRef<str>);
-    fn set_goal(&mut self, goal: Self::HabitType);
-    fn name(&self) -> String;
-    fn get_by_date(&self, date: NaiveDate) -> Option<&Self::HabitType>;
-    fn insert_entry(&mut self, date: NaiveDate, val: Self::HabitType);
-    fn reached_goal(&self, date: NaiveDate) -> bool;
-    fn remaining(&self, date: NaiveDate) -> u32;
-    fn total(&self) -> u32;
-    fn modify(&mut self, date: NaiveDate, event: TrackEvent);
-    fn set_view_month_offset(&mut self, offset: u32);
-    fn view_month_offset(&self) -> u32;
-}
-
-#[typetag::serde(tag = "type")]
-pub trait HabitWrapper: erased_serde::Serialize {
-    fn remaining(&self, date: NaiveDate) -> u32;
-    fn total(&self) -> u32;
-    fn modify(&mut self, date: NaiveDate, event: TrackEvent);
-    fn draw(&self, printer: &Printer);
-    fn on_event(&mut self, event: Event) -> EventResult;
-    fn required_size(&mut self, _: Vec2) -> Vec2;
-    fn take_focus(&mut self, _: Direction) -> bool;
-    fn set_view_month_offset(&mut self, offset: u32);
-    fn view_month_offset(&self) -> u32;
-    fn get_name(&self) -> String;
-}
-
-macro_rules! auto_habit_impl {
-    ($struct_name:ident) => {
-        #[typetag::serde]
-        impl HabitWrapper for $struct_name {
-            fn remaining(&self, date: NaiveDate) -> u32 {
-                Habit::remaining(self, date)
-            }
-            fn total(&self) -> u32 {
-                Habit::total(self)
-            }
-            fn modify(&mut self, date: NaiveDate, event: TrackEvent) {
-                Habit::modify(self, date, event);
-            }
-            fn draw(&self, printer: &Printer) {
-                ShadowView::draw(self, printer)
-            }
-            fn on_event(&mut self, event: Event) -> EventResult {
-                ShadowView::on_event(self, event)
-            }
-            fn required_size(&mut self, x: Vec2) -> Vec2 {
-                ShadowView::required_size(self, x)
-            }
-            fn take_focus(&mut self, d: Direction) -> bool {
-                ShadowView::take_focus(self, d)
-            }
-            fn set_view_month_offset(&mut self, offset: u32) {
-                Habit::set_view_month_offset(self, offset)
-            }
-            fn view_month_offset(&self) -> u32 {
-                Habit::view_month_offset(self)
-            }
-            fn get_name(&self) -> String {
-                Habit::name(self)
-            }
-        }
-    };
-}
-
-auto_habit_impl!(Count);
-auto_habit_impl!(Bit);
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Count {
-    name: String,
-    stats: HashMap<NaiveDate, u32>,
-    goal: u32,
-
-    #[serde(skip)]
-    view_month_offset: u32,
-}
-
-impl Count {
-    pub fn new(name: impl AsRef<str>, goal: u32) -> Self {
-        return Count {
-            name: name.as_ref().to_owned(),
-            stats: HashMap::new(),
-            goal,
-            view_month_offset: 0,
-        };
-    }
-}
-
-impl Habit for Count {
-    type HabitType = u32;
-
-    fn name(&self) -> String {
-        return self.name.clone();
-    }
-    fn set_name(&mut self, n: impl AsRef<str>) {
-        self.name = n.as_ref().to_owned();
-    }
-    fn set_goal(&mut self, g: Self::HabitType) {
-        self.goal = g;
-    }
-    fn get_by_date(&self, date: NaiveDate) -> Option<&Self::HabitType> {
-        self.stats.get(&date)
-    }
-    fn insert_entry(&mut self, date: NaiveDate, val: Self::HabitType) {
-        *self.stats.entry(date).or_insert(val) = val;
-    }
-    fn reached_goal(&self, date: NaiveDate) -> bool {
-        if let Some(val) = self.stats.get(&date) {
-            if val >= &self.goal {
-                return true;
-            }
-        }
-        return false;
-    }
-    fn remaining(&self, date: NaiveDate) -> u32 {
-        if self.reached_goal(date) {
-            return 0;
-        } else {
-            if let Some(val) = self.stats.get(&date) {
-                return self.goal - val;
-            } else {
-                return self.goal;
-            }
-        }
-    }
-    fn total(&self) -> u32 {
-        return self.goal;
-    }
-    fn modify(&mut self, date: NaiveDate, event: TrackEvent) {
-        if let Some(val) = self.stats.get_mut(&date) {
-            match event {
-                TrackEvent::Increment => *val += 1,
-                TrackEvent::Decrement => {
-                    if *val > 0 {
-                        *val -= 1
-                    } else {
-                        *val = 0
-                    };
-                }
-            }
-        } else {
-            self.insert_entry(date, 1);
-        }
-    }
-    fn set_view_month_offset(&mut self, offset: u32) {
-        self.view_month_offset = offset;
-    }
-    fn view_month_offset(&self) -> u32 {
-        self.view_month_offset
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Bit {
-    name: String,
-    stats: HashMap<NaiveDate, CustomBool>,
-    goal: CustomBool,
-
-    #[serde(skip)]
-    view_month_offset: u32,
-}
-
-impl Bit {
-    pub fn new(name: impl AsRef<str>) -> Self {
-        return Bit {
-            name: name.as_ref().to_owned(),
-            stats: HashMap::new(),
-            goal: CustomBool(true),
-            view_month_offset: 0,
-        };
-    }
-}
-
-impl Habit for Bit {
-    type HabitType = CustomBool;
-    fn name(&self) -> String {
-        return self.name.clone();
-    }
-    fn set_name(&mut self, n: impl AsRef<str>) {
-        self.name = n.as_ref().to_owned();
-    }
-    fn set_goal(&mut self, g: Self::HabitType) {
-        self.goal = g;
-    }
-    fn get_by_date(&self, date: NaiveDate) -> Option<&Self::HabitType> {
-        self.stats.get(&date)
-    }
-    fn insert_entry(&mut self, date: NaiveDate, val: Self::HabitType) {
-        *self.stats.entry(date).or_insert(val) = val;
-    }
-    fn reached_goal(&self, date: NaiveDate) -> bool {
-        if let Some(val) = self.stats.get(&date) {
-            if val.0 >= self.goal.0 {
-                return true;
-            }
-        }
-        return false;
-    }
-    fn remaining(&self, date: NaiveDate) -> u32 {
-        if let Some(val) = self.stats.get(&date) {
-            if val.0 {
-                return 0;
-            } else {
-                return 1;
-            }
-        } else {
-            return 1;
-        }
-    }
-    fn total(&self) -> u32 {
-        return 1;
-    }
-    fn modify(&mut self, date: NaiveDate, _: TrackEvent) {
-        if let Some(val) = self.stats.get_mut(&date) {
-            *val = (val.0 ^ true).into();
-        } else {
-            self.insert_entry(date, CustomBool(true));
-        }
-    }
-    fn set_view_month_offset(&mut self, offset: u32) {
-        self.view_month_offset = offset;
-    }
-    fn view_month_offset(&self) -> u32 {
-        self.view_month_offset
-    }
-}
diff --git a/src/habit/bit.rs b/src/habit/bit.rs
new file mode 100644
index 0000000..292b96a
--- /dev/null
+++ b/src/habit/bit.rs
@@ -0,0 +1,117 @@
+use std::collections::HashMap;
+
+use chrono::NaiveDate;
+use serde::{Deserialize, Serialize};
+
+use crate::habit::traits::Habit;
+use crate::habit::{TrackEvent, ViewMode};
+use crate::CONFIGURATION;
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+pub struct CustomBool(bool);
+
+use std::fmt;
+impl fmt::Display for CustomBool {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{:^3}",
+            if self.0 {
+                CONFIGURATION.true_chr
+            } else {
+                CONFIGURATION.false_chr
+            }
+        )
+    }
+}
+
+impl From<bool> for CustomBool {
+    fn from(b: bool) -> Self {
+        CustomBool(b)
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Bit {
+    name: String,
+    stats: HashMap<NaiveDate, CustomBool>,
+    goal: CustomBool,
+
+    #[serde(skip)]
+    view_month_offset: u32,
+
+    #[serde(skip)]
+    view_mode: ViewMode,
+}
+
+impl Bit {
+    pub fn new(name: impl AsRef<str>) -> Self {
+        return Bit {
+            name: name.as_ref().to_owned(),
+            stats: HashMap::new(),
+            goal: CustomBool(true),
+            view_month_offset: 0,
+            view_mode: ViewMode::Day,
+        };
+    }
+}
+
+impl Habit for Bit {
+    type HabitType = CustomBool;
+    fn name(&self) -> String {
+        return self.name.clone();
+    }
+    fn set_name(&mut self, n: impl AsRef<str>) {
+        self.name = n.as_ref().to_owned();
+    }
+    fn set_goal(&mut self, g: Self::HabitType) {
+        self.goal = g;
+    }
+    fn get_by_date(&self, date: NaiveDate) -> Option<&Self::HabitType> {
+        self.stats.get(&date)
+    }
+    fn insert_entry(&mut self, date: NaiveDate, val: Self::HabitType) {
+        *self.stats.entry(date).or_insert(val) = val;
+    }
+    fn reached_goal(&self, date: NaiveDate) -> bool {
+        if let Some(val) = self.stats.get(&date) {
+            if val.0 >= self.goal.0 {
+                return true;
+            }
+        }
+        return false;
+    }
+    fn remaining(&self, date: NaiveDate) -> u32 {
+        if let Some(val) = self.stats.get(&date) {
+            if val.0 {
+                return 0;
+            } else {
+                return 1;
+            }
+        } else {
+            return 1;
+        }
+    }
+    fn goal(&self) -> u32 {
+        return 1;
+    }
+    fn modify(&mut self, date: NaiveDate, _: TrackEvent) {
+        if let Some(val) = self.stats.get_mut(&date) {
+            *val = (val.0 ^ true).into();
+        } else {
+            self.insert_entry(date, CustomBool(true));
+        }
+    }
+    fn set_view_month_offset(&mut self, offset: u32) {
+        self.view_month_offset = offset;
+    }
+    fn view_month_offset(&self) -> u32 {
+        self.view_month_offset
+    }
+    fn set_view_mode(&mut self, mode: ViewMode) {
+        self.view_mode = mode;
+    }
+    fn view_mode(&self) -> ViewMode {
+        self.view_mode
+    }
+}
diff --git a/src/habit/count.rs b/src/habit/count.rs
new file mode 100644
index 0000000..a0e0aee
--- /dev/null
+++ b/src/habit/count.rs
@@ -0,0 +1,102 @@
+use std::collections::HashMap;
+
+use chrono::NaiveDate;
+use serde::{Deserialize, Serialize};
+
+use crate::habit::traits::Habit;
+use crate::habit::{TrackEvent, ViewMode};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Count {
+    name: String,
+    stats: HashMap<NaiveDate, u32>,
+    goal: u32,
+
+    #[serde(skip)]
+    view_month_offset: u32,
+
+    #[serde(skip)]
+    view_mode: ViewMode,
+}
+
+impl Count {
+    pub fn new(name: impl AsRef<str>, goal: u32) -> Self {
+        return Count {
+            name: name.as_ref().to_owned(),
+            stats: HashMap::new(),
+            goal,
+            view_month_offset: 0,
+            view_mode: ViewMode::Day,
+        };
+    }
+}
+
+impl Habit for Count {
+    type HabitType = u32;
+
+    fn name(&self) -> String {
+        return self.name.clone();
+    }
+    fn set_name(&mut self, n: impl AsRef<str>) {
+        self.name = n.as_ref().to_owned();
+    }
+    fn set_goal(&mut self, g: Self::HabitType) {
+        self.goal = g;
+    }
+    fn get_by_date(&self, date: NaiveDate) -> Option<&Self::HabitType> {
+        self.stats.get(&date)
+    }
+    fn insert_entry(&mut self, date: NaiveDate, val: Self::HabitType) {
+        *self.stats.entry(date).or_insert(val) = val;
+    }
+    fn reached_goal(&self, date: NaiveDate) -> bool {
+        if let Some(val) = self.stats.get(&date) {
+            if val >= &self.goal {
+                return true;
+            }
+        }
+        return false;
+    }
+    fn remaining(&self, date: NaiveDate) -> u32 {
+        if self.reached_goal(date) {
+            return 0;
+        } else {
+            if let Some(val) = self.stats.get(&date) {
+                return self.goal - val;
+            } else {
+                return self.goal;
+            }
+        }
+    }
+    fn goal(&self) -> u32 {
+        return self.goal;
+    }
+    fn modify(&mut self, date: NaiveDate, event: TrackEvent) {
+        if let Some(val) = self.stats.get_mut(&date) {
+            match event {
+                TrackEvent::Increment => *val += 1,
+                TrackEvent::Decrement => {
+                    if *val > 0 {
+                        *val -= 1
+                    } else {
+                        *val = 0
+                    };
+                }
+            }
+        } else {
+            self.insert_entry(date, 1);
+        }
+    }
+    fn set_view_month_offset(&mut self, offset: u32) {
+        self.view_month_offset = offset;
+    }
+    fn view_month_offset(&self) -> u32 {
+        self.view_month_offset
+    }
+    fn set_view_mode(&mut self, mode: ViewMode) {
+        self.view_mode = mode;
+    }
+    fn view_mode(&self) -> ViewMode {
+        self.view_mode
+    }
+}
diff --git a/src/habit/mod.rs b/src/habit/mod.rs
new file mode 100644
index 0000000..482ca06
--- /dev/null
+++ b/src/habit/mod.rs
@@ -0,0 +1,20 @@
+use std::collections::HashMap;
+
+use chrono::NaiveDate;
+use serde::{Deserialize, Serialize};
+
+use cursive::direction::Direction;
+use cursive::event::{Event, EventResult};
+use cursive::{Printer, Vec2};
+
+mod traits;
+pub use traits::{Habit, HabitWrapper};
+
+mod count;
+pub use count::Count;
+
+mod bit;
+pub use bit::Bit;
+
+mod prelude;
+pub use prelude::{TrackEvent, ViewMode};
diff --git a/src/habit/prelude.rs b/src/habit/prelude.rs
new file mode 100644
index 0000000..9196f00
--- /dev/null
+++ b/src/habit/prelude.rs
@@ -0,0 +1,20 @@
+use serde::{Deserialize, Serialize};
+
+pub enum TrackEvent {
+    Increment,
+    Decrement,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+pub enum ViewMode {
+    Day,
+    Week,
+    Month,
+    Year,
+}
+
+impl std::default::Default for ViewMode {
+    fn default() -> Self {
+        ViewMode::Day
+    }
+}
diff --git a/src/habit/traits.rs b/src/habit/traits.rs
new file mode 100644
index 0000000..e28e55d
--- /dev/null
+++ b/src/habit/traits.rs
@@ -0,0 +1,94 @@
+use chrono::NaiveDate;
+use cursive::direction::Direction;
+use cursive::event::{Event, EventResult};
+use cursive::{Printer, Vec2};
+
+use typetag;
+
+use crate::habit::{Bit, Count, TrackEvent, ViewMode};
+use crate::views::ShadowView;
+
+pub trait Habit {
+    type HabitType;
+
+    fn set_name(&mut self, name: impl AsRef<str>);
+    fn set_goal(&mut self, goal: Self::HabitType);
+    fn name(&self) -> String;
+    fn get_by_date(&self, date: NaiveDate) -> Option<&Self::HabitType>;
+    fn insert_entry(&mut self, date: NaiveDate, val: Self::HabitType);
+    fn reached_goal(&self, date: NaiveDate) -> bool;
+    fn remaining(&self, date: NaiveDate) -> u32;
+    fn goal(&self) -> u32;
+    fn modify(&mut self, date: NaiveDate, event: TrackEvent);
+
+    fn set_view_month_offset(&mut self, offset: u32);
+    fn view_month_offset(&self) -> u32;
+
+    fn set_view_mode(&mut self, mode: ViewMode);
+    fn view_mode(&self) -> ViewMode;
+}
+
+#[typetag::serde(tag = "type")]
+pub trait HabitWrapper: erased_serde::Serialize {
+    fn remaining(&self, date: NaiveDate) -> u32;
+    fn goal(&self) -> u32;
+    fn modify(&mut self, date: NaiveDate, event: TrackEvent);
+    fn draw(&self, printer: &Printer);
+    fn on_event(&mut self, event: Event) -> EventResult;
+    fn required_size(&mut self, _: Vec2) -> Vec2;
+    fn take_focus(&mut self, _: Direction) -> bool;
+    fn get_name(&self) -> String;
+
+    fn set_view_month_offset(&mut self, offset: u32);
+    fn view_month_offset(&self) -> u32;
+
+    fn set_view_mode(&mut self, mode: ViewMode);
+    fn view_mode(&self) -> ViewMode;
+}
+
+macro_rules! auto_habit_impl {
+    ($struct_name:ident) => {
+        #[typetag::serde]
+        impl HabitWrapper for $struct_name {
+            fn remaining(&self, date: NaiveDate) -> u32 {
+                Habit::remaining(self, date)
+            }
+            fn goal(&self) -> u32 {
+                Habit::goal(self)
+            }
+            fn modify(&mut self, date: NaiveDate, event: TrackEvent) {
+                Habit::modify(self, date, event);
+            }
+            fn draw(&self, printer: &Printer) {
+                ShadowView::draw(self, printer)
+            }
+            fn on_event(&mut self, event: Event) -> EventResult {
+                ShadowView::on_event(self, event)
+            }
+            fn required_size(&mut self, x: Vec2) -> Vec2 {
+                ShadowView::required_size(self, x)
+            }
+            fn take_focus(&mut self, d: Direction) -> bool {
+                ShadowView::take_focus(self, d)
+            }
+            fn get_name(&self) -> String {
+                Habit::name(self)
+            }
+            fn set_view_month_offset(&mut self, offset: u32) {
+                Habit::set_view_month_offset(self, offset)
+            }
+            fn view_month_offset(&self) -> u32 {
+                Habit::view_month_offset(self)
+            }
+            fn set_view_mode(&mut self, mode: ViewMode) {
+                Habit::set_view_mode(self, mode)
+            }
+            fn view_mode(&self) -> ViewMode {
+                Habit::view_mode(self)
+            }
+        }
+    };
+}
+
+auto_habit_impl!(Count);
+auto_habit_impl!(Bit);
diff --git a/src/main.rs b/src/main.rs
index 4f91990..387dc64 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -9,7 +9,7 @@ mod theme;
 mod utils;
 mod views;
 
-use crate::app::{App, ViewMode};
+use crate::app::App;
 use crate::command::{open_command_window, Command};
 use crate::habit::{Bit, Count, Habit};
 use crate::utils::{load_configuration_file, AppConfig};
diff --git a/src/views.rs b/src/views.rs
index d25e59b..9e4a844 100644
--- a/src/views.rs
+++ b/src/views.rs
@@ -7,7 +7,8 @@ use cursive::{Printer, Vec2};
 use chrono::prelude::*;
 use chrono::{Duration, Local, NaiveDate};
 
-use crate::habit::{Bit, Count, Habit, TrackEvent};
+use crate::habit::{Bit, Count, Habit, TrackEvent, ViewMode};
+
 use crate::CONFIGURATION;
 
 pub trait ShadowView {
@@ -62,26 +63,66 @@ where
             },
         );
 
-        let mut i = 1;
-        while let Some(d) = NaiveDate::from_ymd_opt(year, month, i) {
-            let day_style;
-            if self.reached_goal(d) {
-                day_style = goal_reached_style;
-            } else {
-                day_style = todo_style;
-            }
-            let coords: Vec2 = ((i % 7) * 3, i / 7 + 2).into();
-            if let Some(c) = self.get_by_date(d) {
-                printer.with_style(day_style, |p| {
-                    p.print(coords, &format!("{:^3}", c));
-                });
-            } else {
+        let draw_month = |printer: &Printer| {
+            let days = (1..31)
+                .map(|i| NaiveDate::from_ymd_opt(year, month, i))
+                .flatten() // dates 28-31 may not exist, ignore them if they don't
+                .collect::<Vec<_>>();
+            for (week, line_nr) in days.chunks(7).zip(2..) {
+                let weekly_goal = self.goal() * week.len() as u32;
+                let is_this_week = week.contains(&Local::now().naive_utc().date());
+                let remaining = week.iter().map(|&i| self.remaining(i)).sum::<u32>();
+                let completions = weekly_goal - remaining;
+                let full = CONFIGURATION.view_width - 8;
+                let bars_to_fill = (completions * full as u32) / weekly_goal;
+                let percentage = (completions as f64 * 100.) / weekly_goal as f64;
                 printer.with_style(future_style, |p| {
-                    p.print(coords, &format!("{:^3}", CONFIGURATION.future_chr));
+                    p.print((4, line_nr), &"―".repeat(full));
+                });
+                printer.with_style(goal_reached_style, |p| {
+                    p.print((4, line_nr), &"―".repeat(bars_to_fill as usize));
                 });
+                printer.with_style(
+                    if is_this_week {
+                        Style::none()
+                    } else {
+                        future_style
+                    },
+                    |p| {
+                        p.print((0, line_nr), &format!("{:2.0}% ", percentage));
+                    },
+                );
             }
-            i += 1;
-        }
+        };
+
+        let draw_day = |printer: &Printer| {
+            let mut i = 0;
+            while let Some(d) = NaiveDate::from_ymd_opt(year, month, i + 1) {
+                let day_style;
+                if self.reached_goal(d) {
+                    day_style = goal_reached_style;
+                } else {
+                    day_style = todo_style;
+                }
+                let coords: Vec2 = ((i % 7) * 3, i / 7 + 2).into();
+                if let Some(c) = self.get_by_date(d) {
+                    printer.with_style(day_style, |p| {
+                        p.print(coords, &format!("{:^3}", c));
+                    });
+                } else {
+                    printer.with_style(future_style, |p| {
+                        p.print(coords, &format!("{:^3}", CONFIGURATION.future_chr));
+                    });
+                }
+                i += 1;
+            }
+        };
+
+        match self.view_mode() {
+            ViewMode::Day => draw_day(printer),
+            ViewMode::Week => draw_month(printer),
+            _ => draw_day(printer),
+        };
     }
 
     fn required_size(&mut self, _: Vec2) -> Vec2 {