Big UI and navigation Rewrite

new navigation
add some color to the apps
redesign menus
new settings menu
new quick settings
code clean up
size reduction by converting navigation images to font
and more...

59 files changed, 1922 insertions, 492 deletions

diff --git a/src/displayapp/screens/ApplicationList.cpp b/src/displayapp/screens/ApplicationList.cpp
index 60039045..db244822 100644
--- a/src/displayapp/screens/ApplicationList.cpp
+++ b/src/displayapp/screens/ApplicationList.cpp
@@ -9,9 +9,13 @@
 using namespace Pinetime::Applications::Screens;
 
 ApplicationList::ApplicationList(Pinetime::Applications::DisplayApp *app,
-        Pinetime::Controllers::Settings &settingsController) :
+          Pinetime::Controllers::Settings &settingsController,
+          Pinetime::Controllers::Battery& batteryController,
+          Controllers::DateTime& dateTimeController) :
         Screen(app),
         settingsController{settingsController},
+        batteryController{batteryController},
+        dateTimeController{dateTimeController},
         screens{app, 
           settingsController.GetAppMenu(),
           {
@@ -33,47 +37,41 @@ bool ApplicationList::Refresh() {
   return running;
 }
 
-bool ApplicationList::OnButtonPushed() {
-  running = false;
-  app->StartApp(Apps::Clock);
-  return true;
-}
-
 bool ApplicationList::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
   return screens.OnTouchEvent(event);
 }
 
 std::unique_ptr<Screen> ApplicationList::CreateScreen1() {
   std::array<Screens::Tile::Applications, 6> applications {
-          {{Symbols::clock, Apps::Clock},
-          {Symbols::music, Apps::Music},
-          {Symbols::sun, Apps::Brightness},
-          {Symbols::list, Apps::SysInfo},
-          {Symbols::check, Apps::FirmwareValidation},
-          {Symbols::heartBeat, Apps::HeartRate}
+          {
+            {Symbols::stopWatch,    Apps::StopWatch},
+            {Symbols::music,        Apps::Music},
+            {Symbols::map,          Apps::Navigation},
+            {Symbols::shoe,         Apps::Clock},
+            {Symbols::heartBeat,    Apps::HeartRate},
+            {"",                    Apps::None},
           }
-
-
   };
 
-  return std::make_unique<Screens::Tile>(0, app, settingsController, applications);
+  return std::make_unique<Screens::Tile>(0, 2, app, settingsController, batteryController, dateTimeController, applications);
 }
 
 std::unique_ptr<Screen> ApplicationList::CreateScreen2() {
   std::array<Screens::Tile::Applications, 6> applications {
-          {{Symbols::map, Apps::Navigation},
-           {Symbols::stopWatch, Apps::StopWatch},
-           {Symbols::paintbrush, Apps::Paint},
-           {Symbols::info, Apps::Notifications},
-           {Symbols::paddle, Apps::Paddle},
-           {"2", Apps::Twos}
+          {
+            {Symbols::paintbrush,   Apps::Paint},
+            {Symbols::paddle,       Apps::Paddle},
+            {"2",                   Apps::Twos},
+            {"",                    Apps::None},
+            {"",                    Apps::None},
+            {"",                    Apps::None},
           }
   };
 
-  return std::make_unique<Screens::Tile>(1, app, settingsController, applications);
+  return std::make_unique<Screens::Tile>(1, 2, app, settingsController, batteryController, dateTimeController, applications);
 }
 
-std::unique_ptr<Screen> ApplicationList::CreateScreen3() {
+/*std::unique_ptr<Screen> ApplicationList::CreateScreen3() {
   std::array<Screens::Tile::Applications, 6> applications {
           {{"A", Apps::Meter},
            {"B", Apps::Navigation},
@@ -84,6 +82,6 @@ std::unique_ptr<Screen> ApplicationList::CreateScreen3() {
           }
   };
 
-  return std::make_unique<Screens::Tile>(2, app, settingsController, applications);
-}
+  return std::make_unique<Screens::Tile>(2, 3, app, settingsController, batteryController, dateTimeController, applications);
+}*/
 
diff --git a/src/displayapp/screens/ApplicationList.h b/src/displayapp/screens/ApplicationList.h
index 0a0c6388..e334ccde 100644
--- a/src/displayapp/screens/ApplicationList.h
+++ b/src/displayapp/screens/ApplicationList.h
@@ -4,6 +4,9 @@
 
 #include "Screen.h"
 #include "ScreenList.h"
+#include "components/datetime/DateTimeController.h"
+#include "components/settings/Settings.h"
+#include "components/battery/BatteryController.h"
 
 namespace Pinetime {
   namespace Applications {
@@ -11,21 +14,22 @@ namespace Pinetime {
       class ApplicationList : public Screen {
         public:
           explicit ApplicationList(DisplayApp* app,
-            Pinetime::Controllers::Settings &settingsController);
+            Pinetime::Controllers::Settings &settingsController,
+            Pinetime::Controllers::Battery& batteryController,
+            Controllers::DateTime& dateTimeController);
           ~ApplicationList() override;
           bool Refresh() override;
-          bool OnButtonPushed() override;
           bool OnTouchEvent(TouchEvents event) override;
         private:
 
           Controllers::Settings& settingsController;
-          
-          bool running = true;
+          Pinetime::Controllers::Battery& batteryController;
+          Controllers::DateTime& dateTimeController;
 
           ScreenList<2> screens;
           std::unique_ptr<Screen> CreateScreen1();
           std::unique_ptr<Screen> CreateScreen2();
-          std::unique_ptr<Screen> CreateScreen3();
+          //std::unique_ptr<Screen> CreateScreen3();
       };
     }
   }
diff --git a/src/displayapp/screens/BatteryInfo.cpp b/src/displayapp/screens/BatteryInfo.cpp
new file mode 100644
index 00000000..ae39138f
--- /dev/null
+++ b/src/displayapp/screens/BatteryInfo.cpp
@@ -0,0 +1,144 @@
+#include "BatteryInfo.h"
+#include "../DisplayApp.h"
+#include "components/battery/BatteryController.h"
+
+using namespace Pinetime::Applications::Screens;
+
+static void lv_update_task(struct _lv_task_t *task) {  
+  auto user_data = static_cast<BatteryInfo *>(task->user_data);
+  user_data->UpdateScreen();
+}
+
+static void lv_anim_task(struct _lv_task_t *task) {  
+  auto user_data = static_cast<BatteryInfo *>(task->user_data);
+  user_data->UpdateAnim();
+}
+
+BatteryInfo::BatteryInfo(
+    Pinetime::Applications::DisplayApp *app, 
+    Pinetime::Controllers::Battery& batteryController) : 
+  Screen(app),
+  batteryController{batteryController}
+{
+
+  batteryPercent = batteryController.PercentRemaining();
+  batteryVoltage = batteryController.Voltage();
+
+  charging_bar = lv_bar_create(lv_scr_act(), nullptr);
+  lv_obj_set_size(charging_bar, 200, 15);
+  lv_bar_set_range(charging_bar, 0, 100);
+  lv_obj_align(charging_bar, nullptr, LV_ALIGN_CENTER, 0, 10);
+  lv_bar_set_anim_time(charging_bar, 2000);
+  lv_obj_set_style_local_radius(charging_bar, LV_BAR_PART_BG, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);
+  lv_obj_set_style_local_bg_color(charging_bar, LV_BAR_PART_BG, LV_STATE_DEFAULT, lv_color_hex(0x222222));
+  lv_obj_set_style_local_bg_opa(charging_bar, LV_BAR_PART_BG, LV_STATE_DEFAULT, LV_OPA_100);
+  lv_obj_set_style_local_bg_color(charging_bar, LV_BAR_PART_INDIC , LV_STATE_DEFAULT, lv_color_hex(0xFF0000));
+  lv_bar_set_value(charging_bar, batteryPercent, LV_ANIM_OFF);
+
+  status = lv_label_create(lv_scr_act(), nullptr);  
+  lv_label_set_text_static(status,"Reading Battery status");
+  lv_label_set_align(status, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(status, charging_bar, LV_ALIGN_OUT_BOTTOM_MID, 0, 20);
+  
+  percent = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_font(percent, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_76);
+  if ( batteryPercent >= 0) {
+    lv_label_set_text_fmt(percent,"%02i%%", batteryPercent);
+  } else {
+    lv_label_set_text(percent,"--%");
+  }
+  lv_label_set_align(percent, LV_LABEL_ALIGN_LEFT);
+  lv_obj_align(percent, nullptr, LV_ALIGN_CENTER, 0, -60);
+
+  // hack to not use the flot functions from printf
+  uint8_t batteryVoltageBytes[2];
+  batteryVoltageBytes[1] = static_cast<uint8_t>(batteryVoltage);    //truncate whole numbers
+  batteryVoltageBytes[0] = static_cast<uint8_t>((batteryVoltage - batteryVoltageBytes[1]) * 100); //remove whole part of flt and shift 2 places over
+  //
+
+  voltage = lv_label_create(lv_scr_act(), nullptr);  
+  lv_obj_set_style_local_text_color(voltage, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0xC6A600));
+  lv_label_set_text_fmt(voltage,"%1i.%02i volts", batteryVoltageBytes[1], batteryVoltageBytes[0]);
+  lv_label_set_align(voltage, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(voltage, nullptr, LV_ALIGN_CENTER, 0, 95);
+
+  lv_obj_t * backgroundLabel = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_long_mode(backgroundLabel, LV_LABEL_LONG_CROP);
+  lv_obj_set_size(backgroundLabel, 240, 240);
+  lv_obj_set_pos(backgroundLabel, 0, 0);
+  lv_label_set_text_static(backgroundLabel, "");
+
+  taskUpdate = lv_task_create(lv_update_task, 500000, LV_TASK_PRIO_LOW, this);
+  taskAnim = lv_task_create(lv_anim_task, 1000, LV_TASK_PRIO_LOW, this);
+  UpdateScreen();
+}
+
+
+BatteryInfo::~BatteryInfo() {
+  lv_task_del(taskUpdate);
+  lv_task_del(taskAnim);
+  lv_obj_clean(lv_scr_act());
+}
+
+void BatteryInfo::UpdateAnim() {
+  batteryPercent = batteryController.PercentRemaining();
+
+  if ( batteryPercent >= 0 ) {
+    if ( batteryController.IsCharging() ) {
+      animation +=1;
+      if (animation >= 100) {
+        animation = 0;
+      }
+
+    } else {
+      if (animation > batteryPercent) {
+        animation--;
+      }
+      if (animation < batteryPercent) {
+        animation++;
+      }
+    }
+
+    lv_bar_set_value(charging_bar, animation, LV_ANIM_OFF);
+  }
+}
+
+void BatteryInfo::UpdateScreen() {
+
+  batteryController.Update();
+
+  batteryPercent = batteryController.PercentRemaining();
+  batteryVoltage = batteryController.Voltage();
+
+  if ( batteryPercent >= 0 ) {
+    if ( batteryController.IsCharging() ) {
+      lv_obj_set_style_local_bg_color(charging_bar, LV_BAR_PART_INDIC , LV_STATE_DEFAULT, lv_color_hex(0xFF0000));
+      lv_label_set_text_static(status,"Battery charging");
+
+    } else {
+      lv_obj_set_style_local_bg_color(charging_bar, LV_BAR_PART_INDIC , LV_STATE_DEFAULT, lv_color_hex(0x00FF00));
+      lv_label_set_text_static(status,"Battery discharging");
+    }
+    
+    lv_label_set_text_fmt(percent,"%02i%%", batteryPercent);
+    
+  } else {
+    lv_label_set_text_static(status,"Reading Battery status");
+    lv_label_set_text(percent,"--%");
+  }
+
+  lv_obj_align(status, charging_bar, LV_ALIGN_OUT_BOTTOM_MID, 0, 20);
+  // hack to not use the flot functions from printf
+  uint8_t batteryVoltageBytes[2];
+  batteryVoltageBytes[1] = static_cast<uint8_t>(batteryVoltage);    //truncate whole numbers
+  batteryVoltageBytes[0] = static_cast<uint8_t>((batteryVoltage - batteryVoltageBytes[1]) * 100); //remove whole part of flt and shift 2 places over
+  //
+  lv_label_set_text_fmt(voltage,"%1i.%02i volts", batteryVoltageBytes[1], batteryVoltageBytes[0]);
+ 
+}
+
+bool BatteryInfo::Refresh() {
+  
+  return running;
+}
+
diff --git a/src/displayapp/screens/BatteryInfo.h b/src/displayapp/screens/BatteryInfo.h
new file mode 100644
index 00000000..206f1ab0
--- /dev/null
+++ b/src/displayapp/screens/BatteryInfo.h
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <cstdint>
+#include <FreeRTOS.h>
+#include <timers.h>
+#include "Screen.h"
+#include <lvgl/lvgl.h>
+
+
+namespace Pinetime {
+  namespace Controllers {
+    class Battery;
+  }
+
+  namespace Applications {
+    namespace Screens {
+
+      class BatteryInfo : public Screen{
+        public:
+          BatteryInfo(DisplayApp* app, 
+            Pinetime::Controllers::Battery& batteryController);
+          ~BatteryInfo() override;
+
+          bool Refresh() override;
+          
+
+          void UpdateScreen();
+          void UpdateAnim();
+
+        private:          
+
+          Pinetime::Controllers::Battery& batteryController;
+
+          lv_obj_t* voltage;
+          lv_obj_t* percent;
+          lv_obj_t* charging_bar;
+          lv_obj_t* status;
+
+          lv_task_t* taskUpdate;
+          lv_task_t* taskAnim;
+
+          int8_t animation = 0;
+          int8_t batteryPercent = -1;
+          float batteryVoltage = 0.0f;
+
+      };
+    }
+  }
+}
diff --git a/src/displayapp/screens/Brightness.cpp b/src/displayapp/screens/Brightness.cpp
index 36820417..38469cf5 100644
--- a/src/displayapp/screens/Brightness.cpp
+++ b/src/displayapp/screens/Brightness.cpp
@@ -33,11 +33,6 @@ bool Brightness::Refresh() {
   return running;
 }
 
-bool Brightness::OnButtonPushed() {
-  running = false;
-  return true;
-}
-
 const char *Brightness::LevelToString(Pinetime::Controllers::BrightnessController::Levels level) {
   switch(level) {
     case Pinetime::Controllers::BrightnessController::Levels::Off: return "Off";
diff --git a/src/displayapp/screens/Brightness.h b/src/displayapp/screens/Brightness.h
index 7aee968e..60b33cfd 100644
--- a/src/displayapp/screens/Brightness.h
+++ b/src/displayapp/screens/Brightness.h
@@ -13,12 +13,12 @@ namespace Pinetime {
           Brightness(DisplayApp* app, Controllers::BrightnessController& brightness);
           ~Brightness() override;
           bool Refresh() override;
-          bool OnButtonPushed() override;
+          
           bool OnTouchEvent(TouchEvents event) override;
 
           void OnValueChanged();
         private:
-          bool running = true;
+          
           Controllers::BrightnessController& brightness;
 
           lv_obj_t * slider_label;
diff --git a/src/displayapp/screens/Clock.cpp b/src/displayapp/screens/Clock.cpp
index 69180370..d8cc573a 100644
--- a/src/displayapp/screens/Clock.cpp
+++ b/src/displayapp/screens/Clock.cpp
@@ -54,11 +54,6 @@ bool Clock::Refresh() {
   return running;
 }
 
-bool Clock::OnButtonPushed() {
-  running = false;
-  return false;
-}
-
 bool Clock::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
   return screens.OnTouchEvent(event);
 }
diff --git a/src/displayapp/screens/Clock.h b/src/displayapp/screens/Clock.h
index 964ccbf6..a5163655 100644
--- a/src/displayapp/screens/Clock.h
+++ b/src/displayapp/screens/Clock.h
@@ -33,7 +33,7 @@ namespace Pinetime {
           ~Clock() override;
 
           bool Refresh() override;
-          bool OnButtonPushed() override;
+          
           bool OnTouchEvent(TouchEvents event) override;
 
         private:
@@ -54,7 +54,7 @@ namespace Pinetime {
           //std::unique_ptr<Screen> WatchFaceMinimalScreen();
           //std::unique_ptr<Screen> WatchFaceCustomScreen();
 
-          bool running = true;
+          
 
       };
     }
diff --git a/src/displayapp/screens/DropDownDemo.cpp b/src/displayapp/screens/DropDownDemo.cpp
index 944c63bb..c3ec5d7d 100644
--- a/src/displayapp/screens/DropDownDemo.cpp
+++ b/src/displayapp/screens/DropDownDemo.cpp
@@ -44,11 +44,6 @@ bool DropDownDemo::Refresh() {
   return running;
 }
 
-bool DropDownDemo::OnButtonPushed() {
-  running = false;
-  return true;
-}
-
 bool DropDownDemo::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
   // If the dropdown is opened, notify Display app that it doesn't need to handle the event
   // (this will prevent displayApp from going back to the menu or clock scree).
diff --git a/src/displayapp/screens/DropDownDemo.h b/src/displayapp/screens/DropDownDemo.h
index d66aeed0..821ae528 100644
--- a/src/displayapp/screens/DropDownDemo.h
+++ b/src/displayapp/screens/DropDownDemo.h
@@ -14,12 +14,12 @@ namespace Pinetime {
           ~DropDownDemo() override;
 
           bool Refresh() override;
-          bool OnButtonPushed() override;
+          
           bool OnTouchEvent(TouchEvents event) override;
 
         private:
           lv_obj_t * ddlist;
-          bool running = true;
+          
           bool isDropDownOpened = false;
       };
     }
diff --git a/src/displayapp/screens/FirmwareUpdate.cpp b/src/displayapp/screens/FirmwareUpdate.cpp
index 2f0bb5ad..e894850e 100644
--- a/src/displayapp/screens/FirmwareUpdate.cpp
+++ b/src/displayapp/screens/FirmwareUpdate.cpp
@@ -65,11 +65,6 @@ bool FirmwareUpdate::DisplayProgression() const {
   return running;
 }
 
-bool FirmwareUpdate::OnButtonPushed() {
-  running = false;
-  return true;
-}
-
 void FirmwareUpdate::UpdateValidated() {
   lv_label_set_recolor(percentLabel, true);
   lv_label_set_text(percentLabel, "#00ff00 Image Ok!#");
diff --git a/src/displayapp/screens/FirmwareUpdate.h b/src/displayapp/screens/FirmwareUpdate.h
index 262e7afb..27be3631 100644
--- a/src/displayapp/screens/FirmwareUpdate.h
+++ b/src/displayapp/screens/FirmwareUpdate.h
@@ -16,7 +16,7 @@ namespace Pinetime {
           ~FirmwareUpdate() override;
 
           bool Refresh() override;
-          bool OnButtonPushed() override;
+          
 
         private:
           enum class States { Idle, Running, Validated, Error };
@@ -25,7 +25,7 @@ namespace Pinetime {
           lv_obj_t* percentLabel;
           lv_obj_t* titleLabel;
           mutable char percentStr[10];
-          bool running = true;
+          
           States state;
 
           bool DisplayProgression() const;
diff --git a/src/displayapp/screens/FirmwareValidation.cpp b/src/displayapp/screens/FirmwareValidation.cpp
index adacd8cd..f78b1a67 100644
--- a/src/displayapp/screens/FirmwareValidation.cpp
+++ b/src/displayapp/screens/FirmwareValidation.cpp
@@ -46,20 +46,20 @@ FirmwareValidation::FirmwareValidation(Pinetime::Applications::DisplayApp *app,
     lv_obj_align(buttonValidate, NULL, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0);
     buttonValidate->user_data = this;
     lv_obj_set_event_cb(buttonValidate, ButtonEventHandler);
+    lv_obj_set_style_local_bg_color(buttonValidate, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x009900));
 
     labelButtonValidate = lv_label_create(buttonValidate, nullptr);
-    lv_label_set_recolor(labelButtonValidate, true);
-    lv_label_set_text(labelButtonValidate, "#00ff00 Validate#");
+    lv_label_set_text_static(labelButtonValidate, "Validate");    
 
     buttonReset = lv_btn_create(lv_scr_act(), nullptr);
     buttonReset->user_data = this;
     lv_obj_align(buttonReset, nullptr, LV_ALIGN_IN_BOTTOM_RIGHT, 0, 0);
+    lv_obj_set_style_local_bg_color(buttonReset, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x990000));
     lv_obj_set_event_cb(buttonReset, ButtonEventHandler);
-
+    
     labelButtonReset = lv_label_create(buttonReset, nullptr);
-    lv_label_set_recolor(labelButtonReset, true);
-    lv_label_set_text(labelButtonReset, "#ff0000 Reset#");
-  }
+    lv_label_set_text_static(labelButtonReset, "Reset"); 
+  }    
 }
 
 
@@ -71,11 +71,6 @@ bool FirmwareValidation::Refresh() {
   return running;
 }
 
-bool FirmwareValidation::OnButtonPushed() {
-  running = false;
-  return true;
-}
-
 void FirmwareValidation::OnButtonEvent(lv_obj_t *object, lv_event_t event) {
   if(object == buttonValidate && event == LV_EVENT_PRESSED) {
     validator.Validate();
diff --git a/src/displayapp/screens/FirmwareValidation.h b/src/displayapp/screens/FirmwareValidation.h
index 9eea86bd..b83f8238 100644
--- a/src/displayapp/screens/FirmwareValidation.h
+++ b/src/displayapp/screens/FirmwareValidation.h
@@ -17,7 +17,7 @@ namespace Pinetime {
           ~FirmwareValidation() override;
 
           bool Refresh() override;
-          bool OnButtonPushed() override;
+          
 
           void OnButtonEvent(lv_obj_t *object, lv_event_t event);
 
@@ -32,7 +32,7 @@ namespace Pinetime {
           lv_obj_t* labelButtonValidate;
           lv_obj_t* buttonReset;
           lv_obj_t* labelButtonReset;
-          bool running = true;
+          
       };
     }
   }
diff --git a/src/displayapp/screens/FlashLight.cpp b/src/displayapp/screens/FlashLight.cpp
new file mode 100644
index 00000000..0ef1b333
--- /dev/null
+++ b/src/displayapp/screens/FlashLight.cpp
@@ -0,0 +1,79 @@
+#include "FlashLight.h"
+#include "../DisplayApp.h"
+#include "Symbols.h"
+
+using namespace Pinetime::Applications::Screens;
+
+namespace {
+  static void event_handler(lv_obj_t * obj, lv_event_t event) {
+    FlashLight* screen = static_cast<FlashLight *>(obj->user_data);
+    screen->OnClickEvent(obj, event);
+  }
+}
+
+FlashLight::FlashLight(
+    Pinetime::Applications::DisplayApp *app,
+    System::SystemTask &systemTask,
+    Controllers::BrightnessController& brightness) : 
+  Screen(app),
+  systemTask{systemTask},
+  brightness{brightness}
+  
+{
+  brightness.Backup();
+  brightness.Set(Controllers::BrightnessController::Levels::High);
+  // Set the background
+  lv_obj_set_style_local_bg_color(lv_scr_act(), LV_OBJ_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0xFFFFFF));
+  
+  flashLight = lv_label_create(lv_scr_act(), NULL);  
+  lv_obj_set_style_local_text_color(flashLight, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x000000));
+  lv_obj_set_style_local_text_font(flashLight, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &lv_font_sys_48);
+  lv_label_set_text_static(flashLight, Symbols::highlight);
+  lv_obj_align(flashLight, NULL, LV_ALIGN_CENTER, 0, 0);
+
+  backgroundAction = lv_label_create(lv_scr_act(), nullptr);  
+  lv_label_set_long_mode(backgroundAction, LV_LABEL_LONG_CROP);
+  lv_obj_set_size(backgroundAction, 240, 240);
+  lv_obj_set_pos(backgroundAction, 0, 0);
+  lv_label_set_text(backgroundAction, "");
+  lv_obj_set_click(backgroundAction, true);
+  backgroundAction->user_data = this;  
+  lv_obj_set_event_cb(backgroundAction, event_handler);
+  
+  systemTask.PushMessage(Pinetime::System::SystemTask::Messages::DisableSleeping);
+
+}
+
+
+FlashLight::~FlashLight() {
+  lv_obj_clean(lv_scr_act());
+  lv_obj_set_style_local_bg_color(lv_scr_act(), LV_OBJ_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x000000));
+  brightness.Restore();
+  systemTask.PushMessage(Pinetime::System::SystemTask::Messages::EnableSleeping);
+}
+
+void FlashLight::OnClickEvent(lv_obj_t *obj, lv_event_t event) {
+  if(obj == backgroundAction) {
+    if (event == LV_EVENT_CLICKED) {
+      isOn = !isOn;
+
+      if ( isOn ) {
+        lv_obj_set_style_local_bg_color(lv_scr_act(), LV_OBJ_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0xFFFFFF));
+        lv_obj_set_style_local_text_color(flashLight, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x000000));
+      } else {
+        lv_obj_set_style_local_bg_color(lv_scr_act(), LV_OBJ_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x000000));
+        lv_obj_set_style_local_text_color(flashLight, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0xFFFFFF));
+      }
+
+    }
+  }
+}
+
+bool FlashLight::Refresh() {
+  return running;
+}
+
+bool FlashLight::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
+  return true;
+}
+
diff --git a/src/displayapp/screens/FlashLight.h b/src/displayapp/screens/FlashLight.h
new file mode 100644
index 00000000..c62472ab
--- /dev/null
+++ b/src/displayapp/screens/FlashLight.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <cstdint>
+#include "Screen.h"
+#include <lvgl/lvgl.h>
+#include "systemtask/SystemTask.h"
+#include "components/brightness/BrightnessController.h"
+
+
+namespace Pinetime {
+ 
+  namespace Applications {
+    namespace Screens {
+
+      class FlashLight : public Screen{
+        public:
+          FlashLight(DisplayApp* app, System::SystemTask &systemTask, Controllers::BrightnessController& brightness);
+          ~FlashLight() override;
+
+          bool Refresh() override;
+          
+          bool OnTouchEvent(Pinetime::Applications::TouchEvents event) override;
+          void OnClickEvent(lv_obj_t *obj, lv_event_t event);
+
+        private:
+          Pinetime::System::SystemTask& systemTask;
+          Controllers::BrightnessController& brightness;
+
+          lv_obj_t* flashLight;
+          lv_obj_t* backgroundAction;
+          bool isOn = true;
+
+      };
+    }
+  }
+}
diff --git a/src/displayapp/screens/HeartRate.cpp b/src/displayapp/screens/HeartRate.cpp
index 401d57d9..0bc3c352 100644
--- a/src/displayapp/screens/HeartRate.cpp
+++ b/src/displayapp/screens/HeartRate.cpp
@@ -27,26 +27,28 @@ namespace {
   }
 }
 
-HeartRate::HeartRate(Pinetime::Applications::DisplayApp *app, Controllers::HeartRateController& heartRateController) : Screen(app), heartRateController{heartRateController} {
+HeartRate::HeartRate(Pinetime::Applications::DisplayApp *app, Controllers::HeartRateController& heartRateController, System::SystemTask &systemTask) : 
+  Screen(app), heartRateController{heartRateController}, systemTask{systemTask} {
   
-  label_hr = lv_label_create(lv_scr_act(), NULL);
+  label_hr = lv_label_create(lv_scr_act(), nullptr);
 
-  lv_obj_set_style_local_text_font(label_hr, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_extrabold_compressed);
-
-  lv_obj_align(label_hr, lv_scr_act(), LV_ALIGN_CENTER, -70, -40);
+  lv_obj_set_style_local_text_font(label_hr, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_76);
+  lv_obj_set_style_local_text_color(label_hr, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GRAY);
   lv_label_set_text(label_hr, "000");
+  lv_obj_align(label_hr, nullptr, LV_ALIGN_CENTER, 0, -40);  
 
-  label_bpm = lv_label_create(lv_scr_act(), NULL);
-  lv_label_set_text(label_bpm, "Heart rate BPM");
+  label_bpm = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_text(label_bpm, "Heart rate BPM");  
   lv_obj_align(label_bpm, label_hr, LV_ALIGN_OUT_TOP_MID, 0, -20);
 
 
-  label_status = lv_label_create(lv_scr_act(), NULL);
+  label_status = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_color(label_status, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x222222));
   lv_label_set_text(label_status, ToString(Pinetime::Controllers::HeartRateController::States::NotEnoughData));
   
   lv_obj_align(label_status, label_hr, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);
 
-  btn_startStop = lv_btn_create(lv_scr_act(), NULL);
+  btn_startStop = lv_btn_create(lv_scr_act(), nullptr);
   btn_startStop->user_data = this;
   lv_obj_set_height(btn_startStop, 50);
   lv_obj_set_event_cb(btn_startStop, btnStartStopEventHandler);
@@ -58,21 +60,20 @@ HeartRate::HeartRate(Pinetime::Applications::DisplayApp *app, Controllers::Heart
 
 HeartRate::~HeartRate() {
   lv_obj_clean(lv_scr_act());
+  systemTask.PushMessage(Pinetime::System::SystemTask::Messages::EnableSleeping);
 }
 
 bool HeartRate::Refresh() {
-  char hr[4];
 
   auto state = heartRateController.State();
   switch(state) {
     case Controllers::HeartRateController::States::NoTouch:
     case Controllers::HeartRateController::States::NotEnoughData:
-    case Controllers::HeartRateController::States::Stopped:
+    //case Controllers::HeartRateController::States::Stopped:
       lv_label_set_text(label_hr, "000");
       break;
     default:
-      sprintf(hr, "%03d", heartRateController.HeartRate());
-      lv_label_set_text(label_hr, hr);
+      lv_label_set_text_fmt(label_hr, "%03d", heartRateController.HeartRate());
   }
 
   lv_label_set_text(label_status, ToString(state));
@@ -81,20 +82,19 @@ bool HeartRate::Refresh() {
   return running;
 }
 
-bool HeartRate::OnButtonPushed() {
-  running = false;
-  return true;
-}
-
 void HeartRate::OnStartStopEvent(lv_event_t event) {
   if (event == LV_EVENT_CLICKED) {
     if(heartRateController.State() == Controllers::HeartRateController::States::Stopped) {
       heartRateController.Start();
       UpdateStartStopButton(heartRateController.State() != Controllers::HeartRateController::States::Stopped);
+      systemTask.PushMessage(Pinetime::System::SystemTask::Messages::DisableSleeping);
+      lv_obj_set_style_local_text_color(label_hr, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GREEN);
     }
     else {
       heartRateController.Stop();
       UpdateStartStopButton(heartRateController.State() != Controllers::HeartRateController::States::Stopped);
+      systemTask.PushMessage(Pinetime::System::SystemTask::Messages::EnableSleeping);
+      lv_obj_set_style_local_text_color(label_hr, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GRAY);
     }
   }
 }
diff --git a/src/displayapp/screens/HeartRate.h b/src/displayapp/screens/HeartRate.h
index b9424998..c8f36999 100644
--- a/src/displayapp/screens/HeartRate.h
+++ b/src/displayapp/screens/HeartRate.h
@@ -4,6 +4,7 @@
 #include <chrono>
 #include "Screen.h"
 #include <bits/unique_ptr.h>
+#include "systemtask/SystemTask.h"
 #include <libs/lvgl/src/lv_core/lv_style.h>
 #include <libs/lvgl/src/lv_core/lv_obj.h>
 
@@ -16,25 +17,24 @@ namespace Pinetime {
 
       class HeartRate : public Screen{
       public:
-        HeartRate(DisplayApp* app, Controllers::HeartRateController& HeartRateController);
+        HeartRate(DisplayApp* app, Controllers::HeartRateController& HeartRateController, System::SystemTask &systemTask);
         ~HeartRate() override;
 
         bool Refresh() override;
-        bool OnButtonPushed() override;
+        
         void OnStartStopEvent(lv_event_t event);
 
       private:
         Controllers::HeartRateController& heartRateController;
+        Pinetime::System::SystemTask& systemTask;
         void UpdateStartStopButton(bool isRunning);
         lv_obj_t* label_hr;
         lv_obj_t* label_bpm;
         lv_obj_t* label_status;
-        lv_style_t labelBigStyle;
-        lv_style_t* labelStyle;
         lv_obj_t* btn_startStop;
         lv_obj_t* label_startStop;
 
-        bool running = true;
+        
 
       };
     }
diff --git a/src/displayapp/screens/InfiniPaint.cpp b/src/displayapp/screens/InfiniPaint.cpp
index 6d1f75b8..b2f0fdfe 100644
--- a/src/displayapp/screens/InfiniPaint.cpp
+++ b/src/displayapp/screens/InfiniPaint.cpp
@@ -6,7 +6,7 @@ using namespace Pinetime::Applications::Screens;
 
 InfiniPaint::InfiniPaint(Pinetime::Applications::DisplayApp* app, Pinetime::Components::LittleVgl& lvgl) : Screen(app), lvgl{lvgl} {
   app->SetTouchMode(DisplayApp::TouchModes::Polling);
-  std::fill(b, b + bufferSize, LV_COLOR_WHITE);
+  std::fill(b, b + bufferSize, selectColor);
 }
 
 InfiniPaint::~InfiniPaint() {
@@ -19,12 +19,44 @@ bool InfiniPaint::Refresh() {
   return running;
 }
 
-bool InfiniPaint::OnButtonPushed() {
-  running = false;
-  return true;
-}
-
 bool InfiniPaint::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
+  switch(event) {
+    case Pinetime::Applications::TouchEvents::LongTap:      
+      switch (color) {
+        case 0:
+          selectColor = LV_COLOR_MAGENTA;
+          break;
+        case 1:
+          selectColor = LV_COLOR_GREEN;
+          break;
+        case 2:
+          selectColor = LV_COLOR_WHITE;
+          break;
+        case 3:
+          selectColor = LV_COLOR_RED;
+          break;
+        case 4:
+          selectColor = LV_COLOR_CYAN;
+          break;
+        case 5:
+          selectColor = LV_COLOR_YELLOW;
+          break;
+        case 6:
+          selectColor = LV_COLOR_BLUE;
+          break;
+        case 7:
+          selectColor = LV_COLOR_BLACK;
+          break;
+      
+        default:
+          color = 0;
+          break;
+      }
+
+      std::fill(b, b + bufferSize, selectColor);  
+      color++;
+      return true;
+  }
   return true;
 }
 
diff --git a/src/displayapp/screens/InfiniPaint.h b/src/displayapp/screens/InfiniPaint.h
index 9a7ac076..da9c39ba 100644
--- a/src/displayapp/screens/InfiniPaint.h
+++ b/src/displayapp/screens/InfiniPaint.h
@@ -19,8 +19,6 @@ namespace Pinetime {
 
         bool Refresh() override;
 
-        bool OnButtonPushed() override;
-
         bool OnTouchEvent(TouchEvents event) override;
 
         bool OnTouchEvent(uint16_t x, uint16_t y) override;
@@ -31,7 +29,9 @@ namespace Pinetime {
         static constexpr uint16_t height = 10;
         static constexpr uint16_t bufferSize = width * height;
         lv_color_t b[bufferSize];
-        bool running = true;
+        lv_color_t selectColor = LV_COLOR_WHITE;
+        uint8_t color = 2;
+        
       };
     }
   }
diff --git a/src/displayapp/screens/Label.cpp b/src/displayapp/screens/Label.cpp
index 4be7742a..cc268775 100644
--- a/src/displayapp/screens/Label.cpp
+++ b/src/displayapp/screens/Label.cpp
@@ -2,13 +2,45 @@
 
 using namespace Pinetime::Applications::Screens;
 
-Label::Label(Pinetime::Applications::DisplayApp *app, const char *text)  : Screen(app), text{text} {
-  label = lv_label_create(lv_scr_act(), nullptr);
-  lv_label_set_align(label, LV_LABEL_ALIGN_LEFT);
-  lv_obj_set_size(label, 240, 240);
-  lv_label_set_text(label, text);
+Label::Label(uint8_t screenID, uint8_t numScreens,
+  Pinetime::Applications::DisplayApp *app, lv_obj_t* labelText)  : 
+  Screen(app), 
+  labelText{labelText} {
+  
+  if ( numScreens > 1 ) {
+    pageIndicatorBasePoints[0].x = 240 - 1;
+    pageIndicatorBasePoints[0].y = 6;
+    pageIndicatorBasePoints[1].x = 240 - 1;
+    pageIndicatorBasePoints[1].y = 240 - 6;
+    
+    pageIndicatorBase = lv_line_create(lv_scr_act(), NULL);
+    lv_obj_set_style_local_line_width(pageIndicatorBase, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, 3);
+    lv_obj_set_style_local_line_color(pageIndicatorBase, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x111111));
+    lv_obj_set_style_local_line_rounded(pageIndicatorBase, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, true);
+    lv_line_set_points(pageIndicatorBase, pageIndicatorBasePoints, 2);
+
+  
+    uint16_t indicatorSize = 228 / numScreens;
+    uint16_t indicatorPos = indicatorSize * screenID;
+
+    pageIndicatorPoints[0].x = 240 - 1;
+    pageIndicatorPoints[0].y = (6 + indicatorPos);
+    pageIndicatorPoints[1].x = 240 - 1;
+    pageIndicatorPoints[1].y = (6 + indicatorPos) + indicatorSize;
+
+    pageIndicator = lv_line_create(lv_scr_act(), NULL);
+    lv_obj_set_style_local_line_width(pageIndicator, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, 3);
+    lv_obj_set_style_local_line_color(pageIndicator, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GRAY);
+    lv_obj_set_style_local_line_rounded(pageIndicator, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, true);
+    lv_line_set_points(pageIndicator, pageIndicatorPoints, 2);
+  }
+
 }
 
 Label::~Label() {
   lv_obj_clean(lv_scr_act());
 }
+
+bool Label::Refresh() {
+  return running;
+}
diff --git a/src/displayapp/screens/Label.h b/src/displayapp/screens/Label.h
index dba89bbf..a1bcba95 100644
--- a/src/displayapp/screens/Label.h
+++ b/src/displayapp/screens/Label.h
@@ -9,13 +9,22 @@ namespace Pinetime {
 
       class Label : public Screen {
         public:
-          Label(DisplayApp* app, const char* text);
+          Label( uint8_t screenID, uint8_t numScreens,
+            DisplayApp* app, lv_obj_t* labelText );
           ~Label() override;
-          bool Refresh() override {return false;}
+          
+          bool Refresh() override;
+          
 
         private:
-          lv_obj_t * label = nullptr;
-          const char* text = nullptr;
+
+          bool running = true;
+          
+          lv_obj_t * labelText = nullptr;
+          lv_point_t pageIndicatorBasePoints[2];
+          lv_point_t pageIndicatorPoints[2];
+          lv_obj_t* pageIndicatorBase;
+          lv_obj_t* pageIndicator;
       };
     }
   }
diff --git a/src/displayapp/screens/List.cpp b/src/displayapp/screens/List.cpp
new file mode 100644
index 00000000..87cfa6db
--- /dev/null
+++ b/src/displayapp/screens/List.cpp
@@ -0,0 +1,126 @@
+#include "List.h"
+#include "../DisplayApp.h"
+#include "Symbols.h"
+
+using namespace Pinetime::Applications::Screens;
+
+namespace {
+  static void ButtonEventHandler(lv_obj_t * obj, lv_event_t event) {
+    List* screen = static_cast<List *>(obj->user_data);
+    screen->OnButtonEvent(obj, event);
+  }
+
+}
+
+List::List(uint8_t screenID, uint8_t numScreens,
+    DisplayApp* app,
+    Controllers::Settings &settingsController, 
+    std::array<Applications, MAXLISTITEMS>& applications) : 
+    Screen(app),
+    settingsController{settingsController}
+{
+
+  // Set the background to Black
+  lv_obj_set_style_local_bg_color(lv_scr_act(), LV_OBJ_PART_MAIN, LV_STATE_DEFAULT, lv_color_make(0, 0, 0));
+
+  settingsController.SetSettingsMenu(screenID);
+
+  if ( numScreens > 1 ) {
+    pageIndicatorBasePoints[0].x = 240 - 1;
+    pageIndicatorBasePoints[0].y = 6;
+    pageIndicatorBasePoints[1].x = 240 - 1;
+    pageIndicatorBasePoints[1].y = 240 - 6;
+    
+    pageIndicatorBase = lv_line_create(lv_scr_act(), NULL);
+    lv_obj_set_style_local_line_width(pageIndicatorBase, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, 3);
+    lv_obj_set_style_local_line_color(pageIndicatorBase, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x111111));
+    lv_obj_set_style_local_line_rounded(pageIndicatorBase, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, true);
+    lv_line_set_points(pageIndicatorBase, pageIndicatorBasePoints, 2);
+
+  
+    uint16_t indicatorSize = 228 / numScreens;
+    uint16_t indicatorPos = indicatorSize * screenID;
+
+    pageIndicatorPoints[0].x = 240 - 1;
+    pageIndicatorPoints[0].y = 6 + indicatorPos;
+    pageIndicatorPoints[1].x = 240 - 1;
+    pageIndicatorPoints[1].y = 6 + indicatorPos + indicatorSize;
+
+    pageIndicator = lv_line_create(lv_scr_act(), NULL);
+    lv_obj_set_style_local_line_width(pageIndicator, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, 3);
+    lv_obj_set_style_local_line_color(pageIndicator, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GRAY);
+    lv_obj_set_style_local_line_rounded(pageIndicator, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, true);
+    lv_line_set_points(pageIndicator, pageIndicatorPoints, 2);
+  }
+
+
+  lv_obj_t* container1 = lv_cont_create(lv_scr_act(), nullptr);
+
+  //lv_obj_set_style_local_bg_color(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x111111));
+  lv_obj_set_style_local_bg_opa(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
+  lv_obj_set_style_local_pad_all(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 10);
+  lv_obj_set_style_local_pad_inner(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 5);
+  lv_obj_set_style_local_border_width(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 0);
+
+  lv_obj_set_pos(container1, 0, 0);
+  lv_obj_set_width(container1, LV_HOR_RES - 15);
+  lv_obj_set_height(container1, LV_VER_RES);
+  lv_cont_set_layout(container1, LV_LAYOUT_COLUMN_LEFT);
+
+  lv_obj_t * labelBt;
+  lv_obj_t * labelBtIco;
+
+  for(int i = 0; i < MAXLISTITEMS; i++) {
+    apps[i] = applications[i].application;
+    if ( applications[i].application != Apps::None) {    
+
+      itemApps[i] = lv_btn_create(container1, nullptr);
+      lv_obj_set_style_local_bg_opa(itemApps[i], LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_20);
+      lv_obj_set_style_local_radius(itemApps[i], LV_BTN_PART_MAIN, LV_STATE_DEFAULT, 20);
+      lv_obj_set_style_local_bg_color(itemApps[i], LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_AQUA);
+
+      lv_obj_set_width(itemApps[i], LV_HOR_RES - 25);
+      lv_obj_set_height(itemApps[i], 52);
+      lv_obj_set_event_cb(itemApps[i], ButtonEventHandler);
+      lv_btn_set_layout(itemApps[i], LV_LAYOUT_ROW_MID);
+      itemApps[i]->user_data = this;
+
+      labelBtIco = lv_label_create(itemApps[i], nullptr);
+      lv_obj_set_style_local_text_color(labelBtIco, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_YELLOW);
+      lv_label_set_text_static(labelBtIco, applications[i].icon);
+
+      labelBt = lv_label_create(itemApps[i], nullptr);
+      lv_label_set_text_fmt(labelBt, " %s", applications[i].name);
+      
+    }
+  }
+
+  lv_obj_t * backgroundLabel = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_long_mode(backgroundLabel, LV_LABEL_LONG_CROP);
+  lv_obj_set_size(backgroundLabel, LV_HOR_RES, LV_VER_RES);
+  lv_obj_set_pos(backgroundLabel, 0, 0);
+  lv_label_set_text_static(backgroundLabel, "");
+
+}
+
+List::~List() {  
+  lv_obj_clean(lv_scr_act());
+}
+
+bool List::Refresh() {
+
+  return running;
+}
+
+void List::OnButtonEvent(lv_obj_t * object, lv_event_t event) {
+  if ( event == LV_EVENT_RELEASED ) {
+    for(int i = 0; i < MAXLISTITEMS; i++) {
+      if ( apps[i] != Apps::None && object == itemApps[i] ) {
+        app->StartApp(apps[i], DisplayApp::FullRefreshDirections::Down);
+        running = false;
+        return;
+      }
+    }
+  }
+}
+
diff --git a/src/displayapp/screens/List.h b/src/displayapp/screens/List.h
new file mode 100644
index 00000000..739a91c3
--- /dev/null
+++ b/src/displayapp/screens/List.h
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <lvgl/lvgl.h>
+#include <cstdint>
+#include <memory>
+#include "Screen.h"
+#include "../Apps.h"
+#include "components/settings/Settings.h"
+
+#define MAXLISTITEMS 4
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      class List : public Screen {
+        public:
+          struct Applications {
+            const char* icon;
+            const char* name;
+            Pinetime::Applications::Apps application;
+          };
+
+          explicit List(uint8_t screenID, uint8_t numScreens,
+              DisplayApp* app,
+              Controllers::Settings& settingsController, 
+              std::array<Applications, MAXLISTITEMS>& applications);
+          ~List() override;
+
+          bool Refresh() override;
+          
+
+          void OnButtonEvent(lv_obj_t *object, lv_event_t event);
+
+        private:
+
+          Controllers::Settings& settingsController;
+          Pinetime::Applications::Apps apps[MAXLISTITEMS];
+
+          lv_obj_t * itemApps[MAXLISTITEMS];
+
+          lv_point_t pageIndicatorBasePoints[2];
+          lv_point_t pageIndicatorPoints[2];
+          lv_obj_t* pageIndicatorBase;
+          lv_obj_t* pageIndicator;
+         
+      };
+    }
+  }
+}
diff --git a/src/displayapp/screens/Meter.cpp b/src/displayapp/screens/Meter.cpp
index 58a0636f..2c042cac 100644
--- a/src/displayapp/screens/Meter.cpp
+++ b/src/displayapp/screens/Meter.cpp
@@ -36,8 +36,3 @@ bool Meter::Refresh() {
 
   return running;
 }
-
-bool Meter::OnButtonPushed() {
-  running = false;
-  return true;
-}
diff --git a/src/displayapp/screens/Meter.h b/src/displayapp/screens/Meter.h
index 86888dda..6a1fc3bf 100644
--- a/src/displayapp/screens/Meter.h
+++ b/src/displayapp/screens/Meter.h
@@ -15,14 +15,13 @@ namespace Pinetime {
           ~Meter() override;
 
           bool Refresh() override;
-          bool OnButtonPushed() override;
 
         private:
           lv_style_t style_lmeter;
           lv_obj_t * lmeter;
 
           uint32_t value=0;
-          bool running = true;
+          
 
       };
     }
diff --git a/src/displayapp/screens/Music.cpp b/src/displayapp/screens/Music.cpp
index b68f3781..85d35c96 100644
--- a/src/displayapp/screens/Music.cpp
+++ b/src/displayapp/screens/Music.cpp
@@ -134,11 +134,6 @@ Music::~Music() {
   lv_obj_clean(lv_scr_act());
 }
 
-bool Music::OnButtonPushed() {
-  running = false;
-  return true;
-}
-
 bool Music::Refresh() {
   if (artist != musicService.getArtist()) {
     artist = musicService.getArtist();
diff --git a/src/displayapp/screens/Music.h b/src/displayapp/screens/Music.h
index 66bde21b..096ab74d 100644
--- a/src/displayapp/screens/Music.h
+++ b/src/displayapp/screens/Music.h
@@ -37,7 +37,7 @@ namespace Pinetime {
         
         bool Refresh() override;
         
-        bool OnButtonPushed() override;
+        
         
         void OnObjectEvent(lv_obj_t *obj, lv_event_t event);
       
@@ -81,7 +81,7 @@ namespace Pinetime {
         bool playing;
         
         /** Watchapp */
-        bool running = true;
+        
       };
     }
   }
diff --git a/src/displayapp/screens/Navigation.cpp b/src/displayapp/screens/Navigation.cpp
index 9fbcbe57..cfe60e23 100644
--- a/src/displayapp/screens/Navigation.cpp
+++ b/src/displayapp/screens/Navigation.cpp
@@ -22,16 +22,7 @@
 
 using namespace Pinetime::Applications::Screens;
 
-/**
- * Set the pixel array to display by the image
- * This just calls lv_img_set_src but adds type safety
- *
- * @param img pointer to an image object
- * @param data the image array
- */
-inline void lv_img_set_src_arr(lv_obj_t *img, const lv_img_dsc_t *src_img) {
-  lv_img_set_src(img, src_img);
-}
+LV_FONT_DECLARE(lv_font_navi_80)
 
 /**
  * Navigation watchapp
@@ -39,36 +30,37 @@ inline void lv_img_set_src_arr(lv_obj_t *img, const lv_img_dsc_t *src_img) {
  */
 Navigation::Navigation(Pinetime::Applications::DisplayApp *app, Pinetime::Controllers::NavigationService &nav) : Screen(app), navService(nav) {
 
-  constexpr uint8_t FONT_HEIGHT = 12;
-  constexpr uint8_t LINE_PAD = 15;
-  constexpr int8_t MIDDLE_OFFSET = -25;
+  imgFlag = lv_label_create(lv_scr_act(), nullptr);  
+  lv_obj_set_style_local_text_font(imgFlag, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &lv_font_navi_80);
+  lv_obj_set_style_local_text_color(imgFlag, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_CYAN);
+  lv_label_set_text(imgFlag, iconForName("flag"));
+  lv_obj_align(imgFlag, nullptr, LV_ALIGN_CENTER, 0, -60);
 
-  imgFlag = lv_img_create(lv_scr_act(), nullptr);
-  lv_img_set_src_arr(imgFlag, &flag);
-  lv_obj_align(imgFlag, nullptr, LV_ALIGN_IN_TOP_MID, 0, 15);
 
   txtNarrative = lv_label_create(lv_scr_act(), nullptr);
-  lv_label_set_long_mode(txtNarrative, LV_LABEL_LONG_SROLL);
-  lv_obj_align(txtNarrative, nullptr, LV_ALIGN_IN_LEFT_MID, 12, MIDDLE_OFFSET + 1 * FONT_HEIGHT);
-  lv_label_set_text(txtNarrative, "Narrative");
-  lv_label_set_align(txtNarrative, LV_LABEL_ALIGN_CENTER);
-  lv_label_set_anim_speed(txtNarrative, 15);
+  lv_label_set_long_mode(txtNarrative, LV_LABEL_LONG_BREAK);
   lv_obj_set_width(txtNarrative, LV_HOR_RES);
+  lv_label_set_text(txtNarrative, "Welcome to navigation!");
+  lv_label_set_align(txtNarrative, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(txtNarrative, nullptr, LV_ALIGN_CENTER, 0, 10);
 
   txtManDist = lv_label_create(lv_scr_act(), nullptr);
-  lv_label_set_long_mode(txtManDist, LV_LABEL_LONG_SROLL);
-  lv_obj_align(txtManDist, nullptr, LV_ALIGN_IN_LEFT_MID, 12, MIDDLE_OFFSET + 2 * FONT_HEIGHT + LINE_PAD);
-  lv_label_set_text(txtManDist, "0M");
-  lv_label_set_align(txtManDist, LV_LABEL_ALIGN_CENTER);
+  lv_label_set_long_mode(txtManDist, LV_LABEL_LONG_BREAK);
+  lv_obj_set_style_local_text_color(txtManDist, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GREEN);
   lv_obj_set_width(txtManDist, LV_HOR_RES);
+  lv_label_set_text(txtManDist, "--M");
+  lv_label_set_align(txtManDist, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(txtManDist, nullptr, LV_ALIGN_CENTER, 0, 60);  
 
   //Route Progress
-  barProgress = lv_bar_create(lv_scr_act(), NULL);
+  barProgress = lv_bar_create(lv_scr_act(), nullptr);
   lv_obj_set_size(barProgress, 200, 20);
-  lv_obj_align(barProgress, NULL, LV_ALIGN_IN_BOTTOM_MID, 0, 0);
+  lv_obj_align(barProgress, nullptr, LV_ALIGN_IN_BOTTOM_MID, 0, -10);
+  lv_obj_set_style_local_bg_color(barProgress, LV_BAR_PART_BG, LV_STATE_DEFAULT, lv_color_hex(0x222222));
+  lv_obj_set_style_local_bg_color(barProgress, LV_BAR_PART_INDIC , LV_STATE_DEFAULT, LV_COLOR_ORANGE);
   lv_bar_set_anim_time(barProgress, 500);
   lv_bar_set_range(barProgress, 0, 100);
-  lv_bar_set_value(barProgress, 0, LV_ANIM_ON);
+  lv_bar_set_value(barProgress, 0, LV_ANIM_OFF);
 }
 
 Navigation::~Navigation() {
@@ -79,8 +71,8 @@ bool Navigation::Refresh() {
 
   if (m_flag != navService.getFlag()) {
     m_flag = navService.getFlag();
-
-    lv_img_set_src_arr(imgFlag, iconForName(m_flag));
+    lv_label_set_text(imgFlag, iconForName(m_flag));
+    //lv_img_set_src_arr(imgFlag, iconForName(m_flag));
   }
 
   if (m_narrative != navService.getNarrative()) {
@@ -95,23 +87,22 @@ bool Navigation::Refresh() {
 
   if (m_progress != navService.getProgress()) {
     m_progress = navService.getProgress();
-    lv_bar_set_value(barProgress, m_progress, LV_ANIM_ON);
+    lv_bar_set_value(barProgress, m_progress, LV_ANIM_OFF);
+    if ( m_progress > 90 ) {
+      lv_obj_set_style_local_bg_color(barProgress, LV_BAR_PART_INDIC , LV_STATE_DEFAULT, LV_COLOR_RED);
+    } else {
+      lv_obj_set_style_local_bg_color(barProgress, LV_BAR_PART_INDIC , LV_STATE_DEFAULT, LV_COLOR_ORANGE);
+    }
   }
 
   return running;
 }
 
-bool Navigation::OnButtonPushed() {
-  running = false;
-  return true;
-}
-
-const lv_img_dsc_t* Navigation::iconForName(std::string icon)
-{
-    for (auto iter : m_iconMap) {
-        if (iter.first == icon) {
-            return iter.second;
-        }
+const char* Navigation::iconForName(std::string icon) {
+  for (auto iter : m_iconMap) {
+    if (iter.first == icon) {
+      return iter.second;
     }
-    return &invalid;
+  }
+  return "\xEE\xA4\x90";
 }
diff --git a/src/displayapp/screens/Navigation.h b/src/displayapp/screens/Navigation.h
index 9fdd37d9..53108f98 100644
--- a/src/displayapp/screens/Navigation.h
+++ b/src/displayapp/screens/Navigation.h
@@ -22,94 +22,7 @@
 #include <string>
 #include "Screen.h"
 #include <array>
-#include <lvgl/src/lv_draw/lv_img_decoder.h>
 
-#include "displayapp/icons/navigation/arrive-left.c"
-#include "displayapp/icons/navigation/arrive-right.c"
-#include "displayapp/icons/navigation/arrive-straight.c"
-#include "displayapp/icons/navigation/arrive.c"
-#include "displayapp/icons/navigation/close.c"
-#include "displayapp/icons/navigation/continue-left.c"
-#include "displayapp/icons/navigation/continue-right.c"
-#include "displayapp/icons/navigation/continue-slight-left.c"
-#include "displayapp/icons/navigation/continue-slight-right.c"
-#include "displayapp/icons/navigation/continue-straight.c"
-#include "displayapp/icons/navigation/continue-uturn.c"
-#include "displayapp/icons/navigation/continue.c"
-#include "displayapp/icons/navigation/depart-left.c"
-#include "displayapp/icons/navigation/depart-right.c"
-#include "displayapp/icons/navigation/depart-straight.c"
-#include "displayapp/icons/navigation/end-of-road-left.c"
-#include "displayapp/icons/navigation/end-of-road-right.c"
-#include "displayapp/icons/navigation/ferry.c"
-#include "displayapp/icons/navigation/flag.c"
-#include "displayapp/icons/navigation/fork-left.c"
-#include "displayapp/icons/navigation/fork-right.c"
-#include "displayapp/icons/navigation/fork-slight-left.c"
-#include "displayapp/icons/navigation/fork-slight-right.c"
-#include "displayapp/icons/navigation/fork-straight.c"
-#include "displayapp/icons/navigation/invalid.c"
-#include "displayapp/icons/navigation/invalid-left.c"
-#include "displayapp/icons/navigation/invalid-right.c"
-#include "displayapp/icons/navigation/invalid-slight-left.c"
-#include "displayapp/icons/navigation/invalid-slight-right.c"
-#include "displayapp/icons/navigation/invalid-straight.c"
-#include "displayapp/icons/navigation/invalid-uturn.c"
-#include "displayapp/icons/navigation/merge-left.c"
-#include "displayapp/icons/navigation/merge-right.c"
-#include "displayapp/icons/navigation/merge-slight-left.c"
-#include "displayapp/icons/navigation/merge-slight-right.c"
-#include "displayapp/icons/navigation/merge-straight.c"
-#include "displayapp/icons/navigation/new-name-left.c"
-#include "displayapp/icons/navigation/new-name-right.c"
-#include "displayapp/icons/navigation/new-name-sharp-left.c"
-#include "displayapp/icons/navigation/new-name-sharp-right.c"
-#include "displayapp/icons/navigation/new-name-slight-left.c"
-#include "displayapp/icons/navigation/new-name-slight-right.c"
-#include "displayapp/icons/navigation/new-name-straight.c"
-#include "displayapp/icons/navigation/notification-left.c"
-#include "displayapp/icons/navigation/notification-right.c"
-#include "displayapp/icons/navigation/notification-sharp-left.c"
-#include "displayapp/icons/navigation/notification-sharp-right.c"
-#include "displayapp/icons/navigation/notification-slight-left.c"
-#include "displayapp/icons/navigation/notification-slight-right.c"
-#include "displayapp/icons/navigation/notification-straight.c"
-#include "displayapp/icons/navigation/off-ramp-left.c"
-#include "displayapp/icons/navigation/off-ramp-right.c"
-#include "displayapp/icons/navigation/off-ramp-slight-left.c"
-#include "displayapp/icons/navigation/off-ramp-slight-right.c"
-#include "displayapp/icons/navigation/on-ramp-left.c"
-#include "displayapp/icons/navigation/on-ramp-right.c"
-#include "displayapp/icons/navigation/on-ramp-sharp-left.c"
-#include "displayapp/icons/navigation/on-ramp-sharp-right.c"
-#include "displayapp/icons/navigation/on-ramp-slight-left.c"
-#include "displayapp/icons/navigation/on-ramp-slight-right.c"
-#include "displayapp/icons/navigation/on-ramp-straight.c"
-#include "displayapp/icons/navigation/rotary.c"
-#include "displayapp/icons/navigation/rotary-left.c"
-#include "displayapp/icons/navigation/rotary-right.c"
-#include "displayapp/icons/navigation/rotary-sharp-left.c"
-#include "displayapp/icons/navigation/rotary-sharp-right.c"
-#include "displayapp/icons/navigation/rotary-slight-left.c"
-#include "displayapp/icons/navigation/rotary-slight-right.c"
-#include "displayapp/icons/navigation/rotary-straight.c"
-#include "displayapp/icons/navigation/roundabout.c"
-#include "displayapp/icons/navigation/roundabout-left.c"
-#include "displayapp/icons/navigation/roundabout-right.c"
-#include "displayapp/icons/navigation/roundabout-sharp-left.c"
-#include "displayapp/icons/navigation/roundabout-sharp-right.c"
-#include "displayapp/icons/navigation/roundabout-slight-left.c"
-#include "displayapp/icons/navigation/roundabout-slight-right.c"
-#include "displayapp/icons/navigation/roundabout-straight.c"
-#include "displayapp/icons/navigation/turn-left.c"
-#include "displayapp/icons/navigation/turn-right.c"
-#include "displayapp/icons/navigation/turn-sharp-left.c"
-#include "displayapp/icons/navigation/turn-sharp-right.c"
-#include "displayapp/icons/navigation/turn-slight-left.c"
-#include "displayapp/icons/navigation/turn-slight-right.c"
-#include "displayapp/icons/navigation/turn-straight.c"
-#include "displayapp/icons/navigation/updown.c"
-#include "displayapp/icons/navigation/uturn.c"
 
 namespace Pinetime {
   namespace Controllers {
@@ -124,8 +37,7 @@ namespace Pinetime {
         ~Navigation() override;
 
         bool Refresh() override;
-        bool OnButtonPushed() override;
-
+        
       private:
 
         lv_obj_t *imgFlag;
@@ -141,97 +53,97 @@ namespace Pinetime {
         int m_progress;
 
         /** Watchapp */
-        bool running = true;
-
-        const lv_img_dsc_t* iconForName(std::string icon);
-
-        std::array<std::pair<std::string, const lv_img_dsc_t*>, 89 > m_iconMap = { {
-            {"arrive-left", &arrive_left},
-            {"arrive-right", &arrive_right},
-            {"arrive-straight", &arrive_straight},
-            {"arrive", &arrive},
-            {"close", &close},
-            {"continue-left", &continue_left},
-            {"continue-right", &continue_right},
-            {"continue-slight-left", &continue_slight_left},
-            {"continue-slight-right", &continue_slight_right},
-            {"continue-straight", &continue_straight},
-            {"continue-uturn", &continue_uturn},
-            {"continue", &continue_icon},
-            {"depart-left", &depart_left},
-            {"depart-right", &depart_right},
-            {"depart-straight", &depart_straight},
-            {"end-of-road-left", &end_of_road_left},
-            {"end-of-road-right", &end_of_road_right},
-            {"ferry", &ferry},
-            {"flag", &flag},
-            {"fork-left", &fork_left},
-            {"fork-right", &fork_right},
-            {"fork-slight-left", &fork_slight_left},
-            {"fork-slight-right", &fork_slight_right},
-            {"fork-straight", &fork_straight},
-            {"invalid", &invalid},
-            {"invalid-left", &invalid_left},
-            {"invalid-right", &invalid_right},
-            {"invalid-slight-left", &invalid_slight_left},
-            {"invalid-slight-right", &invalid_slight_right},
-            {"invalid-straight", &invalid_straight},
-            {"invalid-uturn", &invalid_uturn},
-            {"merge-left", &merge_left},
-            {"merge-right", &merge_right},
-            {"merge-slight-left", &merge_slight_left},
-            {"merge-slight-right", &merge_slight_right},
-            {"merge-straight", &merge_straight},
-            {"new-name-left", &new_name_left},
-            {"new-name-right", &new_name_right},
-            {"new-name-sharp-left", &new_name_sharp_left},
-            {"new-name-sharp-right", &new_name_sharp_right},
-            {"new-name-slight-left", &new_name_slight_left},
-            {"new-name-slight-right", &new_name_slight_right},
-            {"new-name-straight", &new_name_straight},
-            {"notification-left", &notification_left},
-            {"notification-right", &notification_right},
-            {"notification-sharp-left", &notification_sharp_left},
-            {"notification-sharp-right", &notification_sharp_right},
-            {"notification-slight-left", &notification_slight_left},
-            {"notification-slight-right", &notification_slight_right},
-            {"notification-straight", &notification_straight},
-            {"off-ramp-left", &off_ramp_left},
-            {"off-ramp-right", &off_ramp_right},
-            {"off-ramp-slight-left", &off_ramp_slight_left},
-            {"off-ramp-slight-right", &off_ramp_slight_right},
-            {"on-ramp-left", &on_ramp_left},
-            {"on-ramp-right", &on_ramp_right},
-            {"on-ramp-sharp-left", &on_ramp_sharp_left},
-            {"on-ramp-sharp-right", &on_ramp_sharp_right},
-            {"on-ramp-slight-left", &on_ramp_slight_left},
-            {"on-ramp-slight-right", &on_ramp_slight_right},
-            {"on-ramp-straight", &on_ramp_straight},
-            {"rotary", &rotary},
-            {"rotary-left", &rotary_left},
-            {"rotary-right", &rotary_right},
-            {"rotary-sharp-left", &rotary_sharp_left},
-            {"rotary-sharp-right", &rotary_sharp_right},
-            {"rotary-slight-left", &rotary_slight_left},
-            {"rotary-slight-right", &rotary_slight_right},
-            {"rotary-straight", &rotary_straight},
-            {"roundabout", &roundabout},
-            {"roundabout-left", &roundabout_left},
-            {"roundabout-right", &roundabout_right},
-            {"roundabout-sharp-left", &roundabout_sharp_left},
-            {"roundabout-sharp-right", &roundabout_sharp_right},
-            {"roundabout-slight-left", &roundabout_slight_left},
-            {"roundabout-slight-right", &roundabout_slight_right},
-            {"roundabout-straight", &roundabout_straight},
-            {"turn-left", &turn_left},
-            {"turn-right", &turn_right},
-            {"turn-sharp-left", &turn_sharp_left},
-            {"turn-sharp-right", &turn_sharp_right},
-            {"turn-slight-left", &turn_slight_left},
-            {"turn-slight-right", &turn_slight_right},
-            {"turn-straight", &turn_straight},
-            {"updown", &updown},
-            {"uturn", &uturn} } };
+        
+        const char* iconForName(std::string icon);
+        
+        std::array<std::pair<std::string, const char*>, 89 > m_iconMap = { {
+            {"arrive-left"                ,"\xEE\xA4\x81" },
+            {"arrive-right"               ,"\xEE\xA4\x82" },
+            {"arrive-straight"            ,"\xEE\xA4\x80" },
+            {"arrive"                     ,"\xEE\xA4\x80" },
+            {"close"                      ,"\xEE\xA4\x83" },
+            {"continue-left"              ,"\xEE\xA4\x85" },
+            {"continue-right"             ,"\xEE\xA4\x86" },
+            {"continue-slight-left"       ,"\xEE\xA4\x87" },
+            {"continue-slight-right"      ,"\xEE\xA4\x88" },
+            {"continue-straight"          ,"\xEE\xA4\x84" },
+            {"continue-uturn"             ,"\xEE\xA4\x89" },
+            {"continue"                   ,"\xEE\xA4\x84" },
+            {"depart-left"                ,"\xEE\xA4\x8B" },
+            {"depart-right"               ,"\xEE\xA4\x8C" },
+            {"depart-straight"            ,"\xEE\xA4\x8A" },
+            {"end-of-road-left"           ,"\xEE\xA4\x8D" },
+            {"end-of-road-right"          ,"\xEE\xA4\x8E" },
+            {"ferry"                      ,"\xEE\xA4\x8F" },
+            {"flag"                       ,"\xEE\xA4\x90" },
+            {"fork-left"                  ,"\xEE\xA4\x92" },
+            {"fork-right"                 ,"\xEE\xA4\x93" },
+            {"fork-slight-left"           ,"\xEE\xA4\x94" },
+            {"fork-slight-right"          ,"\xEE\xA4\x95" },
+            {"fork-straight"              ,"\xEE\xA4\x96" },
+            {"invalid"                    ,"\xEE\xA4\x84" },
+            {"invalid-left"               ,"\xEE\xA4\x85" },
+            {"invalid-right"              ,"\xEE\xA4\x86" },
+            {"invalid-slight-left"        ,"\xEE\xA4\x87" },
+            {"invalid-slight-right"       ,"\xEE\xA4\x88" },
+            {"invalid-straight"           ,"\xEE\xA4\x84" },
+            {"invalid-uturn"              ,"\xEE\xA4\x89" },
+            {"merge-left"                 ,"\xEE\xA4\x97" },
+            {"merge-right"                ,"\xEE\xA4\x98" },
+            {"merge-slight-left"          ,"\xEE\xA4\x99" },
+            {"merge-slight-right"         ,"\xEE\xA4\x9A" },
+            {"merge-straight"             ,"\xEE\xA4\x84" },
+            {"new-name-left"              ,"\xEE\xA4\x85" },
+            {"new-name-right"             ,"\xEE\xA4\x86" },
+            {"new-name-sharp-left"        ,"\xEE\xA4\x9B" },
+            {"new-name-sharp-right"       ,"\xEE\xA4\x9C" },
+            {"new-name-slight-left"       ,"\xEE\xA4\x87" },
+            {"new-name-slight-right"      ,"\xEE\xA4\x88" },
+            {"new-name-straight"          ,"\xEE\xA4\x84" },
+            {"notification-left"          ,"\xEE\xA4\x85" },
+            {"notification-right"         ,"\xEE\xA4\x86" },
+            {"notification-sharp-left"    ,"\xEE\xA4\x9B" },
+            {"notification-sharp-right"   ,"\xEE\xA4\xA5" },
+            {"notification-slight-left"   ,"\xEE\xA4\x87" },
+            {"notification-slight-right"  ,"\xEE\xA4\x88" },
+            {"notification-straight"      ,"\xEE\xA4\x84" },
+            {"off-ramp-left"              ,"\xEE\xA4\x9D" },
+            {"off-ramp-right"             ,"\xEE\xA4\x9E" },
+            {"off-ramp-slight-left"       ,"\xEE\xA4\x9F" },
+            {"off-ramp-slight-right"      ,"\xEE\xA4\xA0" },
+            {"on-ramp-left"               ,"\xEE\xA4\x85" },
+            {"on-ramp-right"              ,"\xEE\xA4\x86" },
+            {"on-ramp-sharp-left"         ,"\xEE\xA4\x9B" },
+            {"on-ramp-sharp-right"        ,"\xEE\xA4\xA5" },
+            {"on-ramp-slight-left"        ,"\xEE\xA4\x87" },
+            {"on-ramp-slight-right"       ,"\xEE\xA4\x88" },
+            {"on-ramp-straight"           ,"\xEE\xA4\x84" },
+            {"rotary"                     ,"\xEE\xA4\xA1" },
+            {"rotary-left"                ,"\xEE\xA4\xA2" },
+            {"rotary-right"               ,"\xEE\xA4\xA3" },
+            {"rotary-sharp-left"          ,"\xEE\xA4\xA4" },
+            {"rotary-sharp-right"         ,"\xEE\xA4\xA5" },
+            {"rotary-slight-left"         ,"\xEE\xA4\xA6" },
+            {"rotary-slight-right"        ,"\xEE\xA4\xA7" },
+            {"rotary-straight"            ,"\xEE\xA4\xA8" },
+            {"roundabout"                 ,"\xEE\xA4\xA1" },
+            {"roundabout-left"            ,"\xEE\xA4\xA2" },
+            {"roundabout-right"           ,"\xEE\xA4\xA3" },
+            {"roundabout-sharp-left"      ,"\xEE\xA4\xA4" },
+            {"roundabout-sharp-right"     ,"\xEE\xA4\xA5" },
+            {"roundabout-slight-left"     ,"\xEE\xA4\xA6" },
+            {"roundabout-slight-right"    ,"\xEE\xA4\xA7" },
+            {"roundabout-straight"        ,"\xEE\xA4\xA8" },
+            {"turn-left"                  ,"\xEE\xA4\x85" },
+            {"turn-right"                 ,"\xEE\xA4\x86" },
+            {"turn-sharp-left"            ,"\xEE\xA4\x9B" },
+            {"turn-sharp-right"           ,"\xEE\xA4\xA5" },
+            {"turn-slight-left"           ,"\xEE\xA4\x87" },
+            {"turn-slight-right"          ,"\xEE\xA4\x88" },
+            {"turn-straight"              ,"\xEE\xA4\x84" },
+            {"updown"                     ,"\xEE\xA4\xA9" },
+            {"uturn"                      ,"\xEE\xA4\x89" },
+        } };
       };
     }
   }
diff --git a/src/displayapp/screens/Notifications.cpp b/src/displayapp/screens/Notifications.cpp
index c903ed0f..ea6adc64 100644
--- a/src/displayapp/screens/Notifications.cpp
+++ b/src/displayapp/screens/Notifications.cpp
@@ -18,21 +18,21 @@ Notifications::Notifications(DisplayApp *app,
   if(notification.valid) {
     currentId = notification.id;
     currentItem = std::make_unique<NotificationItem>("\nNotification",
-                                           notification.message.data(),
-                                           notification.index,
-                                           notification.category,
-                                           notificationManager.NbNotifications(),
-                                           mode,
-                                           alertNotificationService);
+                                          notification.message.data(),
+                                          notification.index,
+                                          notification.category,
+                                          notificationManager.NbNotifications(),
+                                          mode,
+                                          alertNotificationService);
     validDisplay = true;
   } else {
     currentItem = std::make_unique<NotificationItem>("\nNotification",
-                                           "No notification to display",
-                                           0,
-                                           notification.category,
-                                           notificationManager.NbNotifications(),
-                                           Modes::Preview,
-                                           alertNotificationService);
+                                          "No notification to display",
+                                          0,
+                                          notification.category,
+                                          notificationManager.NbNotifications(),
+                                          Modes::Preview,
+                                          alertNotificationService);
   }
 
   if(mode == Modes::Preview) {
@@ -62,11 +62,6 @@ bool Notifications::Refresh() {
 
     timeoutLinePoints[1].x = pos;
     lv_line_set_points(timeoutLine, timeoutLinePoints, 2);
-
-    if (!running) {
-      // Start clock app when exiting this one
-      app->StartApp(Apps::Clock);
-    }
   }
 
   return running;
@@ -74,7 +69,7 @@ bool Notifications::Refresh() {
 
 bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
   switch (event) {
-    case Pinetime::Applications::TouchEvents::SwipeUp: {
+    case Pinetime::Applications::TouchEvents::SwipeDown: {
       Controllers::NotificationManager::Notification previousNotification;
       if(validDisplay)
         previousNotification = notificationManager.GetPrevious(currentId);
@@ -86,7 +81,7 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
       validDisplay = true;
       currentId = previousNotification.id;
       currentItem.reset(nullptr);
-      app->SetFullRefresh(DisplayApp::FullRefreshDirections::Up);
+      app->SetFullRefresh(DisplayApp::FullRefreshDirections::Down);
       currentItem = std::make_unique<NotificationItem>("\nNotification",
                                              previousNotification.message.data(),
                                              previousNotification.index,
@@ -96,19 +91,22 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
                                              alertNotificationService);
     }
       return true;
-    case Pinetime::Applications::TouchEvents::SwipeDown: {
+    case Pinetime::Applications::TouchEvents::SwipeUp: {
       Controllers::NotificationManager::Notification nextNotification;
       if(validDisplay)
         nextNotification = notificationManager.GetNext(currentId);
       else
         nextNotification = notificationManager.GetLastNotification();
 
-      if (!nextNotification.valid) return true;
+      if (!nextNotification.valid) {
+        running = false;
+        return false;
+      }
 
       validDisplay = true;
       currentId = nextNotification.id;
       currentItem.reset(nullptr);
-      app->SetFullRefresh(DisplayApp::FullRefreshDirections::Down);
+      app->SetFullRefresh(DisplayApp::FullRefreshDirections::Up);
       currentItem = std::make_unique<NotificationItem>("\nNotification",
                                              nextNotification.message.data(),
                                              nextNotification.index,
@@ -127,12 +125,6 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
   }
 }
 
-
-bool Notifications::OnButtonPushed() {
-  running = false;
-  return true;
-}
-
 namespace {
   static void AcceptIncomingCallEventHandler(lv_obj_t* obj, lv_event_t event) {
     auto* item = static_cast<Notifications::NotificationItem*>(obj->user_data);
diff --git a/src/displayapp/screens/Notifications.h b/src/displayapp/screens/Notifications.h
index 028a3780..0d54ddbe 100644
--- a/src/displayapp/screens/Notifications.h
+++ b/src/displayapp/screens/Notifications.h
@@ -20,7 +20,6 @@ namespace Pinetime {
           ~Notifications() override;
 
           bool Refresh() override;
-          bool OnButtonPushed() override;
           bool OnTouchEvent(Pinetime::Applications::TouchEvents event) override;
 
         class NotificationItem {
@@ -55,7 +54,7 @@ namespace Pinetime {
         };
 
         private:
-          bool running = true;
+          
 
           struct NotificationData {
             const char* title;
diff --git a/src/displayapp/screens/Paddle.cpp b/src/displayapp/screens/Paddle.cpp
index eda06547..e86cf01b 100644
--- a/src/displayapp/screens/Paddle.cpp
+++ b/src/displayapp/screens/Paddle.cpp
@@ -103,7 +103,8 @@ Paddle::Paddle(Pinetime::Applications::DisplayApp* app, Pinetime::Components::Li
   app->SetTouchMode(DisplayApp::TouchModes::Polling);
 	
   points = lv_label_create(lv_scr_act(), nullptr);
-  lv_label_set_text(points, "0");	
+  lv_label_set_text(points, "0000");
+  lv_obj_set_style_local_text_color(points, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x444444));
   lv_obj_align(points, lv_scr_act(), LV_ALIGN_IN_TOP_MID, 0, 0);
 	
   paddle.header.always_zero = 0;
@@ -164,18 +165,12 @@ bool Paddle::Refresh() {
       ballX = 107;
       ballY = 107; 
       score = 0;	    
-    } 
-    sprintf(scoreStr, "%d", score);	
-    lv_label_set_text(points, scoreStr);	  
+    }
+    lv_label_set_text_fmt(points, "%04d", score);
   }      
   return running;
 }
 
-bool Paddle::OnButtonPushed() {
-  running = false;
-  return true;
-}
-
 bool Paddle::OnTouchEvent(Pinetime::Applications::TouchEvents event) { 
   return true; 
 }
diff --git a/src/displayapp/screens/Paddle.h b/src/displayapp/screens/Paddle.h
index 358bd2f5..453d99ae 100644
--- a/src/displayapp/screens/Paddle.h
+++ b/src/displayapp/screens/Paddle.h
@@ -17,7 +17,7 @@ namespace Pinetime {
           ~Paddle() override;
 
           bool Refresh() override;
-          bool OnButtonPushed() override;
+          
           bool OnTouchEvent(TouchEvents event) override;
           bool OnTouchEvent(uint16_t x, uint16_t y) override;
           
@@ -36,8 +36,6 @@ namespace Pinetime {
           int counter = 0;	            // init Frame refresh limit counter
           int score = 0;   
 
-          char scoreStr[10];
-
           lv_img_dsc_t paddle; 
           lv_img_dsc_t ball;
 
@@ -45,7 +43,7 @@ namespace Pinetime {
           lv_obj_t* paddle_image;		// pointer to paddle image
           lv_obj_t* ball_image;		// pointer to ball image
 
-          bool running = true;
+          
       };
     }
   }
diff --git a/src/displayapp/screens/Screen.h b/src/displayapp/screens/Screen.h
index 638dac99..cf4f6994 100644
--- a/src/displayapp/screens/Screen.h
+++ b/src/displayapp/screens/Screen.h
@@ -56,6 +56,8 @@ namespace Pinetime {
 
         protected:
           DisplayApp* app;
+          bool running = true;
+
       };
     }
   }
diff --git a/src/displayapp/screens/ScreenList.h b/src/displayapp/screens/ScreenList.h
index 43b33f40..23bcd98b 100644
--- a/src/displayapp/screens/ScreenList.h
+++ b/src/displayapp/screens/ScreenList.h
@@ -29,11 +29,6 @@ namespace Pinetime {
             return running;
           }
 
-          bool OnButtonPushed() override {
-            running = false;
-            return true;
-          }
-
           bool OnTouchEvent(TouchEvents event) override {
 
             if ( mode == ScreenListModes::UpDown) {
@@ -108,7 +103,7 @@ namespace Pinetime {
           uint8_t screenIndex = 0;          
           std::unique_ptr<Screen> current;
 
-          bool running = true;
+          
       };
     }
   }
diff --git a/src/displayapp/screens/StopWatch.cpp b/src/displayapp/screens/StopWatch.cpp
index 63f18d4b..e07a960f 100644
--- a/src/displayapp/screens/StopWatch.cpp
+++ b/src/displayapp/screens/StopWatch.cpp
@@ -50,14 +50,16 @@ StopWatch::StopWatch(DisplayApp* app)
     currentTimeSeparated {}, lapBuffer {}, lapNr {}, lapPressed {false} {
 
   time = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_font(time, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_extrabold_compressed);
-  lv_obj_align(time, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 0, -45);
+  lv_obj_set_style_local_text_font(time, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_76);
+  lv_obj_set_style_local_text_color(time, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GRAY);
   lv_label_set_text(time, "00:00");
+  lv_obj_align(time, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 0, -45);  
 
   msecTime = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_font(msecTime, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_bold_20);
-  lv_obj_align(msecTime, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 108, 3);
+  //lv_obj_set_style_local_text_font(msecTime, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_bold_20);
+  lv_obj_set_style_local_text_color(msecTime, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GRAY);
   lv_label_set_text(msecTime, "00");
+  lv_obj_align(msecTime, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 108, 3);  
 
   btnPlayPause = lv_btn_create(lv_scr_act(), nullptr);
   btnPlayPause->user_data = this;
@@ -68,12 +70,14 @@ StopWatch::StopWatch(DisplayApp* app)
   lv_label_set_text(txtPlayPause, Symbols::play);
 
   lapOneText = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_font(lapOneText, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_bold_20);
+  //lv_obj_set_style_local_text_font(lapOneText, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_bold_20);
+  lv_obj_set_style_local_text_color(lapOneText, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_YELLOW);
   lv_obj_align(lapOneText, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 50, 30);
   lv_label_set_text(lapOneText, "");
 
   lapTwoText = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_font(lapTwoText, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_bold_20);
+  //lv_obj_set_style_local_text_font(lapTwoText, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_bold_20);
+  lv_obj_set_style_local_text_color(lapTwoText, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_YELLOW);
   lv_obj_align(lapTwoText, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 50, 55);
   lv_label_set_text(lapTwoText, "");
 
@@ -156,6 +160,11 @@ bool StopWatch::Refresh() {
         // Store the current time elapsed in cache
         oldTimeElapsed += timeElapsed;
         currentState = States::Halted;
+        lv_obj_set_style_local_text_color(time, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_YELLOW);
+        lv_obj_set_style_local_text_color(msecTime, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_YELLOW);
+      } else {
+        lv_obj_set_style_local_text_color(time, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GREEN);
+        lv_obj_set_style_local_text_color(msecTime, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GREEN);
       }
       break;
     }
@@ -170,6 +179,8 @@ bool StopWatch::Refresh() {
       if (currentEvent == Events::Stop) {
         currentState = States::Init;
         oldTimeElapsed = 0;
+        lv_obj_set_style_local_text_color(time, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GRAY);
+        lv_obj_set_style_local_text_color(msecTime, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GRAY);
       }
       break;
     }
@@ -177,11 +188,6 @@ bool StopWatch::Refresh() {
   return running;
 }
 
-bool StopWatch::OnButtonPushed() {
-  running = false;
-  return true;
-}
-
 void StopWatch::playPauseBtnEventHandler(lv_event_t event) {
   if (event == LV_EVENT_CLICKED) {
     if (currentState == States::Init) {
diff --git a/src/displayapp/screens/StopWatch.h b/src/displayapp/screens/StopWatch.h
index f9dd5c76..b882cab5 100644
--- a/src/displayapp/screens/StopWatch.h
+++ b/src/displayapp/screens/StopWatch.h
@@ -66,7 +66,7 @@ namespace Pinetime::Applications::Screens {
     StopWatch(DisplayApp* app);
     ~StopWatch() override;
     bool Refresh() override;
-    bool OnButtonPushed() override;
+    
     void playPauseBtnEventHandler(lv_event_t event);
     void stopLapBtnEventHandler(lv_event_t event);
 
diff --git a/src/displayapp/screens/Symbols.h b/src/displayapp/screens/Symbols.h
index 9a13a755..0750f2c1 100644
--- a/src/displayapp/screens/Symbols.h
+++ b/src/displayapp/screens/Symbols.h
@@ -39,6 +39,19 @@ namespace Pinetime {
         static constexpr const char* stop = "\xEF\x81\x8D";
         static constexpr const char* stopWatch = "\xEF\x8B\xB2";
         static constexpr const char* lapsFlag = "\xEF\x80\xA4";
+
+        // lv_font_sys_48.c
+        static constexpr const char* settings             = "\xEE\xA4\x82";//e902
+
+        static constexpr const char* brightnessHigh       = "\xEE\xA4\x84";//e904
+        static constexpr const char* brightnessLow        = "\xEE\xA4\x85";//e905
+        static constexpr const char* brightnessMedium     = "\xEE\xA4\x86";//e906
+
+        static constexpr const char* notificationsOff     = "\xEE\xA4\x8B";//e90b
+        static constexpr const char* notificationsOn      = "\xEE\xA4\x8C";//e90c
+
+        static constexpr const char* highlight            = "\xEE\xA4\x87";//e907
+
       }
     }
   }
diff --git a/src/displayapp/screens/SystemInfo.cpp b/src/displayapp/screens/SystemInfo.cpp
index 949fd345..f3ac7490 100644
--- a/src/displayapp/screens/SystemInfo.cpp
+++ b/src/displayapp/screens/SystemInfo.cpp
@@ -25,7 +25,8 @@ SystemInfo::SystemInfo(Pinetime::Applications::DisplayApp *app,
           {
                 [this]() -> std::unique_ptr<Screen> { return CreateScreen1(); },
                 [this]() -> std::unique_ptr<Screen> { return CreateScreen2(); },
-                [this]() -> std::unique_ptr<Screen> { return CreateScreen3(); }
+                [this]() -> std::unique_ptr<Screen> { return CreateScreen3(); },
+                [this]() -> std::unique_ptr<Screen> { return CreateScreen4(); }
           },
           Screens::ScreenListModes::UpDown
         } {}
@@ -49,16 +50,46 @@ bool SystemInfo::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
   return screens.OnTouchEvent(event);
 }
 
+void SystemInfo::CreateContainer() {
+
+  if ( container1 ) {
+    container1 = lv_cont_create(lv_scr_act(), nullptr);
+
+    lv_obj_set_style_local_bg_opa(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
+    lv_obj_set_style_local_pad_all(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 10);
+    lv_obj_set_style_local_pad_inner(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 5);
+    lv_obj_set_style_local_border_width(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 0);
+
+    lv_obj_set_pos(container1, 0, 0);
+    lv_obj_set_width(container1, LV_HOR_RES - 10);
+    lv_obj_set_height(container1, LV_VER_RES);
+    lv_cont_set_layout(container1, LV_LAYOUT_CENTER);
+  }
+}
+
 std::unique_ptr<Screen> SystemInfo::CreateScreen1() {
+  CreateContainer();
+
+  lv_obj_t * label = lv_label_create(container1, nullptr);
+  lv_label_set_recolor(label, true);
+  lv_label_set_text_fmt(label, 
+              "#FFFF00 InfiniTime#\n\n"
+              "#444444 Version# %ld.%ld.%ld\n\n"
+              "#444444 Build date#\n"
+              "\t%s\n"
+              "\t%s\n",
+          Version::Major(), Version::Minor(), Version::Patch(),
+          __DATE__, __TIME__);
+  lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
+  return std::unique_ptr<Screen>(new Screens::Label(0, 4, app, label));
+}
+
+std::unique_ptr<Screen> SystemInfo::CreateScreen2() {
+  CreateContainer();
+
   auto batteryPercent = static_cast<uint8_t>(batteryController.PercentRemaining());
+  float batteryVoltage = batteryController.Voltage();
 
-  uint8_t brightness = 0;
-  switch(brightnessController.Level()) {
-    case Controllers::BrightnessController::Levels::Off: brightness = 0; break;
-    case Controllers::BrightnessController::Levels::Low: brightness = 1; break;
-    case Controllers::BrightnessController::Levels::Medium: brightness = 2; break;
-    case Controllers::BrightnessController::Levels::High: brightness = 3; break;
-  }
   auto resetReason = [this]() {
     switch (watchdog.ResetReason()) {
       case Drivers::Watchdog::ResetReasons::Watchdog: return "wtdg";
@@ -87,41 +118,73 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen1() {
   uptimeSeconds = uptimeSeconds % secondsInAMinute;
   // TODO handle more than 100 days of uptime
 
-  sprintf(t1, "InfiniTime\n"
-              "Version:%ld.%ld.%ld\n"
-              "Build: %s\n"
-              "       %s\n"
-              "Date: %02d/%02d/%04d\n"
-              "Time: %02d:%02d:%02d\n"
-              "Uptime: %02lud %02lu:%02lu:%02lu\n"
-              "Battery: %d%%\n"
-              "Backlight: %d/3\n"
-              "Last reset: %s\n",
-          Version::Major(), Version::Minor(), Version::Patch(),
-          __DATE__, __TIME__,
+  if (batteryPercent == -1) batteryPercent = 0;
+
+  // hack to not use the flot functions from printf
+  uint8_t batteryVoltageBytes[2];
+  batteryVoltageBytes[1] = static_cast<uint8_t>(batteryVoltage);    //truncate whole numbers
+  batteryVoltageBytes[0] = static_cast<uint8_t>((batteryVoltage - batteryVoltageBytes[1]) * 100); //remove whole part of flt and shift 2 places over
+  //
+
+  lv_obj_t * label = lv_label_create(container1, nullptr);
+  lv_label_set_recolor(label, true);
+  lv_label_set_text_fmt(label, 
+              "#444444 Date# %02d/%02d/%04d\n"
+              "#444444 Time# %02d:%02d:%02d\n"
+              "#444444 Uptime#\n %02lud %02lu:%02lu:%02lu\n"
+              "#444444 Battery# %d%%/%1i.%02iv\n"
+              "#444444 Backlight# %s\n"
+              "#444444 Last reset# %s\n",
           dateTimeController.Day(), static_cast<uint8_t>(dateTimeController.Month()), dateTimeController.Year(),
           dateTimeController.Hours(), dateTimeController.Minutes(), dateTimeController.Seconds(),
           uptimeDays, uptimeHours, uptimeMinutes, uptimeSeconds,
-          batteryPercent, brightness, resetReason);
+          batteryPercent, batteryVoltageBytes[1], batteryVoltageBytes[0], brightnessController.ToString(), resetReason
+          );
+  return std::unique_ptr<Screen>(new Screens::Label(1, 4, app, label));
 
-  return std::make_unique<Screens::Label>(app, t1);
 }
 
-std::unique_ptr<Screen> SystemInfo::CreateScreen2() {
+std::unique_ptr<Screen> SystemInfo::CreateScreen3() {
+  lv_mem_monitor_t mon;
+  lv_mem_monitor(&mon);  
+  CreateContainer();
+
+  lv_obj_t * label = lv_label_create(container1, nullptr);
+  lv_label_set_recolor(label, true);
   auto& bleAddr = bleController.Address();
-  sprintf(t2, "BLE MAC: \n  %02x:%02x:%02x:%02x:%02x:%02x",
-          bleAddr[5], bleAddr[4], bleAddr[3], bleAddr[2], bleAddr[1], bleAddr[0]);
-  return std::make_unique<Screens::Label>(app, t2);
+  lv_label_set_text_fmt(label, 
+              "#444444 BLE MAC#\n"
+              " %02x:%02x:%02x:%02x:%02x:%02x"
+              "\n"
+              "#444444 Memory#\n"
+              " #444444 used# %d (%d%%)\n"
+              " #444444 frag# %d%%\n"
+              " #444444 free# %d"
+              "\n"
+              "#444444 Steps# %li",
+          bleAddr[5], bleAddr[4], bleAddr[3], bleAddr[2], bleAddr[1], bleAddr[0],
+          (int)mon.total_size - mon.free_size,
+          mon.used_pct,
+          mon.frag_pct,
+          (int)mon.free_biggest_size,
+          0
+          );
+
+  return std::unique_ptr<Screen>(new Screens::Label(2, 4, app, label));
 }
 
-std::unique_ptr<Screen> SystemInfo::CreateScreen3() {
-  sprintf(t3, "Hello from\nthe developer!\n"
+std::unique_ptr<Screen> SystemInfo::CreateScreen4() {
+  CreateContainer();
+  lv_obj_t * label = lv_label_create(container1, nullptr);
+  lv_label_set_recolor(label, true);
+  lv_label_set_text_static(label,
               "Software Licensed\n"
               "under the terms of\n"
               "the GNU General\n"
               "Public License v3\n"
-              "Source code:\n"
-              "https://github.com/\n"
-              "  JF002/InfiniTime");
-  return std::make_unique<Screens::Label>(app, t3);
-}
+              "#444444 Source code#\n"
+              "#FFFF00 https://github.com/#\n"
+              "#FFFF00 JF002/InfiniTime#");
+  lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
+  return std::unique_ptr<Screen>(new Screens::Label(3, 4, app, label));
+}
\ No newline at end of file
diff --git a/src/displayapp/screens/SystemInfo.h b/src/displayapp/screens/SystemInfo.h
index 75268c71..574ded74 100644
--- a/src/displayapp/screens/SystemInfo.h
+++ b/src/displayapp/screens/SystemInfo.h
@@ -35,20 +35,21 @@ namespace Pinetime {
         private:
           bool running = true;
 
+          lv_obj_t* container1;
+
           Pinetime::Controllers::DateTime& dateTimeController;
           Pinetime::Controllers::Battery& batteryController;
           Pinetime::Controllers::BrightnessController& brightnessController;
           Pinetime::Controllers::Ble& bleController;
           Pinetime::Drivers::WatchdogView& watchdog;
 
-          char t1[200];
-          char t2[200];
-          char t3[200];
-
-          ScreenList<3> screens;
+          ScreenList<4> screens;
           std::unique_ptr<Screen> CreateScreen1();
           std::unique_ptr<Screen> CreateScreen2();
           std::unique_ptr<Screen> CreateScreen3();
+          std::unique_ptr<Screen> CreateScreen4();
+
+          void CreateContainer();
       };
     }
   }
diff --git a/src/displayapp/screens/Tile.cpp b/src/displayapp/screens/Tile.cpp
index ca753db9..8fa7fd07 100644
--- a/src/displayapp/screens/Tile.cpp
+++ b/src/displayapp/screens/Tile.cpp
@@ -1,56 +1,136 @@
 #include "Tile.h"
 #include "../DisplayApp.h"
+#include "BatteryIcon.h"
 
 using namespace Pinetime::Applications::Screens;
 
-static void event_handler(lv_obj_t * obj, lv_event_t event) {
-  Tile* screen = static_cast<Tile *>(obj->user_data);
-  uint32_t* eventDataPtr = (uint32_t*) lv_event_get_data();
-  uint32_t eventData = *eventDataPtr;
-  screen->OnObjectEvent(obj, event, eventData);
+
+namespace {
+  static void lv_update_task(struct _lv_task_t *task) {  
+    auto user_data = static_cast<Tile *>(task->user_data);
+    user_data->UpdateScreen();
+  }
+
+  static void event_handler(lv_obj_t * obj, lv_event_t event) {
+    Tile* screen = static_cast<Tile *>(obj->user_data);
+    uint32_t* eventDataPtr = (uint32_t*) lv_event_get_data();
+    uint32_t eventData = *eventDataPtr;
+    screen->OnObjectEvent(obj, event, eventData);
+  }
 }
 
-Tile::Tile(uint8_t screenID, DisplayApp* app, Controllers::Settings& settingsController, std::array<Applications, 6>& applications) : Screen(app) {
+Tile::Tile(uint8_t screenID, uint8_t numScreens,
+    DisplayApp* app,
+    Controllers::Settings& settingsController,
+    Pinetime::Controllers::Battery& batteryController,
+    Controllers::DateTime& dateTimeController,
+    std::array<Applications, 6>& applications) : 
+  Screen(app),
+  batteryController{batteryController},
+  dateTimeController{dateTimeController} {
   
   settingsController.SetAppMenu(screenID);
+
+  // Time
+  label_time = lv_label_create(lv_scr_act(), nullptr);  
+  lv_label_set_text_fmt(label_time,  "%02i:%02i", dateTimeController.Hours(), dateTimeController.Minutes());      
+  lv_label_set_align( label_time, LV_LABEL_ALIGN_CENTER );    
+  lv_obj_align(label_time, nullptr, LV_ALIGN_IN_TOP_LEFT, 15, 6);
+
+  // Battery
+  batteryIcon = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_text(batteryIcon, BatteryIcon::GetBatteryIcon(batteryController.PercentRemaining()));
+  lv_obj_align(batteryIcon, nullptr, LV_ALIGN_IN_TOP_RIGHT, -15, 6);
+
+  if ( numScreens > 1 ) {
+    pageIndicatorBasePoints[0].x = 240 - 1;
+    pageIndicatorBasePoints[0].y = 6;
+    pageIndicatorBasePoints[1].x = 240 - 1;
+    pageIndicatorBasePoints[1].y = 240 - 6;
+    
+    pageIndicatorBase = lv_line_create(lv_scr_act(), nullptr);
+    lv_obj_set_style_local_line_width(pageIndicatorBase, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, 3);
+    lv_obj_set_style_local_line_color(pageIndicatorBase, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x111111));
+    lv_obj_set_style_local_line_rounded(pageIndicatorBase, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, true);
+    lv_line_set_points(pageIndicatorBase, pageIndicatorBasePoints, 2);
+
+  
+    uint16_t indicatorSize = 228 / numScreens;
+    uint16_t indicatorPos = indicatorSize * screenID;
+
+    pageIndicatorPoints[0].x = 240 - 1;
+    pageIndicatorPoints[0].y = 6 + indicatorPos;
+    pageIndicatorPoints[1].x = 240 - 1;
+    pageIndicatorPoints[1].y = 6 + indicatorPos + indicatorSize;
+
+    pageIndicator = lv_line_create(lv_scr_act(), nullptr);
+    lv_obj_set_style_local_line_width(pageIndicator, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, 3);
+    lv_obj_set_style_local_line_color(pageIndicator, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GRAY);
+    lv_obj_set_style_local_line_rounded(pageIndicator, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, true);
+    lv_line_set_points(pageIndicator, pageIndicatorPoints, 2);
+  }
   
-  for(int i = 0, appIndex = 0; i < 8; i++) {
-    if(i == 3) btnm_map1[i] = "\n";
-    else if(i == 7) btnm_map1[i] = "";
-    else {
-      btnm_map1[i] = applications[appIndex].icon;
-      apps[appIndex] = applications[appIndex].application;
-      appIndex++;
+  uint8_t btIndex = 0;
+  for(uint8_t i = 0; i < 6; i++) {
+    if(i == 3) btnmMap[btIndex++] = "\n";
+    if ( applications[i].application == Apps::None ) {
+      btnmMap[btIndex] = " ";
+    } else {
+      btnmMap[btIndex] = applications[i].icon;
     }
+    btIndex++;
+    apps[i] = applications[i].application;
   }
+  btnmMap[btIndex] = "";
 
   btnm1 = lv_btnmatrix_create(lv_scr_act(), nullptr);
-  lv_btnmatrix_set_map(btnm1, btnm_map1);
-  lv_obj_set_size(btnm1, LV_HOR_RES, LV_VER_RES);
+  lv_btnmatrix_set_map(btnm1, btnmMap);
+  lv_obj_set_size(btnm1, LV_HOR_RES - 10, LV_VER_RES - 60);
+  lv_obj_align(btnm1, NULL, LV_ALIGN_CENTER, 0, 10);
+
+  lv_obj_set_style_local_radius(btnm1, LV_BTNMATRIX_PART_BTN, LV_STATE_DEFAULT, 20);
+  lv_obj_set_style_local_bg_opa(btnm1, LV_BTNMATRIX_PART_BTN, LV_STATE_DEFAULT, LV_OPA_20);
+  lv_obj_set_style_local_bg_color(btnm1, LV_BTNMATRIX_PART_BTN, LV_STATE_DEFAULT, LV_COLOR_AQUA);
+  lv_obj_set_style_local_bg_opa(btnm1, LV_BTNMATRIX_PART_BTN, LV_STATE_DISABLED, LV_OPA_20);
+  lv_obj_set_style_local_bg_color(btnm1, LV_BTNMATRIX_PART_BTN, LV_STATE_DISABLED, lv_color_hex(0x111111));
+
+  for(uint8_t i = 0; i < 6; i++) {
+    if ( applications[i].application == Apps::None ) {
+      lv_btnmatrix_set_btn_ctrl(btnm1, i, LV_BTNMATRIX_CTRL_DISABLED );
+    }
+  }
 
   btnm1->user_data = this;
   lv_obj_set_event_cb(btnm1, event_handler);
+
+  lv_obj_t * backgroundLabel = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_long_mode(backgroundLabel, LV_LABEL_LONG_CROP);
+  lv_obj_set_size(backgroundLabel, 240, 240);
+  lv_obj_set_pos(backgroundLabel, 0, 0);
+  lv_label_set_text_static(backgroundLabel, "");
+
+  taskUpdate = lv_task_create(lv_update_task, 500000, LV_TASK_PRIO_MID, this);
 }
 
 Tile::~Tile() {
+  lv_task_del(taskUpdate);
   lv_obj_clean(lv_scr_act());
 }
 
+void Tile::UpdateScreen() {
+  lv_label_set_text_fmt(label_time,  "%02i:%02i", dateTimeController.Hours(), dateTimeController.Minutes());
+  lv_label_set_text(batteryIcon, BatteryIcon::GetBatteryIcon(batteryController.PercentRemaining()));
+}
+
 bool Tile::Refresh() {
   return running;
 }
 
 void Tile::OnObjectEvent(lv_obj_t *obj, lv_event_t event, uint32_t buttonId) {
   if(event == LV_EVENT_VALUE_CHANGED) {
-    app->StartApp(apps[buttonId]);
+    app->StartApp(apps[buttonId], DisplayApp::FullRefreshDirections::Down);
     running = false;
   }
 }
 
-bool Tile::OnButtonPushed() {
-  app->StartApp(Apps::Clock);
-  running = false;
-  return true;
-}
-
 
diff --git a/src/displayapp/screens/Tile.h b/src/displayapp/screens/Tile.h
index f717a220..54ffcdae 100644
--- a/src/displayapp/screens/Tile.h
+++ b/src/displayapp/screens/Tile.h
@@ -5,7 +5,10 @@
 #include <memory>
 #include "Screen.h"
 #include "../Apps.h"
+#include "components/datetime/DateTimeController.h"
 #include "components/settings/Settings.h"
+#include "components/datetime/DateTimeController.h"
+#include "components/battery/BatteryController.h"
 
 namespace Pinetime {
   namespace Applications {
@@ -17,19 +20,35 @@ namespace Pinetime {
             Pinetime::Applications::Apps application;
           };
 
-          explicit Tile(uint8_t screenID, DisplayApp* app, Controllers::Settings& settingsController, std::array<Applications, 6>& applications);
+          explicit Tile(uint8_t screenID, uint8_t numScreens,
+            DisplayApp* app, 
+            Controllers::Settings& settingsController,
+            Pinetime::Controllers::Battery& batteryController,
+            Controllers::DateTime& dateTimeController,
+            std::array<Applications, 6>& applications);
+
           ~Tile() override;
 
           bool Refresh() override;
-          bool OnButtonPushed() override;
-
+          void UpdateScreen();
           void OnObjectEvent(lv_obj_t* obj, lv_event_t event, uint32_t buttonId);
 
         private:
-          lv_obj_t * btnm1;
-          bool running = true;
 
-          const char* btnm_map1[8];
+          Pinetime::Controllers::Battery& batteryController;
+          Controllers::DateTime& dateTimeController;
+
+          lv_task_t* taskUpdate;
+
+          lv_obj_t* label_time;
+          lv_obj_t* batteryIcon;
+          lv_point_t pageIndicatorBasePoints[2];
+          lv_point_t pageIndicatorPoints[2];
+          lv_obj_t* pageIndicatorBase;
+          lv_obj_t* pageIndicator;
+          lv_obj_t* btnm1;
+      
+          const char* btnmMap[8];
           Pinetime::Applications::Apps apps[6];
       };
     }
diff --git a/src/displayapp/screens/Twos.cpp b/src/displayapp/screens/Twos.cpp
index b51a9ec6..5210a4d6 100644
--- a/src/displayapp/screens/Twos.cpp
+++ b/src/displayapp/screens/Twos.cpp
@@ -101,11 +101,6 @@ bool Twos::Refresh() {
   return running;
 }
 
-bool Twos::OnButtonPushed() {
-  running = false;
-  return true;
-}
-
 bool Twos::placeNewTile() {
   std::vector< std::pair <int,int> > availableCells; 
   for(int row = 0; row < 4; row++) {
diff --git a/src/displayapp/screens/Twos.h b/src/displayapp/screens/Twos.h
index ec021971..7223c7a8 100644
--- a/src/displayapp/screens/Twos.h
+++ b/src/displayapp/screens/Twos.h
@@ -15,7 +15,7 @@ namespace Pinetime {
           Twos(DisplayApp* app);
           ~Twos() override;
           bool Refresh() override;
-          bool OnButtonPushed() override;
+          
           bool OnTouchEvent(TouchEvents event) override;
 
         private:
@@ -26,7 +26,7 @@ namespace Pinetime {
           lv_style_t style_cell4;
           lv_style_t style_cell5;
           
-          bool running = true;
+          
           lv_obj_t *scoreText;
           lv_obj_t *gridDisplay;
           Tile grid[4][4];
diff --git a/src/displayapp/screens/WatchFaceDigital.cpp b/src/displayapp/screens/WatchFaceDigital.cpp
index c39fe496..6fe076c5 100644
--- a/src/displayapp/screens/WatchFaceDigital.cpp
+++ b/src/displayapp/screens/WatchFaceDigital.cpp
@@ -249,9 +249,3 @@ bool WatchFaceDigital::Refresh() {
 }
 
 
-bool WatchFaceDigital::OnButtonPushed() {
-  running = false;
-  return false;
-}
-
-
diff --git a/src/displayapp/screens/WatchFaceDigital.h b/src/displayapp/screens/WatchFaceDigital.h
index 70a9ce5d..8f23985c 100644
--- a/src/displayapp/screens/WatchFaceDigital.h
+++ b/src/displayapp/screens/WatchFaceDigital.h
@@ -32,7 +32,7 @@ namespace Pinetime {
           ~WatchFaceDigital() override;
 
           bool Refresh() override;
-          bool OnButtonPushed() override;
+          
 
           void OnObjectEvent(lv_obj_t *pObj, lv_event_t i);
         private:
@@ -74,7 +74,7 @@ namespace Pinetime {
           Controllers::Settings& settingsController;
           Controllers::HeartRateController& heartRateController;
 
-          bool running = true;
+          
 
       };
     }
diff --git a/src/displayapp/screens/settings/QuickSettings.cpp b/src/displayapp/screens/settings/QuickSettings.cpp
new file mode 100644
index 00000000..9fd051b8
--- /dev/null
+++ b/src/displayapp/screens/settings/QuickSettings.cpp
@@ -0,0 +1,177 @@
+#include "QuickSettings.h"
+#include "displayapp/DisplayApp.h"
+#include "displayapp/screens/Symbols.h"
+#include "displayapp/screens/BatteryIcon.h"
+
+
+using namespace Pinetime::Applications::Screens;
+
+namespace {
+  static void ButtonEventHandler(lv_obj_t * obj, lv_event_t event) {
+    QuickSettings* screen = static_cast<QuickSettings *>(obj->user_data);
+    screen->OnButtonEvent(obj, event);
+  }
+
+  static void lv_update_task(struct _lv_task_t *task) {  
+    auto user_data = static_cast<QuickSettings *>(task->user_data);
+    user_data->UpdateScreen();
+  }
+}
+
+QuickSettings::QuickSettings(
+    Pinetime::Applications::DisplayApp *app, 
+    Pinetime::Controllers::Battery& batteryController,
+    Controllers::DateTime& dateTimeController,
+    Controllers::BrightnessController& brightness,
+    Pinetime::Controllers::Settings &settingsController) : 
+  Screen(app),
+  batteryController{batteryController},
+  dateTimeController{dateTimeController},
+  brightness{brightness},
+  settingsController{settingsController}
+{
+
+  // Time
+  label_time = lv_label_create(lv_scr_act(), nullptr);  
+  lv_label_set_text_fmt(label_time,  "%02i:%02i", dateTimeController.Hours(), dateTimeController.Minutes());      
+  lv_label_set_align( label_time, LV_LABEL_ALIGN_CENTER );    
+  lv_obj_align(label_time, lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 15, 4);
+
+  batteryIcon = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_text(batteryIcon, BatteryIcon::GetBatteryIcon(batteryController.PercentRemaining()));
+  lv_obj_align(batteryIcon, nullptr, LV_ALIGN_IN_TOP_RIGHT, -15, 4);
+  
+
+  lv_obj_t * lbl_btn;
+
+  btn1 = lv_btn_create(lv_scr_act(), nullptr);
+  btn1->user_data = this;
+  lv_obj_set_event_cb(btn1, ButtonEventHandler);
+  lv_obj_align(btn1, nullptr, LV_ALIGN_CENTER, -50, -30);  
+  lv_obj_set_style_local_radius(btn1, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, 20);
+  lv_obj_set_style_local_bg_color(btn1, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x111111));  
+  lv_obj_set_style_local_bg_grad_dir(btn1, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_GRAD_DIR_NONE);
+
+  lv_btn_set_fit2(btn1, LV_FIT_TIGHT, LV_FIT_TIGHT);  
+
+  btn1_lvl = lv_label_create(btn1, nullptr);
+  lv_obj_set_style_local_text_font(btn1_lvl, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &lv_font_sys_48);
+  lv_label_set_text_static(btn1_lvl, brightness.GetIcon());
+
+
+  btn2 = lv_btn_create(lv_scr_act(), nullptr);
+  btn2->user_data = this;
+  lv_obj_set_event_cb(btn2, ButtonEventHandler);
+  lv_obj_align(btn2, nullptr, LV_ALIGN_CENTER, 50, -30);  
+  lv_obj_set_style_local_radius(btn2, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, 20);
+  lv_obj_set_style_local_bg_color(btn2, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x111111));
+  lv_obj_set_style_local_bg_grad_dir(btn2, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_GRAD_DIR_NONE);
+  lv_btn_set_fit2(btn2, LV_FIT_TIGHT, LV_FIT_TIGHT);
+
+  lbl_btn = lv_label_create(btn2, nullptr);
+  lv_obj_set_style_local_text_font(lbl_btn, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &lv_font_sys_48);
+  lv_label_set_text_static(lbl_btn, Symbols::highlight);
+  
+
+  btn3 = lv_btn_create(lv_scr_act(), nullptr);
+  btn3->user_data = this;
+  lv_obj_set_event_cb(btn3, ButtonEventHandler);
+  lv_obj_align(btn3, nullptr, LV_ALIGN_CENTER, -50, 60);
+  lv_btn_set_checkable(btn3, true);
+  lv_obj_set_style_local_radius(btn3, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, 20);
+  lv_obj_set_style_local_bg_color(btn3, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x111111));
+  lv_obj_set_style_local_bg_grad_dir(btn3, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_GRAD_DIR_NONE);
+  lv_obj_set_style_local_bg_color(btn3, LV_BTN_PART_MAIN, LV_STATE_CHECKED, LV_COLOR_GREEN);
+  lv_obj_set_style_local_bg_grad_dir(btn1, LV_BTN_PART_MAIN, LV_STATE_CHECKED, LV_GRAD_DIR_NONE);
+  lv_btn_set_fit2(btn3, LV_FIT_TIGHT, LV_FIT_TIGHT);
+
+  btn3_lvl = lv_label_create(btn3, nullptr);
+  lv_obj_set_style_local_text_font(btn3_lvl, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &lv_font_sys_48);  
+
+  if ( settingsController.GetVibrationStatus() == Controllers::Settings::Vibration::ON ) {    
+    lv_obj_add_state(btn3, LV_STATE_CHECKED);
+    lv_label_set_text_static(btn3_lvl, Symbols::notificationsOn);
+  } else {
+    lv_label_set_text_static(btn3_lvl, Symbols::notificationsOff);
+  }
+
+  btn4 = lv_btn_create(lv_scr_act(), nullptr);
+  btn4->user_data = this;
+  lv_obj_set_event_cb(btn4, ButtonEventHandler);
+  lv_obj_align(btn4, nullptr, LV_ALIGN_CENTER, 50, 60);  
+  lv_obj_set_style_local_radius(btn4, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, 20);
+  lv_obj_set_style_local_bg_color(btn4, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x111111));
+  lv_obj_set_style_local_bg_grad_dir(btn4, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_GRAD_DIR_NONE);
+  lv_btn_set_fit2(btn4, LV_FIT_TIGHT, LV_FIT_TIGHT);
+
+  lbl_btn = lv_label_create(btn4, nullptr);
+  lv_obj_set_style_local_text_font(lbl_btn, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &lv_font_sys_48);
+  lv_label_set_text_static(lbl_btn, Symbols::settings);
+
+  lv_obj_t * backgroundLabel = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_long_mode(backgroundLabel, LV_LABEL_LONG_CROP);
+  lv_obj_set_size(backgroundLabel, 240, 240);
+  lv_obj_set_pos(backgroundLabel, 0, 0);
+  lv_label_set_text_static(backgroundLabel, "");
+
+  taskUpdate = lv_task_create(lv_update_task, 500000, LV_TASK_PRIO_MID, this);
+  
+}
+
+
+QuickSettings::~QuickSettings() {
+  lv_task_del(taskUpdate);
+  lv_obj_clean(lv_scr_act());
+  settingsController.SaveSettings();
+}
+
+void QuickSettings::UpdateScreen() {
+  lv_label_set_text_fmt(label_time,  "%02i:%02i", dateTimeController.Hours(), dateTimeController.Minutes());
+  lv_label_set_text(batteryIcon, BatteryIcon::GetBatteryIcon(batteryController.PercentRemaining()));
+}
+
+void QuickSettings::OnButtonEvent(lv_obj_t *object, lv_event_t event) {
+  if(object == btn2 && event == LV_EVENT_PRESSED) {
+    
+    running = false;
+    app->StartApp(Apps::FlashLight, DisplayApp::FullRefreshDirections::None);
+
+  } else if(object == btn1 && event == LV_EVENT_PRESSED) {
+    
+    brightness.Step();
+    lv_label_set_text_static(btn1_lvl, brightness.GetIcon());
+    settingsController.SetBrightness( brightness.Level() );
+
+  } else if(object == btn3 && event == LV_EVENT_VALUE_CHANGED) {
+    
+    if(lv_obj_get_state(btn3, LV_BTN_PART_MAIN) & LV_STATE_CHECKED) {
+      settingsController.SetVibrationStatus( Controllers::Settings::Vibration::ON );
+      lv_label_set_text_static(btn3_lvl, Symbols::notificationsOn);
+    } else {
+      settingsController.SetVibrationStatus(Controllers::Settings::Vibration::OFF);
+      lv_label_set_text_static(btn3_lvl, Symbols::notificationsOff);
+    }
+
+  } else if(object == btn4 && event == LV_EVENT_PRESSED) {
+    running = false;
+    settingsController.SetSettingsMenu(0);
+    app->StartApp(Apps::Settings, DisplayApp::FullRefreshDirections::Up);
+
+  }
+
+}
+
+bool QuickSettings::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
+  switch (event) {
+    case Pinetime::Applications::TouchEvents::SwipeLeft:
+      running = false;
+      return false;
+
+    default:
+      return true;
+  }
+}
+
+bool QuickSettings::Refresh() {
+  return running;
+}
diff --git a/src/displayapp/screens/settings/QuickSettings.h b/src/displayapp/screens/settings/QuickSettings.h
new file mode 100644
index 00000000..329be55b
--- /dev/null
+++ b/src/displayapp/screens/settings/QuickSettings.h
@@ -0,0 +1,57 @@
+#pragma once
+
+#include <cstdint>
+#include <FreeRTOS.h>
+#include <timers.h>
+#include "displayapp/screens/Screen.h"
+#include <lvgl/lvgl.h>
+#include "components/datetime/DateTimeController.h"
+#include "components/brightness/BrightnessController.h"
+#include "components/settings/Settings.h"
+#include "components/battery/BatteryController.h"
+
+
+namespace Pinetime {
+
+  namespace Applications {
+    namespace Screens {
+
+      class QuickSettings : public Screen{
+        public:
+          QuickSettings(DisplayApp* app, 
+            Pinetime::Controllers::Battery& batteryController,
+            Controllers::DateTime& dateTimeController,
+            Controllers::BrightnessController& brightness,
+            Pinetime::Controllers::Settings &settingsController);
+
+          ~QuickSettings() override;
+
+          bool Refresh() override;
+          
+          bool OnTouchEvent(Pinetime::Applications::TouchEvents event) override;
+          void OnButtonEvent(lv_obj_t *object, lv_event_t event);
+
+          void UpdateScreen();
+
+        private:          
+
+          Pinetime::Controllers::Battery& batteryController;
+          Controllers::DateTime& dateTimeController;
+          Controllers::BrightnessController& brightness;
+          Controllers::Settings& settingsController;
+
+          lv_task_t* taskUpdate;
+          lv_obj_t * batteryIcon;
+          lv_obj_t * label_time;
+
+          lv_obj_t * btn1;
+          lv_obj_t * btn1_lvl;
+          lv_obj_t * btn2;
+          lv_obj_t * btn3;
+          lv_obj_t * btn3_lvl;
+          lv_obj_t * btn4;
+
+      };
+    }
+  }
+}
diff --git a/src/displayapp/screens/settings/SettingDisplay.cpp b/src/displayapp/screens/settings/SettingDisplay.cpp
new file mode 100644
index 00000000..6c1bc9b5
--- /dev/null
+++ b/src/displayapp/screens/settings/SettingDisplay.cpp
@@ -0,0 +1,109 @@
+#include "SettingDisplay.h"
+#include <lvgl/lvgl.h>
+#include "displayapp/DisplayApp.h"
+#include "displayapp/Messages.h"
+#include "displayapp/screens/Screen.h"
+#include "displayapp/screens/Symbols.h"
+
+using namespace Pinetime::Applications::Screens;
+
+namespace {
+  static void event_handler(lv_obj_t * obj, lv_event_t event) {
+    SettingDisplay* screen = static_cast<SettingDisplay *>(obj->user_data);
+    screen->UpdateSelected(obj, event);
+  }
+}
+
+SettingDisplay::SettingDisplay(
+  Pinetime::Applications::DisplayApp *app, Pinetime::Controllers::Settings &settingsController) :
+  Screen(app),
+  settingsController{settingsController}
+{
+
+  lv_obj_t * container1 = lv_cont_create(lv_scr_act(), nullptr);
+
+  lv_obj_set_style_local_bg_opa(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
+  lv_obj_set_style_local_pad_all(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 10);
+  lv_obj_set_style_local_pad_inner(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 5);
+  lv_obj_set_style_local_border_width(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 0);
+
+  lv_obj_set_pos(container1, 10, 60);
+  lv_obj_set_width(container1, LV_HOR_RES - 20);
+  lv_obj_set_height(container1, LV_VER_RES - 50);
+  lv_cont_set_layout(container1, LV_LAYOUT_COLUMN_LEFT);
+
+  lv_obj_t * title = lv_label_create(lv_scr_act(), nullptr);  
+  lv_label_set_text_static(title,"Display timeout");
+  lv_label_set_align(title, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(title, lv_scr_act(), LV_ALIGN_IN_TOP_MID, 10, 15);
+
+  lv_obj_t * icon = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_color(icon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_ORANGE);
+  lv_label_set_text_static(icon, Symbols::sun);
+  lv_label_set_align(icon, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(icon, title, LV_ALIGN_OUT_LEFT_MID, -10, 0);
+  
+  optionsTotal = 0;
+  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
+  lv_checkbox_set_text_static(cbOption[optionsTotal], "  5 seconds");
+  cbOption[optionsTotal]->user_data = this;
+  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);  
+  if (settingsController.GetScreenTimeOut() == 5000 ) {
+    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  }
+  optionsTotal++;
+  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
+  lv_checkbox_set_text_static(cbOption[optionsTotal], " 15 seconds");
+  cbOption[optionsTotal]->user_data = this;
+  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);  
+  if (settingsController.GetScreenTimeOut() == 15000 ) {
+    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  }
+  optionsTotal++;
+  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
+  lv_checkbox_set_text_static(cbOption[optionsTotal], " 20 seconds");
+  cbOption[optionsTotal]->user_data = this;
+  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);
+  if (settingsController.GetScreenTimeOut() == 20000 ) {
+    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  }
+  optionsTotal++;
+  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
+  lv_checkbox_set_text_static(cbOption[optionsTotal], " 30 seconds");
+  cbOption[optionsTotal]->user_data = this;
+  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);
+  if (settingsController.GetScreenTimeOut() == 30000 ) {
+    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  }
+  optionsTotal++;
+}
+
+SettingDisplay::~SettingDisplay() {
+  lv_obj_clean(lv_scr_act());
+  settingsController.SaveSettings();
+}
+
+bool SettingDisplay::Refresh() {
+  return running;
+}
+
+
+void SettingDisplay::UpdateSelected(lv_obj_t *object, lv_event_t event) {
+  if(event == LV_EVENT_VALUE_CHANGED) {
+    for(int i = 0; i < optionsTotal; i++) {
+      if ( object == cbOption[i] ) {
+        lv_checkbox_set_checked(cbOption[i], true);
+        
+        if ( i == 0 ) { settingsController.SetScreenTimeOut(5000); };
+        if ( i == 1 ) { settingsController.SetScreenTimeOut(15000); };
+        if ( i == 2 ) { settingsController.SetScreenTimeOut(20000); };
+        if ( i == 3 ) { settingsController.SetScreenTimeOut(30000); };
+        
+        app->PushMessage(Applications::Display::Messages::UpdateTimeOut);
+
+      } else {
+        lv_checkbox_set_checked(cbOption[i], false);
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/displayapp/screens/settings/SettingDisplay.h b/src/displayapp/screens/settings/SettingDisplay.h
new file mode 100644
index 00000000..9565d3c7
--- /dev/null
+++ b/src/displayapp/screens/settings/SettingDisplay.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <cstdint>
+#include <lvgl/lvgl.h>
+#include "components/settings/Settings.h"
+#include "displayapp/screens/Screen.h"
+
+namespace Pinetime {
+
+  namespace Applications {
+    namespace Screens {
+
+      class SettingDisplay : public Screen{
+        public:
+          SettingDisplay(DisplayApp* app, Pinetime::Controllers::Settings &settingsController);
+          ~SettingDisplay() override;
+
+          bool Refresh() override;
+          void UpdateSelected(lv_obj_t *object, lv_event_t event);
+         
+        private:          
+
+          Controllers::Settings& settingsController;
+          uint8_t optionsTotal;
+          lv_obj_t * cbOption[4];
+          
+      };
+    }
+  }
+}
diff --git a/src/displayapp/screens/settings/SettingTimeFormat.cpp b/src/displayapp/screens/settings/SettingTimeFormat.cpp
new file mode 100644
index 00000000..ff217bda
--- /dev/null
+++ b/src/displayapp/screens/settings/SettingTimeFormat.cpp
@@ -0,0 +1,89 @@
+#include "SettingTimeFormat.h"
+#include <lvgl/lvgl.h>
+#include "displayapp/DisplayApp.h"
+#include "displayapp/screens/Screen.h"
+#include "displayapp/screens/Symbols.h"
+
+using namespace Pinetime::Applications::Screens;
+
+namespace {
+  static void event_handler(lv_obj_t * obj, lv_event_t event) {
+    SettingTimeFormat* screen = static_cast<SettingTimeFormat *>(obj->user_data);
+    screen->UpdateSelected(obj, event);
+  }
+}
+
+SettingTimeFormat::SettingTimeFormat(
+  Pinetime::Applications::DisplayApp *app, Pinetime::Controllers::Settings &settingsController) :
+  Screen(app),
+  settingsController{settingsController}
+{
+
+  lv_obj_t * container1 = lv_cont_create(lv_scr_act(), nullptr);
+
+  lv_obj_set_style_local_bg_opa(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
+  lv_obj_set_style_local_pad_all(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 10);
+  lv_obj_set_style_local_pad_inner(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 5);
+  lv_obj_set_style_local_border_width(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 0);
+
+  lv_obj_set_pos(container1, 10, 60);
+  lv_obj_set_width(container1, LV_HOR_RES - 20);
+  lv_obj_set_height(container1, LV_VER_RES - 50);
+  lv_cont_set_layout(container1, LV_LAYOUT_COLUMN_LEFT);
+
+  lv_obj_t * title = lv_label_create(lv_scr_act(), nullptr);  
+  lv_label_set_text_static(title,"Time format");
+  lv_label_set_align(title, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(title, lv_scr_act(), LV_ALIGN_IN_TOP_MID, 15, 15);
+
+  lv_obj_t * icon = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_color(icon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_ORANGE);
+  lv_label_set_text_static(icon, Symbols::clock);
+  lv_label_set_align(icon, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(icon, title, LV_ALIGN_OUT_LEFT_MID, -10, 0);
+
+  optionsTotal = 0;
+  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
+  lv_checkbox_set_text_static(cbOption[optionsTotal], " 12-hour");
+  cbOption[optionsTotal]->user_data = this;
+  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);  
+  if (settingsController.GetClockType() == Controllers::Settings::ClockType::H12 ) {
+    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  }
+
+  optionsTotal++;
+  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
+  lv_checkbox_set_text_static(cbOption[optionsTotal], " 24-hour");
+  cbOption[optionsTotal]->user_data = this;
+  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);  
+  if (settingsController.GetClockType() == Controllers::Settings::ClockType::H24 ) {
+    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  }
+  optionsTotal++;
+}
+
+SettingTimeFormat::~SettingTimeFormat() {
+  lv_obj_clean(lv_scr_act());
+  settingsController.SaveSettings();
+}
+
+bool SettingTimeFormat::Refresh() {
+  return running;
+}
+
+
+void SettingTimeFormat::UpdateSelected(lv_obj_t *object, lv_event_t event) {
+  if(event == LV_EVENT_VALUE_CHANGED) {
+    for(int i = 0; i < optionsTotal; i++) {
+      if ( object == cbOption[i] ) {
+        lv_checkbox_set_checked(cbOption[i], true);
+        
+        if ( i == 0 ) { settingsController.SetClockType(Controllers::Settings::ClockType::H12); };
+        if ( i == 1 ) { settingsController.SetClockType(Controllers::Settings::ClockType::H24); };
+        
+      } else {
+        lv_checkbox_set_checked(cbOption[i], false);
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/displayapp/screens/settings/SettingTimeFormat.h b/src/displayapp/screens/settings/SettingTimeFormat.h
new file mode 100644
index 00000000..a6380493
--- /dev/null
+++ b/src/displayapp/screens/settings/SettingTimeFormat.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <cstdint>
+#include <lvgl/lvgl.h>
+#include "components/settings/Settings.h"
+#include "displayapp/screens/Screen.h"
+
+namespace Pinetime {
+
+  namespace Applications {
+    namespace Screens {
+
+      class SettingTimeFormat : public Screen{
+        public:
+          SettingTimeFormat(DisplayApp* app, Pinetime::Controllers::Settings &settingsController);
+          ~SettingTimeFormat() override;
+
+          bool Refresh() override;
+          void UpdateSelected(lv_obj_t *object, lv_event_t event);
+         
+        private:          
+
+          Controllers::Settings& settingsController;
+          uint8_t optionsTotal;
+          lv_obj_t * cbOption[2];
+          
+      };
+    }
+  }
+}
diff --git a/src/displayapp/screens/settings/SettingWakeUp.cpp b/src/displayapp/screens/settings/SettingWakeUp.cpp
new file mode 100644
index 00000000..927a9e3a
--- /dev/null
+++ b/src/displayapp/screens/settings/SettingWakeUp.cpp
@@ -0,0 +1,107 @@
+#include "SettingWakeUp.h"
+#include <lvgl/lvgl.h>
+#include "displayapp/DisplayApp.h"
+#include "displayapp/screens/Screen.h"
+#include "displayapp/screens/Symbols.h"
+#include "components/settings/Settings.h"
+
+using namespace Pinetime::Applications::Screens;
+
+namespace {
+  static void event_handler(lv_obj_t * obj, lv_event_t event) {
+    SettingWakeUp* screen = static_cast<SettingWakeUp *>(obj->user_data);
+    screen->UpdateSelected(obj, event);
+  }
+}
+
+SettingWakeUp::SettingWakeUp(
+  Pinetime::Applications::DisplayApp *app, Pinetime::Controllers::Settings &settingsController) :
+  Screen(app),
+  settingsController{settingsController}
+{
+
+  lv_obj_t * container1 = lv_cont_create(lv_scr_act(), nullptr);
+
+  lv_obj_set_style_local_bg_opa(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
+  lv_obj_set_style_local_pad_all(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 10);
+  lv_obj_set_style_local_pad_inner(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 5);
+  lv_obj_set_style_local_border_width(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 0);
+
+  lv_obj_set_pos(container1, 10, 60);
+  lv_obj_set_width(container1, LV_HOR_RES - 20);
+  lv_obj_set_height(container1, LV_VER_RES - 50);
+  lv_cont_set_layout(container1, LV_LAYOUT_COLUMN_LEFT);
+
+  lv_obj_t * title = lv_label_create(lv_scr_act(), nullptr);  
+  lv_label_set_text_static(title,"Wake Up");
+  lv_label_set_align(title, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(title, lv_scr_act(), LV_ALIGN_IN_TOP_MID, 15, 15);
+
+  lv_obj_t * icon = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_color(icon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_ORANGE);
+  lv_label_set_text_static(icon, Symbols::clock);
+  lv_label_set_align(icon, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(icon, title, LV_ALIGN_OUT_LEFT_MID, -10, 0);
+
+  optionsTotal = 0;
+  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
+  lv_checkbox_set_text_static(cbOption[optionsTotal], " None");
+  cbOption[optionsTotal]->user_data = this;
+  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);  
+  if (settingsController.getWakeUpMode() == Pinetime::Controllers::Settings::WakeUpMode::None ) {
+    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  }
+  optionsTotal++;
+  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
+  lv_checkbox_set_text_static(cbOption[optionsTotal], " Single Tap");
+  cbOption[optionsTotal]->user_data = this;
+  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);  
+  if (settingsController.getWakeUpMode() == Pinetime::Controllers::Settings::WakeUpMode::SingleTap ) {
+    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  }
+  optionsTotal++;
+  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
+  lv_checkbox_set_text_static(cbOption[optionsTotal], " Double Tap");
+  cbOption[optionsTotal]->user_data = this;
+  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);  
+  if (settingsController.getWakeUpMode() == Pinetime::Controllers::Settings::WakeUpMode::DoubleTap ) {
+    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  }
+  optionsTotal++;
+  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
+  lv_checkbox_set_text_static(cbOption[optionsTotal], " Raise Wrist");
+  cbOption[optionsTotal]->user_data = this;
+  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);  
+  if (settingsController.getWakeUpMode() == Pinetime::Controllers::Settings::WakeUpMode::RaiseWrist ) {
+    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  }
+  optionsTotal++;
+}
+
+SettingWakeUp::~SettingWakeUp() {
+  lv_obj_clean(lv_scr_act());
+  settingsController.SaveSettings();
+}
+
+bool SettingWakeUp::Refresh() {
+  return running;
+}
+
+
+void SettingWakeUp::UpdateSelected(lv_obj_t *object, lv_event_t event) {
+  if(event == LV_EVENT_VALUE_CHANGED) {
+    for(int i = 0; i < optionsTotal; i++) {
+      if ( object == cbOption[i] ) {
+        lv_checkbox_set_checked(cbOption[i], true);
+        
+        if ( i == 0 ) { settingsController.setWakeUpMode(Pinetime::Controllers::Settings::WakeUpMode::None); };
+        if ( i == 1 ) { settingsController.setWakeUpMode(Pinetime::Controllers::Settings::WakeUpMode::SingleTap); };
+        if ( i == 2 ) { settingsController.setWakeUpMode(Pinetime::Controllers::Settings::WakeUpMode::DoubleTap); };
+        if ( i == 3 ) { settingsController.setWakeUpMode(Pinetime::Controllers::Settings::WakeUpMode::RaiseWrist); };
+        
+      } else {
+        lv_checkbox_set_checked(cbOption[i], false);
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/displayapp/screens/settings/SettingWakeUp.h b/src/displayapp/screens/settings/SettingWakeUp.h
new file mode 100644
index 00000000..99ddd363
--- /dev/null
+++ b/src/displayapp/screens/settings/SettingWakeUp.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <cstdint>
+#include <lvgl/lvgl.h>
+#include "components/settings/Settings.h"
+#include "displayapp/screens/Screen.h"
+
+namespace Pinetime {
+
+  namespace Applications {
+    namespace Screens {
+
+      class SettingWakeUp : public Screen{
+        public:
+          SettingWakeUp(DisplayApp* app, Pinetime::Controllers::Settings &settingsController);
+          ~SettingWakeUp() override;
+
+          bool Refresh() override;
+          void UpdateSelected(lv_obj_t *object, lv_event_t event);
+         
+        private:          
+
+          Controllers::Settings& settingsController;
+          uint8_t optionsTotal;
+          lv_obj_t * cbOption[3];
+          
+      };
+    }
+  }
+}
diff --git a/src/displayapp/screens/settings/SettingWatchFace.cpp b/src/displayapp/screens/settings/SettingWatchFace.cpp
new file mode 100644
index 00000000..f763acd4
--- /dev/null
+++ b/src/displayapp/screens/settings/SettingWatchFace.cpp
@@ -0,0 +1,88 @@
+#include "SettingWatchFace.h"
+#include <lvgl/lvgl.h>
+#include "displayapp/DisplayApp.h"
+#include "displayapp/screens/Screen.h"
+#include "displayapp/screens/Symbols.h"
+
+using namespace Pinetime::Applications::Screens;
+
+namespace {
+  static void event_handler(lv_obj_t * obj, lv_event_t event) {
+    SettingWatchFace* screen = static_cast<SettingWatchFace *>(obj->user_data);
+    screen->UpdateSelected(obj, event);
+  }
+}
+
+SettingWatchFace::SettingWatchFace(
+  Pinetime::Applications::DisplayApp *app, Pinetime::Controllers::Settings &settingsController) :
+  Screen(app),
+  settingsController{settingsController}
+{
+
+  lv_obj_t * container1 = lv_cont_create(lv_scr_act(), nullptr);
+
+  //lv_obj_set_style_local_bg_color(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x111111));
+  lv_obj_set_style_local_bg_opa(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
+  lv_obj_set_style_local_pad_all(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 10);
+  lv_obj_set_style_local_pad_inner(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 5);
+  lv_obj_set_style_local_border_width(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 0);
+
+  lv_obj_set_pos(container1, 10, 60);
+  lv_obj_set_width(container1, LV_HOR_RES - 20);
+  lv_obj_set_height(container1, LV_VER_RES - 50);
+  lv_cont_set_layout(container1, LV_LAYOUT_COLUMN_LEFT);
+
+  lv_obj_t * title = lv_label_create(lv_scr_act(), nullptr);  
+  lv_label_set_text_static(title,"Watch face");
+  lv_label_set_align(title, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(title, lv_scr_act(), LV_ALIGN_IN_TOP_MID, 10, 15);
+
+  lv_obj_t * icon = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_color(icon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_ORANGE);
+  lv_label_set_text_static(icon, Symbols::clock);
+  lv_label_set_align(icon, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(icon, title, LV_ALIGN_OUT_LEFT_MID, -10, 0);
+
+  optionsTotal = 0;
+  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
+  lv_checkbox_set_text_static(cbOption[optionsTotal], " Digital face");
+  cbOption[optionsTotal]->user_data = this;
+  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);  
+  if (settingsController.GetClockFace() == 0 ) {
+    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  }
+
+  optionsTotal++;
+  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
+  lv_checkbox_set_text_static(cbOption[optionsTotal], " Analog face");
+  cbOption[optionsTotal]->user_data = this;
+  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);  
+  if (settingsController.GetClockFace() == 1 ) {
+    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  }
+
+  optionsTotal++;
+}
+
+SettingWatchFace::~SettingWatchFace() {
+  lv_obj_clean(lv_scr_act());
+  settingsController.SaveSettings();
+}
+
+bool SettingWatchFace::Refresh() {
+  return running;
+}
+
+
+void SettingWatchFace::UpdateSelected(lv_obj_t *object, lv_event_t event) {
+  if(event == LV_EVENT_VALUE_CHANGED) {
+    for(uint8_t i = 0; i < optionsTotal; i++) {
+      if ( object == cbOption[i] ) {
+        lv_checkbox_set_checked(cbOption[i], true);
+        settingsController.SetClockFace(i);
+      } else {
+        lv_checkbox_set_checked(cbOption[i], false);
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/displayapp/screens/settings/SettingWatchFace.h b/src/displayapp/screens/settings/SettingWatchFace.h
new file mode 100644
index 00000000..8c30ed28
--- /dev/null
+++ b/src/displayapp/screens/settings/SettingWatchFace.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <cstdint>
+#include <lvgl/lvgl.h>
+#include "components/settings/Settings.h"
+#include "displayapp/screens/Screen.h"
+
+namespace Pinetime {
+
+  namespace Applications {
+    namespace Screens {
+
+      class SettingWatchFace : public Screen{
+        public:
+          SettingWatchFace(DisplayApp* app, Pinetime::Controllers::Settings &settingsController);
+          ~SettingWatchFace() override;
+
+          bool Refresh() override;
+          void UpdateSelected(lv_obj_t *object, lv_event_t event);
+         
+        private:          
+
+          Controllers::Settings& settingsController;
+          uint8_t optionsTotal;
+          lv_obj_t * cbOption[2];
+          
+      };
+    }
+  }
+}
diff --git a/src/displayapp/screens/settings/Settings.cpp b/src/displayapp/screens/settings/Settings.cpp
new file mode 100644
index 00000000..b2825915
--- /dev/null
+++ b/src/displayapp/screens/settings/Settings.cpp
@@ -0,0 +1,69 @@
+#include "Settings.h"
+#include <lvgl/lvgl.h>
+#include <array>
+#include "displayapp/screens/List.h"
+#include "displayapp/Apps.h"
+#include "displayapp/DisplayApp.h"
+#include "displayapp/screens/Symbols.h"
+
+using namespace Pinetime::Applications::Screens;
+
+Settings::Settings(
+  Pinetime::Applications::DisplayApp *app,
+  Pinetime::Controllers::Settings &settingsController) :
+    Screen(app), 
+    settingsController{settingsController},
+    screens{app, 
+      settingsController.GetSettingsMenu(),
+      {
+        [this]() -> std::unique_ptr<Screen> { return CreateScreen1(); },
+        [this]() -> std::unique_ptr<Screen> { return CreateScreen2(); }
+      },
+      Screens::ScreenListModes::UpDown          
+    } {}
+
+Settings::~Settings() {
+  lv_obj_clean(lv_scr_act());
+}
+
+bool Settings::Refresh() {
+  
+  if(running)
+    running = screens.Refresh();
+  return running;
+}
+
+bool Settings::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
+  return screens.OnTouchEvent(event);
+}
+
+std::unique_ptr<Screen> Settings::CreateScreen1() {
+
+  std::array<Screens::List::Applications, 4> applications {
+          {                        
+            {Symbols::sun,    "Display",     Apps::SettingDisplay},
+            {Symbols::clock,  "Wake Up",     Apps::SettingWakeUp},
+            {Symbols::clock,  "Time format", Apps::SettingTimeFormat},
+            {Symbols::clock,  "Watch face",  Apps::SettingWatchFace},
+          }
+
+  };
+
+  return std::unique_ptr<Screen>(new Screens::List(0, 2, app, settingsController, applications));
+}
+
+
+std::unique_ptr<Screen> Settings::CreateScreen2() {
+
+  std::array<Screens::List::Applications, 4> applications {
+          {
+            {Symbols::batteryHalf,  "Battery",   Apps::BatteryInfo},
+            {Symbols::check,        "Firmware",  Apps::FirmwareValidation},
+            {Symbols::list,         "About",     Apps::SysInfo},
+            {"",   "",     Apps::None},
+          }
+
+  };
+
+  return std::unique_ptr<Screen>(new Screens::List(1, 2, app, settingsController, applications));
+}
diff --git a/src/displayapp/screens/settings/Settings.h b/src/displayapp/screens/settings/Settings.h
new file mode 100644
index 00000000..9955e1d4
--- /dev/null
+++ b/src/displayapp/screens/settings/Settings.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <cstdint>
+#include "displayapp/screens/Screen.h"
+#include "displayapp/screens/ScreenList.h"
+
+namespace Pinetime {
+
+
+  namespace Applications {
+    namespace Screens {
+
+      class Settings : public Screen{
+        public:
+          Settings(DisplayApp* app,
+          Pinetime::Controllers::Settings &settingsController);
+          ~Settings() override;
+
+          bool Refresh() override;
+          
+          void OnButtonEvent(lv_obj_t *object, lv_event_t event);
+          bool OnTouchEvent(Pinetime::Applications::TouchEvents event) override;
+
+        private:          
+
+          Controllers::Settings& settingsController;
+          
+          ScreenList<2> screens;
+
+          std::unique_ptr<Screen> CreateScreen1();
+          std::unique_ptr<Screen> CreateScreen2();
+
+
+      };
+    }
+  }
+}