Update DisplayApp.cpp

.github/workflows/main.yml

@@ -3,7 +3,7 @@ name: CI
 # Run this workflow whenever the build may be affected
 on:
   push:
-    branches: [ main, wb/fuzzy, wb/fuzzy-norm, wb/fuzzy-analog, wb/fuzzy-everything-wolf ]
+    branches: [ main, wb/fuzzy, wb/fuzzy-norm, wb/fuzzy-analog, wb/fuzzy-everything-wolf, wb/smellthis ]
     paths-ignore:
       - 'doc/**'
       - '**.md'
@@ -91,6 +91,12 @@ jobs:
     - 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:  |

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);
+       }

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;

src/CMakeLists.txt

@@ -424,7 +424,7 @@ list(APPEND SOURCE_FILES
 
         ## Watch faces
         displayapp/screens/WatchFaceAnalog.cpp
-        displayapp/screens/WatchFaceDigital.cpp
+        #displayapp/screens/WatchFaceDigital.cpp
         #displayapp/screens/WatchFaceInfineat.cpp
         #displayapp/screens/WatchFaceTerminal.cpp
         displayapp/screens/WatchFacePineTimeStyle.cpp
@@ -778,7 +778,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)
@@ -847,7 +847,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}>
         )
@@ -861,7 +861,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}>
         -O3
@@ -874,7 +874,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}>
         )
@@ -886,7 +886,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}>
         )
@@ -898,7 +898,7 @@ target_include_directories(littlefs SYSTEM PUBLIC ${INCLUDES_FROM_LIBS})
 target_compile_options(littlefs 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}>
         )
@@ -910,7 +910,7 @@ target_include_directories(sunset SYSTEM PUBLIC ${INCLUDES_FROM_LIBS})
 target_compile_options(sunset 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}>
         )
@@ -926,7 +926,7 @@ 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}>
         )
@@ -961,7 +961,7 @@ 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}>
         )
@@ -1004,7 +1004,7 @@ 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}>
         )
@@ -1036,7 +1036,7 @@ 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}>
         )
@@ -1075,7 +1075,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}>
         )
@@ -1110,7 +1110,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}>
         )

src/components/settings/Settings.h

@@ -318,7 +318,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;

src/displayapp/DisplayApp.cpp

@@ -232,6 +232,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::DimScreen:
         DimScreen();
@@ -377,7 +382,39 @@ void DisplayApp::Refresh() {
         break;
       case Messages::Chime:
         LoadNewScreen(Apps::Clock, DisplayApp::FullRefreshDirections::None);
+
+        // 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(35);
+          vTaskDelay(800);
+        }
         break;
       case Messages::OnChargingEvent:
         RestoreBrightness();

src/displayapp/UserApps.h

@@ -7,7 +7,7 @@
 #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"

src/displayapp/apps/Apps.h.in

@@ -46,7 +46,6 @@ namespace Pinetime {
     };
 
     enum class WatchFace : uint8_t {
-      Digital,
       Analog,
       PineTimeStyle,
     };
@@ -69,8 +68,7 @@ namespace Pinetime {
       static constexpr size_t Count = sizeof...(Ws);
     };
 
-    using UserWatchFaceTypes = WatchFaceTypeList<WatchFace::Digital,
-                                                 WatchFace::Analog,
+    using UserWatchFaceTypes = WatchFaceTypeList<WatchFace::Analog,
                                                  WatchFace::PineTimeStyle>;
 
     static_assert(UserWatchFaceTypes::Count >= 1);

src/displayapp/apps/CMakeLists.txt

@@ -1,9 +1,9 @@
-if(DEFINED ENABLE_USERAPPS)
-    set(USERAPP_TYPES ${ENABLE_USERAPPS} CACHE STRING "List of user apps to build into the firmware")
-else ()
-    set(USERAPP_TYPES "Apps::Navigation, Apps::Alarm, Apps::Steps, Apps::HeartRate, Apps::Music, Apps::Twos" CACHE STRING "List of user apps to build into the firmware")
-    #Apps::Paint, Apps::Metronome, Apps::Paddle, Apps::StopWatch, Apps::Timer, 
-endif ()
+#if(DEFINED ENABLE_USERAPPS)
+#    set(USERAPP_TYPES ${ENABLE_USERAPPS} CACHE STRING "List of user apps to build into the firmware")
+#else ()
+    set(USERAPP_TYPES "Apps::Navigation, Apps::StopWatch, Apps::Timer, Apps::Alarm, Apps::Steps, Apps::HeartRate, Apps::Music, Apps::Twos" CACHE STRING "List of user apps to build into the firmware")
+    #Apps::Paint, Apps::Metronome, Apps::Paddle
+#endif ()
 
 add_library(infinitime_apps INTERFACE)
 target_sources(infinitime_apps INTERFACE "${CMAKE_CURRENT_BINARY_DIR}/Apps.h")

src/displayapp/fonts/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(FONTS jetbrains_mono_42 jetbrains_mono_76 jetbrains_mono_bold_20
+set(FONTS jetbrains_mono_42 noto_serif_cjk_20 noto_serif_cjk_15 jetbrains_mono_76 jetbrains_mono_bold_20
    jetbrains_mono_extrabold_compressed lv_font_sys_48
    open_sans_light fontawesome_weathericons)
 find_program(LV_FONT_CONV "lv_font_conv" NO_CACHE REQUIRED

src/displayapp/fonts/fonts.json

@@ -14,6 +14,26 @@
       "size": 20,
       "patches": ["jetbrains_mono_bold_20.c_zero.patch", "jetbrains_mono_bold_20.c_M.patch"]
    },
+   "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": [
          {

src/displayapp/screens/WatchFaceAnalog.cpp

@@ -1,7 +1,7 @@
 #include "displayapp/screens/WatchFaceAnalog.h"
 #include <cmath>
 #include <lvgl/lvgl.h>
-// #include <nrf_log.h>
+#include <nrf_log.h>
 #include "displayapp/screens/BatteryIcon.h"
 #include "displayapp/screens/BleIcon.h"
 #include "displayapp/screens/Symbols.h"
@@ -44,15 +44,41 @@ namespace {
                        .y = CoordinateYRelocate(radius * static_cast<int32_t>(Cosine(angle)) / LV_TRIG_SCALE)};
   }
 
-  int16_t CoordinateYRelocateSundial(int16_t y) {
-    return std::abs(y - SunDialVerticalOffset);
+  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);
   }
 
-  lv_point_t CoordinateRelocateSundial(int16_t radius, int16_t angle) {
-    return lv_point_t {.x = CoordinateXRelocate(radius * static_cast<int32_t>(Sine(angle)) / LV_TRIG_SCALE),
-                       .y = CoordinateYRelocateSundial(radius * static_cast<int32_t>(Cosine(angle)) / LV_TRIG_SCALE)};
+  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,
@@ -74,29 +100,53 @@ WatchFaceAnalog::WatchFaceAnalog(Controllers::DateTime& dateTimeController,
 
   location = settingsController.GetLocation();
 
-  // begin sundial watch face
+  // 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);
+
+    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);
+
     major_scales = lv_linemeter_create(lv_scr_act(), nullptr);
-    lv_linemeter_set_scale(major_scales, 165, 11);
-    lv_linemeter_set_angle_offset(major_scales, 180);
+    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_IN_TOP_MID, 0, -LV_HOR_RES/2+SunDialVerticalOffset);
+    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, 40);
+    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);
 
-    one = lv_label_create(lv_scr_act(), NULL);
-    lv_label_set_align(one, LV_LABEL_ALIGN_LEFT);
-    lv_label_set_text(one, "I");
-    lv_obj_align(one, NULL, LV_ALIGN_IN_TOP_LEFT, 20, SunDialVerticalOffset-20);
-    lv_obj_set_style_local_text_color(one, LV_LABEL_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);
 
-    twelve = lv_label_create(lv_scr_act(), NULL);
-    lv_label_set_align(twelve, LV_LABEL_ALIGN_RIGHT);
-    lv_label_set_text(twelve, "XII");
-    lv_obj_align(twelve, NULL, LV_ALIGN_IN_TOP_RIGHT, -20, SunDialVerticalOffset-20);
-    lv_obj_set_style_local_text_color(twelve, LV_LABEL_PART_MAIN, 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);
@@ -133,6 +183,11 @@ WatchFaceAnalog::WatchFaceAnalog(Controllers::DateTime& dateTimeController,
     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());
@@ -182,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);
@@ -212,69 +261,64 @@ WatchFaceAnalog::~WatchFaceAnalog() {
 }
 
 
-void WatchFaceAnalog::drawWatchFaceModeNight(){
+void WatchFaceAnalog::drawWatchFaceWadokei(){
   uint8_t hour = dateTimeController.Hours();
   uint8_t minute = dateTimeController.Minutes();
 
   if (sHour != hour || sMinute != minute) {
-    // sun.setPosition(settings.lat.toFloat(), settings.lon.toFloat(), settings.gmtOffset / 3600);
     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(); //360;
-    minutesSunset = sun.calcSunset(); //1080;
+    minutesSunrise = sun.calcSunrise();
+    minutesSunset = sun.calcSunset();
     minutesDaytime = (minutesSunset - minutesSunrise);
     minutesNighttime = (1440 - minutesDaytime);
 
     minutesBeforeSunset = minutesSunset - (hour * 60 + minute); // i.e.zero degrees
-    HourLength = 90; // sundial hand length
+    HourLength = 40; // wadokei hand length
 
-    int16_t hourAngle;
+    int16_t hourAngle=0;
+    // auto const hourAngle = ((hour * 15 + minute / 2)+180)%360; //24-hr rotation with 0/24 at the bottom
 
-    if(minutesBeforeSunset > 0 && minutesBeforeSunset < minutesDaytime) { // day (after sunrise)
-      hourAngle = 180.0 * minutesBeforeSunset / minutesDaytime + 90;
-    } else { // night (before sunrise or after sunset)
-      lv_style_set_line_color(&hour_line_style, LV_STATE_DEFAULT, DARK_GRAY);
-      lv_style_set_line_color(&hour_line_style_trace, LV_STATE_DEFAULT, DARK_GRAY);
-      lv_obj_set_style_local_scale_end_color(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, DARK_GRAY);
-      lv_obj_set_style_local_text_color(label_date_day, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, DARK_ORANGE);
-      lv_obj_set_style_local_text_color(one, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, DARK_GRAY);
-      lv_obj_set_style_local_text_color(twelve, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, DARK_GRAY);
-
-      if(minutesBeforeSunset > minutesDaytime) { // before sunrise
-        hourAngle = 180.0 * (minutesBeforeSunset - minutesDaytime) / minutesNighttime + 90;
-      } else { // after sunset
-        hourAngle = 180 + 180.0 * minutesBeforeSunset / minutesNighttime + 90;
+    if(minutesBeforeSunset > minutesDaytime) {
+      hourAngle = -180.0 - 180.0 * (minutesBeforeSunset - minutesDaytime) / minutesNighttime;
     }
+    else if(minutesBeforeSunset > 0 ) {
+      hourAngle = -180.0 * minutesBeforeSunset / minutesDaytime;
     }
-  /*NRF_LOG_INFO("a: %d, la: %f, lo: %f, ri: %d, se: %d, be: %d",
-    hourAngle,
-    (float)location.latitude,
-    (float)location.longitude,
-    minutesSunrise,
-    minutesSunset,
-    minutesBeforeSunset);*/
+    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] = CoordinateRelocateSundial(HourLength*.75, hourAngle);
-    hour_point_trace[1] = CoordinateRelocateSundial(HourLength, hourAngle);
+    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] = CoordinateRelocateSundial(0, hourAngle);
-    hour_point[1] = CoordinateRelocateSundial(HourLength*.75, hourAngle);
+    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) {
-    drawWatchFaceModeNight();
+    drawWatchFaceWadokei();
     return;
   }
 
@@ -366,14 +410,14 @@ void WatchFaceAnalog::Refresh() {
     currentDate = std::chrono::time_point_cast<days>(currentDateTime.Get());
     if (currentDate.IsUpdated()) {
       if (settingsController.GetClockType() == Controllers::Settings::ClockType::Fuzzy) {
-        char const* MonthsString[] = {"--", "IANUARIUS","FEBRUARIUS","MARTIUS","APRILIS","MARTIUSIUNIUS","QUINTILIS","SEXTILIS","SEPTEMBER","OCTOBER","NOVEMBER","DECEMBER"};
+        /*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, -20);
+          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());
       }

src/displayapp/screens/WatchFaceAnalog.h

@@ -52,6 +52,7 @@ namespace Pinetime {
         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;
@@ -70,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;
@@ -92,7 +94,7 @@ namespace Pinetime {
         Controllers::NotificationManager& notificationManager;
         Controllers::Settings& settingsController;
 
-        void drawWatchFaceModeNight();
+        void drawWatchFaceWadokei();
         void UpdateClock();
         void SetBatteryIcon();
 

src/displayapp/screens/WatchFaceDigital.cpp

@@ -1,239 +0,0 @@
-#include "displayapp/screens/WatchFaceDigital.h"
-
-#include <lvgl/lvgl.h>
-#include <cstdio>
-#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;
-
-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)
-  : currentDateTime {{}},
-    dateTimeController {dateTimeController},
-    notificationManager {notificationManager},
-    settingsController {settingsController},
-    heartRateController {heartRateController},
-    motionController {motionController},
-    statusIcons(batteryController, bleController) {
-
-  sHour = 99;
-  sMinute = 99;
-  statusIcons.Create();
-
-  lv_obj_t* bg = lv_img_create(lv_scr_act(), nullptr);
-  lv_img_set_src(bg, "F:/images/aor.bin");
-  lv_img_set_auto_size(bg, false);
-  lv_obj_set_size(bg, 240, 240);
-  // lv_img_set_src(bg, image.fileName);
-  lv_img_set_offset_x(bg, 0);
-  lv_img_set_offset_y(bg, 0);
-  // lv_obj_set_style_local_image_recolor_opa(bg, LV_IMG_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_COVER);
-  // lv_obj_set_style_local_image_recolor(bg, LV_IMG_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_CYAN);
-  lv_obj_align(bg, nullptr, LV_ALIGN_CENTER, 0, 0);
-
-  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);
-  lv_label_set_text_static(notificationIcon, NotificationIcon::GetIcon(false));
-  lv_obj_align(notificationIcon, nullptr, LV_ALIGN_IN_TOP_LEFT, 0, 0);
-
-  label_date = lv_label_create(lv_scr_act(), nullptr);
-  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);
-
-  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);
-
-  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, lv_color_hex(0xCE1B1B));
-  lv_obj_align(heartbeatIcon, lv_scr_act(), LV_ALIGN_IN_BOTTOM_LEFT, 0, 0);
-
-  heartbeatValue = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(heartbeatValue, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0xCE1B1B));
-  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, lv_color_hex(0x00FFE7));
-  lv_label_set_text_static(stepValue, "0");
-  lv_obj_align(stepValue, lv_scr_act(), LV_ALIGN_IN_BOTTOM_RIGHT, 0, 0);
-
-  stepIcon = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(stepIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x00FFE7));
-  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();
-}
-
-WatchFaceDigital::~WatchFaceDigital() {
-  lv_task_del(taskRefresh);
-  lv_obj_clean(lv_scr_act());
-}
-
-void WatchFaceDigital::Refresh() {
-  statusIcons.Update();
-
-  notificationState = notificationManager.AreNewNotificationsAvailable();
-  if (notificationState.IsUpdated()) {
-    lv_label_set_text_static(notificationIcon, NotificationIcon::GetIcon(notificationState.Get()));
-  }
-
-  currentDateTime = dateTimeController.CurrentDateTime();
-
-  if (currentDateTime.IsUpdated()) {
-
-    uint8_t hour = dateTimeController.Hours();
-    uint8_t minute = dateTimeController.Minutes();
-
-    if (sHour != hour || sMinute != minute || forceRefresh == true) {
-      forceRefresh = false;
-      sHour = hour;
-      sMinute = minute;
-
-      if (settingsController.GetClockType() == Controllers::Settings::ClockType::Fuzzy) {
-        printTimeWords(static_cast<int>(hour), static_cast<int>(minute));
-        lv_label_set_text(label_time_ampm, "");
-        lv_obj_align(label_time, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 0, -10);
-        lv_obj_set_style_local_text_font(label_time, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_42);
-        lv_label_set_recolor(label_time, true);
-        lv_obj_align(label_date, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 0, 60);
-      } else 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);
-        lv_obj_set_style_local_text_font(label_time, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_extrabold_compressed);
-        lv_obj_align(label_date, lv_scr_act(), LV_ALIGN_CENTER, 0, 60);
-      } 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);
-        lv_obj_set_style_local_text_font(label_time, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_extrabold_compressed);
-        lv_obj_align(label_date, lv_scr_act(), LV_ALIGN_CENTER, 0, 60);
-      }
-      lv_obj_realign(label_time);
-      lv_obj_realign(label_date);
-    }
-
-    currentDate = std::chrono::time_point_cast<days>(currentDateTime.Get());
-    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_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, lv_color_hex(0xCE1B1B));
-      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 WatchFaceDigital::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
-  if ((event == Pinetime::Applications::TouchEvents::LongTap)) {
-    Pinetime::Controllers::Settings::ClockType clockType = settingsController.GetClockType();
-    if (clockType == Pinetime::Controllers::Settings::ClockType::Fuzzy) {
-      settingsController.SetClockType(Pinetime::Controllers::Settings::ClockType::H12);
-    } else {
-      settingsController.SetClockType(Pinetime::Controllers::Settings::ClockType::Fuzzy);
-    }
-    settingsController.SaveSettings();
-    forceRefresh=true;
-    WatchFaceDigital::Refresh();
-    return true;
-  }
-  return false;
-}
-
-
-char const* twelve = "twelve";
-
-void WatchFaceDigital::printTimeWords(int h, int m) {
-  const char* mod;
-  char const* accent = "#808080";
-  char const* color = "#ffffff";
-  char const* oclock = "o' clock";
-  char const* past = "past";
-  char const* to = "to";
-  char const* hash = "#";
-  char const* nearly = "nearly";
-  char const* fmt = "%s %s%s\n%s %s%s %s %s%s";
-
-  if (m  <= 30) {
-    mod = mods[m / 5];
-  } else {
-    mod = mods[(60-m) / 5];
-  }
-  h  = (h % 12);
-
-  if (m >= 56) {
-    lv_label_set_text_fmt(label_time, "%s %s %s%s\n%s %s%s", color, nearly, nums[(h+1) % 12], hash, accent, oclock, hash);
-  }
-  else if (m == 0 || m <= 4) {
-    lv_label_set_text_fmt(label_time, "%s %s%s\n%s %s%s", color, nums[h], hash, accent, oclock, hash);
-  }
-
-  else if (m <= 32) {
-    lv_label_set_text_fmt(label_time, fmt, color, mod, hash, accent, past, hash, color, nums[h], hash);
-  }
-
-  else if (m > 32) {
-    lv_label_set_text_fmt(label_time, fmt, color, mod, hash, accent, to, hash, color, nums[(h+1) % 12], hash);
-  }
-
-}

src/displayapp/screens/WatchFaceDigital.h

@@ -1,104 +0,0 @@
-#pragma once
-
-#include <lvgl/src/lv_core/lv_obj.h>
-#include <chrono>
-#include <cstdint>
-#include <memory>
-#include "displayapp/screens/Screen.h"
-#include "components/datetime/DateTimeController.h"
-#include "components/ble/BleController.h"
-#include "displayapp/widgets/StatusIcons.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 WatchFaceDigital : 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);
-        ~WatchFaceDigital() override;
-
-        bool OnTouchEvent(TouchEvents event) override;
-        void Refresh() override;
-
-      private:
-        uint8_t sHour, sMinute;
-        uint8_t displayedHour = -1;
-        uint8_t displayedMinute = -1;
-
-        char const* mods[7] = {"", "five", "ten", "quarter", "twenty", "twenty five", "half"};
-        char const* nums[13] = {"twelve", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve"};
-
-        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::nanoseconds>> currentDateTime;
-        Utility::DirtyValue<uint32_t> stepCount {};
-        Utility::DirtyValue<uint8_t> heartbeat {};
-        Utility::DirtyValue<bool> heartbeatRunning {};
-        Utility::DirtyValue<bool> notificationState {};
-        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* label_time;
-        lv_obj_t* label_time_ampm;
-        lv_obj_t* label_date;
-        lv_obj_t* heartbeatIcon;
-        lv_obj_t* heartbeatValue;
-        lv_obj_t* stepIcon;
-        lv_obj_t* stepValue;
-        lv_obj_t* notificationIcon;
-
-        Controllers::DateTime& dateTimeController;
-        Controllers::NotificationManager& notificationManager;
-        Controllers::Settings& settingsController;
-        Controllers::HeartRateController& heartRateController;
-        Controllers::MotionController& motionController;
-
-        lv_task_t* taskRefresh;
-        bool forceRefresh=false;
-        Widgets::StatusIcons statusIcons;
-
-        void printTimeWords(int h, int m);
-      };
-    }
-
-    template <>
-    struct WatchFaceTraits<WatchFace::Digital> {
-      static constexpr WatchFace watchFace = WatchFace::Digital;
-      static constexpr const char* name = "Digital 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);
-      };
-
-      static bool IsAvailable(Pinetime::Controllers::FS& /*filesystem*/) {
-        return true;
-      }
-    };
-  }
-}

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) {

src/libs/lv_conf.h

@@ -417,6 +417,8 @@ typedef void* lv_indev_drv_user_data_t;            /*Type of user data in the in
                                LV_FONT_DECLARE(jetbrains_mono_extrabold_compressed) \
                                LV_FONT_DECLARE(jetbrains_mono_42) \
                                LV_FONT_DECLARE(jetbrains_mono_76) \
+                               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)

src/resources/CMakeLists.txt

@@ -5,7 +5,7 @@ message(STATUS "Using ${LV_FONT_CONV} to generate font files")
 
 find_program(LV_IMG_CONV "lv_img_conv.py" NO_CACHE REQUIRED
     HINTS "${CMAKE_CURRENT_SOURCE_DIR}")
-message(STATUS "Using ${LV_IMG_CONV} to generate image files")
+message(STATUS "Using ${LV_IMG_CONV} to generate font files")
 
 if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12)
    # FindPython3 module introduces with CMake 3.12

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/"
    }
 }

src/resources/images.json

@@ -6,13 +6,6 @@
       "binary_format": "ARGB8565_RBSWAP",
       "target_path": "/images/"
    },
-   "aor" : {
-      "sources": "images/aor.png",
-      "color_format": "CF_TRUE_COLOR_ALPHA",
-      "output_format": "bin",
-      "binary_format": "ARGB8565_RBSWAP",
-      "target_path": "/images/"
-   },
    "navigation0" : {
       "sources": "images/navigation0.png",
       "color_format": "CF_INDEXED_1_BIT",