Tweak build/ignore

Merge branch 'main' into wb/wadokei-merge
Fix merge issues, adjust font size and initial screen
2024-12-17 23:51:55 -08:00 · 2024-12-17 23:25:20 -08:00 · 2024-12-05 17:19:34 -08:00 · 2024-12-05 16:41:43 -08:00 · 2024-06-11 21:27:26 -07:00 · 2024-06-10 20:19:43 -07:00
38 changed files with 679 additions and 1755 deletions
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -3,7 +3,7 @@ name: CI
 # Run this workflow whenever the build may be affected
 on:
  push:
-    branches: [ main ]
+    branches: [ main, 'wb/*' ]
    paths-ignore:
      - 'doc/**'
      - '**.md'
@@ -98,6 +98,15 @@ jobs:
        git clone https://github.com/InfiniTimeOrg/InfiniSim.git --depth 1 --branch main
        git -C InfiniSim submodule update --init lv_drivers

+    - name: Add sunset lib to InfiniSim
+      run: patch -i docker/infinisim-cmake.patch InfiniSim/CMakeLists.txt
+
+    - name: Remove Terminal from InfiniSim
+      run: patch -i docker/infinisim-terminal.patch InfiniSim/littlefs-do-main.cpp
+
+    - name: Remove Digital from InfiniSim
+      run: patch -i docker/infinisim-main.patch InfiniSim/main.cpp
+
    - name: CMake
      # disable BUILD_RESOURCES as this is already done when building the firmware
      run:  |
--- a/.gitignore
+++ b/.gitignore
@@ -50,3 +50,8 @@ src/arm-none-eabi

 # clangd
 .cache/
+
+nRF5_SDK/
+
+# Licensed fonts
+Vulf*Mono*
--- a/.gitmodules
+++ b/.gitmodules
@@ -7,3 +7,6 @@
 [submodule "src/libs/arduinoFFT"]
 	path = src/libs/arduinoFFT
 	url = https://github.com/kosme/arduinoFFT.git
+[submodule "src/libs/sunset"]
+	path = src/libs/sunset
+	url = https://github.com/buelowp/sunset.git
--- a/README.md
+++ b/README.md
@@ -20,6 +20,16 @@

 </div>

+## Wadokei fork
+
+Based on [Sudrien's Watchy Wadokei](https://github.com/Sudrien/watchy_wadokei) --
+displays an Edo-period Japanese clock face and a sunrise/sunset-based hour hand.
+
+Also chimes hours according to the number on the face (9,8,7,6,5,4) at the top
+of each modern hour (so noon and 1pm will be 9 chimes, 2pm and 3pm will be 8, etc).
+
+See https://github.com/Sudrien/watchy_wadokei/blob/main/Reckoning.md for more ideas!
+
 ## New to InfiniTime?

 - [Getting started with InfiniTime](doc/gettingStarted/gettingStarted-1.0.md)
--- a/docker/infinisim-cmake.patch
+++ b/docker/infinisim-cmake.patch
@@ -0,0 +1,19 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index edd6748..641b74a 100644
+--- a/CMakeLists.txt
+++ b/CMakeLists.txt
+@@ -243,6 +243,14 @@ add_library(littlefs STATIC
+ target_include_directories(littlefs PUBLIC "${InfiniTime_DIR}/src/libs/littlefs")
+ target_link_libraries(infinisim PRIVATE littlefs)
+ 
+# sunset
+add_library(sunset STATIC
+  ${InfiniTime_DIR}/src/libs/sunset/src/sunset.h
+  ${InfiniTime_DIR}/src/libs/sunset/src/sunset.cpp
+)
+target_include_directories(sunset PUBLIC "${InfiniTime_DIR}/src/libs/sunset")
+target_link_libraries(infinisim PRIVATE sunset)
+
+ # QCBOR
+ add_library(QCBOR STATIC
+   ${InfiniTime_DIR}/src/libs/QCBOR/src/ieee754.c
--- a/docker/infinisim-main.patch
+++ b/docker/infinisim-main.patch
@@ -0,0 +1,20 @@
+diff --git a/main.cpp b/main.cpp
+index 8070db7..530ff4b 100644
+--- a/main.cpp
+++ b/main.cpp
+@@ -823,14 +823,10 @@ public:
+     void switch_to_screen(uint8_t screen_idx)
+     {
+       if (screen_idx == 1) {
+-        settingsController.SetWatchFace(Pinetime::Applications::WatchFace::Digital);
+-        displayApp.StartApp(Pinetime::Applications::Apps::Clock, Pinetime::Applications::DisplayApp::FullRefreshDirections::None);
+-      }
+-      else if (screen_idx == 2) {
+         settingsController.SetWatchFace(Pinetime::Applications::WatchFace::Analog);
+         displayApp.StartApp(Pinetime::Applications::Apps::Clock, Pinetime::Applications::DisplayApp::FullRefreshDirections::None);
+       }
+-      else if (screen_idx == 3) {
+      else if (screen_idx == 2) {
+         settingsController.SetWatchFace(Pinetime::Applications::WatchFace::PineTimeStyle);
+         displayApp.StartApp(Pinetime::Applications::Apps::Clock, Pinetime::Applications::DisplayApp::FullRefreshDirections::None);
+       }
--- a/docker/infinisim-terminal.patch
+++ b/docker/infinisim-terminal.patch
@@ -0,0 +1,17 @@
+diff --git a/littlefs-do-main.cpp b/littlefs-do-main.cpp
+index 0a5dfbd..3e818af 100644
+--- a/littlefs-do-main.cpp
+++ b/littlefs-do-main.cpp
+@@ -537,10 +537,10 @@ int command_settings(const std::string &program_name, const std::vector<std::str
+   {
+     auto clockface = settingsController.GetWatchFace();
+     auto clockface_str = [](auto val) {
+-      if (val == Pinetime::Applications::WatchFace::Digital) return "Digital";
+      //if (val == Pinetime::Applications::WatchFace::Digital) return "Digital";
+       if (val == Pinetime::Applications::WatchFace::Analog) return "Analog";
+       if (val == Pinetime::Applications::WatchFace::PineTimeStyle) return "PineTimeStyle";
+-      if (val == Pinetime::Applications::WatchFace::Terminal) return "Terminal";
+      //if (val == Pinetime::Applications::WatchFace::Terminal) return "Terminal";
+       return "unknown";
+     }(clockface);
+     std::cout << "ClockFace: " << static_cast<uint32_t>(clockface) << " " << clockface_str << std::endl;
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -174,6 +174,11 @@ set(LITTLEFS_SRC
        libs/littlefs/lfs.c
        )

+set(SUNSET_SRC
+        libs/sunset/src/sunset.h
+        libs/sunset/src/sunset.cpp
+        )
+
 set(LVGL_SRC
        libs/lv_conf.h
        libs/lvgl/lvgl.h
@@ -366,8 +371,6 @@ list(APPEND SOURCE_FILES
        displayapp/DisplayApp.cpp
        displayapp/screens/Screen.cpp
        displayapp/screens/Tile.cpp
-        displayapp/screens/InfiniPaint.cpp
-        displayapp/screens/Paddle.cpp
        displayapp/screens/StopWatch.cpp
        displayapp/screens/BatteryIcon.cpp
        displayapp/screens/BleIcon.cpp
@@ -376,14 +379,9 @@ list(APPEND SOURCE_FILES
        displayapp/screens/Label.cpp
        displayapp/screens/FirmwareUpdate.cpp
        displayapp/screens/Music.cpp
-        displayapp/screens/Navigation.cpp
-        displayapp/screens/Metronome.cpp
-        displayapp/screens/Motion.cpp
-        displayapp/screens/Weather.cpp
        displayapp/screens/FirmwareValidation.cpp
        displayapp/screens/ApplicationList.cpp
        displayapp/screens/Notifications.cpp
-        displayapp/screens/Twos.cpp
        displayapp/screens/HeartRate.cpp
        displayapp/screens/FlashLight.cpp
        displayapp/screens/List.cpp
@@ -415,17 +413,21 @@ list(APPEND SOURCE_FILES
        displayapp/screens/settings/SettingSetDateTime.cpp
        displayapp/screens/settings/SettingSetDate.cpp
        displayapp/screens/settings/SettingSetTime.cpp
+        displayapp/screens/settings/SettingLocation.cpp
        displayapp/screens/settings/SettingChimes.cpp
        displayapp/screens/settings/SettingShakeThreshold.cpp
        displayapp/screens/settings/SettingBluetooth.cpp
+        displayapp/screens/settings/SettingLocation.cpp

        ## Watch faces
        displayapp/screens/WatchFaceAnalog.cpp
-        displayapp/screens/WatchFaceDigital.cpp
-        displayapp/screens/WatchFaceInfineat.cpp
-        displayapp/screens/WatchFaceTerminal.cpp
+        #displayapp/screens/WatchFaceDigital.cpp
+        #displayapp/screens/WatchFaceInfineat.cpp
+        #displayapp/screens/WatchFaceTerminal.cpp
        displayapp/screens/WatchFacePineTimeStyle.cpp
-        displayapp/screens/WatchFaceCasioStyleG7710.cpp
+        #displayapp/screens/WatchFaceCasioStyleG7710.cpp
+        #displayapp/screens/WatchFaceFuzzy.cpp
+        #displayapp/screens/WatchFaceSundial.cpp

        ##

@@ -592,9 +594,7 @@ set(INCLUDE_FILES
        displayapp/TouchEvents.h
        displayapp/screens/Screen.h
        displayapp/screens/Tile.h
-        displayapp/screens/InfiniPaint.h
        displayapp/screens/StopWatch.h
-        displayapp/screens/Paddle.h
        displayapp/screens/BatteryIcon.h
        displayapp/screens/BleIcon.h
        displayapp/screens/NotificationIcon.h
@@ -608,11 +608,7 @@ set(INCLUDE_FILES
        displayapp/Apps.h
        displayapp/screens/Notifications.h
        displayapp/screens/HeartRate.h
-        displayapp/screens/Metronome.h
-        displayapp/screens/Motion.h
        displayapp/screens/Timer.h
-        displayapp/screens/Dice.h
-        displayapp/screens/Alarm.h
        displayapp/Colors.h
        displayapp/widgets/Counter.h
        displayapp/widgets/PageIndicator.h
@@ -777,7 +773,7 @@ link_directories(
 set(COMMON_FLAGS -MP -MD -mthumb -mabi=aapcs -ftree-vrp -ffunction-sections -fdata-sections -fno-strict-aliasing -fno-builtin -fshort-enums -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16 -fstack-usage -fno-exceptions -fno-non-call-exceptions)
 set(WARNING_FLAGS -Wall -Wextra -Warray-bounds=2 -Wformat=2 -Wformat-overflow=2 -Wformat-truncation=2 -Wformat-nonliteral -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-expansion-to-defined -Wreturn-type -Werror=return-type -Werror)
 set(DEBUG_FLAGS -Og -g3)
-set(RELEASE_FLAGS -Os)
+set(DEBUG_FLAGS -Os)
 set(CXX_FLAGS -fno-rtti)
 set(ASM_FLAGS -x assembler-with-cpp)
 add_definitions(-DCONFIG_GPIO_AS_PINRESET)
@@ -846,7 +842,7 @@ add_subdirectory(displayapp/fonts)
 target_compile_options(infinitime_fonts PUBLIC
        ${COMMON_FLAGS}
        $<$<CONFIG:DEBUG>: ${DEBUG_FLAGS}>
-        $<$<CONFIG:RELEASE>: ${RELEASE_FLAGS}>
+        $<$<CONFIG:RELEASE>: ${DEBUG_FLAGS}>
        $<$<COMPILE_LANGUAGE:CXX>: ${CXX_FLAGS}>
        $<$<COMPILE_LANGUAGE:ASM>: ${ASM_FLAGS}>
        )
@@ -860,7 +856,7 @@ target_include_directories(nrf-sdk SYSTEM PUBLIC ${INCLUDES_FROM_LIBS})
 target_compile_options(nrf-sdk PRIVATE
        ${COMMON_FLAGS}
        $<$<CONFIG:DEBUG>: ${DEBUG_FLAGS}>
-        $<$<CONFIG:RELEASE>: ${RELEASE_FLAGS}>
+        $<$<CONFIG:RELEASE>: ${DEBUG_FLAGS}>
        $<$<COMPILE_LANGUAGE:CXX>: ${CXX_FLAGS}>
        $<$<COMPILE_LANGUAGE:ASM>: ${ASM_FLAGS}>
        )
@@ -872,7 +868,7 @@ target_include_directories(nimble SYSTEM PUBLIC ${INCLUDES_FROM_LIBS})
 target_compile_options(nimble PRIVATE
        ${COMMON_FLAGS}
        $<$<CONFIG:DEBUG>: ${DEBUG_FLAGS}>
-        $<$<CONFIG:RELEASE>: ${RELEASE_FLAGS}>
+        $<$<CONFIG:RELEASE>: ${DEBUG_FLAGS}>
        $<$<COMPILE_LANGUAGE:CXX>: ${CXX_FLAGS}>
        $<$<COMPILE_LANGUAGE:ASM>: ${ASM_FLAGS}>
        )
@@ -884,7 +880,7 @@ target_include_directories(lvgl SYSTEM PUBLIC ${INCLUDES_FROM_LIBS})
 target_compile_options(lvgl PRIVATE
        ${COMMON_FLAGS}
        $<$<CONFIG:DEBUG>: ${DEBUG_FLAGS}>
-        $<$<CONFIG:RELEASE>: ${RELEASE_FLAGS}>
+        $<$<CONFIG:RELEASE>: ${DEBUG_FLAGS}>
        $<$<COMPILE_LANGUAGE:CXX>: ${CXX_FLAGS}>
        $<$<COMPILE_LANGUAGE:ASM>: ${ASM_FLAGS}>
        )
@@ -894,6 +890,18 @@ add_library(littlefs STATIC ${LITTLEFS_SRC})
 target_include_directories(littlefs SYSTEM PUBLIC . ../)
 target_include_directories(littlefs SYSTEM PUBLIC ${INCLUDES_FROM_LIBS})
 target_compile_options(littlefs PRIVATE
+        ${COMMON_FLAGS}
+        $<$<CONFIG:DEBUG>: ${DEBUG_FLAGS}>
+        $<$<CONFIG:RELEASE>: ${DEBUG_FLAGS}>
+        $<$<COMPILE_LANGUAGE:CXX>: ${CXX_FLAGS}>
+        $<$<COMPILE_LANGUAGE:ASM>: ${ASM_FLAGS}>
+        )
+
+# SUNSET_SRC
+add_library(sunset STATIC ${SUNSET_SRC})
+target_include_directories(sunset SYSTEM PUBLIC . ../)
+target_include_directories(sunset SYSTEM PUBLIC ${INCLUDES_FROM_LIBS})
+target_compile_options(sunset PRIVATE
        ${COMMON_FLAGS}
        $<$<CONFIG:DEBUG>: ${DEBUG_FLAGS}>
        $<$<CONFIG:RELEASE>: ${RELEASE_FLAGS}>
@@ -907,12 +915,12 @@ set(EXECUTABLE_FILE_NAME ${EXECUTABLE_NAME}-${pinetime_VERSION_MAJOR}.${pinetime
 set(NRF5_LINKER_SCRIPT "${CMAKE_SOURCE_DIR}/gcc_nrf52.ld")
 add_executable(${EXECUTABLE_NAME} ${SOURCE_FILES})
 set_target_properties(${EXECUTABLE_NAME} PROPERTIES OUTPUT_NAME ${EXECUTABLE_FILE_NAME})
-target_link_libraries(${EXECUTABLE_NAME} nimble nrf-sdk lvgl littlefs infinitime_fonts infinitime_apps)
+target_link_libraries(${EXECUTABLE_NAME} nimble nrf-sdk lvgl littlefs sunset infinitime_fonts infinitime_apps)
 target_compile_options(${EXECUTABLE_NAME} PUBLIC
        ${COMMON_FLAGS}
        ${WARNING_FLAGS}
        $<$<CONFIG:DEBUG>: ${DEBUG_FLAGS}>
-        $<$<CONFIG:RELEASE>: ${RELEASE_FLAGS}>
+        $<$<CONFIG:RELEASE>: ${DEBUG_FLAGS}>
        $<$<COMPILE_LANGUAGE:CXX>: ${CXX_FLAGS}>
        $<$<COMPILE_LANGUAGE:ASM>: ${ASM_FLAGS}>
        )
@@ -941,13 +949,13 @@ set(IMAGE_MCUBOOT_FILE_NAME_BIN ${EXECUTABLE_MCUBOOT_NAME}-image-${pinetime_VERS
 set(DFU_MCUBOOT_FILE_NAME ${EXECUTABLE_MCUBOOT_NAME}-dfu-${pinetime_VERSION_MAJOR}.${pinetime_VERSION_MINOR}.${pinetime_VERSION_PATCH}.zip)
 set(NRF5_LINKER_SCRIPT_MCUBOOT "${CMAKE_SOURCE_DIR}/gcc_nrf52-mcuboot.ld")
 add_executable(${EXECUTABLE_MCUBOOT_NAME} ${SOURCE_FILES})
-target_link_libraries(${EXECUTABLE_MCUBOOT_NAME} nimble nrf-sdk lvgl littlefs infinitime_fonts infinitime_apps)
+target_link_libraries(${EXECUTABLE_MCUBOOT_NAME} nimble nrf-sdk lvgl littlefs sunset infinitime_fonts infinitime_apps)
 set_target_properties(${EXECUTABLE_MCUBOOT_NAME} PROPERTIES OUTPUT_NAME ${EXECUTABLE_MCUBOOT_FILE_NAME})
 target_compile_options(${EXECUTABLE_MCUBOOT_NAME} PUBLIC
        ${COMMON_FLAGS}
        ${WARNING_FLAGS}
        $<$<CONFIG:DEBUG>: ${DEBUG_FLAGS}>
-        $<$<CONFIG:RELEASE>: ${RELEASE_FLAGS}>
+        $<$<CONFIG:RELEASE>: ${DEBUG_FLAGS}>
        $<$<COMPILE_LANGUAGE:CXX>: ${CXX_FLAGS}>
        $<$<COMPILE_LANGUAGE:ASM>: ${ASM_FLAGS}>
        )
@@ -983,14 +991,14 @@ endif()
 set(EXECUTABLE_RECOVERY_NAME "pinetime-recovery")
 set(EXECUTABLE_RECOVERY_FILE_NAME ${EXECUTABLE_RECOVERY_NAME}-${pinetime_VERSION_MAJOR}.${pinetime_VERSION_MINOR}.${pinetime_VERSION_PATCH})
 add_executable(${EXECUTABLE_RECOVERY_NAME} ${RECOVERY_SOURCE_FILES})
-target_link_libraries(${EXECUTABLE_RECOVERY_NAME} nimble nrf-sdk littlefs infinitime_fonts infinitime_apps)
+target_link_libraries(${EXECUTABLE_RECOVERY_NAME} nimble nrf-sdk littlefs sunset infinitime_fonts infinitime_apps)
 set_target_properties(${EXECUTABLE_RECOVERY_NAME} PROPERTIES OUTPUT_NAME ${EXECUTABLE_RECOVERY_FILE_NAME})
 target_compile_definitions(${EXECUTABLE_RECOVERY_NAME} PUBLIC "PINETIME_IS_RECOVERY")
 target_compile_options(${EXECUTABLE_RECOVERY_NAME} PUBLIC
        ${COMMON_FLAGS}
        ${WARNING_FLAGS}
        $<$<CONFIG:DEBUG>: ${DEBUG_FLAGS}>
-        $<$<CONFIG:RELEASE>: ${RELEASE_FLAGS}>
+        $<$<CONFIG:RELEASE>: ${DEBUG_FLAGS}>
        $<$<COMPILE_LANGUAGE:CXX>: ${CXX_FLAGS}>
        $<$<COMPILE_LANGUAGE:ASM>: ${ASM_FLAGS}>
        )
@@ -1015,14 +1023,14 @@ set(IMAGE_RECOVERY_MCUBOOT_FILE_NAME ${EXECUTABLE_RECOVERY_MCUBOOT_NAME}-image-$
 set(IMAGE_RECOVERY_MCUBOOT_FILE_NAME_HEX ${IMAGE_RECOVERY_MCUBOOT_FILE_NAME}.hex)
 set(DFU_RECOVERY_MCUBOOT_FILE_NAME ${EXECUTABLE_RECOVERY_MCUBOOT_NAME}-dfu-${pinetime_VERSION_MAJOR}.${pinetime_VERSION_MINOR}.${pinetime_VERSION_PATCH}.zip)
 add_executable(${EXECUTABLE_RECOVERY_MCUBOOT_NAME} ${RECOVERY_SOURCE_FILES})
-target_link_libraries(${EXECUTABLE_RECOVERY_MCUBOOT_NAME} nimble nrf-sdk littlefs infinitime_fonts infinitime_apps)
+target_link_libraries(${EXECUTABLE_RECOVERY_MCUBOOT_NAME} nimble nrf-sdk littlefs sunset infinitime_fonts infinitime_apps)
 set_target_properties(${EXECUTABLE_RECOVERY_MCUBOOT_NAME} PROPERTIES OUTPUT_NAME ${EXECUTABLE_RECOVERY_MCUBOOT_FILE_NAME})
 target_compile_definitions(${EXECUTABLE_RECOVERY_MCUBOOT_NAME} PUBLIC "PINETIME_IS_RECOVERY")
 target_compile_options(${EXECUTABLE_RECOVERY_MCUBOOT_NAME} PUBLIC
        ${COMMON_FLAGS}
        ${WARNING_FLAGS}
        $<$<CONFIG:DEBUG>: ${DEBUG_FLAGS}>
-        $<$<CONFIG:RELEASE>: ${RELEASE_FLAGS}>
+        $<$<CONFIG:RELEASE>: ${DEBUG_FLAGS}>
        $<$<COMPILE_LANGUAGE:CXX>: ${CXX_FLAGS}>
        $<$<COMPILE_LANGUAGE:ASM>: ${ASM_FLAGS}>
        )
@@ -1061,7 +1069,7 @@ target_compile_options(${EXECUTABLE_RECOVERYLOADER_NAME} PUBLIC
        ${COMMON_FLAGS}
        ${WARNING_FLAGS}
        $<$<CONFIG:DEBUG>: ${DEBUG_FLAGS}>
-        $<$<CONFIG:RELEASE>: ${RELEASE_FLAGS}>
+        $<$<CONFIG:RELEASE>: ${DEBUG_FLAGS}>
        $<$<COMPILE_LANGUAGE:CXX>: ${CXX_FLAGS}>
        $<$<COMPILE_LANGUAGE:ASM>: ${ASM_FLAGS}>
        )
@@ -1096,7 +1104,7 @@ target_compile_options(${EXECUTABLE_MCUBOOT_RECOVERYLOADER_NAME} PUBLIC
        ${COMMON_FLAGS}
        ${WARNING_FLAGS}
        $<$<CONFIG:DEBUG>: ${DEBUG_FLAGS}>
-        $<$<CONFIG:RELEASE>: ${RELEASE_FLAGS}>
+        $<$<CONFIG:RELEASE>: ${DEBUG_FLAGS}>
        $<$<COMPILE_LANGUAGE:CXX>: ${CXX_FLAGS}>
        $<$<COMPILE_LANGUAGE:ASM>: ${ASM_FLAGS}>
        )
--- a/src/FreeRTOSConfig.h
+++ b/src/FreeRTOSConfig.h
@@ -62,7 +62,8 @@
 #define configTICK_RATE_HZ                      1024
 #define configMAX_PRIORITIES                    (3)
 #define configMINIMAL_STACK_SIZE                (120)
-#define configTOTAL_HEAP_SIZE                   (1024 * 40)
+// how much heap can one smartwatch need, michael, 40kb?
+#define configTOTAL_HEAP_SIZE                   (1024 * 39)
 #define configMAX_TASK_NAME_LEN                 (4)
 #define configUSE_16_BIT_TICKS                  0
 #define configIDLE_SHOULD_YIELD                 1
--- a/src/components/datetime/DateTimeController.cpp
+++ b/src/components/datetime/DateTimeController.cpp
@@ -162,7 +162,7 @@ std::string DateTime::FormattedTime() {
  auto hour = Hours();
  auto minute = Minutes();
  // Return time as a string in 12- or 24-hour format
-  char buff[9];
+  char buff[11];
  if (settingsController.GetClockType() == ClockType::H12) {
    uint8_t hour12;
    const char* amPmStr;
--- a/src/components/settings/Settings.h
+++ b/src/components/settings/Settings.h
@@ -9,7 +9,7 @@ namespace Pinetime {
  namespace Controllers {
    class Settings {
    public:
-      enum class ClockType : uint8_t { H24, H12 };
+      enum class ClockType : uint8_t { H24, H12, FUZZY };
      enum class WeatherFormat : uint8_t { Metric, Imperial };
      enum class Notification : uint8_t { On, Off, Sleep };
      enum class ChimesOption : uint8_t { None, Hours, HalfHours };
@@ -50,6 +50,12 @@ namespace Pinetime {
        int colorIndex = 0;
      };

+      struct Location {
+        int16_t latitude;
+        int16_t longitude;
+        int8_t tzOffset;
+      };
+
      Settings(Pinetime::Controllers::FS& fs);

      Settings(const Settings&) = delete;
@@ -290,6 +296,21 @@ namespace Pinetime {
        return settings.stepsGoal;
      };

+      void SetLocation(Location loc) {
+        if (
+          loc.latitude != settings.location.latitude ||
+          loc.longitude != settings.location.longitude ||
+          loc.tzOffset != settings.location.tzOffset
+          ) {
+          settingsChanged = true;
+        }
+        settings.location = loc;
+      };
+
+      Location GetLocation() const {
+        return settings.location;
+      };
+
      void SetBleRadioEnabled(bool enabled) {
        bleRadioEnabled = enabled;
      };
@@ -314,7 +335,7 @@ namespace Pinetime {
        WeatherFormat weatherFormat = WeatherFormat::Metric;
        Notification notificationStatus = Notification::On;

-        Pinetime::Applications::WatchFace watchFace = Pinetime::Applications::WatchFace::Digital;
+        Pinetime::Applications::WatchFace watchFace = Pinetime::Applications::WatchFace::Analog; //Digital
        ChimesOption chimesOption = ChimesOption::None;

        PineTimeStyle PTS;
@@ -325,6 +346,7 @@ namespace Pinetime {
        uint16_t shakeWakeThreshold = 150;

        Controllers::BrightnessController::Levels brightLevel = Controllers::BrightnessController::Levels::Medium;
+        Location location = {(int16_t)44,(int16_t)-123,(int8_t)-8};
      };

      SettingsData settings;
--- a/src/displayapp/DisplayApp.cpp
+++ b/src/displayapp/DisplayApp.cpp
@@ -46,9 +46,11 @@
 #include "displayapp/screens/settings/SettingDisplay.h"
 #include "displayapp/screens/settings/SettingSteps.h"
 #include "displayapp/screens/settings/SettingSetDateTime.h"
+#include "displayapp/screens/settings/SettingLocation.h"
 #include "displayapp/screens/settings/SettingChimes.h"
 #include "displayapp/screens/settings/SettingShakeThreshold.h"
 #include "displayapp/screens/settings/SettingBluetooth.h"
+#include "displayapp/screens/settings/SettingLocation.h"

 #include "libs/lv_conf.h"
 #include "UserApps.h"
@@ -289,6 +291,11 @@ void DisplayApp::Refresh() {

  Messages msg;
  if (xQueueReceive(msgQueue, &msg, queueTimeout) == pdTRUE) {
+
+    // let's do otaku chimes
+    uint8_t myHour = dateTimeController.Hours();
+    uint8_t myChimes = 9-(((int)floor(myHour/2))%6);
+
    switch (msg) {
      case Messages::GoToSleep:
      case Messages::GoToAOD:
@@ -473,7 +480,39 @@ void DisplayApp::Refresh() {
        break;
      case Messages::Chime:
        LoadNewScreen(Apps::Clock, DisplayApp::FullRefreshDirections::None);
-        motorController.RunForDuration(35);
+
+        // hour chime
+        // 0    9
+        // 1    9  
+        // 2    8
+        // 3    8  
+        // 4    7
+        // 5    7  
+        // 6    6
+        // 7    6  
+        // 8    5
+        // 9    5  
+        // 10   4
+        // 11   4   
+        // 12   9
+        // 13   9   
+        // 14   8
+        // 15   8   
+        // 16   7
+        // 17   7   
+        // 18   6
+        // 19   6   
+        // 20   5
+        // 21   5   
+        // 22   4
+        // 23   4   
+        // NRF_LOG_INFO("buzzing %d times", myChimes);
+
+        for (uint8_t i=0; i<myChimes; i++){
+          // NRF_LOG_INFO("buzz!");
+          motorController.RunForDuration(15);
+          vTaskDelay(1000);
+        }
        break;
      case Messages::OnChargingEvent:
        motorController.RunForDuration(15);
@@ -612,6 +651,9 @@ void DisplayApp::LoadScreen(Apps app, DisplayApp::FullRefreshDirections directio
    case Apps::SettingSetDateTime:
      currentScreen = std::make_unique<Screens::SettingSetDateTime>(this, dateTimeController, settingsController);
      break;
+    case Apps::SettingLocation:
+      currentScreen = std::make_unique<Screens::SettingLocation>(settingsController);
+      break;
    case Apps::SettingChimes:
      currentScreen = std::make_unique<Screens::SettingChimes>(settingsController);
      break;
--- a/src/displayapp/UserApps.h
+++ b/src/displayapp/UserApps.h
@@ -8,12 +8,14 @@
 #include "displayapp/screens/Twos.h"
 #include "displayapp/screens/Tile.h"
 #include "displayapp/screens/ApplicationList.h"
-#include "displayapp/screens/WatchFaceDigital.h"
+//#include "displayapp/screens/WatchFaceDigital.h"
 #include "displayapp/screens/WatchFaceAnalog.h"
-#include "displayapp/screens/WatchFaceCasioStyleG7710.h"
-#include "displayapp/screens/WatchFaceInfineat.h"
+// #include "displayapp/screens/WatchFaceCasioStyleG7710.h"
+// #include "displayapp/screens/WatchFaceInfineat.h"
 #include "displayapp/screens/WatchFacePineTimeStyle.h"
-#include "displayapp/screens/WatchFaceTerminal.h"
+// #include "displayapp/screens/WatchFaceTerminal.h"
+// #include "displayapp/screens/WatchFaceFuzzy.h"
+// #include "displayapp/screens/WatchFaceSundial.h"

 namespace Pinetime {
  namespace Applications {
--- a/src/displayapp/apps/Apps.h.in
+++ b/src/displayapp/apps/Apps.h.in
@@ -39,6 +39,7 @@ namespace Pinetime {
      SettingWakeUp,
      SettingSteps,
      SettingSetDateTime,
+      SettingLocation,
      SettingChimes,
      SettingShakeThreshold,
      SettingBluetooth,
@@ -46,12 +47,14 @@ namespace Pinetime {
    };

    enum class WatchFace : uint8_t {
-      Digital,
      Analog,
      PineTimeStyle,
+      Digital,
      Terminal,
-      Infineat,
-      CasioStyleG7710,
+      Fuzzy,
+      //Sundial,
+      //Infineat,
+      //CasioStyleG7710,
    };

    template <Apps>
@@ -72,7 +75,9 @@ namespace Pinetime {
      static constexpr size_t Count = sizeof...(Ws);
    };

-    using UserWatchFaceTypes = WatchFaceTypeList<@WATCHFACE_TYPES@>;
+    using UserWatchFaceTypes = WatchFaceTypeList<WatchFace::Analog,
+                                                 WatchFace::PineTimeStyle>;
+    //using UserWatchFaceTypes = WatchFaceTypeList<@WATCHFACE_TYPES@>;

    static_assert(UserWatchFaceTypes::Count >= 1);
  }
--- a/src/displayapp/apps/CMakeLists.txt
+++ b/src/displayapp/apps/CMakeLists.txt
@@ -1,20 +1,14 @@
+#"Apps::Navigation, Apps::StopWatch, Apps::Timer, Apps::Alarm, Apps::Steps, Apps::HeartRate, Apps::Music, Apps::Twos"
+#Apps::Paint, Apps::Metronome, Apps::Paddle
 if(DEFINED ENABLE_USERAPPS)
    set(USERAPP_TYPES ${ENABLE_USERAPPS} CACHE STRING "List of user apps to build into the firmware")
 else ()
    set(DEFAULT_USER_APP_TYPES "Apps::StopWatch")
-    set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Alarm")
    set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Timer")
    set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Steps")
    set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::HeartRate")
    set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Music")
-    set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Paint")
-    set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Paddle")
-    set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Twos")
    set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Dice")
-    set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Metronome")
-    set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Navigation")
-    set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Weather")
-    #set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Motion")
    set(USERAPP_TYPES "${DEFAULT_USER_APP_TYPES}" CACHE STRING "List of user apps to build into the firmware")
 endif ()

@@ -22,11 +16,7 @@ if(DEFINED ENABLE_WATCHFACES)
    set(WATCHFACE_TYPES ${ENABLE_WATCHFACES} CACHE STRING "List of watch faces to build into the firmware")
 else()
    set(DEFAULT_WATCHFACE_TYPES "WatchFace::Digital")
-    set(DEFAULT_WATCHFACE_TYPES "${DEFAULT_WATCHFACE_TYPES}, WatchFace::Analog")
-    set(DEFAULT_WATCHFACE_TYPES "${DEFAULT_WATCHFACE_TYPES}, WatchFace::PineTimeStyle")
-    set(DEFAULT_WATCHFACE_TYPES "${DEFAULT_WATCHFACE_TYPES}, WatchFace::Terminal")
-    set(DEFAULT_WATCHFACE_TYPES "${DEFAULT_WATCHFACE_TYPES}, WatchFace::Infineat")
-    set(DEFAULT_WATCHFACE_TYPES "${DEFAULT_WATCHFACE_TYPES}, WatchFace::CasioStyleG7710")
+    set(DEFAULT_WATCHFACE_TYPES "${DEFAULT_WATCHFACE_TYPES}, WatchFace::Fuzzy")
    set(WATCHFACE_TYPES "${DEFAULT_WATCHFACE_TYPES}" CACHE STRING "List of watch faces to build into the firmware")
 endif()

--- a/src/displayapp/fonts/CMakeLists.txt
+++ b/src/displayapp/fonts/CMakeLists.txt
@@ -1,4 +1,4 @@
-set(FONTS jetbrains_mono_42 jetbrains_mono_76 jetbrains_mono_bold_20 jetbrains_mono_14
+set(FONTS jetbrains_mono_42 noto_serif_cjk_20 noto_serif_cjk_15 jetbrains_mono_76 jetbrains_mono_bold_20 jetbrains_mono_bold_24
   jetbrains_mono_extrabold_compressed lv_font_sys_48
   open_sans_light fontawesome_weathericons)
 find_program(LV_FONT_CONV "lv_font_conv" NO_CACHE REQUIRED
--- a/src/displayapp/fonts/fonts.json
+++ b/src/displayapp/fonts/fonts.json
@@ -1,23 +1,9 @@
 {
-   "jetbrains_mono_14": {
-      "sources": [
-         {
-            "file": "JetBrainsMono-Regular.ttf",
-            "range": "0x20-0x7e, 0x410-0x44f, 0xB0"
-         },
-         {
-            "file": "NotoSerifCJKjp-VF.ttf",
-            "symbols": "大雪"
-         }
-      ],
-      "bpp": 1,
-      "size": 14
-   },
   "jetbrains_mono_bold_20": {
      "sources": [
         {
-            "file": "JetBrainsMono-Bold.ttf",
-            "range": "0x20-0x7e, 0x410-0x44f, 0xB0"
+            "file": "Vulf_Mono-Italic.woff",
+            "range": "0x20-0x7e, 0xB0"
         },
         {
            "file": "FontAwesome5-Solid+Brands+Regular.woff",
@@ -25,18 +11,53 @@
         }
      ],
      "bpp": 1,
-      "size": 20,
-      "patches": ["jetbrains_mono_bold_20.c_zero.patch", "jetbrains_mono_bold_20.c_M.patch"]
+      "size": 18
+   },
+   "jetbrains_mono_bold_24": {
+      "sources": [
+         {
+            "file": "Vulf_Mono-Italic.woff",
+            "range": "0x20-0x7e, 0xB0"
+         },
+         {
+            "file": "FontAwesome5-Solid+Brands+Regular.woff",
+            "range": "0xf294, 0xf242, 0xf54b, 0xf21e, 0xf1e6, 0xf017, 0xf129, 0xf03a, 0xf185, 0xf560, 0xf001, 0xf3fd, 0xf1fc, 0xf45d, 0xf59f, 0xf5a0, 0xf027, 0xf028, 0xf6a9, 0xf04b, 0xf04c, 0xf048, 0xf051, 0xf095, 0xf3dd, 0xf04d, 0xf2f2, 0xf024, 0xf252, 0xf569, 0xf06e, 0xf015, 0xf00c, 0xf0f3, 0xf522, 0xf743"
+         }
+      ],
+      "bpp": 1,
+      "size": 26
+   },
+   "noto_serif_cjk_20": {
+      "sources": [
+         {
+            "file": "NotoSerifCJKjp-VF.ttf",
+            "symbols": "丑寅卯辰巳午未申酉戌亥子四五六七八九"
+         }
+      ],
+      "bpp": 1,
+      "size": 20
+   },
+   "noto_serif_cjk_15": {
+      "sources": [
+         {
+            "file": "NotoSerifCJKjp-VF.ttf",
+            "symbols": "四五六七八九"
+         }
+      ],
+      "bpp": 1,
+      "size": 15
   },
   "jetbrains_mono_42": {
      "sources": [
         {
            "file": "JetBrainsMono-Regular.ttf",
-            "range": "0x25, 0x2b, 0x2d, 0x2e, 0x30-0x3a, 0x43, 0x46, 0x4b-0x4d, 0x66, 0x69, 0x6b, 0x6d, 0x74, 0xb0"
+            "disabledfile": "Vulf Mono Light Italic.ttf",
+            "range": "0x20, 0x25, 0x27, 0x2b, 0x2d, 0x30-0x3a, 0x4b-0x4d, 0x61-0x7a",
+            "disabledrange": "0x25, 0x2b, 0x2d, 0x2e, 0x30-0x3a, 0x43, 0x46, 0x4b-0x4d, 0x66, 0x69, 0x6b, 0x6d, 0x74, 0xb0"
         }
      ],
      "bpp": 1,
-      "size": 42
+      "size": 30
   },
   "jetbrains_mono_76": {
      "sources": [
@@ -68,16 +89,6 @@
      "bpp": 1,
      "size": 150
   },
-   "noto_serif_cjk_14": {
-      "sources": [
-         {
-            "file": "NotoSerifCJKjp-VF.ttf",
-            "symbols": "大雪"
-         }
-      ],
-      "bpp": 1,
-      "size": 14
-   },
   "lv_font_sys_48": {
      "sources": [
         {
--- a/src/displayapp/screens/WatchFaceAnalog.cpp
+++ b/src/displayapp/screens/WatchFaceAnalog.cpp
@@ -1,22 +1,27 @@
 #include "displayapp/screens/WatchFaceAnalog.h"
 #include <cmath>
 #include <lvgl/lvgl.h>
+#include <nrf_log.h>
 #include "displayapp/screens/BatteryIcon.h"
 #include "displayapp/screens/BleIcon.h"
 #include "displayapp/screens/Symbols.h"
 #include "displayapp/screens/NotificationIcon.h"
 #include "components/settings/Settings.h"
 #include "displayapp/InfiniTimeTheme.h"
+#include "sunset/src/sunset.h"

 using namespace Pinetime::Applications::Screens;

 namespace {
-  constexpr int16_t HourLength = 70;
+  int16_t HourLength = 70;
  constexpr int16_t MinuteLength = 90;
  constexpr int16_t SecondLength = 110;
+  constexpr int16_t SunDialVerticalOffset = 40;

  // sin(90) = 1 so the value of _lv_trigo_sin(90) is the scaling factor
  const auto LV_TRIG_SCALE = _lv_trigo_sin(90);
+  const lv_color_t DARK_GRAY = lv_color_make(48, 48, 48);
+  const lv_color_t DARK_ORANGE = lv_color_make(48, 26, 0);

  int16_t Cosine(int16_t angle) {
    return _lv_trigo_sin(angle + 90);
@@ -39,6 +44,41 @@ namespace {
                       .y = CoordinateYRelocate(radius * static_cast<int32_t>(Cosine(angle)) / LV_TRIG_SCALE)};
  }

+  void printKoku(const char* str, uint8_t i, bool big){
+    lv_obj_t* koku = lv_label_create(lv_scr_act(), NULL);
+    lv_label_set_align(koku, LV_LABEL_ALIGN_CENTER);
+    lv_label_set_text(koku, str);
+    lv_point_t pt;
+    if (big) {
+      pt = CoordinateRelocate(LV_HOR_RES/2-20, i*30);
+      lv_obj_set_style_local_text_font(koku, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &noto_serif_cjk_20);
+    } else {
+      pt = CoordinateRelocate(LV_HOR_RES/2-45, i*30);
+      lv_obj_set_style_local_text_font(koku, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &noto_serif_cjk_15);
+    }
+    lv_obj_align(koku, NULL, LV_ALIGN_CENTER, LV_HOR_RES/2-pt.x, LV_HOR_RES/2-pt.y);
+    lv_obj_set_style_local_text_color(koku, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_WHITE);
+  }
+
+  void drawTime(lv_obj_t * obj, uint8_t hour, uint8_t minute, lv_color_t color, uint8_t x, uint8_t y) {
+    lv_label_set_align(obj, LV_LABEL_ALIGN_CENTER);
+    lv_label_set_text_fmt(obj, "%02d:%02d", hour, minute);
+    lv_obj_set_pos(obj, 0, 0);
+    lv_obj_align(obj, NULL, LV_ALIGN_CENTER, x, y);
+    lv_obj_set_style_local_text_color(obj, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color);
+    lv_obj_set_style_local_text_font(obj, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_bold_20);
+  }
+
+  void drawCircle(uint8_t width, bool left, lv_coord_t offset, lv_color_t color){
+    lv_obj_t * cir = lv_obj_create(lv_scr_act(), nullptr);
+    lv_obj_set_size(cir, width, width);
+    if (left)
+      lv_obj_align(cir, nullptr, LV_ALIGN_IN_LEFT_MID, offset, 0);
+    else
+      lv_obj_align(cir, nullptr, LV_ALIGN_IN_RIGHT_MID, offset, 0);
+    lv_obj_set_style_local_bg_color(cir, LV_OBJ_PART_MAIN, LV_STATE_DEFAULT, color);
+    lv_obj_set_style_local_radius(cir, LV_OBJ_PART_MAIN, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);
+  }
 }

 WatchFaceAnalog::WatchFaceAnalog(Controllers::DateTime& dateTimeController,
@@ -58,41 +98,97 @@ WatchFaceAnalog::WatchFaceAnalog(Controllers::DateTime& dateTimeController,
  sMinute = 99;
  sSecond = 99;

-  minor_scales = lv_linemeter_create(lv_scr_act(), nullptr);
-  lv_linemeter_set_scale(minor_scales, 300, 51);
-  lv_linemeter_set_angle_offset(minor_scales, 180);
-  lv_obj_set_size(minor_scales, 240, 240);
-  lv_obj_align(minor_scales, nullptr, LV_ALIGN_CENTER, 0, 0);
-  lv_obj_set_style_local_bg_opa(minor_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
-  lv_obj_set_style_local_scale_width(minor_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 4);
-  lv_obj_set_style_local_scale_end_line_width(minor_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 1);
-  lv_obj_set_style_local_scale_end_color(minor_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GRAY);
+  location = settingsController.GetLocation();

-  major_scales = lv_linemeter_create(lv_scr_act(), nullptr);
-  lv_linemeter_set_scale(major_scales, 300, 11);
-  lv_linemeter_set_angle_offset(major_scales, 180);
-  lv_obj_set_size(major_scales, 240, 240);
-  lv_obj_align(major_scales, nullptr, LV_ALIGN_CENTER, 0, 0);
-  lv_obj_set_style_local_bg_opa(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
-  lv_obj_set_style_local_scale_width(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 6);
-  lv_obj_set_style_local_scale_end_line_width(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 4);
-  lv_obj_set_style_local_scale_end_color(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_WHITE);
+  // begin Japanese watch face
+  if (settingsController.GetClockType() == Controllers::Settings::ClockType::FUZZY) {
+    lv_obj_t * nighttime = lv_obj_create(lv_scr_act(), nullptr);
+    lv_obj_set_size(nighttime, LV_HOR_RES, LV_HOR_RES/2);
+    lv_obj_set_pos(nighttime, 0, 0);
+    lv_obj_set_style_local_bg_color(nighttime, LV_OBJ_PART_MAIN, LV_STATE_DEFAULT, DARK_GRAY);
+    lv_obj_set_style_local_radius(nighttime, LV_OBJ_PART_MAIN, LV_STATE_DEFAULT, 0);

-  large_scales = lv_linemeter_create(lv_scr_act(), nullptr);
-  lv_linemeter_set_scale(large_scales, 180, 3);
-  lv_linemeter_set_angle_offset(large_scales, 180);
-  lv_obj_set_size(large_scales, 240, 240);
-  lv_obj_align(large_scales, nullptr, LV_ALIGN_CENTER, 0, 0);
-  lv_obj_set_style_local_bg_opa(large_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
-  lv_obj_set_style_local_scale_width(large_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 20);
-  lv_obj_set_style_local_scale_end_line_width(large_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 4);
-  lv_obj_set_style_local_scale_end_color(large_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_AQUA);
+    drawCircle(35, true, 4, DARK_GRAY);
+    drawCircle(25, true, 33, DARK_GRAY);
+    drawCircle(35, false, -3, LV_COLOR_BLACK);
+    drawCircle(25, false, -32, LV_COLOR_BLACK);

-  twelve = lv_label_create(lv_scr_act(), nullptr);
-  lv_label_set_align(twelve, LV_LABEL_ALIGN_CENTER);
-  lv_label_set_text_static(twelve, "12");
-  lv_obj_set_pos(twelve, 110, 10);
-  lv_obj_set_style_local_text_color(twelve, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_AQUA);
+    major_scales = lv_linemeter_create(lv_scr_act(), nullptr);
+    lv_linemeter_set_scale(major_scales, 360, 13);
+    lv_linemeter_set_angle_offset(major_scales, 15);
+    lv_obj_set_size(major_scales, 240, 240);
+    lv_obj_align(major_scales, nullptr, LV_ALIGN_CENTER, 0, 0);
+    lv_obj_set_style_local_bg_opa(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
+    lv_obj_set_style_local_scale_width(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 50);
+    lv_obj_set_style_local_scale_end_line_width(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 1);
+    lv_obj_set_style_local_scale_end_color(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_WHITE);
+
+    axis = lv_arc_create(lv_scr_act(), NULL);
+    lv_obj_set_size(axis, 70, 70);
+    lv_arc_set_bg_angles(axis, 0, 360);
+    lv_arc_set_end_angle(axis, 360);
+    lv_obj_align(axis, NULL, LV_ALIGN_CENTER, 0, 0);
+    lv_obj_set_style_local_line_width(axis, LV_ARC_PART_INDIC, LV_STATE_DEFAULT, 40);
+    lv_obj_set_style_local_line_color(axis, LV_ARC_PART_INDIC, LV_STATE_DEFAULT, LV_COLOR_WHITE);
+
+    const char* kokuZodiac[] = {"子","丑","寅","卯","辰","巳","午","未","申","酉","戌","亥"};
+    const char* kokuNums[] = {"九","八","七","六","五","四"};
+
+    twelve = lv_label_create(lv_scr_act(), nullptr);
+
+    for (int i=0;i<12;i++) {
+      printKoku(kokuZodiac[i], i, true);
+      printKoku(kokuNums[i%6], i, false);
+    }
+
+    lv_style_init(&hour_line_style);
+    lv_style_set_line_width(&hour_line_style, LV_STATE_DEFAULT, 10);
+    lv_style_set_line_rounded(&hour_line_style, LV_STATE_DEFAULT, true);
+    lv_style_init(&hour_line_style_trace);
+    lv_style_set_line_width(&hour_line_style_trace, LV_STATE_DEFAULT, 10);
+    lv_style_set_line_rounded(&hour_line_style_trace, LV_STATE_DEFAULT, true);
+  } else {
+    minor_scales = lv_linemeter_create(lv_scr_act(), nullptr);
+    lv_linemeter_set_scale(minor_scales, 300, 51);
+    lv_linemeter_set_angle_offset(minor_scales, 180);
+    lv_obj_set_size(minor_scales, 240, 240);
+    lv_obj_align(minor_scales, nullptr, LV_ALIGN_CENTER, 0, 0);
+    lv_obj_set_style_local_bg_opa(minor_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
+    lv_obj_set_style_local_scale_width(minor_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 4);
+    lv_obj_set_style_local_scale_end_line_width(minor_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 1);
+    lv_obj_set_style_local_scale_end_color(minor_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GRAY);
+
+    major_scales = lv_linemeter_create(lv_scr_act(), nullptr);
+    lv_linemeter_set_scale(major_scales, 300, 11);
+    lv_linemeter_set_angle_offset(major_scales, 180);
+    lv_obj_set_size(major_scales, 240, 240);
+    lv_obj_align(major_scales, nullptr, LV_ALIGN_CENTER, 0, 0);
+    lv_obj_set_style_local_bg_opa(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
+    lv_obj_set_style_local_scale_width(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 6);
+    lv_obj_set_style_local_scale_end_line_width(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 4);
+    lv_obj_set_style_local_scale_end_color(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_WHITE);
+
+    large_scales = lv_linemeter_create(lv_scr_act(), nullptr);
+    lv_linemeter_set_scale(large_scales, 180, 3);
+    lv_linemeter_set_angle_offset(large_scales, 180);
+    lv_obj_set_size(large_scales, 240, 240);
+    lv_obj_align(large_scales, nullptr, LV_ALIGN_CENTER, 0, 0);
+    lv_obj_set_style_local_bg_opa(large_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
+    lv_obj_set_style_local_scale_width(large_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 20);
+    lv_obj_set_style_local_scale_end_line_width(large_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 4);
+    lv_obj_set_style_local_scale_end_color(large_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_AQUA);
+
+    twelve = lv_label_create(lv_scr_act(), nullptr);
+    lv_label_set_align(twelve, LV_LABEL_ALIGN_CENTER);
+    lv_label_set_text_static(twelve, "12");
+    lv_obj_set_pos(twelve, 110, 10);
+    lv_obj_set_style_local_text_color(twelve, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_AQUA);
+  
+    lv_style_init(&hour_line_style);
+    lv_style_set_line_width(&hour_line_style, LV_STATE_DEFAULT, 7);
+    lv_style_init(&hour_line_style_trace);
+    lv_style_set_line_width(&hour_line_style_trace, LV_STATE_DEFAULT, 3);
+  }

  batteryIcon.Create(lv_scr_act());
  lv_obj_align(batteryIcon.GetObject(), nullptr, LV_ALIGN_IN_TOP_RIGHT, 0, 0);
@@ -111,7 +207,6 @@ WatchFaceAnalog::WatchFaceAnalog(Controllers::DateTime& dateTimeController,
  lv_obj_align(notificationIcon, nullptr, LV_ALIGN_IN_TOP_LEFT, 0, 0);

  // Date - Day / Week day
-
  label_date_day = lv_label_create(lv_scr_act(), nullptr);
  lv_obj_set_style_local_text_color(label_date_day, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, Colors::orange);
  lv_label_set_text_fmt(label_date_day, "%s\n%02i", dateTimeController.DayOfWeekShortToString(), dateTimeController.Day());
@@ -142,16 +237,10 @@ WatchFaceAnalog::WatchFaceAnalog(Controllers::DateTime& dateTimeController,
  lv_style_set_line_rounded(&minute_line_style_trace, LV_STATE_DEFAULT, false);
  lv_obj_add_style(minute_body_trace, LV_LINE_PART_MAIN, &minute_line_style_trace);

-  lv_style_init(&hour_line_style);
-  lv_style_set_line_width(&hour_line_style, LV_STATE_DEFAULT, 7);
  lv_style_set_line_color(&hour_line_style, LV_STATE_DEFAULT, LV_COLOR_WHITE);
-  lv_style_set_line_rounded(&hour_line_style, LV_STATE_DEFAULT, true);
  lv_obj_add_style(hour_body, LV_LINE_PART_MAIN, &hour_line_style);

-  lv_style_init(&hour_line_style_trace);
-  lv_style_set_line_width(&hour_line_style_trace, LV_STATE_DEFAULT, 3);
  lv_style_set_line_color(&hour_line_style_trace, LV_STATE_DEFAULT, LV_COLOR_WHITE);
-  lv_style_set_line_rounded(&hour_line_style_trace, LV_STATE_DEFAULT, false);
  lv_obj_add_style(hour_body_trace, LV_LINE_PART_MAIN, &hour_line_style_trace);

  taskRefresh = lv_task_create(RefreshTaskCallback, LV_DISP_DEF_REFR_PERIOD, LV_TASK_PRIO_MID, this);
@@ -171,12 +260,73 @@ WatchFaceAnalog::~WatchFaceAnalog() {
  lv_obj_clean(lv_scr_act());
 }

+
+void WatchFaceAnalog::drawWatchFaceWadokei(){
+  uint8_t hour = dateTimeController.Hours();
+  uint8_t minute = dateTimeController.Minutes();
+
+  if (sHour != hour || sMinute != minute) {
+    sun.setPosition((float)location.latitude, (float)location.longitude, location.tzOffset);
+
+    //from minutes past midnight
+    sun.setCurrentDate(dateTimeController.Year(), static_cast<uint8_t>(dateTimeController.Month())+1, dateTimeController.Day());
+    sun.setTZOffset(location.tzOffset);
+
+    minutesSunrise = sun.calcSunrise();
+    minutesSunset = sun.calcSunset();
+    minutesDaytime = (minutesSunset - minutesSunrise);
+    minutesNighttime = (1440 - minutesDaytime);
+
+    minutesBeforeSunset = minutesSunset - (hour * 60 + minute); // i.e.zero degrees
+    HourLength = 40; // wadokei hand length
+
+    int16_t hourAngle=0;
+    // auto const hourAngle = ((hour * 15 + minute / 2)+180)%360; //24-hr rotation with 0/24 at the bottom
+
+    if(minutesBeforeSunset > minutesDaytime) {
+      hourAngle = -180.0 - 180.0 * (minutesBeforeSunset - minutesDaytime) / minutesNighttime;
+    }
+    else if(minutesBeforeSunset > 0 ) {
+      hourAngle = -180.0 * minutesBeforeSunset / minutesDaytime;
+    }
+    else {
+      hourAngle = -180.0 * minutesBeforeSunset / minutesNighttime;
+    }
+
+    // NRF_LOG_INFO("angle: %d, day: %d, night: %d, bef: %d",
+    //   hourAngle+90,
+    //   minutesDaytime,
+    //   minutesNighttime,
+    //   minutesBeforeSunset);
+
+    sHour = hour;
+    sMinute = minute;
+
+    hour_point_trace[0] = CoordinateRelocate(28, hourAngle+90-66); //axis radius minus line stroke
+    hour_point_trace[1] = CoordinateRelocate(HourLength, hourAngle+90);
+
+    hour_point[0] = CoordinateRelocate(28, hourAngle+90+66); //axis radius minus line stroke
+    hour_point[1] = CoordinateRelocate(HourLength, hourAngle+90);
+
+    lv_line_set_points(hour_body, hour_point, 2);
+    lv_line_set_points(hour_body_trace, hour_point_trace, 2);
+
+    drawTime(twelve, hour, minute, LV_COLOR_BLACK, 0, 0);
+    lv_obj_move_foreground(twelve);
+  }
+}
+
 void WatchFaceAnalog::UpdateClock() {
+  if (settingsController.GetClockType() == Controllers::Settings::ClockType::FUZZY) {
+    drawWatchFaceWadokei();
+    return;
+  }
+
  uint8_t hour = dateTimeController.Hours();
  uint8_t minute = dateTimeController.Minutes();
  uint8_t second = dateTimeController.Seconds();

-  if (sMinute != minute) {
+  if (minute>99 && sMinute != minute) { // disable
    auto const angle = minute * 6;
    minute_point[0] = CoordinateRelocate(30, angle);
    minute_point[1] = CoordinateRelocate(MinuteLength, angle);
@@ -203,7 +353,8 @@ void WatchFaceAnalog::UpdateClock() {
    lv_line_set_points(hour_body_trace, hour_point_trace, 2);
  }

-  if (sSecond != second) {
+
+  if (second>99 && sSecond != second) { // disable
    sSecond = second;
    auto const angle = second * 6;

@@ -256,9 +407,20 @@ void WatchFaceAnalog::Refresh() {
  if (currentDateTime.IsUpdated()) {
    UpdateClock();

-    currentDate = std::chrono::time_point_cast<std::chrono::days>(currentDateTime.Get());
+    currentDate = std::chrono::time_point_cast<days>(currentDateTime.Get());
    if (currentDate.IsUpdated()) {
-      lv_label_set_text_fmt(label_date_day, "%s\n%02i", dateTimeController.DayOfWeekShortToString(), dateTimeController.Day());
+      if (settingsController.GetClockType() == Controllers::Settings::ClockType::FUZZY) {
+        /*char const* MonthsString[] = {"--", "IANUARIUS","FEBRUARIUS","MARTIUS","APRILIS","MARTIUSIUNIUS","QUINTILIS","SEXTILIS","SEPTEMBER","OCTOBER","NOVEMBER","DECEMBER"};
+        char const* DaysString[] = {"--", "LUNAE", "MARTIS", "MERCURII", "IOVIS", "VENERIS", "SATURNI", "SOLIS"};
+        char const* RomanNumeralsString[] = {"--", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XI", "XII"};
+        lv_label_set_text_fmt(label_date_day, "%s\n%s %s",
+          DaysString[static_cast<uint8_t>(dateTimeController.DayOfWeek())],
+          RomanNumeralsString[static_cast<uint8_t>(dateTimeController.Day())],
+          MonthsString[static_cast<uint8_t>(dateTimeController.Month())]);*/
+        lv_obj_align(label_date_day, nullptr, LV_ALIGN_IN_BOTTOM_MID, 0, -2000);
+      } else {
+        lv_label_set_text_fmt(label_date_day, "%s\n%02i", dateTimeController.DayOfWeekShortToString(), dateTimeController.Day());
+      }
    }
  }
 }
--- a/src/displayapp/screens/WatchFaceAnalog.h
+++ b/src/displayapp/screens/WatchFaceAnalog.h
@@ -11,6 +11,7 @@
 #include "components/ble/NotificationManager.h"
 #include "displayapp/screens/BatteryIcon.h"
 #include "utility/DirtyValue.h"
+#include "sunset/src/sunset.h"

 namespace Pinetime {
  namespace Controllers {
@@ -43,12 +44,15 @@ namespace Pinetime {
        Utility::DirtyValue<bool> bleState {};
        Utility::DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds>> currentDateTime;
        Utility::DirtyValue<bool> notificationState {false};
-        Utility::DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::days>> currentDate;
+        using days = std::chrono::duration<int32_t, std::ratio<86400>>; // TODO: days is standard in c++20
+        Utility::DirtyValue<std::chrono::time_point<std::chrono::system_clock, days>> currentDate;

        lv_obj_t* minor_scales;
        lv_obj_t* major_scales;
        lv_obj_t* large_scales;
+        lv_obj_t* one;
        lv_obj_t* twelve;
+        lv_obj_t* axis;

        lv_obj_t* hour_body;
        lv_obj_t* hour_body_trace;
@@ -67,6 +71,7 @@ namespace Pinetime {
        lv_style_t minute_line_style;
        lv_style_t minute_line_style_trace;
        lv_style_t second_line_style;
+        lv_style_t axis_style;

        lv_obj_t* label_date_day;
        lv_obj_t* plugIcon;
@@ -75,12 +80,21 @@ namespace Pinetime {

        BatteryIcon batteryIcon;

+        Controllers::Settings::Location location;
+        SunSet sun;
+        int16_t minutesSunrise;
+        int16_t minutesSunset;
+        int16_t minutesDaytime;
+        int16_t minutesNighttime;
+        int16_t minutesBeforeSunset;
+
        Controllers::DateTime& dateTimeController;
        const Controllers::Battery& batteryController;
        const Controllers::Ble& bleController;
        Controllers::NotificationManager& notificationManager;
        Controllers::Settings& settingsController;

+        void drawWatchFaceWadokei();
        void UpdateClock();
        void SetBatteryIcon();

--- a/src/displayapp/screens/WatchFaceCasioStyleG7710.cpp
+++ b/src/displayapp/screens/WatchFaceCasioStyleG7710.cpp
@@ -1,334 +0,0 @@
-#include "displayapp/screens/WatchFaceCasioStyleG7710.h"
-
-#include <lvgl/lvgl.h>
-#include <cstdio>
-#include "displayapp/screens/BatteryIcon.h"
-#include "displayapp/screens/BleIcon.h"
-#include "displayapp/screens/NotificationIcon.h"
-#include "displayapp/screens/Symbols.h"
-#include "components/battery/BatteryController.h"
-#include "components/ble/BleController.h"
-#include "components/ble/NotificationManager.h"
-#include "components/heartrate/HeartRateController.h"
-#include "components/motion/MotionController.h"
-#include "components/settings/Settings.h"
-using namespace Pinetime::Applications::Screens;
-
-WatchFaceCasioStyleG7710::WatchFaceCasioStyleG7710(Controllers::DateTime& dateTimeController,
-                                                   const Controllers::Battery& batteryController,
-                                                   const Controllers::Ble& bleController,
-                                                   Controllers::NotificationManager& notificatioManager,
-                                                   Controllers::Settings& settingsController,
-                                                   Controllers::HeartRateController& heartRateController,
-                                                   Controllers::MotionController& motionController,
-                                                   Controllers::FS& filesystem)
-  : currentDateTime {{}},
-    batteryIcon(false),
-    dateTimeController {dateTimeController},
-    batteryController {batteryController},
-    bleController {bleController},
-    notificatioManager {notificatioManager},
-    settingsController {settingsController},
-    heartRateController {heartRateController},
-    motionController {motionController} {
-
-  lfs_file f = {};
-  if (filesystem.FileOpen(&f, "/fonts/lv_font_dots_40.bin", LFS_O_RDONLY) >= 0) {
-    filesystem.FileClose(&f);
-    font_dot40 = lv_font_load("F:/fonts/lv_font_dots_40.bin");
-  }
-
-  if (filesystem.FileOpen(&f, "/fonts/7segments_40.bin", LFS_O_RDONLY) >= 0) {
-    filesystem.FileClose(&f);
-    font_segment40 = lv_font_load("F:/fonts/7segments_40.bin");
-  }
-
-  if (filesystem.FileOpen(&f, "/fonts/7segments_115.bin", LFS_O_RDONLY) >= 0) {
-    filesystem.FileClose(&f);
-    font_segment115 = lv_font_load("F:/fonts/7segments_115.bin");
-  }
-
-  label_battery_value = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_align(label_battery_value, lv_scr_act(), LV_ALIGN_IN_TOP_RIGHT, 0, 0);
-  lv_obj_set_style_local_text_color(label_battery_value, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-  lv_label_set_text_static(label_battery_value, "00%");
-
-  batteryIcon.Create(lv_scr_act());
-  batteryIcon.SetColor(color_text);
-  lv_obj_align(batteryIcon.GetObject(), label_battery_value, LV_ALIGN_OUT_LEFT_MID, -5, 0);
-
-  batteryPlug = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(batteryPlug, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-  lv_label_set_text_static(batteryPlug, Symbols::plug);
-  lv_obj_align(batteryPlug, batteryIcon.GetObject(), LV_ALIGN_OUT_LEFT_MID, -5, 0);
-
-  bleIcon = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(bleIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-  lv_label_set_text_static(bleIcon, Symbols::bluetooth);
-  lv_obj_align(bleIcon, batteryPlug, LV_ALIGN_OUT_LEFT_MID, -5, 0);
-
-  notificationIcon = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(notificationIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-  lv_label_set_text_static(notificationIcon, NotificationIcon::GetIcon(false));
-  lv_obj_align(notificationIcon, bleIcon, LV_ALIGN_OUT_LEFT_MID, -5, 0);
-
-  label_day_of_week = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_align(label_day_of_week, lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 10, 64);
-  lv_obj_set_style_local_text_color(label_day_of_week, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-  lv_obj_set_style_local_text_font(label_day_of_week, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, font_dot40);
-  lv_label_set_text_static(label_day_of_week, "SUN");
-
-  label_week_number = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_align(label_week_number, lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 5, 22);
-  lv_obj_set_style_local_text_color(label_week_number, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-  lv_obj_set_style_local_text_font(label_week_number, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, font_dot40);
-  lv_label_set_text_static(label_week_number, "WK26");
-
-  label_day_of_year = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_align(label_day_of_year, lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 100, 30);
-  lv_obj_set_style_local_text_color(label_day_of_year, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-  lv_obj_set_style_local_text_font(label_day_of_year, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, font_segment40);
-  lv_label_set_text_static(label_day_of_year, "181-184");
-
-  lv_style_init(&style_line);
-  lv_style_set_line_width(&style_line, LV_STATE_DEFAULT, 2);
-  lv_style_set_line_color(&style_line, LV_STATE_DEFAULT, color_text);
-  lv_style_set_line_rounded(&style_line, LV_STATE_DEFAULT, true);
-
-  lv_style_init(&style_border);
-  lv_style_set_line_width(&style_border, LV_STATE_DEFAULT, 6);
-  lv_style_set_line_color(&style_border, LV_STATE_DEFAULT, color_text);
-  lv_style_set_line_rounded(&style_border, LV_STATE_DEFAULT, true);
-
-  line_icons = lv_line_create(lv_scr_act(), nullptr);
-  lv_line_set_points(line_icons, line_icons_points, 3);
-  lv_obj_add_style(line_icons, LV_LINE_PART_MAIN, &style_line);
-  lv_obj_align(line_icons, nullptr, LV_ALIGN_IN_TOP_RIGHT, -10, 18);
-
-  line_day_of_week_number = lv_line_create(lv_scr_act(), nullptr);
-  lv_line_set_points(line_day_of_week_number, line_day_of_week_number_points, 4);
-  lv_obj_add_style(line_day_of_week_number, LV_LINE_PART_MAIN, &style_border);
-  lv_obj_align(line_day_of_week_number, nullptr, LV_ALIGN_IN_TOP_LEFT, 0, 8);
-
-  line_day_of_year = lv_line_create(lv_scr_act(), nullptr);
-  lv_line_set_points(line_day_of_year, line_day_of_year_points, 3);
-  lv_obj_add_style(line_day_of_year, LV_LINE_PART_MAIN, &style_line);
-  lv_obj_align(line_day_of_year, nullptr, LV_ALIGN_IN_TOP_RIGHT, 0, 60);
-
-  label_date = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_align(label_date, lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 100, 70);
-  lv_obj_set_style_local_text_color(label_date, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-  lv_obj_set_style_local_text_font(label_date, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, font_segment40);
-  lv_label_set_text_static(label_date, "6-30");
-
-  line_date = lv_line_create(lv_scr_act(), nullptr);
-  lv_line_set_points(line_date, line_date_points, 3);
-  lv_obj_add_style(line_date, LV_LINE_PART_MAIN, &style_line);
-  lv_obj_align(line_date, nullptr, LV_ALIGN_IN_TOP_RIGHT, 0, 100);
-
-  label_time = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(label_time, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-  lv_obj_set_style_local_text_font(label_time, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, font_segment115);
-  lv_obj_align(label_time, lv_scr_act(), LV_ALIGN_CENTER, 0, 40);
-
-  line_time = lv_line_create(lv_scr_act(), nullptr);
-  lv_line_set_points(line_time, line_time_points, 3);
-  lv_obj_add_style(line_time, LV_LINE_PART_MAIN, &style_line);
-  lv_obj_align(line_time, nullptr, LV_ALIGN_IN_BOTTOM_RIGHT, 0, -25);
-
-  label_time_ampm = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(label_time_ampm, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-  lv_label_set_text_static(label_time_ampm, "");
-  lv_obj_align(label_time_ampm, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 5, -5);
-
-  backgroundLabel = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_click(backgroundLabel, true);
-  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, "");
-
-  heartbeatIcon = lv_label_create(lv_scr_act(), nullptr);
-  lv_label_set_text_static(heartbeatIcon, Symbols::heartBeat);
-  lv_obj_set_style_local_text_color(heartbeatIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-  lv_obj_align(heartbeatIcon, lv_scr_act(), LV_ALIGN_IN_BOTTOM_LEFT, 5, -2);
-
-  heartbeatValue = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(heartbeatValue, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-  lv_label_set_text_static(heartbeatValue, "");
-  lv_obj_align(heartbeatValue, heartbeatIcon, LV_ALIGN_OUT_RIGHT_MID, 5, 0);
-
-  stepValue = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(stepValue, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-  lv_label_set_text_static(stepValue, "0");
-  lv_obj_align(stepValue, lv_scr_act(), LV_ALIGN_IN_BOTTOM_RIGHT, -5, -2);
-
-  stepIcon = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(stepIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-  lv_label_set_text_static(stepIcon, Symbols::shoe);
-  lv_obj_align(stepIcon, stepValue, LV_ALIGN_OUT_LEFT_MID, -5, 0);
-
-  taskRefresh = lv_task_create(RefreshTaskCallback, LV_DISP_DEF_REFR_PERIOD, LV_TASK_PRIO_MID, this);
-  Refresh();
-}
-
-WatchFaceCasioStyleG7710::~WatchFaceCasioStyleG7710() {
-  lv_task_del(taskRefresh);
-
-  lv_style_reset(&style_line);
-  lv_style_reset(&style_border);
-
-  if (font_dot40 != nullptr) {
-    lv_font_free(font_dot40);
-  }
-
-  if (font_segment40 != nullptr) {
-    lv_font_free(font_segment40);
-  }
-
-  if (font_segment115 != nullptr) {
-    lv_font_free(font_segment115);
-  }
-
-  lv_obj_clean(lv_scr_act());
-}
-
-void WatchFaceCasioStyleG7710::Refresh() {
-  powerPresent = batteryController.IsPowerPresent();
-  if (powerPresent.IsUpdated()) {
-    lv_label_set_text_static(batteryPlug, BatteryIcon::GetPlugIcon(powerPresent.Get()));
-  }
-
-  batteryPercentRemaining = batteryController.PercentRemaining();
-  if (batteryPercentRemaining.IsUpdated()) {
-    auto batteryPercent = batteryPercentRemaining.Get();
-    batteryIcon.SetBatteryPercentage(batteryPercent);
-    lv_label_set_text_fmt(label_battery_value, "%d%%", batteryPercent);
-  }
-
-  bleState = bleController.IsConnected();
-  bleRadioEnabled = bleController.IsRadioEnabled();
-  if (bleState.IsUpdated() || bleRadioEnabled.IsUpdated()) {
-    lv_label_set_text_static(bleIcon, BleIcon::GetIcon(bleState.Get()));
-  }
-  lv_obj_realign(label_battery_value);
-  lv_obj_realign(batteryIcon.GetObject());
-  lv_obj_realign(batteryPlug);
-  lv_obj_realign(bleIcon);
-  lv_obj_realign(notificationIcon);
-
-  notificationState = notificatioManager.AreNewNotificationsAvailable();
-  if (notificationState.IsUpdated()) {
-    lv_label_set_text_static(notificationIcon, NotificationIcon::GetIcon(notificationState.Get()));
-  }
-
-  currentDateTime = std::chrono::time_point_cast<std::chrono::minutes>(dateTimeController.CurrentDateTime());
-  if (currentDateTime.IsUpdated()) {
-    uint8_t hour = dateTimeController.Hours();
-    uint8_t minute = dateTimeController.Minutes();
-
-    if (settingsController.GetClockType() == Controllers::Settings::ClockType::H12) {
-      char ampmChar[2] = "A";
-      if (hour == 0) {
-        hour = 12;
-      } else if (hour == 12) {
-        ampmChar[0] = 'P';
-      } else if (hour > 12) {
-        hour = hour - 12;
-        ampmChar[0] = 'P';
-      }
-      lv_label_set_text(label_time_ampm, ampmChar);
-      lv_label_set_text_fmt(label_time, "%2d:%02d", hour, minute);
-    } else {
-      lv_label_set_text_fmt(label_time, "%02d:%02d", hour, minute);
-    }
-    lv_obj_realign(label_time);
-
-    currentDate = std::chrono::time_point_cast<std::chrono::days>(currentDateTime.Get());
-    if (currentDate.IsUpdated()) {
-      const char* weekNumberFormat = "%V";
-
-      uint16_t year = dateTimeController.Year();
-      Controllers::DateTime::Months month = dateTimeController.Month();
-      uint8_t day = dateTimeController.Day();
-      int dayOfYear = dateTimeController.DayOfYear();
-      if (settingsController.GetClockType() == Controllers::Settings::ClockType::H24) {
-        // 24h mode: ddmmyyyy, first DOW=Monday;
-        lv_label_set_text_fmt(label_date, "%3d-%2d", day, month);
-        weekNumberFormat = "%V"; // Replaced by the week number of the year (Monday as the first day of the week) as a decimal number
-                                 // [01,53]. If the week containing 1 January has four or more days in the new year, then it is considered
-                                 // week 1. Otherwise, it is the last week of the previous year, and the next week is week 1. Both January
-                                 // 4th and the first Thursday of January are always in week 1. [ tm_year, tm_wday, tm_yday]
-      } else {
-        // 12h mode: mmddyyyy, first DOW=Sunday;
-        lv_label_set_text_fmt(label_date, "%3d-%2d", month, day);
-        weekNumberFormat = "%U"; // Replaced by the week number of the year as a decimal number [00,53]. The first Sunday of January is the
-                                 // first day of week 1; days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday]
-      }
-
-      time_t ttTime =
-        std::chrono::system_clock::to_time_t(std::chrono::time_point_cast<std::chrono::system_clock::duration>(currentDateTime.Get()));
-      tm* tmTime = std::localtime(&ttTime);
-
-      // TODO: When we start using C++20, use std::chrono::year::is_leap
-      int daysInCurrentYear = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 ? 366 : 365;
-      uint16_t daysTillEndOfYearNumber = daysInCurrentYear - dayOfYear;
-
-      char buffer[8];
-      strftime(buffer, 8, weekNumberFormat, tmTime);
-      uint8_t weekNumber = atoi(buffer);
-
-      lv_label_set_text_fmt(label_day_of_week, "%s", dateTimeController.DayOfWeekShortToString());
-      lv_label_set_text_fmt(label_day_of_year, "%3d-%3d", dayOfYear, daysTillEndOfYearNumber);
-      lv_label_set_text_fmt(label_week_number, "WK%02d", weekNumber);
-
-      lv_obj_realign(label_day_of_week);
-      lv_obj_realign(label_day_of_year);
-      lv_obj_realign(label_week_number);
-      lv_obj_realign(label_date);
-    }
-  }
-
-  heartbeat = heartRateController.HeartRate();
-  heartbeatRunning = heartRateController.State() != Controllers::HeartRateController::States::Stopped;
-  if (heartbeat.IsUpdated() || heartbeatRunning.IsUpdated()) {
-    if (heartbeatRunning.Get()) {
-      lv_obj_set_style_local_text_color(heartbeatIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
-      lv_label_set_text_fmt(heartbeatValue, "%d", heartbeat.Get());
-    } else {
-      lv_obj_set_style_local_text_color(heartbeatIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x1B1B1B));
-      lv_label_set_text_static(heartbeatValue, "");
-    }
-
-    lv_obj_realign(heartbeatIcon);
-    lv_obj_realign(heartbeatValue);
-  }
-
-  stepCount = motionController.NbSteps();
-  if (stepCount.IsUpdated()) {
-    lv_label_set_text_fmt(stepValue, "%lu", stepCount.Get());
-    lv_obj_realign(stepValue);
-    lv_obj_realign(stepIcon);
-  }
-}
-
-bool WatchFaceCasioStyleG7710::IsAvailable(Pinetime::Controllers::FS& filesystem) {
-  lfs_file file = {};
-
-  if (filesystem.FileOpen(&file, "/fonts/lv_font_dots_40.bin", LFS_O_RDONLY) < 0) {
-    return false;
-  }
-
-  filesystem.FileClose(&file);
-  if (filesystem.FileOpen(&file, "/fonts/7segments_40.bin", LFS_O_RDONLY) < 0) {
-    return false;
-  }
-
-  filesystem.FileClose(&file);
-  if (filesystem.FileOpen(&file, "/fonts/7segments_115.bin", LFS_O_RDONLY) < 0) {
-    return false;
-  }
-
-  filesystem.FileClose(&file);
-  return true;
-}
--- a/src/displayapp/screens/WatchFaceCasioStyleG7710.h
+++ b/src/displayapp/screens/WatchFaceCasioStyleG7710.h
@@ -1,126 +0,0 @@
-#pragma once
-
-#include <displayapp/screens/BatteryIcon.h>
-#include <lvgl/src/lv_core/lv_obj.h>
-#include <chrono>
-#include <cstdint>
-#include <memory>
-#include <displayapp/Controllers.h>
-#include "displayapp/screens/Screen.h"
-#include "components/datetime/DateTimeController.h"
-#include "components/ble/BleController.h"
-#include "utility/DirtyValue.h"
-#include "displayapp/apps/Apps.h"
-
-namespace Pinetime {
-  namespace Controllers {
-    class Settings;
-    class Battery;
-    class Ble;
-    class NotificationManager;
-    class HeartRateController;
-    class MotionController;
-  }
-
-  namespace Applications {
-    namespace Screens {
-
-      class WatchFaceCasioStyleG7710 : public Screen {
-      public:
-        WatchFaceCasioStyleG7710(Controllers::DateTime& dateTimeController,
-                                 const Controllers::Battery& batteryController,
-                                 const Controllers::Ble& bleController,
-                                 Controllers::NotificationManager& notificatioManager,
-                                 Controllers::Settings& settingsController,
-                                 Controllers::HeartRateController& heartRateController,
-                                 Controllers::MotionController& motionController,
-                                 Controllers::FS& filesystem);
-        ~WatchFaceCasioStyleG7710() override;
-
-        void Refresh() override;
-
-        static bool IsAvailable(Pinetime::Controllers::FS& filesystem);
-
-      private:
-        Utility::DirtyValue<uint8_t> batteryPercentRemaining {};
-        Utility::DirtyValue<bool> powerPresent {};
-        Utility::DirtyValue<bool> bleState {};
-        Utility::DirtyValue<bool> bleRadioEnabled {};
-        Utility::DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::minutes>> currentDateTime {};
-        Utility::DirtyValue<uint32_t> stepCount {};
-        Utility::DirtyValue<uint8_t> heartbeat {};
-        Utility::DirtyValue<bool> heartbeatRunning {};
-        Utility::DirtyValue<bool> notificationState {};
-        Utility::DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::days>> currentDate;
-
-        lv_point_t line_icons_points[3] {{0, 5}, {117, 5}, {122, 0}};
-        lv_point_t line_day_of_week_number_points[4] {{0, 0}, {100, 0}, {95, 95}, {0, 95}};
-        lv_point_t line_day_of_year_points[3] {{0, 5}, {130, 5}, {135, 0}};
-        lv_point_t line_date_points[3] {{0, 5}, {135, 5}, {140, 0}};
-        lv_point_t line_time_points[3] {{0, 0}, {230, 0}, {235, 5}};
-
-        lv_color_t color_text = lv_color_hex(0x98B69A);
-
-        lv_style_t style_line;
-        lv_style_t style_border;
-
-        lv_obj_t* label_time;
-        lv_obj_t* line_time;
-        lv_obj_t* label_time_ampm;
-        lv_obj_t* label_date;
-        lv_obj_t* line_date;
-        lv_obj_t* label_day_of_week;
-        lv_obj_t* label_week_number;
-        lv_obj_t* line_day_of_week_number;
-        lv_obj_t* label_day_of_year;
-        lv_obj_t* line_day_of_year;
-        lv_obj_t* backgroundLabel;
-        lv_obj_t* bleIcon;
-        lv_obj_t* batteryPlug;
-        lv_obj_t* label_battery_value;
-        lv_obj_t* heartbeatIcon;
-        lv_obj_t* heartbeatValue;
-        lv_obj_t* stepIcon;
-        lv_obj_t* stepValue;
-        lv_obj_t* notificationIcon;
-        lv_obj_t* line_icons;
-
-        BatteryIcon batteryIcon;
-
-        Controllers::DateTime& dateTimeController;
-        const Controllers::Battery& batteryController;
-        const Controllers::Ble& bleController;
-        Controllers::NotificationManager& notificatioManager;
-        Controllers::Settings& settingsController;
-        Controllers::HeartRateController& heartRateController;
-        Controllers::MotionController& motionController;
-
-        lv_task_t* taskRefresh;
-        lv_font_t* font_dot40 = nullptr;
-        lv_font_t* font_segment40 = nullptr;
-        lv_font_t* font_segment115 = nullptr;
-      };
-    }
-
-    template <>
-    struct WatchFaceTraits<WatchFace::CasioStyleG7710> {
-      static constexpr WatchFace watchFace = WatchFace::CasioStyleG7710;
-      static constexpr const char* name = "Casio G7710";
-
-      static Screens::Screen* Create(AppControllers& controllers) {
-        return new Screens::WatchFaceCasioStyleG7710(controllers.dateTimeController,
-                                                     controllers.batteryController,
-                                                     controllers.bleController,
-                                                     controllers.notificationManager,
-                                                     controllers.settingsController,
-                                                     controllers.heartRateController,
-                                                     controllers.motionController,
-                                                     controllers.filesystem);
-      };
-
-      static bool IsAvailable(Pinetime::Controllers::FS& filesystem) {
-        return Screens::WatchFaceCasioStyleG7710::IsAvailable(filesystem);
-      }
-    };
-  }
-}
--- a/src/displayapp/screens/WatchFaceDigital.cpp
+++ b/src/displayapp/screens/WatchFaceDigital.cpp
@@ -1,4 +1,4 @@
-#include "displayapp/screens/WatchFaceDigital.h"
+#include "displayapp/screens/WatchFaceFuzzy.h"

 #include <lvgl/lvgl.h>
 #include <cstdio>
@@ -6,8 +6,6 @@
 #include "displayapp/screens/NotificationIcon.h"
 #include "displayapp/screens/Symbols.h"
 #include "displayapp/screens/WeatherSymbols.h"
-#include "components/battery/BatteryController.h"
-#include "components/ble/BleController.h"
 #include "components/ble/NotificationManager.h"
 #include "components/heartrate/HeartRateController.h"
 #include "components/motion/MotionController.h"
@@ -16,24 +14,20 @@

 using namespace Pinetime::Applications::Screens;

-WatchFaceDigital::WatchFaceDigital(Controllers::DateTime& dateTimeController,
-                                   const Controllers::Battery& batteryController,
-                                   const Controllers::Ble& bleController,
-                                   Controllers::NotificationManager& notificationManager,
-                                   Controllers::Settings& settingsController,
-                                   Controllers::HeartRateController& heartRateController,
-                                   Controllers::MotionController& motionController,
-                                   Controllers::SimpleWeatherService& weatherService)
+WatchFaceFuzzy::WatchFaceFuzzy(Controllers::DateTime& dateTimeController,
+                               Controllers::NotificationManager& notificationManager,
+                               Controllers::Settings& settingsController,
+                               Controllers::HeartRateController& heartRateController,
+                               Controllers::MotionController& motionController,
+                               Controllers::SimpleWeatherService& weatherService)
  : currentDateTime {{}},
    dateTimeController {dateTimeController},
    notificationManager {notificationManager},
    settingsController {settingsController},
    heartRateController {heartRateController},
    motionController {motionController},
-    weatherService {weatherService},
-    statusIcons(batteryController, bleController) {
-
-  statusIcons.Create();
+    weatherService {weatherService}
+{

  notificationIcon = lv_label_create(lv_scr_act(), nullptr);
  lv_obj_set_style_local_text_color(notificationIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_LIME);
@@ -57,13 +51,9 @@ WatchFaceDigital::WatchFaceDigital(Controllers::DateTime& dateTimeController,
  lv_obj_set_style_local_text_color(label_date, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x999999));

  label_time = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_font(label_time, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_extrabold_compressed);
-
-  lv_obj_align(label_time, lv_scr_act(), LV_ALIGN_IN_RIGHT_MID, 0, 0);
-
-  label_time_ampm = lv_label_create(lv_scr_act(), nullptr);
-  lv_label_set_text_static(label_time_ampm, "");
-  lv_obj_align(label_time_ampm, lv_scr_act(), LV_ALIGN_IN_RIGHT_MID, -30, -55);
+  lv_obj_set_style_local_text_font(label_time, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_bold_24);
+  lv_label_set_recolor(label_time, true);
+  lv_obj_align(label_time, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 0, 0);

  heartbeatIcon = lv_label_create(lv_scr_act(), nullptr);
  lv_label_set_text_static(heartbeatIcon, Symbols::heartBeat);
@@ -89,14 +79,12 @@ WatchFaceDigital::WatchFaceDigital(Controllers::DateTime& dateTimeController,
  Refresh();
 }

-WatchFaceDigital::~WatchFaceDigital() {
+WatchFaceFuzzy::~WatchFaceFuzzy() {
  lv_task_del(taskRefresh);
  lv_obj_clean(lv_scr_act());
 }

-void WatchFaceDigital::Refresh() {
-  statusIcons.Update();
-
+void WatchFaceFuzzy::Refresh() {
  notificationState = notificationManager.AreNewNotificationsAvailable();
  if (notificationState.IsUpdated()) {
    lv_label_set_text_static(notificationIcon, NotificationIcon::GetIcon(notificationState.Get()));
@@ -108,43 +96,18 @@ void WatchFaceDigital::Refresh() {
    uint8_t hour = dateTimeController.Hours();
    uint8_t minute = dateTimeController.Minutes();

-    if (settingsController.GetClockType() == Controllers::Settings::ClockType::H12) {
-      char ampmChar[3] = "AM";
-      if (hour == 0) {
-        hour = 12;
-      } else if (hour == 12) {
-        ampmChar[0] = 'P';
-      } else if (hour > 12) {
-        hour = hour - 12;
-        ampmChar[0] = 'P';
-      }
-      lv_label_set_text(label_time_ampm, ampmChar);
-      lv_label_set_text_fmt(label_time, "%2d:%02d", hour, minute);
-      lv_obj_align(label_time, lv_scr_act(), LV_ALIGN_IN_RIGHT_MID, 0, 0);
-    } else {
-      lv_label_set_text_fmt(label_time, "%02d:%02d", hour, minute);
-      lv_obj_align(label_time, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
-    }
+    printTimeWords(hour, minute);

-    currentDate = std::chrono::time_point_cast<std::chrono::days>(currentDateTime.Get());
+    currentDateTime = std::chrono::time_point_cast<std::chrono::minutes>(dateTimeController.CurrentDateTime());
    if (currentDate.IsUpdated()) {
      uint16_t year = dateTimeController.Year();
      uint8_t day = dateTimeController.Day();
-      if (settingsController.GetClockType() == Controllers::Settings::ClockType::H24) {
-        lv_label_set_text_fmt(label_date,
-                              "%s %d %s %d",
-                              dateTimeController.DayOfWeekShortToString(),
-                              day,
-                              dateTimeController.MonthShortToString(),
-                              year);
-      } else {
-        lv_label_set_text_fmt(label_date,
-                              "%s %s %d %d",
-                              dateTimeController.DayOfWeekShortToString(),
-                              dateTimeController.MonthShortToString(),
-                              day,
-                              year);
-      }
+      lv_label_set_text_fmt(label_date,
+                            "%s %d %s %d",
+                            dateTimeController.DayOfWeekShortToString(),
+                            day,
+                            dateTimeController.MonthShortToString(),
+                            year);
      lv_obj_realign(label_date);
    }
  }
@@ -191,3 +154,36 @@ void WatchFaceDigital::Refresh() {
    lv_obj_realign(weatherIcon);
  }
 }
+
+char const* WatchFaceFuzzy::mods[] = {"", "five", "ten", "quarter", "twenty", "twenty five", "half"};
+char const* WatchFaceFuzzy::nums[] = {"twelve", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve"};
+
+void WatchFaceFuzzy::printTimeWords(int h, int m) {
+  const char* mod;
+
+  if (m  <= 30) {
+    mod = mods[m / 5];
+  } else {
+    mod = mods[(60-m) / 5];
+  }
+  h  = (h % 12);
+
+  if (m >= 57) {
+    sprintf(timeStr, "#ffffff nearly %s#\n#808080 o' clock#", nums[(h+1) % 12]);
+  }
+  else if (m == 0 || m <= 4) {
+    sprintf(timeStr, "#ffffff %s#\n#808080 o' clock#", nums[h]);
+  }
+
+  else if (m <= 32) {
+    sprintf(timeStr, "#ffffff %s#\n#808080 past# #FFFFFF %s#", mod, nums[h]);
+  }
+
+  else if (m > 32) {
+    sprintf(timeStr, "#ffffff %s#\n#808080 to# #FFFFFF %s#", mod, nums[(h+1) % 12]);
+  }
+
+  printf("%s\n", timeStr);
+  lv_label_set_text(label_time, timeStr);
+  lv_obj_realign(label_time);
+}
--- a/src/displayapp/screens/WatchFaceDigital.h
+++ b/src/displayapp/screens/WatchFaceDigital.h
@@ -12,6 +12,8 @@
 #include "utility/DirtyValue.h"
 #include "displayapp/apps/Apps.h"

+extern lv_font_t jetbrains_mono_bold_24;
+
 namespace Pinetime {
  namespace Controllers {
    class Settings;
@@ -25,17 +27,15 @@ namespace Pinetime {
  namespace Applications {
    namespace Screens {

-      class WatchFaceDigital : public Screen {
+      class WatchFaceFuzzy : public Screen {
      public:
-        WatchFaceDigital(Controllers::DateTime& dateTimeController,
-                         const Controllers::Battery& batteryController,
-                         const Controllers::Ble& bleController,
-                         Controllers::NotificationManager& notificationManager,
-                         Controllers::Settings& settingsController,
-                         Controllers::HeartRateController& heartRateController,
-                         Controllers::MotionController& motionController,
-                         Controllers::SimpleWeatherService& weather);
-        ~WatchFaceDigital() override;
+        WatchFaceFuzzy(Controllers::DateTime& dateTimeController,
+                       Controllers::NotificationManager& notificationManager,
+                       Controllers::Settings& settingsController,
+                       Controllers::HeartRateController& heartRateController,
+                       Controllers::MotionController& motionController,
+                       Controllers::SimpleWeatherService& weather);
+        ~WatchFaceFuzzy() override;

        void Refresh() override;

@@ -53,7 +53,6 @@ namespace Pinetime {
        Utility::DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::days>> currentDate;

        lv_obj_t* label_time;
-        lv_obj_t* label_time_ampm;
        lv_obj_t* label_date;
        lv_obj_t* heartbeatIcon;
        lv_obj_t* heartbeatValue;
@@ -71,24 +70,26 @@ namespace Pinetime {
        Controllers::SimpleWeatherService& weatherService;

        lv_task_t* taskRefresh;
-        Widgets::StatusIcons statusIcons;
+
+        static char const *nums[];
+        static char const *mods[];
+        char timeStr[64];
+        void printTimeWords(int hour, int minute);
      };
    }

    template <>
-    struct WatchFaceTraits<WatchFace::Digital> {
-      static constexpr WatchFace watchFace = WatchFace::Digital;
-      static constexpr const char* name = "Digital face";
+    struct WatchFaceTraits<WatchFace::Fuzzy> {
+      static constexpr WatchFace watchFace = WatchFace::Fuzzy;
+      static constexpr const char* name = "Fuzzy face";

      static Screens::Screen* Create(AppControllers& controllers) {
-        return new Screens::WatchFaceDigital(controllers.dateTimeController,
-                                             controllers.batteryController,
-                                             controllers.bleController,
-                                             controllers.notificationManager,
-                                             controllers.settingsController,
-                                             controllers.heartRateController,
-                                             controllers.motionController,
-                                             *controllers.weatherController);
+        return new Screens::WatchFaceFuzzy(controllers.dateTimeController,
+                                           controllers.notificationManager,
+                                           controllers.settingsController,
+                                           controllers.heartRateController,
+                                           controllers.motionController,
+                                           *controllers.weatherController);
      };

      static bool IsAvailable(Pinetime::Controllers::FS& /*filesystem*/) {
--- a/src/displayapp/screens/WatchFaceInfineat.cpp
+++ b/src/displayapp/screens/WatchFaceInfineat.cpp
@@ -1,509 +0,0 @@
-#include "displayapp/screens/WatchFaceInfineat.h"
-
-#include <lvgl/lvgl.h>
-#include <cstdio>
-#include "displayapp/screens/Symbols.h"
-#include "displayapp/screens/BleIcon.h"
-#include "components/settings/Settings.h"
-#include "components/battery/BatteryController.h"
-#include "components/ble/BleController.h"
-#include "components/ble/NotificationManager.h"
-#include "components/motion/MotionController.h"
-
-using namespace Pinetime::Applications::Screens;
-
-namespace {
-  void event_handler(lv_obj_t* obj, lv_event_t event) {
-    auto* screen = static_cast<WatchFaceInfineat*>(obj->user_data);
-    screen->UpdateSelected(obj, event);
-  }
-
-  enum class colors {
-    orange,
-    blue,
-    green,
-    rainbow,
-    gray,
-    nordBlue,
-    nordGreen,
-  };
-
-  constexpr int nColors = 7; // must match number of colors in InfineatColors
-
-  constexpr int nLines = WatchFaceInfineat::nLines;
-
-  constexpr std::array<lv_color_t, nLines> orangeColors = {LV_COLOR_MAKE(0xfd, 0x87, 0x2b),
-                                                           LV_COLOR_MAKE(0xdb, 0x33, 0x16),
-                                                           LV_COLOR_MAKE(0x6f, 0x10, 0x00),
-                                                           LV_COLOR_MAKE(0xfd, 0x7a, 0x0a),
-                                                           LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                           LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                           LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                           LV_COLOR_MAKE(0xe8, 0x51, 0x02),
-                                                           LV_COLOR_MAKE(0xea, 0x1c, 0x00)};
-  constexpr std::array<lv_color_t, nLines> blueColors = {LV_COLOR_MAKE(0xe7, 0xf8, 0xff),
-                                                         LV_COLOR_MAKE(0x22, 0x32, 0xd0),
-                                                         LV_COLOR_MAKE(0x18, 0x2a, 0x8b),
-                                                         LV_COLOR_MAKE(0xe7, 0xf8, 0xff),
-                                                         LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                         LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                         LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                         LV_COLOR_MAKE(0x59, 0x91, 0xff),
-                                                         LV_COLOR_MAKE(0x16, 0x36, 0xff)};
-  constexpr std::array<lv_color_t, nLines> greenColors = {LV_COLOR_MAKE(0xb8, 0xff, 0x9b),
-                                                          LV_COLOR_MAKE(0x08, 0x86, 0x08),
-                                                          LV_COLOR_MAKE(0x00, 0x4a, 0x00),
-                                                          LV_COLOR_MAKE(0xb8, 0xff, 0x9b),
-                                                          LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                          LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                          LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                          LV_COLOR_MAKE(0x62, 0xd5, 0x15),
-                                                          LV_COLOR_MAKE(0x00, 0x74, 0x00)};
-  constexpr std::array<lv_color_t, nLines> rainbowColors = {LV_COLOR_MAKE(0x2d, 0xa4, 0x00),
-                                                            LV_COLOR_MAKE(0xac, 0x09, 0xc4),
-                                                            LV_COLOR_MAKE(0xfe, 0x03, 0x03),
-                                                            LV_COLOR_MAKE(0x0d, 0x57, 0xff),
-                                                            LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                            LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                            LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                            LV_COLOR_MAKE(0xe0, 0xb9, 0x00),
-                                                            LV_COLOR_MAKE(0xe8, 0x51, 0x02)};
-  constexpr std::array<lv_color_t, nLines> grayColors = {LV_COLOR_MAKE(0xee, 0xee, 0xee),
-                                                         LV_COLOR_MAKE(0x98, 0x95, 0x9b),
-                                                         LV_COLOR_MAKE(0x19, 0x19, 0x19),
-                                                         LV_COLOR_MAKE(0xee, 0xee, 0xee),
-                                                         LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                         LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                         LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                         LV_COLOR_MAKE(0x91, 0x91, 0x91),
-                                                         LV_COLOR_MAKE(0x3a, 0x3a, 0x3a)};
-  constexpr std::array<lv_color_t, nLines> nordBlueColors = {LV_COLOR_MAKE(0xc3, 0xda, 0xf2),
-                                                             LV_COLOR_MAKE(0x4d, 0x78, 0xce),
-                                                             LV_COLOR_MAKE(0x15, 0x34, 0x51),
-                                                             LV_COLOR_MAKE(0xc3, 0xda, 0xf2),
-                                                             LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                             LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                             LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                             LV_COLOR_MAKE(0x5d, 0x8a, 0xd2),
-                                                             LV_COLOR_MAKE(0x21, 0x51, 0x8a)};
-  constexpr std::array<lv_color_t, nLines> nordGreenColors = {LV_COLOR_MAKE(0xd5, 0xf0, 0xe9),
-                                                              LV_COLOR_MAKE(0x23, 0x83, 0x73),
-                                                              LV_COLOR_MAKE(0x1d, 0x41, 0x3f),
-                                                              LV_COLOR_MAKE(0xd5, 0xf0, 0xe9),
-                                                              LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                              LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                              LV_COLOR_MAKE(0xff, 0xff, 0xff),
-                                                              LV_COLOR_MAKE(0x2f, 0xb8, 0xa2),
-                                                              LV_COLOR_MAKE(0x11, 0x70, 0x5a)};
-
-  constexpr const std::array<lv_color_t, nLines>* returnColor(colors color) {
-    if (color == colors::orange) {
-      return &orangeColors;
-    }
-    if (color == colors::blue) {
-      return &blueColors;
-    }
-    if (color == colors::green) {
-      return &greenColors;
-    }
-    if (color == colors::rainbow) {
-      return &rainbowColors;
-    }
-    if (color == colors::gray) {
-      return &grayColors;
-    }
-    if (color == colors::nordBlue) {
-      return &nordBlueColors;
-    }
-    return &nordGreenColors;
-  }
-}
-
-WatchFaceInfineat::WatchFaceInfineat(Controllers::DateTime& dateTimeController,
-                                     const Controllers::Battery& batteryController,
-                                     const Controllers::Ble& bleController,
-                                     Controllers::NotificationManager& notificationManager,
-                                     Controllers::Settings& settingsController,
-                                     Controllers::MotionController& motionController,
-                                     Controllers::FS& filesystem)
-  : currentDateTime {{}},
-    dateTimeController {dateTimeController},
-    batteryController {batteryController},
-    bleController {bleController},
-    notificationManager {notificationManager},
-    settingsController {settingsController},
-    motionController {motionController} {
-  lfs_file f = {};
-  if (filesystem.FileOpen(&f, "/fonts/teko.bin", LFS_O_RDONLY) >= 0) {
-    filesystem.FileClose(&f);
-    font_teko = lv_font_load("F:/fonts/teko.bin");
-  }
-
-  if (filesystem.FileOpen(&f, "/fonts/bebas.bin", LFS_O_RDONLY) >= 0) {
-    filesystem.FileClose(&f);
-    font_bebas = lv_font_load("F:/fonts/bebas.bin");
-  }
-
-  // Side Cover
-  static constexpr lv_point_t linePoints[nLines][2] = {{{30, 25}, {68, -8}},
-                                                       {{26, 167}, {43, 216}},
-                                                       {{27, 40}, {27, 196}},
-                                                       {{12, 182}, {65, 249}},
-                                                       {{17, 99}, {17, 144}},
-                                                       {{14, 81}, {40, 127}},
-                                                       {{14, 163}, {40, 118}},
-                                                       {{-20, 124}, {25, -11}},
-                                                       {{-29, 89}, {27, 254}}};
-
-  static constexpr lv_style_int_t lineWidths[nLines] = {18, 15, 14, 22, 20, 18, 18, 52, 48};
-
-  const std::array<lv_color_t, nLines>* colors = returnColor(static_cast<enum colors>(settingsController.GetInfineatColorIndex()));
-  for (int i = 0; i < nLines; i++) {
-    lines[i] = lv_line_create(lv_scr_act(), nullptr);
-    lv_obj_set_style_local_line_width(lines[i], LV_LINE_PART_MAIN, LV_STATE_DEFAULT, lineWidths[i]);
-    lv_color_t color = (*colors)[i];
-    lv_obj_set_style_local_line_color(lines[i], LV_LINE_PART_MAIN, LV_STATE_DEFAULT, color);
-    lv_line_set_points(lines[i], linePoints[i], 2);
-  }
-
-  logoPine = lv_img_create(lv_scr_act(), nullptr);
-  lv_img_set_src(logoPine, "F:/images/pine_small.bin");
-  lv_obj_set_pos(logoPine, 15, 106);
-
-  lineBattery = lv_line_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_line_width(lineBattery, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, 24);
-  lv_obj_set_style_local_line_color(lineBattery, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, (*colors)[4]);
-  lv_obj_set_style_local_line_opa(lineBattery, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, 190);
-  lineBatteryPoints[0] = {27, 105};
-  lineBatteryPoints[1] = {27, 106};
-  lv_line_set_points(lineBattery, lineBatteryPoints, 2);
-  lv_obj_move_foreground(lineBattery);
-
-  notificationIcon = lv_obj_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_bg_color(notificationIcon, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, (*colors)[7]);
-  lv_obj_set_style_local_radius(notificationIcon, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);
-  lv_obj_set_size(notificationIcon, 13, 13);
-  lv_obj_set_hidden(notificationIcon, true);
-
-  if (!settingsController.GetInfineatShowSideCover()) {
-    ToggleBatteryIndicatorColor(false);
-    for (auto& line : lines) {
-      lv_obj_set_hidden(line, true);
-    }
-  }
-
-  timeContainer = lv_obj_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_bg_opa(timeContainer, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
-  lv_obj_set_size(timeContainer, 185, 185);
-  lv_obj_align(timeContainer, lv_scr_act(), LV_ALIGN_CENTER, 0, -10);
-
-  labelHour = lv_label_create(lv_scr_act(), nullptr);
-  lv_label_set_text_static(labelHour, "01");
-  lv_obj_set_style_local_text_font(labelHour, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, font_bebas);
-  lv_obj_align(labelHour, timeContainer, LV_ALIGN_IN_TOP_MID, 0, 0);
-
-  labelMinutes = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_font(labelMinutes, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, font_bebas);
-  lv_label_set_text_static(labelMinutes, "00");
-  lv_obj_align(labelMinutes, timeContainer, LV_ALIGN_IN_BOTTOM_MID, 0, 0);
-
-  labelTimeAmPm = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_font(labelTimeAmPm, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, font_teko);
-
-  lv_label_set_text_static(labelTimeAmPm, "");
-  lv_obj_align(labelTimeAmPm, timeContainer, LV_ALIGN_OUT_RIGHT_TOP, 0, 15);
-
-  dateContainer = lv_obj_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_bg_opa(dateContainer, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
-  lv_obj_set_size(dateContainer, 60, 30);
-  lv_obj_align(dateContainer, lv_scr_act(), LV_ALIGN_IN_RIGHT_MID, 0, 5);
-
-  static constexpr lv_color_t grayColor = LV_COLOR_MAKE(0x99, 0x99, 0x99);
-  labelDate = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(labelDate, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, grayColor);
-  lv_obj_set_style_local_text_font(labelDate, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, font_teko);
-  lv_obj_align(labelDate, dateContainer, LV_ALIGN_IN_TOP_MID, 0, 0);
-  lv_label_set_text_static(labelDate, "Mon 01");
-
-  bleIcon = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(bleIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, grayColor);
-  lv_label_set_text_static(bleIcon, Symbols::bluetooth);
-  lv_obj_align(bleIcon, dateContainer, LV_ALIGN_OUT_BOTTOM_MID, 0, 0);
-
-  stepValue = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(stepValue, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, grayColor);
-  lv_obj_set_style_local_text_font(stepValue, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, font_teko);
-  lv_obj_align(stepValue, lv_scr_act(), LV_ALIGN_IN_BOTTOM_RIGHT, 10, 0);
-  lv_label_set_text_static(stepValue, "0");
-
-  stepIcon = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(stepIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, grayColor);
-  lv_label_set_text_static(stepIcon, Symbols::shoe);
-  lv_obj_align(stepIcon, stepValue, LV_ALIGN_OUT_LEFT_MID, -5, 0);
-
-  // Setting buttons
-  btnClose = lv_btn_create(lv_scr_act(), nullptr);
-  btnClose->user_data = this;
-  lv_obj_set_size(btnClose, 60, 60);
-  lv_obj_align(btnClose, lv_scr_act(), LV_ALIGN_CENTER, 0, -80);
-  lv_obj_set_style_local_bg_opa(btnClose, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_70);
-  lv_obj_t* lblClose = lv_label_create(btnClose, nullptr);
-  lv_label_set_text_static(lblClose, "X");
-  lv_obj_set_event_cb(btnClose, event_handler);
-  lv_obj_set_hidden(btnClose, true);
-
-  btnNextColor = lv_btn_create(lv_scr_act(), nullptr);
-  btnNextColor->user_data = this;
-  lv_obj_set_size(btnNextColor, 60, 60);
-  lv_obj_align(btnNextColor, lv_scr_act(), LV_ALIGN_IN_RIGHT_MID, -15, 0);
-  lv_obj_set_style_local_bg_opa(btnNextColor, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_70);
-  lv_obj_t* lblNextColor = lv_label_create(btnNextColor, nullptr);
-  lv_label_set_text_static(lblNextColor, ">");
-  lv_obj_set_event_cb(btnNextColor, event_handler);
-  lv_obj_set_hidden(btnNextColor, true);
-
-  btnPrevColor = lv_btn_create(lv_scr_act(), nullptr);
-  btnPrevColor->user_data = this;
-  lv_obj_set_size(btnPrevColor, 60, 60);
-  lv_obj_align(btnPrevColor, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 15, 0);
-  lv_obj_set_style_local_bg_opa(btnPrevColor, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_70);
-  lv_obj_t* lblPrevColor = lv_label_create(btnPrevColor, nullptr);
-  lv_label_set_text_static(lblPrevColor, "<");
-  lv_obj_set_event_cb(btnPrevColor, event_handler);
-  lv_obj_set_hidden(btnPrevColor, true);
-
-  btnToggleCover = lv_btn_create(lv_scr_act(), nullptr);
-  btnToggleCover->user_data = this;
-  lv_obj_set_size(btnToggleCover, 60, 60);
-  lv_obj_align(btnToggleCover, lv_scr_act(), LV_ALIGN_CENTER, 0, 80);
-  lv_obj_set_style_local_bg_opa(btnToggleCover, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_70);
-  const char* labelToggle = settingsController.GetInfineatShowSideCover() ? "ON" : "OFF";
-  lblToggle = lv_label_create(btnToggleCover, nullptr);
-  lv_label_set_text_static(lblToggle, labelToggle);
-  lv_obj_set_event_cb(btnToggleCover, event_handler);
-  lv_obj_set_hidden(btnToggleCover, true);
-
-  // Button to access the settings
-  btnSettings = lv_btn_create(lv_scr_act(), nullptr);
-  btnSettings->user_data = this;
-  lv_obj_set_size(btnSettings, 150, 150);
-  lv_obj_align(btnSettings, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
-  lv_obj_set_style_local_radius(btnSettings, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, 30);
-  lv_obj_set_style_local_bg_opa(btnSettings, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_70);
-  lv_obj_set_event_cb(btnSettings, event_handler);
-  labelBtnSettings = lv_label_create(btnSettings, nullptr);
-  lv_obj_set_style_local_text_font(labelBtnSettings, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &lv_font_sys_48);
-  lv_label_set_text_static(labelBtnSettings, Symbols::settings);
-  lv_obj_set_hidden(btnSettings, true);
-
-  taskRefresh = lv_task_create(RefreshTaskCallback, LV_DISP_DEF_REFR_PERIOD, LV_TASK_PRIO_MID, this);
-  Refresh();
-}
-
-WatchFaceInfineat::~WatchFaceInfineat() {
-  lv_task_del(taskRefresh);
-
-  if (font_bebas != nullptr) {
-    lv_font_free(font_bebas);
-  }
-  if (font_teko != nullptr) {
-    lv_font_free(font_teko);
-  }
-
-  lv_obj_clean(lv_scr_act());
-}
-
-bool WatchFaceInfineat::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
-  if ((event == Pinetime::Applications::TouchEvents::LongTap) && lv_obj_get_hidden(btnSettings)) {
-    lv_obj_set_hidden(btnSettings, false);
-    savedTick = lv_tick_get();
-    return true;
-  }
-  // Prevent screen from sleeping when double tapping with settings on
-  if ((event == Pinetime::Applications::TouchEvents::DoubleTap) && !lv_obj_get_hidden(btnClose)) {
-    return true;
-  }
-  return false;
-}
-
-void WatchFaceInfineat::CloseMenu() {
-  settingsController.SaveSettings();
-  lv_obj_set_hidden(btnClose, true);
-  lv_obj_set_hidden(btnNextColor, true);
-  lv_obj_set_hidden(btnPrevColor, true);
-  lv_obj_set_hidden(btnToggleCover, true);
-}
-
-bool WatchFaceInfineat::OnButtonPushed() {
-  if (!lv_obj_get_hidden(btnClose)) {
-    CloseMenu();
-    return true;
-  }
-  return false;
-}
-
-void WatchFaceInfineat::UpdateSelected(lv_obj_t* object, lv_event_t event) {
-  if (event == LV_EVENT_CLICKED) {
-    bool showSideCover = settingsController.GetInfineatShowSideCover();
-    int colorIndex = settingsController.GetInfineatColorIndex();
-
-    if (object == btnSettings) {
-      lv_obj_set_hidden(btnSettings, true);
-      lv_obj_set_hidden(btnClose, false);
-      lv_obj_set_hidden(btnNextColor, !showSideCover);
-      lv_obj_set_hidden(btnPrevColor, !showSideCover);
-      lv_obj_set_hidden(btnToggleCover, false);
-    }
-    if (object == btnClose) {
-      CloseMenu();
-    }
-    if (object == btnToggleCover) {
-      settingsController.SetInfineatShowSideCover(!showSideCover);
-      ToggleBatteryIndicatorColor(!showSideCover);
-      for (auto& line : lines) {
-        lv_obj_set_hidden(line, showSideCover);
-      }
-      lv_obj_set_hidden(btnNextColor, showSideCover);
-      lv_obj_set_hidden(btnPrevColor, showSideCover);
-      const char* labelToggle = showSideCover ? "OFF" : "ON";
-      lv_label_set_text_static(lblToggle, labelToggle);
-    }
-    if (object == btnNextColor) {
-      colorIndex = (colorIndex + 1) % nColors;
-      settingsController.SetInfineatColorIndex(colorIndex);
-    }
-    if (object == btnPrevColor) {
-      colorIndex -= 1;
-      if (colorIndex < 0)
-        colorIndex = nColors - 1;
-      settingsController.SetInfineatColorIndex(colorIndex);
-    }
-    if (object == btnNextColor || object == btnPrevColor) {
-      const std::array<lv_color_t, nLines>* colors = returnColor(static_cast<enum colors>(settingsController.GetInfineatColorIndex()));
-      for (int i = 0; i < nLines; i++) {
-        lv_color_t color = (*colors)[i];
-        lv_obj_set_style_local_line_color(lines[i], LV_LINE_PART_MAIN, LV_STATE_DEFAULT, color);
-      }
-      lv_obj_set_style_local_line_color(lineBattery, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, (*colors)[4]);
-      lv_obj_set_style_local_bg_color(notificationIcon, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, (*colors)[7]);
-    }
-  }
-}
-
-void WatchFaceInfineat::Refresh() {
-  notificationState = notificationManager.AreNewNotificationsAvailable();
-  if (notificationState.IsUpdated()) {
-    lv_obj_set_hidden(notificationIcon, !notificationState.Get());
-    lv_obj_align(notificationIcon, lv_scr_act(), LV_ALIGN_IN_TOP_RIGHT, 0, 0);
-  }
-
-  currentDateTime = std::chrono::time_point_cast<std::chrono::minutes>(dateTimeController.CurrentDateTime());
-  if (currentDateTime.IsUpdated()) {
-    uint8_t hour = dateTimeController.Hours();
-    uint8_t minute = dateTimeController.Minutes();
-
-    if (settingsController.GetClockType() == Controllers::Settings::ClockType::H12) {
-      char ampmChar[3] = "AM";
-      if (hour == 0) {
-        hour = 12;
-      } else if (hour == 12) {
-        ampmChar[0] = 'P';
-      } else if (hour > 12) {
-        hour = hour - 12;
-        ampmChar[0] = 'P';
-      }
-      lv_label_set_text(labelTimeAmPm, ampmChar);
-    }
-    lv_label_set_text_fmt(labelHour, "%02d", hour);
-    lv_label_set_text_fmt(labelMinutes, "%02d", minute);
-
-    if (settingsController.GetClockType() == Controllers::Settings::ClockType::H12) {
-      lv_obj_align(labelTimeAmPm, timeContainer, LV_ALIGN_OUT_RIGHT_TOP, 0, 10);
-      lv_obj_align(labelHour, timeContainer, LV_ALIGN_IN_TOP_MID, 0, 5);
-      lv_obj_align(labelMinutes, timeContainer, LV_ALIGN_IN_BOTTOM_MID, 0, 0);
-    }
-
-    currentDate = std::chrono::time_point_cast<std::chrono::days>(currentDateTime.Get());
-    if (currentDate.IsUpdated()) {
-      uint8_t day = dateTimeController.Day();
-      Controllers::DateTime::Days dayOfWeek = dateTimeController.DayOfWeek();
-      lv_label_set_text_fmt(labelDate, "%s %02d", dateTimeController.DayOfWeekShortToStringLow(dayOfWeek), day);
-      lv_obj_realign(labelDate);
-    }
-  }
-
-  batteryPercentRemaining = batteryController.PercentRemaining();
-  isCharging = batteryController.IsCharging();
-  if (batteryController.IsCharging()) { // Charging battery animation
-    chargingBatteryPercent += 1;
-    if (chargingBatteryPercent > 100) {
-      chargingBatteryPercent = batteryPercentRemaining.Get();
-    }
-    SetBatteryLevel(chargingBatteryPercent);
-  } else if (isCharging.IsUpdated() || batteryPercentRemaining.IsUpdated()) {
-    chargingBatteryPercent = batteryPercentRemaining.Get();
-    SetBatteryLevel(chargingBatteryPercent);
-  }
-
-  bleState = bleController.IsConnected();
-  bleRadioEnabled = bleController.IsRadioEnabled();
-  if (bleState.IsUpdated()) {
-    lv_label_set_text_static(bleIcon, BleIcon::GetIcon(bleState.Get()));
-    lv_obj_align(bleIcon, dateContainer, LV_ALIGN_OUT_BOTTOM_MID, 0, 3);
-  }
-
-  stepCount = motionController.NbSteps();
-  if (stepCount.IsUpdated()) {
-    lv_label_set_text_fmt(stepValue, "%lu", stepCount.Get());
-    lv_obj_align(stepValue, lv_scr_act(), LV_ALIGN_IN_BOTTOM_MID, 10, 0);
-    lv_obj_align(stepIcon, stepValue, LV_ALIGN_OUT_LEFT_MID, -5, 0);
-  }
-
-  if (!lv_obj_get_hidden(btnSettings)) {
-    if ((savedTick > 0) && (lv_tick_get() - savedTick > 3000)) {
-      lv_obj_set_hidden(btnSettings, true);
-      savedTick = 0;
-    }
-  }
-}
-
-void WatchFaceInfineat::SetBatteryLevel(uint8_t batteryPercent) {
-  // starting point (y) + Pine64 logo height * (100 - batteryPercent) / 100
-  lineBatteryPoints[1] = {27, static_cast<lv_coord_t>(105 + 32 * (100 - batteryPercent) / 100)};
-  lv_line_set_points(lineBattery, lineBatteryPoints, 2);
-}
-
-void WatchFaceInfineat::ToggleBatteryIndicatorColor(bool showSideCover) {
-  if (!showSideCover) { // make indicator and notification icon color white
-    lv_obj_set_style_local_image_recolor_opa(logoPine, LV_IMG_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_100);
-    lv_obj_set_style_local_image_recolor(logoPine, LV_IMG_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_WHITE);
-    lv_obj_set_style_local_line_color(lineBattery, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_BLACK);
-    lv_obj_set_style_local_bg_color(notificationIcon, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_WHITE);
-  } else {
-    lv_obj_set_style_local_image_recolor_opa(logoPine, LV_IMG_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_0);
-    const std::array<lv_color_t, nLines>* colors = returnColor(static_cast<enum colors>(settingsController.GetInfineatColorIndex()));
-    lv_obj_set_style_local_line_color(lineBattery, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, (*colors)[4]);
-    lv_obj_set_style_local_bg_color(notificationIcon, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, (*colors)[7]);
-  }
-}
-
-bool WatchFaceInfineat::IsAvailable(Pinetime::Controllers::FS& filesystem) {
-  lfs_file file = {};
-
-  if (filesystem.FileOpen(&file, "/fonts/teko.bin", LFS_O_RDONLY) < 0) {
-    return false;
-  }
-
-  filesystem.FileClose(&file);
-  if (filesystem.FileOpen(&file, "/fonts/bebas.bin", LFS_O_RDONLY) < 0) {
-    return false;
-  }
-
-  filesystem.FileClose(&file);
-  if (filesystem.FileOpen(&file, "/images/pine_small.bin", LFS_O_RDONLY) < 0) {
-    return false;
-  }
-
-  filesystem.FileClose(&file);
-  return true;
-}
--- a/src/displayapp/screens/WatchFaceInfineat.h
+++ b/src/displayapp/screens/WatchFaceInfineat.h
@@ -1,123 +0,0 @@
-#pragma once
-
-#include <lvgl/lvgl.h>
-#include <chrono>
-#include <cstdint>
-#include <memory>
-#include <displayapp/Controllers.h>
-#include "displayapp/screens/Screen.h"
-#include "components/datetime/DateTimeController.h"
-#include "utility/DirtyValue.h"
-#include "displayapp/apps/Apps.h"
-
-namespace Pinetime {
-  namespace Controllers {
-    class Settings;
-    class Battery;
-    class Ble;
-    class NotificationManager;
-    class MotionController;
-  }
-
-  namespace Applications {
-    namespace Screens {
-
-      class WatchFaceInfineat : public Screen {
-      public:
-        static constexpr int nLines = 9;
-        WatchFaceInfineat(Controllers::DateTime& dateTimeController,
-                          const Controllers::Battery& batteryController,
-                          const Controllers::Ble& bleController,
-                          Controllers::NotificationManager& notificationManager,
-                          Controllers::Settings& settingsController,
-                          Controllers::MotionController& motionController,
-                          Controllers::FS& fs);
-
-        ~WatchFaceInfineat() override;
-
-        bool OnTouchEvent(TouchEvents event) override;
-        bool OnButtonPushed() override;
-        void UpdateSelected(lv_obj_t* object, lv_event_t event);
-        void CloseMenu();
-
-        void Refresh() override;
-
-        static bool IsAvailable(Pinetime::Controllers::FS& filesystem);
-
-      private:
-        uint32_t savedTick = 0;
-        uint8_t chargingBatteryPercent = 101; // not a mistake ;)
-
-        Utility::DirtyValue<uint8_t> batteryPercentRemaining {};
-        Utility::DirtyValue<bool> isCharging {};
-        Utility::DirtyValue<bool> bleState {};
-        Utility::DirtyValue<bool> bleRadioEnabled {};
-        Utility::DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::minutes>> currentDateTime {};
-        Utility::DirtyValue<uint32_t> stepCount {};
-        Utility::DirtyValue<bool> notificationState {};
-        Utility::DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::days>> currentDate;
-
-        // Lines making up the side cover
-        lv_obj_t* lineBattery;
-
-        lv_point_t lineBatteryPoints[2];
-
-        lv_obj_t* logoPine;
-
-        lv_obj_t* timeContainer;
-        lv_obj_t* labelHour;
-        lv_obj_t* labelMinutes;
-        lv_obj_t* labelTimeAmPm;
-        lv_obj_t* dateContainer;
-        lv_obj_t* labelDate;
-        lv_obj_t* bleIcon;
-        lv_obj_t* stepIcon;
-        lv_obj_t* stepValue;
-        lv_obj_t* notificationIcon;
-        lv_obj_t* btnClose;
-        lv_obj_t* btnNextColor;
-        lv_obj_t* btnToggleCover;
-        lv_obj_t* btnPrevColor;
-        lv_obj_t* btnSettings;
-        lv_obj_t* labelBtnSettings;
-        lv_obj_t* lblToggle;
-
-        lv_obj_t* lines[nLines];
-
-        Controllers::DateTime& dateTimeController;
-        const Controllers::Battery& batteryController;
-        const Controllers::Ble& bleController;
-        Controllers::NotificationManager& notificationManager;
-        Controllers::Settings& settingsController;
-        Controllers::MotionController& motionController;
-
-        void SetBatteryLevel(uint8_t batteryPercent);
-        void ToggleBatteryIndicatorColor(bool showSideCover);
-
-        lv_task_t* taskRefresh;
-        lv_font_t* font_teko = nullptr;
-        lv_font_t* font_bebas = nullptr;
-      };
-    }
-
-    template <>
-    struct WatchFaceTraits<WatchFace::Infineat> {
-      static constexpr WatchFace watchFace = WatchFace::Infineat;
-      static constexpr const char* name = "Infineat face";
-
-      static Screens::Screen* Create(AppControllers& controllers) {
-        return new Screens::WatchFaceInfineat(controllers.dateTimeController,
-                                              controllers.batteryController,
-                                              controllers.bleController,
-                                              controllers.notificationManager,
-                                              controllers.settingsController,
-                                              controllers.motionController,
-                                              controllers.filesystem);
-      };
-
-      static bool IsAvailable(Pinetime::Controllers::FS& filesystem) {
-        return Screens::WatchFaceInfineat::IsAvailable(filesystem);
-      }
-    };
-  }
-}
--- a/src/displayapp/screens/WatchFaceTerminal.cpp
+++ b/src/displayapp/screens/WatchFaceTerminal.cpp
@@ -1,264 +0,0 @@
-#include <lvgl/lvgl.h>
-#include "displayapp/screens/WatchFaceTerminal.h"
-#include "displayapp/screens/BatteryIcon.h"
-#include "displayapp/screens/NotificationIcon.h"
-#include "displayapp/screens/Symbols.h"
-#include "components/battery/BatteryController.h"
-#include "components/ble/BleController.h"
-#include "components/ble/NotificationManager.h"
-#include "components/heartrate/HeartRateController.h"
-#include "components/motion/MotionController.h"
-#include "components/settings/Settings.h"
-
-using namespace Pinetime::Applications::Screens;
-
-WatchFaceTerminal::WatchFaceTerminal(Controllers::DateTime& dateTimeController,
-                                     const Controllers::Battery& batteryController,
-                                     const Controllers::Ble& bleController,
-                                     Controllers::NotificationManager& notificationManager,
-                                     Controllers::Settings& settingsController,
-                                     Controllers::HeartRateController& heartRateController,
-                                     Controllers::MotionController& motionController)
-  : currentDateTime {{}},
-    dateTimeController {dateTimeController},
-    batteryController {batteryController},
-    bleController {bleController},
-    notificationManager {notificationManager},
-    settingsController {settingsController},
-    heartRateController {heartRateController},
-    motionController {motionController} {
-
-  /*Create an array for the points of the line*/
-  // progress_points[0] = {0, 0};
-  // progress_points[1] = {0, 0};
-
-  static lv_style_t style_now_line;
-  lv_style_init(&style_now_line);
-  lv_style_set_line_width(&style_now_line, LV_STATE_DEFAULT, 1);
-  lv_style_set_line_color(&style_now_line, LV_STATE_DEFAULT, LV_COLOR_RED);
-  // lv_style_set_line_rounded(&style_now_line, LV_STATE_DEFAULT, true);
-
-  /*Create a line and apply the new style*/
-  now_line = lv_line_create(lv_scr_act(), NULL);
-  static lv_point_t line_points[] = { {40, 2}, {40, 50}};
-  lv_line_set_points(now_line, line_points, 2);
-  lv_obj_add_style(now_line, LV_LINE_PART_MAIN, &style_now_line);
-  lv_obj_align(now_line, NULL, LV_ALIGN_IN_TOP_LEFT, 0, 0);
-
-  static lv_style_t style_event;
-  lv_style_init(&style_event);
-  lv_style_set_radius(&style_event, LV_STATE_DEFAULT, 5);
-  lv_style_set_bg_opa(&style_event, LV_STATE_DEFAULT, LV_OPA_COVER);
-  lv_style_set_bg_color(&style_event, LV_STATE_DEFAULT, LV_COLOR_MAGENTA);
-  lv_style_set_pad_top(&style_event, LV_STATE_DEFAULT, 2);
-  lv_style_set_pad_bottom(&style_event, LV_STATE_DEFAULT, 2);
-  lv_style_set_pad_left(&style_event, LV_STATE_DEFAULT, 5);
-  lv_style_set_pad_right(&style_event, LV_STATE_DEFAULT, 5);
-  lv_style_set_text_font(&style_event, LV_STATE_DEFAULT, &jetbrains_mono_14);
-
-  static lv_style_t style_flex;
-  lv_style_init(&style_flex);
-  lv_style_copy(&style_flex, &style_event);
-  lv_style_set_bg_color(&style_flex, LV_STATE_DEFAULT, LV_COLOR_PURPLE);
-
-  static lv_style_t style_season;
-  lv_style_init(&style_season);
-  lv_style_copy(&style_season, &style_event);
-  lv_style_set_bg_color(&style_season, LV_STATE_DEFAULT, LV_COLOR_GREEN);
-
-  static lv_style_t style_actualization;
-  lv_style_init(&style_actualization);
-  lv_style_copy(&style_actualization, &style_event);
-  lv_style_set_bg_color(&style_actualization, LV_STATE_DEFAULT, LV_COLOR_TEAL);
-
-  static lv_style_t style_community;
-  lv_style_init(&style_community);
-  lv_style_copy(&style_community, &style_event);
-  lv_style_set_bg_color(&style_community, LV_STATE_DEFAULT, LV_COLOR_OLIVE);
-
-  /* Fixed events */
-  // lv_obj_t* lbl_event;
-  // lbl_event = lv_label_create(lv_scr_act(), nullptr);
-  // lv_label_set_recolor(lbl_event, true);
-  // lv_obj_add_style(lbl_event, LV_LABEL_PART_MAIN, &style_event);
-  // lv_obj_align(lbl_event, lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 5, 10);
-  // lv_label_set_long_mode(lbl_event, LV_LABEL_LONG_BREAK);
-  // lv_obj_set_width(lbl_event, LV_HOR_RES/3);
-  // lv_label_set_text_fmt(lbl_event, "Foo Bar");
-
-  lv_obj_t* lbl_prior_event;
-
-  for(int i=0;i<sizeof(fixedtime)/sizeof(CalendarEntry);i++){
-    lv_obj_t* lbl_event2;
-    lbl_event2 = lv_label_create(lv_scr_act(), nullptr);
-    lv_label_set_recolor(lbl_event2, true);
-    lv_obj_add_style(lbl_event2, LV_LABEL_PART_MAIN, &style_event);
-
-    if (i==0) {
-      lv_obj_align(lbl_event2, lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 5, 10);
-    } else {
-      lv_obj_align(lbl_event2, lbl_prior_event, LV_ALIGN_OUT_RIGHT_TOP, 5, 0);
-    }
-
-    lv_label_set_long_mode(lbl_event2, LV_LABEL_LONG_BREAK);
-    lv_obj_set_width(lbl_event2, LV_HOR_RES/3);
-    lv_label_set_text_fmt(lbl_event2, fixedtime[i].name);
-    fixedtime_labels[i] = lbl_event2;
-    lbl_prior_event = lbl_event2;
-  }
-
-  for(int i=0;i<sizeof(flextime)/sizeof(TaskEntry);i++){
-    lv_obj_t* lbl_event2;
-    lbl_event2 = lv_label_create(lv_scr_act(), nullptr);
-    lv_label_set_recolor(lbl_event2, true);
-    lv_obj_add_style(lbl_event2, LV_LABEL_PART_MAIN, &style_flex);
-
-    if (i==0) {
-      lv_obj_align(lbl_event2, lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 5, 60);
-    } else {
-      lv_obj_align(lbl_event2, lbl_prior_event, LV_ALIGN_OUT_RIGHT_TOP, 5, 0);
-    }
-
-    lv_label_set_long_mode(lbl_event2, LV_LABEL_LONG_BREAK);
-    lv_obj_set_width(lbl_event2, LV_HOR_RES/3);
-    lv_label_set_text_fmt(lbl_event2, flextime[i].name);
-    lbl_prior_event = lbl_event2;
-  }
-
-  for(int i=0;i<sizeof(season)/sizeof(TaskEntry);i++){
-    lv_obj_t* lbl_event2;
-    lbl_event2 = lv_label_create(lv_scr_act(), nullptr);
-    lv_label_set_recolor(lbl_event2, true);
-    lv_obj_add_style(lbl_event2, LV_LABEL_PART_MAIN, &style_season);
-
-    if (i==0) {
-      lv_obj_align(lbl_event2, lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 5, 125);
-    } else {
-      lv_obj_align(lbl_event2, lbl_prior_event, LV_ALIGN_OUT_BOTTOM_MID, 0, 5);
-    }
-
-    lv_label_set_long_mode(lbl_event2, LV_LABEL_LONG_BREAK);
-    lv_obj_set_width(lbl_event2, LV_HOR_RES-10);
-    lv_label_set_text_fmt(lbl_event2, season[i].name);
-    lv_label_set_align(lbl_event2, LV_LABEL_ALIGN_CENTER);
-    lbl_prior_event = lbl_event2;
-  }
-
-  for(int i=0;i<sizeof(actualization)/sizeof(TaskEntry);i++){
-    lv_obj_t* lbl_event2;
-    lbl_event2 = lv_label_create(lv_scr_act(), nullptr);
-    lv_label_set_recolor(lbl_event2, true);
-    lv_obj_add_style(lbl_event2, LV_LABEL_PART_MAIN, &style_actualization);
-
-    if (i==0) {
-      lv_obj_align(lbl_event2, lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 5, 155);
-    } else {
-      lv_obj_align(lbl_event2, lbl_prior_event, LV_ALIGN_OUT_RIGHT_TOP, 5, 0);
-    }
-
-    lv_label_set_long_mode(lbl_event2, LV_LABEL_LONG_BREAK);
-    lv_obj_set_width(lbl_event2, LV_HOR_RES/2-5);
-    lv_label_set_text_fmt(lbl_event2, actualization[i].name);
-    lbl_prior_event = lbl_event2;
-  }
-
-  for(int i=0;i<sizeof(community)/sizeof(TaskEntry);i++){
-    lv_obj_t* lbl_event2;
-    lbl_event2 = lv_label_create(lv_scr_act(), nullptr);
-    lv_label_set_recolor(lbl_event2, true);
-    lv_obj_add_style(lbl_event2, LV_LABEL_PART_MAIN, &style_community);
-
-    if (i==0) {
-      lv_obj_align(lbl_event2, lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 5, 205);
-    } else {
-      lv_obj_align(lbl_event2, lbl_prior_event, LV_ALIGN_OUT_RIGHT_TOP, 5, 0);
-    }
-
-    // lv_label_set_long_mode(lbl_event2, LV_LABEL_LONG_BREAK);
-    // lv_obj_set_width(lbl_event2, LV_HOR_RES*0.55);
-    lv_label_set_text_fmt(lbl_event2, community[i].name);
-    lbl_prior_event = lbl_event2;
-  }
-
-  // lv_obj_t* lbl_event2;
-  // lbl_event2 = lv_label_create(lv_scr_act(), nullptr);
-  // lv_label_set_recolor(lbl_event2, true);
-  // lv_obj_add_style(lbl_event2, LV_LABEL_PART_MAIN, &style_event);
-  // lv_obj_align(lbl_event2, lbl_event, LV_ALIGN_OUT_RIGHT_MID, 5, 0);
-  // // lv_label_set_long_mode(lbl_event2, LV_LABEL_LONG_SROLL);
-  // lv_label_set_text_fmt(lbl_event2, "Baz Bing Boom");
-  // lv_obj_set_width(lbl_event2, LV_HOR_RES-5);
-  // lv_obj_set_height(label_now, 40);
-
-  // batteryValue = lv_label_create(lv_scr_act(), nullptr);
-  // lv_label_set_recolor(batteryValue, true);
-  // lv_obj_align(batteryValue, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 0, -20);
-
-  // connectState = lv_label_create(lv_scr_act(), nullptr);
-  // lv_label_set_recolor(connectState, true);
-  // lv_obj_align(connectState, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 0, 40);
-
-  notificationIcon = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_align(notificationIcon, nullptr, LV_ALIGN_IN_LEFT_MID, 0, -100);
-
-  taskRefresh = lv_task_create(RefreshTaskCallback, LV_DISP_DEF_REFR_PERIOD, LV_TASK_PRIO_MID, this);
-  Refresh();
-}
-
-WatchFaceTerminal::~WatchFaceTerminal() {
-  lv_task_del(taskRefresh);
-  lv_obj_clean(lv_scr_act());
-}
-
-uint32_t timeOffset = 0;
-void WatchFaceTerminal::Refresh() {
-  // if (currentDuration == 0) {
-  //   lv_label_set_text_fmt(label_now, "#007fff Now:# %s",calendar[calIndex].name);
-  //   if (calIndex+1 < sizeof(calendar)/sizeof(CalendarEntry)) {
-  //     lv_label_set_text_fmt(label_next, "#ee3377 Next:# %s", calendar[calIndex+1].name);
-  //   } else {
-  //     lv_label_set_text_fmt(label_next, "");
-  //   }
-  // }
-
-  // progress_points[1] = {0,(lv_coord_t)((double)LV_VER_RES*currentDuration/calendar[calIndex].duration)};
-  // lv_line_set_points(progress_line, progress_points, 2);     /*Set the points*/
-  // lv_label_set_text_fmt(batteryValue, "cI %d sO %d",calIndex, sizeof(calendar)/sizeof(CalendarEntry));
-  int last_width=0;
-  for(int i=0;i<sizeof(fixedtime_labels)/sizeof(CalendarEntry);i++){
-    lv_obj_set_width(fixedtime_labels[i], pow(log(fixedtime[i].duration),2)*10);
-    if (i > 0) {
-      lv_obj_align(fixedtime_labels[i], fixedtime_labels[i-1], LV_ALIGN_OUT_RIGHT_TOP, 5, 0);
-    } else {
-      lv_obj_align(fixedtime_labels[i], lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 5-timeOffset, 10);
-    }
-  }
-  timeOffset++;
-
-
-  // currentDuration++;
-  // if (currentDuration>calendar[calIndex].duration) {
-  //   currentDuration = 0;
-  //   calIndex++;
-  //   if (calIndex > sizeof(calendar)/sizeof(CalendarEntry)-1) {
-  //     calIndex = 0;
-  //   }
-  // }
-  
-
-  notificationState = notificationManager.AreNewNotificationsAvailable();
-  if (notificationState.IsUpdated()) {
-    if (notificationState.Get()) {
-      lv_label_set_text_static(notificationIcon, "You have mail.");
-    } else {
-      lv_label_set_text_static(notificationIcon, "");
-    }
-  }
-
-  currentDateTime = std::chrono::time_point_cast<std::chrono::seconds>(dateTimeController.CurrentDateTime());
-  if (currentDateTime.IsUpdated()) {
-    // uint8_t hour = dateTimeController.Hours();
-    // uint8_t minute = dateTimeController.Minutes();
-    // uint8_t second = dateTimeController.Seconds();
-  }
-}
--- a/src/displayapp/screens/WatchFaceTerminal.h
+++ b/src/displayapp/screens/WatchFaceTerminal.h
@@ -1,137 +0,0 @@
-#pragma once
-
-#include <lvgl/src/lv_core/lv_obj.h>
-#include <chrono>
-#include <cstdint>
-#include <memory>
-#include <displayapp/Controllers.h>
-#include "displayapp/screens/Screen.h"
-#include "components/datetime/DateTimeController.h"
-#include "utility/DirtyValue.h"
-
-namespace Pinetime {
-  namespace Controllers {
-    class Settings;
-    class Battery;
-    class Ble;
-    class NotificationManager;
-    class HeartRateController;
-    class MotionController;
-  }
-
-  struct CalendarEntry {
-    char* name;
-    uint32_t duration;
-  };
-
-  struct TaskEntry {
-    char* name;
-    uint32_t priority;
-  };
-
-  namespace Applications {
-    namespace Screens {
-
-      class WatchFaceTerminal : public Screen {
-      public:
-        WatchFaceTerminal(Controllers::DateTime& dateTimeController,
-                          const Controllers::Battery& batteryController,
-                          const Controllers::Ble& bleController,
-                          Controllers::NotificationManager& notificationManager,
-                          Controllers::Settings& settingsController,
-                          Controllers::HeartRateController& heartRateController,
-                          Controllers::MotionController& motionController);
-        ~WatchFaceTerminal() override;
-
-        void Refresh() override;
-
-      private:
-        Utility::DirtyValue<int> batteryPercentRemaining {};
-        Utility::DirtyValue<bool> powerPresent {};
-        Utility::DirtyValue<bool> bleState {};
-        Utility::DirtyValue<bool> bleRadioEnabled {};
-        Utility::DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>> currentDateTime {};
-        Utility::DirtyValue<uint32_t> stepCount {};
-        Utility::DirtyValue<uint8_t> heartbeat {};
-        Utility::DirtyValue<bool> heartbeatRunning {};
-        Utility::DirtyValue<bool> notificationState {};
-        Utility::DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::days>> currentDate;
-
-        CalendarEntry fixedtime[14] = {
-          {"Present FuckTime", 30},
-          {"Party @ David's", 3*60},
-          {"Catch the L Train", 4*60},
-          {"Sleep", 8*60},
-          {"Wake up", 30},
-          {"Work", 4*60},
-          {"Eat Lunch", 60},
-          {"Afternoon Work", 4*60},
-          {"Get groceries", 20},
-          {"Prepare dinner", 30},
-          {"Eat", 60},
-          {"Sleep", 8*60},
-          {"Rave", 30},
-          {"Repeat", 10}
-        };
-        TaskEntry flextime[5] = {
-          {"Enjoy the sunset", 1},
-          // {"Enjoy the crisp night air", 3},
-          // {"Savor the moment", 5},
-          {"Collect leaves", 7},
-          {"Read southern gothic", 9},
-          {"Attend Food Not Bombs", 11},
-          {"Undermine authority", 13},
-        };
-        TaskEntry season[1] = {
-          {"大雪 Winter begins", 0},
-        };
-        TaskEntry actualization[2] = {
-          {"Become a tea monk", 1},
-          {"Organize BuyNothing", 3},
-        };
-        TaskEntry community[2] = {
-          {"Publish zines", 1},
-          {"Cultivate the next", 3},
-        };
-
-        lv_obj_t* fixedtime_labels[sizeof(fixedtime)/sizeof(CalendarEntry)];
-        uint32_t calIndex = 0;
-        uint32_t currentDuration = 0;
-
-        lv_obj_t* now_line;
-        lv_obj_t* batteryValue;
-        lv_obj_t* notificationIcon;
-
-        Controllers::DateTime& dateTimeController;
-        const Controllers::Battery& batteryController;
-        const Controllers::Ble& bleController;
-        Controllers::NotificationManager& notificationManager;
-        Controllers::Settings& settingsController;
-        Controllers::HeartRateController& heartRateController;
-        Controllers::MotionController& motionController;
-
-        lv_task_t* taskRefresh;
-      };
-    }
-
-    template <>
-    struct WatchFaceTraits<WatchFace::Terminal> {
-      static constexpr WatchFace watchFace = WatchFace::Terminal;
-      static constexpr const char* name = "Terminal";
-
-      static Screens::Screen* Create(AppControllers& controllers) {
-        return new Screens::WatchFaceTerminal(controllers.dateTimeController,
-                                              controllers.batteryController,
-                                              controllers.bleController,
-                                              controllers.notificationManager,
-                                              controllers.settingsController,
-                                              controllers.heartRateController,
-                                              controllers.motionController);
-      };
-
-      static bool IsAvailable(Pinetime::Controllers::FS& /*filesystem*/) {
-        return true;
-      }
-    };
-  }
-}
--- a/src/displayapp/screens/settings/SettingLocation.cpp
+++ b/src/displayapp/screens/settings/SettingLocation.cpp
@@ -0,0 +1,70 @@
+#include "displayapp/screens/settings/SettingLocation.h"
+#include <lvgl/lvgl.h>
+#include <nrf_log.h>
+#include "displayapp/DisplayApp.h"
+#include "displayapp/screens/Symbols.h"
+#include "components/settings/Settings.h"
+#include "displayapp/InfiniTimeTheme.h"
+
+using namespace Pinetime::Applications::Screens;
+
+namespace {
+  constexpr int16_t POS_X_LAT = -80;
+  constexpr int16_t POS_X_LONG = 0;
+  constexpr int16_t POS_X_TZ = 80;
+  constexpr int16_t POS_Y_TEXT = 25;
+
+  void ValueChangedHandler(void* userData) {
+    auto* screen = static_cast<SettingLocation*>(userData);
+    screen->UpdateScreen();
+  }
+}
+
+SettingLocation::SettingLocation(Pinetime::Controllers::Settings& settingsController)
+  : settingsController {settingsController} {
+
+  lv_obj_t* title = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_text_static(title, "Set location\n(lat/long/tz)");
+  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::map);
+  lv_label_set_align(icon, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(icon, title, LV_ALIGN_OUT_LEFT_MID, -10, 0);
+
+  Controllers::Settings::Location loc = settingsController.GetLocation();
+
+  latCounter.Create();
+  latCounter.SetValue(loc.latitude);
+  lv_obj_align(latCounter.GetObject(), nullptr, LV_ALIGN_CENTER, POS_X_LAT, POS_Y_TEXT);
+  latCounter.SetValueChangedEventCallback(this, ValueChangedHandler);
+
+  longCounter.Create();
+  longCounter.SetValue(loc.longitude);
+  lv_obj_align(longCounter.GetObject(), nullptr, LV_ALIGN_CENTER, POS_X_LONG, POS_Y_TEXT);
+  longCounter.SetValueChangedEventCallback(this, ValueChangedHandler);
+
+  tzCounter.Create();
+  tzCounter.SetValue(loc.tzOffset);
+  lv_obj_align(tzCounter.GetObject(), nullptr, LV_ALIGN_CENTER, POS_X_TZ, POS_Y_TEXT);
+  tzCounter.SetValueChangedEventCallback(this, ValueChangedHandler);
+
+  UpdateScreen();
+}
+
+SettingLocation::~SettingLocation() {
+  lv_obj_clean(lv_scr_act());
+  settingsController.SaveSettings();
+}
+
+void SettingLocation::UpdateScreen() {
+  Controllers::Settings::Location loc = {
+    latitude: (int16_t)latCounter.GetValue(),
+    longitude: (int16_t)longCounter.GetValue(),
+    tzOffset: (int8_t)tzCounter.GetValue(),
+  };
+  settingsController.SetLocation(loc);
+}
--- a/src/displayapp/screens/settings/SettingLocation.h
+++ b/src/displayapp/screens/settings/SettingLocation.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <cstdint>
+#include <lvgl/lvgl.h>
+#include "components/datetime/DateTimeController.h"
+#include "components/settings/Settings.h"
+#include "displayapp/widgets/Counter.h"
+#include "displayapp/screens/Screen.h"
+#include "displayapp/widgets/DotIndicator.h"
+#include "displayapp/screens/settings/SettingSetDateTime.h"
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      class SettingLocation : public Screen {
+      public:
+        SettingLocation(Pinetime::Controllers::Settings& settingsController);
+        ~SettingLocation() override;
+
+        void UpdateScreen();
+
+      private:
+        Controllers::Settings& settingsController;
+
+        Widgets::Counter latCounter = Widgets::Counter(-90, 90, jetbrains_mono_bold_20);
+        Widgets::Counter longCounter = Widgets::Counter(-180, 180, jetbrains_mono_bold_20);
+        Widgets::Counter tzCounter = Widgets::Counter(-12, 12, jetbrains_mono_bold_20);
+      };
+    }
+  }
+}
--- a/src/displayapp/screens/settings/SettingSetTime.cpp
+++ b/src/displayapp/screens/settings/SettingSetTime.cpp
@@ -42,8 +42,8 @@ SettingSetTime::SettingSetTime(Pinetime::Controllers::DateTime& dateTimeControll

  lv_obj_t* staticLabel = lv_label_create(lv_scr_act(), nullptr);
  lv_obj_set_style_local_text_font(staticLabel, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_42);
-  lv_label_set_text_static(staticLabel, "00:00:00");
-  lv_obj_align(staticLabel, lv_scr_act(), LV_ALIGN_CENTER, 0, POS_Y_TEXT);
+  lv_label_set_text_static(staticLabel, ":00");
+  lv_obj_align(staticLabel, lv_scr_act(), LV_ALIGN_IN_RIGHT_MID, -33, POS_Y_TEXT);

  hourCounter.Create();
  if (settingsController.GetClockType() == Controllers::Settings::ClockType::H12) {
--- a/src/displayapp/screens/settings/SettingTimeFormat.cpp
+++ b/src/displayapp/screens/settings/SettingTimeFormat.cpp
@@ -13,9 +13,10 @@ namespace {
    const char* name;
  };

-  constexpr std::array<Option, 2> options = {{
+  constexpr std::array<Option, 3> options = {{
    {Pinetime::Controllers::Settings::ClockType::H12, "12-hour"},
    {Pinetime::Controllers::Settings::ClockType::H24, "24-hour"},
+    {Pinetime::Controllers::Settings::ClockType::FUZZY, "Fuzzy"},
  }};

  std::array<CheckboxList::Item, CheckboxList::MaxItems> CreateOptionArray() {
--- a/src/displayapp/screens/settings/SettingWatchFace.h
+++ b/src/displayapp/screens/settings/SettingWatchFace.h
@@ -9,8 +9,8 @@
 #include "displayapp/screens/Screen.h"
 #include "displayapp/screens/Symbols.h"
 #include "displayapp/screens/CheckboxList.h"
-#include "displayapp/screens/WatchFaceInfineat.h"
-#include "displayapp/screens/WatchFaceCasioStyleG7710.h"
+// #include "displayapp/screens/WatchFaceInfineat.h"
+// #include "displayapp/screens/WatchFaceCasioStyleG7710.h"

 namespace Pinetime {

--- a/src/displayapp/screens/settings/Settings.h
+++ b/src/displayapp/screens/settings/Settings.h
@@ -39,6 +39,7 @@ namespace Pinetime {

          {Symbols::shoe, "Steps", Apps::SettingSteps},
          {Symbols::clock, "Date & Time", Apps::SettingSetDateTime},
+          {Symbols::map, "Location", Apps::SettingLocation},
          {Symbols::cloudSunRain, "Weather", Apps::SettingWeatherFormat},
          {Symbols::batteryHalf, "Battery", Apps::BatteryInfo},

--- a/src/displayapp/widgets/Counter.cpp
+++ b/src/displayapp/widgets/Counter.cpp
@@ -136,8 +136,7 @@ void Counter::Create() {

  static constexpr uint8_t padding = 5;
  const uint8_t width = std::max(lv_obj_get_width(number) + padding * 2, 58);
-  static constexpr uint8_t btnHeight = 50;
-  const uint8_t containerHeight = btnHeight * 2 + lv_obj_get_height(number) + padding * 2;
+  containerHeight = btnHeight * 2 + lv_obj_get_height(number) + padding * 2;

  lv_obj_set_size(counterContainer, width, containerHeight);

--- a/src/displayapp/widgets/Counter.h
+++ b/src/displayapp/widgets/Counter.h
@@ -18,6 +18,15 @@ namespace Pinetime {
        void EnableMonthMode();
        void SetMax(int newMax);
        void SetValueChangedEventCallback(void* userData, void (*handler)(void* userData));
+        void SetWidth(uint8_t width) {
+          lv_obj_set_size(counterContainer, width, containerHeight);
+          lv_obj_set_size(upBtn, width, btnHeight);
+          lv_obj_set_size(downBtn, width, btnHeight);
+          linePoints[0] = {0, 0};
+          linePoints[1] = {width, 0};
+          lv_line_set_points(upperLine, linePoints, 2);
+          lv_line_set_points(lowerLine, linePoints, 2);
+        }

        int GetValue() const {
          return value;
@@ -42,6 +51,8 @@ namespace Pinetime {
        int max;
        int value;
        const int leadingZeroCount;
+        uint8_t containerHeight;
+        static constexpr uint8_t btnHeight = 50;
        bool twelveHourMode = false;
        bool monthMode = false;
        lv_font_t& font;
--- a/src/libs/lv_conf.h
+++ b/src/libs/lv_conf.h
@@ -415,9 +415,11 @@ typedef void* lv_indev_drv_user_data_t;            /*Type of user data in the in

 #define LV_FONT_CUSTOM_DECLARE LV_FONT_DECLARE(jetbrains_mono_bold_20) \
                               LV_FONT_DECLARE(jetbrains_mono_extrabold_compressed) \
+                               LV_FONT_DECLARE(jetbrains_mono_bold_24) \
                               LV_FONT_DECLARE(jetbrains_mono_42) \
                               LV_FONT_DECLARE(jetbrains_mono_76) \
-                               LV_FONT_DECLARE(jetbrains_mono_14) \
+                               LV_FONT_DECLARE(noto_serif_cjk_20) \
+                               LV_FONT_DECLARE(noto_serif_cjk_15) \
                               LV_FONT_DECLARE(open_sans_light) \
                               LV_FONT_DECLARE(fontawesome_weathericons) \
                               LV_FONT_DECLARE(lv_font_sys_48)
--- a/src/libs/sunset
+++ b/src/libs/sunset
--- a/src/resources/fonts.json
+++ b/src/resources/fonts.json
@@ -22,41 +22,5 @@
      "size": 120,
      "format": "bin",
      "target_path": "/fonts/"
-   },
-   "lv_font_dots_40": {
-      "sources": [
-         {
-            "file": "fonts/repetitionscrolling.ttf",
-            "symbols": "0123456789-MONTUEWEDTHUFRISATSUN WK"
-         }
-      ],
-      "bpp": 1,
-      "size": 40,
-      "format": "bin",
-      "target_path": "/fonts/"
-   },
-   "7segments_40" : {
-      "sources": [
-         {
-            "file": "fonts/7segment.woff",
-            "symbols": "0123456789: -"
-         }
-      ],
-      "bpp": 1,
-      "size": 40,
-      "format": "bin",
-      "target_path": "/fonts/"
-   },
-   "7segments_115" : {
-      "sources": [
-         {
-            "file": "fonts/7segment.woff",
-            "symbols": "0123456789: -"
-         }
-      ],
-      "bpp": 1,
-      "size": 115,
-      "format": "bin",
-      "target_path": "/fonts/"
   }
 }
Author	SHA1	Message	Date
Will Bradley	156696f864	Tweak build/ignore	2024-12-17 23:51:55 -08:00
Will Bradley	d22f004729	Merge branch 'main' into wb/wadokei-merge	2024-12-17 23:25:20 -08:00
Will Bradley	d8c86882da	Fix merge issues, adjust font size and initial screen	2024-12-05 17:19:34 -08:00
Will Bradley	a550d64789	Merge branch 'main' into wb/wadokei-merge	2024-12-05 16:41:43 -08:00
Will Bradley	49c801b827	Fix location counter width, font, and lat/lng bugs	2024-06-11 21:27:26 -07:00
Ryan Rix	f6a5588544	add location setting and integrate more sundial code from willb	2024-06-10 20:19:43 -07:00
Ryan Rix	41518cc529	add larger font for fuzzy face	2024-06-10 20:19:06 -07:00
Ryan Rix	c20db14c43	how much heap can one smartwatch need, michael, 40kb?	2024-06-09 20:48:06 -07:00
Ryan Rix	9520b2ec9b	remove unused controllers from fuzzy	2024-06-09 20:28:52 -07:00
Ryan Rix	8cf38a3469	remove unused open sans light	2024-06-09 20:28:35 -07:00
Ryan Rix	83cae9b5bc	wip sundial w/ copied analog watchface	2024-06-09 20:28:21 -07:00
Ryan Rix	bb743689e1	vulf-ify me captain	2024-06-09 00:11:00 -07:00
Ryan Rix	4b854a5d09	WIP fuzzy	2024-06-07 16:46:06 -07:00
Will Bradley	652b5c03f8	Adjust hourly chime timing, github, readme	2024-01-18 14:15:18 -08:00
zyphlar	e8ee71b492	Update DisplayApp.cpp	2024-01-18 02:29:45 -08:00
zyphlar	33c92646f2	Update DisplayApp.cpp	2024-01-18 01:40:42 -08:00
Will Bradley	e84c049e65	otaku chimes	2024-01-18 01:30:28 -08:00
Will Bradley	3968b4eb4f	proper hour hand math	2024-01-17 23:41:18 -08:00
Will Bradley	0fc2e611cd	try a better triangle	2024-01-17 16:29:59 -08:00
Will Bradley	59d6aa193a	Got proportional time working and restored apps	2024-01-17 00:03:42 -08:00
Will Bradley	0a83f936b5	Got it working	2024-01-16 22:21:28 -08:00
Will Bradley	5510bfe499	Add fonts, remove Digital	2024-01-16 20:33:04 -08:00
Will Bradley	cf4f54dc87	smell this	2024-01-16 11:06:56 -08:00
Will Bradley	7b3c48a0e5	Add fancy font and fuzzy logic	2024-01-09 22:54:44 -08:00
Will Bradley	d8c3624f6f	Add location, timezone, and long-press switching	2024-01-09 09:19:07 -08:00
zyphlar	20a5fef84c	Add sunset lib	2024-01-08 10:26:07 -08:00
zyphlar	77667c6391	Merge branch 'wb/fuzzy-analog' of github.com:zyphlar/InfiniTime into wb/fuzzy-analog	2024-01-08 10:24:30 -08:00
zyphlar	6c20c2992b	Add sundial	2024-01-07 01:26:03 -08:00
zyphlar	5535fa6af7	add sundial	2024-01-06 21:10:09 -08:00
zyphlar	796e8f1ada	Remove second and minute hands	2024-01-06 17:24:47 -08:00
zyphlar	b7301d51cd	Re-add removed stuff	2024-01-05 13:56:55 -08:00
zyphlar	5c87829d65	Reduce font, adjust to 4 sectors per hour, remove broken inline text color	2024-01-05 13:26:37 -08:00
zyphlar	7cd9e8493d	Compress things a bit	2024-01-05 02:32:50 -08:00
zyphlar	d2989ae23a	Move Fuzzy into Digital, restore Paint	2024-01-05 02:21:58 -08:00
zyphlar	66f6c34b50	disable watchfaceterminal, watchfacecasiostyleg7710, infinipaint for space	2024-01-05 02:07:08 -08:00
zyphlar	6d615b374c	add missing vars	2024-01-05 01:24:48 -08:00
zyphlar	3df7c6a4f3	Emulate dyamon/watchfacefuzzy	2024-01-05 01:13:05 -08:00
zyphlar	e1c652bdfb	build with github	2024-01-05 00:23:31 -08:00