diff options
Diffstat (limited to 'src/displayapp')
109 files changed, 6852 insertions, 0 deletions
diff --git a/src/displayapp/Apps.h b/src/displayapp/Apps.h new file mode 100644 index 00000000..bfa799ba --- /dev/null +++ b/src/displayapp/Apps.h @@ -0,0 +1,7 @@ +#pragma once + +namespace Pinetime { + namespace Applications { + enum class Apps {None, Launcher, Clock, SysInfo, Meter, Gauge, Brightness, Music, FirmwareValidation, Paint, Notifications}; + } +}
\ No newline at end of file diff --git a/src/displayapp/DisplayApp.cpp b/src/displayapp/DisplayApp.cpp new file mode 100644 index 00000000..d4d41333 --- /dev/null +++ b/src/displayapp/DisplayApp.cpp @@ -0,0 +1,278 @@ +#include <string> + +#include "DisplayApp.h" +#include <FreeRTOS.h> +#include <task.h> +#include <libraries/log/nrf_log.h> +#include <nrf_font.h> +#include <queue.h> +#include "components/datetime/DateTimeController.h" +#include <drivers/Cst816s.h> +#include "displayapp/screens/Notifications.h" +#include "displayapp/screens/Tile.h" +#include "displayapp/screens/Meter.h" +#include "displayapp/screens/Gauge.h" +#include "displayapp/screens/Brightness.h" +#include "displayapp/screens/SystemInfo.h" +#include "displayapp/screens/Music.h" +#include "components/ble/NotificationManager.h" +#include "displayapp/screens/FirmwareUpdate.h" +#include "displayapp/screens/ApplicationList.h" +#include "displayapp/screens/FirmwareValidation.h" +#include "displayapp/screens/InfiniPaint.h" +#include "systemtask/SystemTask.h" + +using namespace Pinetime::Applications; + +DisplayApp::DisplayApp(Drivers::St7789 &lcd, Components::LittleVgl &lvgl, Drivers::Cst816S &touchPanel, + Controllers::Battery &batteryController, Controllers::Ble &bleController, + Controllers::DateTime &dateTimeController, Drivers::WatchdogView &watchdog, + System::SystemTask &systemTask, + Pinetime::Controllers::NotificationManager& notificationManager) : + lcd{lcd}, + lvgl{lvgl}, + batteryController{batteryController}, + bleController{bleController}, + dateTimeController{dateTimeController}, + watchdog{watchdog}, + touchPanel{touchPanel}, + currentScreen{new Screens::Clock(this, dateTimeController, batteryController, bleController, notificationManager) }, + systemTask{systemTask}, + notificationManager{notificationManager} { + msgQueue = xQueueCreate(queueSize, itemSize); + onClockApp = true; + modal.reset(new Screens::Modal(this)); +} + +void DisplayApp::Start() { + if (pdPASS != xTaskCreate(DisplayApp::Process, "displayapp", 512, this, 0, &taskHandle)) + APP_ERROR_HANDLER(NRF_ERROR_NO_MEM); +} + +void DisplayApp::Process(void *instance) { + auto *app = static_cast<DisplayApp *>(instance); + NRF_LOG_INFO("displayapp task started!"); + app->InitHw(); + + // Send a dummy notification to unlock the lvgl display driver for the first iteration + xTaskNotifyGive(xTaskGetCurrentTaskHandle()); + + while (1) { + + app->Refresh(); + + } +} + +void DisplayApp::InitHw() { + brightnessController.Init(); +} + +uint32_t acc = 0; +uint32_t count = 0; +bool toggle = true; +void DisplayApp::Refresh() { + TickType_t queueTimeout; + switch (state) { + case States::Idle: + IdleState(); + queueTimeout = portMAX_DELAY; + break; + case States::Running: + RunningState(); + queueTimeout = 20; + break; + default: + queueTimeout = portMAX_DELAY; + break; + } + + Messages msg; + if (xQueueReceive(msgQueue, &msg, queueTimeout)) { + switch (msg) { + case Messages::GoToSleep: + brightnessController.Backup(); + while(brightnessController.Level() != Controllers::BrightnessController::Levels::Off) { + brightnessController.Lower(); + vTaskDelay(100); + } + lcd.DisplayOff(); + systemTask.PushMessage(System::SystemTask::Messages::OnDisplayTaskSleeping); + state = States::Idle; + break; + case Messages::GoToRunning: + lcd.DisplayOn(); + brightnessController.Restore(); + state = States::Running; + break; + case Messages::UpdateDateTime: +// modal->Show(); + break; + case Messages::UpdateBleConnection: +// clockScreen.SetBleConnectionState(bleController.IsConnected() ? Screens::Clock::BleConnectionStates::Connected : Screens::Clock::BleConnectionStates::NotConnected); + break; + case Messages::UpdateBatteryLevel: +// clockScreen.SetBatteryPercentRemaining(batteryController.PercentRemaining()); + break; + case Messages::NewNotification: { + if(onClockApp) { + currentScreen.reset(nullptr); + lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Up); + onClockApp = false; + currentScreen.reset(new Screens::Notifications(this, notificationManager, Screens::Notifications::Modes::Preview)); + } + } + break; + case Messages::TouchEvent: { + if (state != States::Running) break; + auto gesture = OnTouchEvent(); + if(!currentScreen->OnTouchEvent(gesture)) { + switch (gesture) { + case TouchEvents::SwipeUp: + currentScreen->OnButtonPushed(); + lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Up); + break; + case TouchEvents::SwipeDown: + currentScreen->OnButtonPushed(); + lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Down); + break; + default: + break; + } + } + } + break; + case Messages::ButtonPushed: + if(onClockApp) + systemTask.PushMessage(System::SystemTask::Messages::GoToSleep); + else { + auto buttonUsedByApp = currentScreen->OnButtonPushed(); + if (!buttonUsedByApp) { + systemTask.PushMessage(System::SystemTask::Messages::GoToSleep); + } else { + lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Up); + } + } + +// lvgl.SetFullRefresh(components::LittleVgl::FullRefreshDirections::Down); +// currentScreen.reset(nullptr); +// if(toggle) { +// currentScreen.reset(new Screens::Tile(this)); +// toggle = false; +// } else { +// currentScreen.reset(new Screens::Clock(this, dateTimeController, batteryController, bleController)); +// toggle = true; +// } + + break; + case Messages::BleFirmwareUpdateStarted: + lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Down); + currentScreen.reset(nullptr); + currentScreen.reset(new Screens::FirmwareUpdate(this, bleController)); + onClockApp = false; + + break; + } + } + + if(state != States::Idle && touchMode == TouchModes::Polling) { + auto info = touchPanel.GetTouchInfo(); + if(info.action == 2) {// 2 = contact + if(!currentScreen->OnTouchEvent(info.x, info.y)) { + lvgl.SetNewTapEvent(info.x, info.y); + } + } + } +} + +void DisplayApp::RunningState() { +// clockScreen.SetCurrentDateTime(dateTimeController.CurrentDateTime()); + + if(!currentScreen->Refresh()) { + currentScreen.reset(nullptr); + lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Up); + onClockApp = false; + switch(nextApp) { + case Apps::None: + case Apps::Launcher: currentScreen.reset(new Screens::ApplicationList(this)); break; + case Apps::Clock: + currentScreen.reset(new Screens::Clock(this, dateTimeController, batteryController, bleController, notificationManager)); + onClockApp = true; + break; +// case Apps::Test: currentScreen.reset(new Screens::Message(this)); break; + case Apps::SysInfo: currentScreen.reset(new Screens::SystemInfo(this, dateTimeController, batteryController, brightnessController, bleController, watchdog)); break; + case Apps::Meter: currentScreen.reset(new Screens::Meter(this)); break; + case Apps::Gauge: currentScreen.reset(new Screens::Gauge(this)); break; + case Apps::Paint: currentScreen.reset(new Screens::InfiniPaint(this, lvgl)); break; + case Apps::Brightness : currentScreen.reset(new Screens::Brightness(this, brightnessController)); break; + case Apps::Music : currentScreen.reset(new Screens::Music(this, systemTask.nimble().music())); break; + case Apps::FirmwareValidation: currentScreen.reset(new Screens::FirmwareValidation(this, validator)); break; + case Apps::Notifications: currentScreen.reset(new Screens::Notifications(this, notificationManager, Screens::Notifications::Modes::Normal)); break; + } + nextApp = Apps::None; + } + lv_task_handler(); +} + +void DisplayApp::IdleState() { + +} + +void DisplayApp::PushMessage(DisplayApp::Messages msg) { + BaseType_t xHigherPriorityTaskWoken; + xHigherPriorityTaskWoken = pdFALSE; + xQueueSendFromISR(msgQueue, &msg, &xHigherPriorityTaskWoken); + if (xHigherPriorityTaskWoken) { + /* Actual macro used here is port specific. */ + // TODO : should I do something here? + } +} + +TouchEvents DisplayApp::OnTouchEvent() { + auto info = touchPanel.GetTouchInfo(); + if(info.isTouch) { + switch(info.gesture) { + case Pinetime::Drivers::Cst816S::Gestures::SingleTap: + if(touchMode == TouchModes::Gestures) + lvgl.SetNewTapEvent(info.x, info.y); + return TouchEvents::Tap; + case Pinetime::Drivers::Cst816S::Gestures::LongPress: + return TouchEvents::LongTap; + case Pinetime::Drivers::Cst816S::Gestures::DoubleTap: + return TouchEvents::DoubleTap; + case Pinetime::Drivers::Cst816S::Gestures::SlideRight: + return TouchEvents::SwipeRight; + case Pinetime::Drivers::Cst816S::Gestures::SlideLeft: + return TouchEvents::SwipeLeft; + case Pinetime::Drivers::Cst816S::Gestures::SlideDown: + return TouchEvents::SwipeDown; + case Pinetime::Drivers::Cst816S::Gestures::SlideUp: + return TouchEvents::SwipeUp; + case Pinetime::Drivers::Cst816S::Gestures::None: + default: + return TouchEvents::None; + } + } + return TouchEvents::None; +} + +void DisplayApp::StartApp(Apps app) { + nextApp = app; +} + +void DisplayApp::SetFullRefresh(DisplayApp::FullRefreshDirections direction) { + switch(direction){ + case DisplayApp::FullRefreshDirections::Down: + lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Down); + break; + case DisplayApp::FullRefreshDirections::Up: + lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Up); + break; + default: break; + } + +} + +void DisplayApp::SetTouchMode(DisplayApp::TouchModes mode) { + touchMode = mode; +} diff --git a/src/displayapp/DisplayApp.h b/src/displayapp/DisplayApp.h new file mode 100644 index 00000000..2a0efde3 --- /dev/null +++ b/src/displayapp/DisplayApp.h @@ -0,0 +1,92 @@ +#pragma once +#include <FreeRTOS.h> +#include <task.h> +#include <drivers/St7789.h> +#include <drivers/SpiMaster.h> +#include <bits/unique_ptr.h> +#include <queue.h> +#include "components/gfx/Gfx.h" +#include "components/battery/BatteryController.h" +#include "components/brightness/BrightnessController.h" +#include "components/ble/BleController.h" +#include "components/datetime/DateTimeController.h" +#include "components/ble/NotificationManager.h" +#include "components/firmwarevalidator/FirmwareValidator.h" +#include "drivers/Cst816s.h" +#include "LittleVgl.h" +#include <date/date.h> +#include "displayapp/screens/Clock.h" +#include "displayapp/screens/Modal.h" +#include <drivers/Watchdog.h> +#include "TouchEvents.h" +#include "Apps.h" + + +namespace Pinetime { + namespace System { + class SystemTask; + }; + namespace Applications { + class DisplayApp { + public: + enum class States {Idle, Running}; + enum class Messages : uint8_t {GoToSleep, GoToRunning, UpdateDateTime, UpdateBleConnection, UpdateBatteryLevel, TouchEvent, ButtonPushed, + NewNotification, BleFirmwareUpdateStarted }; + + enum class FullRefreshDirections { None, Up, Down }; + enum class TouchModes { Gestures, Polling }; + + DisplayApp(Drivers::St7789 &lcd, Components::LittleVgl &lvgl, Drivers::Cst816S &, + Controllers::Battery &batteryController, Controllers::Ble &bleController, + Controllers::DateTime &dateTimeController, Drivers::WatchdogView &watchdog, + System::SystemTask &systemTask, + Pinetime::Controllers::NotificationManager& notificationManager); + void Start(); + void PushMessage(Messages msg); + + void StartApp(Apps app); + + void SetFullRefresh(FullRefreshDirections direction); + void SetTouchMode(TouchModes mode); + + private: + TaskHandle_t taskHandle; + static void Process(void* instance); + void InitHw(); + Pinetime::Drivers::St7789& lcd; + Pinetime::Components::LittleVgl& lvgl; + void Refresh(); + + States state = States::Running; + void RunningState(); + void IdleState(); + QueueHandle_t msgQueue; + + static constexpr uint8_t queueSize = 10; + static constexpr uint8_t itemSize = 1; + + Pinetime::Controllers::Battery &batteryController; + Pinetime::Controllers::Ble &bleController; + Pinetime::Controllers::DateTime& dateTimeController; + Pinetime::Drivers::WatchdogView& watchdog; + + Pinetime::Drivers::Cst816S& touchPanel; + TouchEvents OnTouchEvent(); + + std::unique_ptr<Screens::Screen> currentScreen; + + bool isClock = true; + + Pinetime::System::SystemTask& systemTask; + Apps nextApp = Apps::None; + bool onClockApp = false; // TODO find a better way to know that we should handle gestures and button differently for the Clock app. + Controllers::BrightnessController brightnessController; + std::unique_ptr<Screens::Modal> modal; + Pinetime::Controllers::NotificationManager& notificationManager; + Pinetime::Controllers::FirmwareValidator validator; + TouchModes touchMode = TouchModes::Gestures; + }; + } +} + + diff --git a/src/displayapp/LittleVgl.cpp b/src/displayapp/LittleVgl.cpp new file mode 100644 index 00000000..7b6275e2 --- /dev/null +++ b/src/displayapp/LittleVgl.cpp @@ -0,0 +1,833 @@ +#include <FreeRTOS.h> +#include <projdefs.h> +#include <task.h> +#include <libs/lvgl/src/lv_core/lv_obj.h> +#include <hal/nrf_rtc.h> +#include <libraries/log/nrf_log.h> + +#include <libs/lvgl/src/lv_themes/lv_theme.h> +#include <libs/lvgl/src/lv_themes/lv_theme_night.h> + +#include "LittleVgl.h" + +using namespace Pinetime::Components; + +extern "C" { +LV_FONT_DECLARE(jetbrains_mono_extrabold_compressed) +LV_FONT_DECLARE(jetbrains_mono_bold_20) +} + +lv_style_t* LabelBigStyle = nullptr; + +static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p) { + auto* lvgl = static_cast<LittleVgl*>(disp_drv->user_data); + lvgl->FlushDisplay(area, color_p); +} + +bool touchpad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data) { + auto* lvgl = static_cast<LittleVgl*>(indev_drv->user_data); + return lvgl->GetTouchPadInfo(data); +} + +LittleVgl::LittleVgl(Pinetime::Drivers::St7789& lcd, Pinetime::Drivers::Cst816S& touchPanel) : lcd{lcd}, touchPanel{touchPanel}, previousClick{0,0} { + lv_init(); + InitTheme(); + InitDisplay(); + InitTouchpad(); +} + +void LittleVgl::InitDisplay() { + lv_disp_buf_init(&disp_buf_2, buf2_1, buf2_2, LV_HOR_RES_MAX * 4); /*Initialize the display buffer*/ + lv_disp_drv_init(&disp_drv); /*Basic initialization*/ + + /*Set up the functions to access to your display*/ + + /*Set the resolution of the display*/ + disp_drv.hor_res = 240; + disp_drv.ver_res = 240; + + /*Used to copy the buffer's content to the display*/ + disp_drv.flush_cb = disp_flush; + /*Set a display buffer*/ + disp_drv.buffer = &disp_buf_2; + disp_drv.user_data = this; + + /*Finally register the driver*/ + lv_disp_drv_register(&disp_drv); +} + +void LittleVgl::InitTouchpad() { + lv_indev_drv_t indev_drv; + + lv_indev_drv_init(&indev_drv); + indev_drv.type = LV_INDEV_TYPE_POINTER; + indev_drv.read_cb = touchpad_read; + indev_drv.user_data = this; + lv_indev_drv_register(&indev_drv); +} + +void LittleVgl::SetFullRefresh(FullRefreshDirections direction) { + if(scrollDirection == FullRefreshDirections::None) { + scrollDirection = direction; + if (scrollDirection == FullRefreshDirections::Down) + lv_disp_set_direction(lv_disp_get_default(), 1); + } +} + +void LittleVgl::FlushDisplay(const lv_area_t *area, lv_color_t *color_p) { + ulTaskNotifyTake(pdTRUE, 500); + // Notification is still needed (even if there is a mutex on SPI) because of the DataCommand pin + // which cannot be set/clear during a transfer. + + + // TODO refactore and remove duplicated code + + uint16_t x, y, y1, y2, width, height = 0; + if(scrollDirection == LittleVgl::FullRefreshDirections::Down) { + if(area->y2 == visibleNbLines-1) { + writeOffset = ((writeOffset + totalNbLines) - visibleNbLines) % totalNbLines; + } + x = area->x1; + width = (area->x2 - area->x1) + 1; + + y1 = (area->y1 + writeOffset) % totalNbLines; + y2 = (area->y2 + writeOffset) % totalNbLines; + y = y1; + height = (y2 - y1) + 1; + + if(area->y2 < visibleNbLines - 1) { + uint16_t toScroll = 0; + if(area->y1 == 0) { + toScroll = height*2; + scrollDirection = FullRefreshDirections::None; + lv_disp_set_direction(lv_disp_get_default(), 0); + } else { + toScroll = height; + } + + if(scrollOffset >= toScroll) + scrollOffset -= toScroll; + else { + toScroll -= scrollOffset; + scrollOffset = (totalNbLines) - toScroll; + } + + lcd.VerticalScrollDefinition(0, 320, 0); + lcd.VerticalScrollStartAddress(scrollOffset); + } + + lcd.BeginDrawBuffer(x, y, width, height); + lcd.NextDrawBuffer(reinterpret_cast<const uint8_t *>(color_p), width * height*2) ; + + } else if(scrollDirection == FullRefreshDirections::Up) { + if(area->y1 == 0) { + writeOffset = (writeOffset + visibleNbLines) % totalNbLines; + } + + x = area->x1; + width = (area->x2 - area->x1) + 1; + + y1 = (area->y1 + writeOffset) % totalNbLines; + y2 = (area->y2 + writeOffset) % totalNbLines; + y = y1; + height = (y2 - y1) + 1; + + if(area->y1 > 0) { + if(area->y2 == visibleNbLines -1) { + scrollOffset += (height * 2); + scrollDirection = FullRefreshDirections::None; + lv_disp_set_direction(lv_disp_get_default(), 0); + } else { + scrollOffset += height; + } + scrollOffset = scrollOffset % totalNbLines; + lcd.VerticalScrollDefinition(0, 320, 0); + lcd.VerticalScrollStartAddress(scrollOffset); + } + + lcd.BeginDrawBuffer(x, y, width, height); + lcd.NextDrawBuffer(reinterpret_cast<const uint8_t *>(color_p), width * height*2); + } else { + x = area->x1; + width = (area->x2 - area->x1) + 1; + y1 = (area->y1 + writeOffset) % totalNbLines; + y2 = (area->y2 + writeOffset) % totalNbLines; + y = y1; + height = (y2 - y1) + 1; + + if (y2 < y1) { + height = (totalNbLines - 1) - y1; + lcd.BeginDrawBuffer(x, y1, width, height); + lcd.NextDrawBuffer(reinterpret_cast<const uint8_t *>(color_p), width * height * 2); + ulTaskNotifyTake(pdTRUE, 500); + height = y2; + lcd.BeginDrawBuffer(x, 0, width, height); + lcd.NextDrawBuffer(reinterpret_cast<const uint8_t *>(color_p), width * height * 2); + } else { + lcd.BeginDrawBuffer(x, y, width, height); + lcd.NextDrawBuffer(reinterpret_cast<const uint8_t *>(color_p), width * height * 2); + } + } + + /* IMPORTANT!!! + * Inform the graphics library that you are ready with the flushing*/ + lv_disp_flush_ready(&disp_drv); +} + +void LittleVgl::SetNewTapEvent(uint16_t x, uint16_t y) { + tap_x = x; + tap_y = y; + tapped = true; +} + +bool LittleVgl::GetTouchPadInfo(lv_indev_data_t *ptr) { + if(tapped) { + ptr->point.x = tap_x; + ptr->point.y = tap_y; + ptr->state = LV_INDEV_STATE_PR; + tapped = false; + } else { + ptr->state = LV_INDEV_STATE_REL; + } + return false; + /* + auto info = touchPanel.GetTouchInfo(); + + if((previousClick.x != info.x || previousClick.y != info.y) && + (info.gesture == Drivers::Cst816S::Gestures::SingleTap)) { + // TODO For an unknown reason, the first touch is taken twice into account. + // 'firstTouch' is a quite'n'dirty workaound until I find a better solution + if(firstTouch) ptr->state = LV_INDEV_STATE_REL; + else ptr->state = LV_INDEV_STATE_PR; + firstTouch = false; + previousClick.x = info.x; + previousClick.y = info.y; + } + else { + ptr->state = LV_INDEV_STATE_REL; + } + + ptr->point.x = info.x; + ptr->point.y = info.y; + return false; + */ +} + +void LittleVgl::InitTheme() { + uint16_t i; + lv_style_t ** style_p = (lv_style_t **)&theme.style; + for(i = 0; i < LV_THEME_STYLE_COUNT; i++) { + *style_p = &def; + style_p++; + } + + InitBaseTheme(); + InitThemeContainer(); + InitThemeButton(); + InitThemeLabel(); + InitThemeLine(); + InitThemeLed(); + InitThemeImage(); + InitThemeBar(); + InitThemeSlider(); + InitThemeSwitch(); + InitThemeMeter(); + InitThemeGauge(); + InitThemeArc(); + InitThemePreload(); + InitThemeChart(); + InitThemeCalendar(); + InitThemeCheckBox(); + InitThemeButtonMatrix(); + InitThemeKnob(); + InitThemeMessageBox(); + InitThemePage(); + InitThemeTextArea(); + InitThemeSpinBox(); + InitThemeList(); + InitThemeDropDownList(); + InitThemeRoller(); + InitThemeTabView(); + InitThemeTileView(); + InitThemeTable(); + InitThemeWindow(); + + lv_theme_set_current(&theme); +} + +void LittleVgl::InitBaseTheme() { + if(font == nullptr) font = &jetbrains_mono_bold_20; + lv_style_copy(&def, &lv_style_plain); /*Initialize the default style*/ + def.text.font = font; + + lv_style_copy(&bg, &lv_style_plain); + bg.body.main_color = LV_COLOR_BLACK; + bg.body.grad_color = LV_COLOR_BLACK; + bg.text.color = LV_COLOR_WHITE; + bg.text.font = font; + bg.image.color = LV_COLOR_WHITE; + + lv_style_copy(&scr, &bg); + scr.body.padding.bottom = 0; + scr.body.padding.top = 0; + scr.body.padding.left = 0; + scr.body.padding.right = 0; + + lv_style_copy(&sb, &def); + sb.body.main_color = lv_color_hsv_to_rgb(hue, 30, 60); + sb.body.grad_color = lv_color_hsv_to_rgb(hue, 30, 60); + sb.body.border.width = 0; + sb.body.padding.inner = LV_DPI / 20; + sb.body.padding.left = 0; + sb.body.padding.right = 0; + sb.body.padding.top = 0; + sb.body.padding.bottom = 0; + sb.body.radius = LV_DPI / 30; + sb.body.opa = LV_OPA_COVER; + + lv_style_copy(&panel, &bg); + panel.body.main_color = lv_color_hsv_to_rgb(hue, 11, 18); + panel.body.grad_color = lv_color_hsv_to_rgb(hue, 11, 18); + panel.body.radius = LV_DPI / 20; + panel.body.border.color = lv_color_hsv_to_rgb(hue, 10, 25); + panel.body.border.width = 1; + panel.body.border.opa = LV_OPA_COVER; + panel.body.padding.left = LV_DPI / 10; + panel.body.padding.right = LV_DPI / 10; + panel.body.padding.top = LV_DPI / 10; + panel.body.padding.bottom = LV_DPI / 10; + panel.line.color = lv_color_hsv_to_rgb(hue, 20, 40); + panel.line.width = 1; + + theme.style.scr = &scr; + theme.style.bg = &bg; + theme.style.panel = &def; +} + +void LittleVgl::InitThemeContainer() { + theme.style.cont = &panel; +} + +void LittleVgl::InitThemeButton() { + + + lv_style_copy(&btn_rel, &def); + btn_rel.body.main_color = lv_color_hsv_to_rgb(hue, 10, 40); + btn_rel.body.grad_color = lv_color_hsv_to_rgb(hue, 10, 20); + btn_rel.body.border.color = lv_color_hex3(0x111); + btn_rel.body.border.width = 1; + btn_rel.body.border.opa = LV_OPA_70; + btn_rel.body.padding.left = LV_DPI / 4; + btn_rel.body.padding.right = LV_DPI / 4; + btn_rel.body.padding.top = LV_DPI / 8; + btn_rel.body.padding.bottom = LV_DPI / 8; + btn_rel.body.shadow.type = LV_SHADOW_BOTTOM; + btn_rel.body.shadow.color = lv_color_hex3(0x111); + btn_rel.body.shadow.width = LV_DPI / 30; + btn_rel.text.color = lv_color_hex3(0xeee); + btn_rel.image.color = lv_color_hex3(0xeee); + + lv_style_copy(&btn_pr, &btn_rel); + btn_pr.body.main_color = lv_color_hsv_to_rgb(hue, 10, 30); + btn_pr.body.grad_color = lv_color_hsv_to_rgb(hue, 10, 10); + + lv_style_copy(&btn_tgl_rel, &btn_rel); + btn_tgl_rel.body.main_color = lv_color_hsv_to_rgb(hue, 10, 20); + btn_tgl_rel.body.grad_color = lv_color_hsv_to_rgb(hue, 10, 40); + btn_tgl_rel.body.shadow.width = LV_DPI / 40; + btn_tgl_rel.text.color = lv_color_hex3(0xddd); + btn_tgl_rel.image.color = lv_color_hex3(0xddd); + + lv_style_copy(&btn_tgl_pr, &btn_rel); + btn_tgl_pr.body.main_color = lv_color_hsv_to_rgb(hue, 10, 10); + btn_tgl_pr.body.grad_color = lv_color_hsv_to_rgb(hue, 10, 30); + btn_tgl_pr.body.shadow.width = LV_DPI / 30; + btn_tgl_pr.text.color = lv_color_hex3(0xddd); + btn_tgl_pr.image.color = lv_color_hex3(0xddd); + + lv_style_copy(&btn_ina, &btn_rel); + btn_ina.body.main_color = lv_color_hsv_to_rgb(hue, 10, 20); + btn_ina.body.grad_color = lv_color_hsv_to_rgb(hue, 10, 20); + btn_ina.body.shadow.width = 0; + btn_ina.text.color = lv_color_hex3(0xaaa); + btn_ina.image.color = lv_color_hex3(0xaaa); + + theme.style.btn.rel = &btn_rel; + theme.style.btn.pr = &btn_pr; + theme.style.btn.tgl_rel = &btn_tgl_rel; + theme.style.btn.tgl_pr = &btn_tgl_pr; + theme.style.btn.ina = &btn_ina; +} + +void LittleVgl::InitThemeLabel() { + lv_style_copy(&prim, &bg); + prim.text.color = lv_color_hsv_to_rgb(hue, 5, 95); + + lv_style_copy(&labelBigStyle, &prim); + labelBigStyle.text.font = &jetbrains_mono_extrabold_compressed; + LabelBigStyle = &(this->labelBigStyle); + + lv_style_copy(&sec, &bg); + sec.text.color = lv_color_hsv_to_rgb(hue, 15, 65); + + lv_style_copy(&hint, &bg); + hint.text.color = lv_color_hsv_to_rgb(hue, 20, 55); + + theme.style.label.prim = &prim; + theme.style.label.sec = &sec; + theme.style.label.hint = &hint; +} + +void LittleVgl::InitThemeLine() { + theme.style.line.decor = &def; +} + +void LittleVgl::InitThemeLed() { + lv_style_copy(&led, &def); + led.body.shadow.width = LV_DPI / 10; + led.body.radius = LV_RADIUS_CIRCLE; + led.body.border.width = LV_DPI / 30; + led.body.border.opa = LV_OPA_30; + led.body.main_color = lv_color_hsv_to_rgb(hue, 100, 100); + led.body.grad_color = lv_color_hsv_to_rgb(hue, 100, 40); + led.body.border.color = lv_color_hsv_to_rgb(hue, 60, 60); + led.body.shadow.color = lv_color_hsv_to_rgb(hue, 100, 100); + + theme.style.led = &led; +} + +void LittleVgl::InitThemeImage() { + theme.style.img.light = &def; + theme.style.img.dark = &def; +} + +void LittleVgl::InitThemeBar() { + lv_style_copy(&bar_bg, &panel); + bar_bg.body.padding.left = LV_DPI / 16; + bar_bg.body.padding.right = LV_DPI / 16; + bar_bg.body.padding.top = LV_DPI / 16; + bar_bg.body.padding.bottom = LV_DPI / 16; + bar_bg.body.radius = LV_RADIUS_CIRCLE; + + lv_style_copy(&bar_indic, &def); + bar_indic.body.main_color = lv_color_hsv_to_rgb(hue, 80, 70); + bar_indic.body.grad_color = lv_color_hsv_to_rgb(hue, 80, 70); + bar_indic.body.border.color = lv_color_hsv_to_rgb(hue, 20, 15); + bar_indic.body.border.width = 1; + bar_indic.body.border.opa = LV_OPA_COVER; + bar_indic.body.radius = LV_RADIUS_CIRCLE; + bar_indic.body.padding.left = 0; + bar_indic.body.padding.right = 0; + bar_indic.body.padding.top = 0; + bar_indic.body.padding.bottom = 0; + + theme.style.bar.bg = &bar_bg; + theme.style.bar.indic = &bar_indic; +} + +void LittleVgl::InitThemeSlider() { + lv_style_copy(&slider_knob, theme.style.btn.rel); + slider_knob.body.radius = LV_RADIUS_CIRCLE; + + theme.style.slider.bg = theme.style.bar.bg; + theme.style.slider.indic = theme.style.bar.indic; + theme.style.slider.knob = &slider_knob; +} + +void LittleVgl::InitThemeSwitch() { + theme.style.sw.bg = theme.style.bar.bg; + theme.style.sw.indic = theme.style.bar.indic; + theme.style.sw.knob_off = theme.style.slider.knob; + theme.style.sw.knob_on = theme.style.slider.knob; +} + +void LittleVgl::InitThemeMeter() { + static lv_style_t lmeter_bg; + lv_style_copy(&lmeter_bg, &def); + lmeter_bg.body.main_color = lv_color_hsv_to_rgb(hue, 10, 70); + lmeter_bg.body.grad_color = lv_color_hsv_to_rgb(hue, 95, 90); + lmeter_bg.body.padding.left = LV_DPI / 10; /*Scale line length*/ + lmeter_bg.body.padding.inner = LV_DPI / 10; /*Text padding*/ + lmeter_bg.body.border.color = lv_color_hex3(0x333); + lmeter_bg.line.color = lv_color_hex3(0x555); + lmeter_bg.line.width = 1; + lmeter_bg.text.color = lv_color_hex3(0xddd); + + theme.style.lmeter = &lmeter_bg; +} + +void LittleVgl::InitThemeGauge() { + static lv_style_t gauge_bg; + lv_style_copy(&gauge_bg, &def); + gauge_bg.body.main_color = lv_color_hsv_to_rgb(hue, 10, 70); + gauge_bg.body.grad_color = gauge_bg.body.main_color; + gauge_bg.line.color = lv_color_hsv_to_rgb(hue, 80, 75); + gauge_bg.line.width = 1; + gauge_bg.text.color = lv_color_hex3(0xddd); + + theme.style.gauge = &gauge_bg; +} + +void LittleVgl::InitThemeArc() { + lv_style_copy(&arc, &def); + arc.line.width = 8; + arc.line.color = lv_color_hsv_to_rgb(hue, 80, 70); + arc.line.rounded = 1; + + /*For preloader*/ + arc.body.border.width = 7; + arc.body.border.color = lv_color_hsv_to_rgb(hue, 11, 48); + arc.body.padding.left = 1; + arc.body.padding.right = 1; + arc.body.padding.top = 1; + arc.body.padding.bottom = 1; + + theme.style.arc = &arc; +} + +void LittleVgl::InitThemePreload() { +// theme.style.preload = theme.style.arc; +} + +void LittleVgl::InitThemeChart() { + theme.style.chart = &panel; +} + +void LittleVgl::InitThemeCalendar() { + + lv_style_copy(&cal_bg, &bg); + cal_bg.body.main_color = lv_color_hsv_to_rgb(hue, 10, 40); + cal_bg.body.grad_color = lv_color_hsv_to_rgb(hue, 10, 40); + cal_bg.body.border.color = lv_color_hex3(0x333); + cal_bg.body.border.width = 1; + cal_bg.body.radius = LV_DPI / 20; + cal_bg.body.padding.left = LV_DPI / 10; + cal_bg.body.padding.right = LV_DPI / 10; + cal_bg.body.padding.top = LV_DPI / 10; + cal_bg.body.padding.bottom = LV_DPI / 10; + + + lv_style_copy(&cal_header, &bg); + cal_header.body.main_color = lv_color_hsv_to_rgb(hue, 10, 20); + cal_header.body.grad_color = lv_color_hsv_to_rgb(hue, 10, 20); + cal_header.body.radius = 0; + cal_header.body.border.width = 1; + cal_header.body.border.color = lv_color_hex3(0x333); + cal_header.body.padding.left = LV_DPI / 10; + cal_header.body.padding.right = LV_DPI / 10; + cal_header.body.padding.top = LV_DPI / 10; + cal_header.body.padding.bottom = LV_DPI / 10; + + + lv_style_copy(&week_box, &panel); + week_box.body.main_color = lv_color_hsv_to_rgb(hue, 30, 45); + week_box.body.grad_color = lv_color_hsv_to_rgb(hue, 30, 45); + week_box.body.radius = LV_DPI / 20; + week_box.body.border.width = 1; + week_box.body.padding.left = LV_DPI / 20; + week_box.body.padding.right = LV_DPI / 20; + week_box.body.padding.top = LV_DPI / 25; + week_box.body.padding.bottom = LV_DPI / 25; + + lv_style_copy(&today_box, &week_box); + today_box.body.main_color = lv_color_hsv_to_rgb(hue, 80, 70); + today_box.body.grad_color = lv_color_hsv_to_rgb(hue, 80, 70); + today_box.body.radius = LV_DPI / 20; + today_box.body.padding.left = LV_DPI / 14; + today_box.body.padding.right = LV_DPI / 14; + today_box.body.padding.top = LV_DPI / 14; + today_box.body.padding.bottom = LV_DPI / 14; + + lv_style_copy(&highlighted_days, &bg); + highlighted_days.text.color = lv_color_hsv_to_rgb(hue, 40, 80); + + lv_style_copy(&ina_days, &bg); + ina_days.text.color = lv_color_hsv_to_rgb(hue, 0, 60); + + theme.style.calendar.bg = &cal_bg; + theme.style.calendar.header = &cal_header; + theme.style.calendar.week_box = &week_box; + theme.style.calendar.today_box = &today_box; + theme.style.calendar.highlighted_days = &highlighted_days; + theme.style.calendar.day_names = &cal_bg; + theme.style.calendar.inactive_days = &ina_days; +} + +void LittleVgl::InitThemeCheckBox() { + + lv_style_copy(&rel, &def); + rel.body.radius = LV_DPI / 20; + rel.body.main_color = lv_color_hsv_to_rgb(hue, 10, 95); + rel.body.grad_color = lv_color_hsv_to_rgb(hue, 10, 95); + rel.body.border.color = lv_color_hsv_to_rgb(hue, 10, 50); + rel.body.border.width = 2; + ; + + lv_style_copy(&pr, &rel); + pr.body.main_color = lv_color_hsv_to_rgb(hue, 10, 80); + pr.body.grad_color = lv_color_hsv_to_rgb(hue, 10, 80); + pr.body.border.color = lv_color_hsv_to_rgb(hue, 10, 20); + pr.body.border.width = 1; + ; + + lv_style_copy(&tgl_rel, &rel); + tgl_rel.body.main_color = lv_color_hsv_to_rgb(hue, 80, 90); + tgl_rel.body.grad_color = lv_color_hsv_to_rgb(hue, 80, 90); + tgl_rel.body.border.color = lv_color_hsv_to_rgb(hue, 80, 50); + + lv_style_copy(&tgl_pr, &tgl_rel); + tgl_pr.body.main_color = lv_color_hsv_to_rgb(hue, 80, 70); + tgl_pr.body.grad_color = lv_color_hsv_to_rgb(hue, 80, 70); + tgl_pr.body.border.color = lv_color_hsv_to_rgb(hue, 80, 30); + tgl_pr.body.border.width = 1; + ; + + lv_style_copy(&ina, &rel); + ina.body.main_color = lv_color_hex3(0x777); + ina.body.grad_color = lv_color_hex3(0x777); + ina.body.border.width = 0; + + theme.style.cb.bg = &lv_style_transp; + theme.style.cb.box.rel = &rel; + theme.style.cb.box.pr = ≺ + theme.style.cb.box.tgl_rel = &tgl_rel; + theme.style.cb.box.tgl_pr = &tgl_pr; + theme.style.cb.box.ina = &def; +} + +void LittleVgl::InitThemeButtonMatrix() { + + lv_style_copy(&btnm_bg, theme.style.btn.rel); + btnm_bg.body.padding.left = 2; + btnm_bg.body.padding.right = 2; + btnm_bg.body.padding.top = 2; + btnm_bg.body.padding.bottom = 2; + btnm_bg.body.padding.inner = 0; + btnm_bg.body.border.width = 1; + + lv_style_copy(&btnm_rel, theme.style.btn.rel); + btnm_rel.body.border.part = LV_BORDER_FULL | LV_BORDER_INTERNAL; + btnm_rel.body.border.width = 1; + btnm_rel.body.radius = 2; + + lv_style_copy(&btnm_pr, theme.style.btn.pr); + btnm_pr.body.border.part = btnm_rel.body.border.part; + btnm_pr.body.border.width = btnm_rel.body.border.width; + btnm_pr.body.radius = btnm_rel.body.radius; + + lv_style_copy(&btnm_tgl_rel, theme.style.btn.tgl_rel); + btnm_tgl_rel.body.border.part = btnm_rel.body.border.part; + btnm_tgl_rel.body.border.width = btnm_rel.body.border.width; + btnm_tgl_rel.body.radius = btnm_rel.body.radius; + + lv_style_copy(&btnm_tgl_pr, theme.style.btn.pr); + btnm_tgl_pr.body.border.part = btnm_rel.body.border.part; + btnm_tgl_pr.body.border.width = btnm_rel.body.border.width; + btnm_tgl_pr.body.radius = btnm_rel.body.radius; + + lv_style_copy(&btnm_ina, theme.style.btn.ina); + btnm_ina.body.border.part = btnm_rel.body.border.part; + btnm_ina.body.border.width = btnm_rel.body.border.width; + btnm_ina.body.radius = btnm_rel.body.radius; + + theme.style.btnm.bg = &btnm_bg; + theme.style.btnm.btn.rel = &btnm_rel; + theme.style.btnm.btn.pr = &btnm_pr; + theme.style.btnm.btn.tgl_rel = &btnm_tgl_rel; + theme.style.btnm.btn.tgl_pr = &btnm_tgl_pr; + theme.style.btnm.btn.ina = &btnm_ina; +} + +void LittleVgl::InitThemeKnob() { + theme.style.kb.bg = &bg; + theme.style.kb.btn.rel = theme.style.btn.rel; + theme.style.kb.btn.pr = theme.style.btn.pr; + theme.style.kb.btn.tgl_rel = theme.style.btn.tgl_rel; + theme.style.kb.btn.tgl_pr = theme.style.btn.tgl_pr; + theme.style.kb.btn.ina = theme.style.btn.ina; +} + +void LittleVgl::InitThemeMessageBox() { + lv_style_copy(&mbox_bg, &bg); + mbox_bg.body.main_color = lv_color_hsv_to_rgb(hue, 30, 30); + mbox_bg.body.grad_color = lv_color_hsv_to_rgb(hue, 30, 30); + mbox_bg.body.border.color = lv_color_hsv_to_rgb(hue, 11, 20); + mbox_bg.body.border.width = 1; + mbox_bg.body.shadow.width = LV_DPI / 10; + mbox_bg.body.shadow.color = lv_color_hex3(0x222); + mbox_bg.body.radius = LV_DPI / 20; + theme.style.mbox.bg = &mbox_bg; + theme.style.mbox.btn.bg = &lv_style_transp; + theme.style.mbox.btn.rel = theme.style.btn.rel; + theme.style.mbox.btn.pr = theme.style.btn.pr; +} + +void LittleVgl::InitThemePage() { + lv_style_copy(&page_scrl, &bg); + page_scrl.body.main_color = lv_color_hsv_to_rgb(hue, 10, 40); + page_scrl.body.grad_color = lv_color_hsv_to_rgb(hue, 10, 40); + page_scrl.body.border.color = lv_color_hex3(0x333); + page_scrl.body.border.width = 1; + page_scrl.body.radius = LV_DPI / 20; + + theme.style.page.bg = &panel; + theme.style.page.scrl = &page_scrl; + theme.style.page.sb = &sb; +} + +void LittleVgl::InitThemeTextArea() { + theme.style.ta.area = &panel; + theme.style.ta.oneline = &panel; + theme.style.ta.cursor = NULL; + theme.style.ta.sb = &def; +} + +void LittleVgl::InitThemeSpinBox() { + theme.style.spinbox.bg = &panel; + theme.style.spinbox.cursor = theme.style.ta.cursor; + theme.style.spinbox.sb = theme.style.ta.sb; +} + +void LittleVgl::InitThemeList() { + + lv_style_copy(&list_bg, &panel); + list_bg.body.padding.top = 0; + list_bg.body.padding.bottom = 0; + list_bg.body.padding.left = 0; + list_bg.body.padding.right = 0; + list_bg.body.padding.inner = 0; + + lv_style_copy(&list_btn_rel, &bg); + list_btn_rel.body.opa = LV_OPA_TRANSP; + list_btn_rel.body.border.part = LV_BORDER_BOTTOM; + list_btn_rel.body.border.color = lv_color_hsv_to_rgb(hue, 10, 5); + list_btn_rel.body.border.width = 1; + list_btn_rel.body.radius = LV_DPI / 10; + list_btn_rel.text.color = lv_color_hsv_to_rgb(hue, 5, 80); + list_btn_rel.image.color = lv_color_hsv_to_rgb(hue, 5, 80); + list_btn_rel.body.padding.top = LV_DPI / 6; + list_btn_rel.body.padding.bottom = LV_DPI / 6; + list_btn_rel.body.padding.left = LV_DPI / 8; + list_btn_rel.body.padding.right = LV_DPI / 8; + + lv_style_copy(&list_btn_pr, theme.style.btn.pr); + list_btn_pr.body.main_color = lv_color_hsv_to_rgb(hue, 10, 5); + list_btn_pr.body.grad_color = lv_color_hsv_to_rgb(hue, 10, 5); + list_btn_pr.body.border.color = lv_color_hsv_to_rgb(hue, 10, 5); + list_btn_pr.body.border.width = 0; + list_btn_pr.body.padding.top = LV_DPI / 6; + list_btn_pr.body.padding.bottom = LV_DPI / 6; + list_btn_pr.body.padding.left = LV_DPI / 8; + list_btn_pr.body.padding.right = LV_DPI / 8; + list_btn_pr.text.color = lv_color_hsv_to_rgb(hue, 5, 80); + list_btn_pr.image.color = lv_color_hsv_to_rgb(hue, 5, 80); + + lv_style_copy(&list_btn_tgl_rel, &list_btn_rel); + list_btn_tgl_rel.body.opa = LV_OPA_COVER; + list_btn_tgl_rel.body.main_color = lv_color_hsv_to_rgb(hue, 80, 70); + list_btn_tgl_rel.body.grad_color = lv_color_hsv_to_rgb(hue, 80, 70); + list_btn_tgl_rel.body.border.color = lv_color_hsv_to_rgb(hue, 60, 40); + list_btn_tgl_rel.body.radius = list_bg.body.radius; + + lv_style_copy(&list_btn_tgl_pr, &list_btn_tgl_rel); + list_btn_tgl_pr.body.main_color = lv_color_hsv_to_rgb(hue, 80, 60); + list_btn_tgl_pr.body.grad_color = lv_color_hsv_to_rgb(hue, 80, 60); + + theme.style.list.sb = &sb; + theme.style.list.bg = &list_bg; + theme.style.list.scrl = &lv_style_transp_tight; + theme.style.list.btn.rel = &list_btn_rel; + theme.style.list.btn.pr = &list_btn_pr; + theme.style.list.btn.tgl_rel = &list_btn_tgl_rel; + theme.style.list.btn.tgl_pr = &list_btn_tgl_pr; + theme.style.list.btn.ina = &def; +} + +void LittleVgl::InitThemeDropDownList() { + lv_style_copy(&ddlist_bg, theme.style.btn.rel); + ddlist_bg.text.line_space = LV_DPI / 8; + ddlist_bg.body.padding.top = LV_DPI / 8; + ddlist_bg.body.padding.bottom = LV_DPI / 8; + ddlist_bg.body.padding.left = LV_DPI / 8; + ddlist_bg.body.padding.right = LV_DPI / 8; + ddlist_bg.body.radius = LV_DPI / 30; + + lv_style_copy(&ddlist_sel, theme.style.btn.rel); + ddlist_sel.body.main_color = lv_color_hsv_to_rgb(hue, 20, 50); + ddlist_sel.body.grad_color = lv_color_hsv_to_rgb(hue, 20, 50); + ddlist_sel.body.radius = 0; + + theme.style.ddlist.bg = &ddlist_bg; + theme.style.ddlist.sel = &ddlist_sel; + theme.style.ddlist.sb = &def; +} + +void LittleVgl::InitThemeRoller() { + lv_style_t roller_bg; + + lv_style_copy(&roller_bg, theme.style.ddlist.bg); + roller_bg.body.main_color = lv_color_hsv_to_rgb(hue, 10, 20); + roller_bg.body.grad_color = lv_color_hsv_to_rgb(hue, 10, 40); + roller_bg.text.color = lv_color_hsv_to_rgb(hue, 5, 70); + roller_bg.text.opa = LV_OPA_60; + + theme.style.roller.bg = &roller_bg; + theme.style.roller.sel = theme.style.ddlist.sel; +} + +void LittleVgl::InitThemeTabView() { + theme.style.tabview.bg = &bg; + theme.style.tabview.indic = &lv_style_transp; + theme.style.tabview.btn.bg = &lv_style_transp; + theme.style.tabview.btn.rel = theme.style.btn.rel; + theme.style.tabview.btn.pr = theme.style.btn.pr; + theme.style.tabview.btn.tgl_rel = theme.style.btn.tgl_rel; + theme.style.tabview.btn.tgl_pr = theme.style.btn.tgl_pr; +} + +void LittleVgl::InitThemeTileView() { + theme.style.tileview.bg = &lv_style_transp_tight; + theme.style.tileview.scrl = &lv_style_transp_tight; + theme.style.tileview.sb = theme.style.page.sb; +} + +void LittleVgl::InitThemeTable() { + lv_style_copy(&cell, &panel); + cell.body.radius = 0; + cell.body.border.width = 1; + cell.body.padding.left = LV_DPI / 12; + cell.body.padding.right = LV_DPI / 12; + cell.body.padding.top = LV_DPI / 12; + cell.body.padding.bottom = LV_DPI / 12; + + theme.style.table.bg = &lv_style_transp_tight; + theme.style.table.cell = &cell; +} + +void LittleVgl::InitThemeWindow() { +// lv_style_copy(&win_bg, &bg); +// win_bg.body.border.color = lv_color_hex3(0x333); +// win_bg.body.border.width = 1; +// +// lv_style_copy(&win_header, &win_bg); +// win_header.body.main_color = lv_color_hsv_to_rgb(hue, 10, 20); +// win_header.body.grad_color = lv_color_hsv_to_rgb(hue, 10, 20); +// win_header.body.radius = 0; +// win_header.body.padding.left = 0; +// win_header.body.padding.right = 0; +// win_header.body.padding.top = 0; +// win_header.body.padding.bottom = 0; +// +// lv_style_copy(&win_btn_pr, &def); +// win_btn_pr.body.main_color = lv_color_hsv_to_rgb(hue, 10, 10); +// win_btn_pr.body.grad_color = lv_color_hsv_to_rgb(hue, 10, 10); +// win_btn_pr.text.color = lv_color_hex3(0xaaa); +// win_btn_pr.image.color = lv_color_hex3(0xaaa); +// +// theme.style.win.bg = &win_bg; +// theme.style.win.sb = &sb; +// theme.style.win.header = &win_header; +// theme.style.win.content = &lv_style_transp; +// theme.style.win.btn.rel = &lv_style_transp; +// theme.style.win.btn.pr = &win_btn_pr; +} diff --git a/src/displayapp/LittleVgl.h b/src/displayapp/LittleVgl.h new file mode 100644 index 00000000..5c1c4434 --- /dev/null +++ b/src/displayapp/LittleVgl.h @@ -0,0 +1,116 @@ +#pragma once + +#include <libs/lvgl/src/lv_core/lv_style.h> +#include <libs/lvgl/src/lv_themes/lv_theme.h> +#include <libs/lvgl/src/lv_hal/lv_hal.h> +#include <drivers/St7789.h> +#include <drivers/Cst816s.h> + +namespace Pinetime { + namespace Components { + class LittleVgl { + public: + enum class FullRefreshDirections { None, Up, Down }; + LittleVgl(Pinetime::Drivers::St7789& lcd, Pinetime::Drivers::Cst816S& touchPanel); + + LittleVgl(const LittleVgl&) = delete; + LittleVgl& operator=(const LittleVgl&) = delete; + LittleVgl(LittleVgl&&) = delete; + LittleVgl& operator=(LittleVgl&&) = delete; + + void FlushDisplay(const lv_area_t * area, lv_color_t * color_p); + bool GetTouchPadInfo(lv_indev_data_t *ptr); + void SetFullRefresh(FullRefreshDirections direction); + void SetNewTapEvent(uint16_t x, uint16_t y); + + private: + void InitDisplay(); + void InitTouchpad(); + void InitTheme(); + void InitBaseTheme(); + void InitThemeContainer(); + void InitThemeButton(); + void InitThemeLabel(); + void InitThemeLine(); + void InitThemeLed(); + void InitThemeImage(); + void InitThemeBar(); + void InitThemeSlider(); + void InitThemeSwitch(); + void InitThemeMeter(); + void InitThemeGauge(); + void InitThemeArc(); + void InitThemePreload(); + void InitThemeChart(); + void InitThemeCalendar(); + void InitThemeCheckBox(); + void InitThemeButtonMatrix(); + void InitThemeKnob(); + void InitThemeMessageBox(); + void InitThemePage(); + void InitThemeTextArea(); + void InitThemeSpinBox(); + void InitThemeList(); + void InitThemeDropDownList(); + void InitThemeRoller(); + void InitThemeTabView(); + void InitThemeTileView(); + void InitThemeTable(); + void InitThemeWindow(); + + Pinetime::Drivers::St7789& lcd; + Pinetime::Drivers::Cst816S& touchPanel; + + + lv_disp_buf_t disp_buf_2; + lv_color_t buf2_1[LV_HOR_RES_MAX * 4]; + lv_color_t buf2_2[LV_HOR_RES_MAX * 4]; + + lv_disp_drv_t disp_drv; + lv_point_t previousClick; + + lv_style_t def; + lv_style_t scr, bg, sb, panel; + lv_font_t * font = nullptr; + uint16_t hue = 10; + lv_theme_t theme; + lv_style_t btn_rel, btn_pr, btn_tgl_rel, btn_tgl_pr, btn_ina; + lv_style_t labelBigStyle; + lv_style_t prim, sec, hint; + lv_style_t led; + lv_style_t bar_bg, bar_indic; + lv_style_t slider_knob; + lv_style_t arc; + lv_style_t cal_bg; + lv_style_t cal_header; + lv_style_t week_box; + lv_style_t today_box; + lv_style_t highlighted_days; + lv_style_t ina_days; + lv_style_t rel, pr, tgl_rel, tgl_pr, ina; + lv_style_t btnm_bg, btnm_rel, btnm_pr, btnm_tgl_rel, btnm_tgl_pr, btnm_ina; + lv_style_t mbox_bg; + lv_style_t page_scrl; + lv_style_t list_bg, list_btn_rel, list_btn_pr, list_btn_tgl_rel, list_btn_tgl_pr; + lv_style_t ddlist_bg, ddlist_sel; + lv_style_t cell; + lv_style_t win_bg; + lv_style_t win_header; + lv_style_t win_btn_pr; + + bool firstTouch = true; + static constexpr uint8_t nbWriteLines = 4; + static constexpr uint16_t totalNbLines = 320; + static constexpr uint16_t visibleNbLines = 240; + static constexpr uint8_t MaxScrollOffset() { return LV_VER_RES_MAX - nbWriteLines; } + FullRefreshDirections scrollDirection = FullRefreshDirections::None; + uint16_t writeOffset = 0; + uint16_t scrollOffset = 0; + + uint16_t tap_x = 0; + uint16_t tap_y = 0; + bool tapped = false; + }; + } +} + diff --git a/src/displayapp/TouchEvents.h b/src/displayapp/TouchEvents.h new file mode 100644 index 00000000..cf2f88dd --- /dev/null +++ b/src/displayapp/TouchEvents.h @@ -0,0 +1,8 @@ +#pragma once + +namespace Pinetime { + namespace Applications { + + enum class TouchEvents { None, Tap, SwipeLeft, SwipeRight, SwipeUp, SwipeDown, LongTap, DoubleTap}; + } +}
\ No newline at end of file diff --git a/src/displayapp/fonts/Readme.md b/src/displayapp/fonts/Readme.md new file mode 100644 index 00000000..7ebf2e23 --- /dev/null +++ b/src/displayapp/fonts/Readme.md @@ -0,0 +1,23 @@ +#Fonts +* [Jetbrains Mono](https://www.jetbrains.com/fr-fr/lp/mono/) +* [Awesome font from LVGL](https://lvgl.io/assets/others/FontAwesome5-Solid+Brands+Regular.woff) + +## Generate the fonts: + + * Open the [LVGL font converter](https://lvgl.io/tools/fontconverter) + * Name : jetbrains_mono_bold_20 + * Size : 20 + * Bpp : 1 bit-per-pixel + * Do not enable font compression and horizontal subpixel hinting + * Load the file `JetBrainsMono-Bold.woff` and specify the following range : `0x20-0x7f` + * Add a 2nd font, load the file `FontAwesome5-Solid+Brands+Regular.woff` and specify the following range : `0xf293, 0xf294, 0xf244, 0xf240, 0xf242, 0xf243, 0xf241, 0xf54b, 0xf21e, 0xf1e6, 0xf54b, 0xf017, 0xf129, 0xf03a, 0xf185, 0xf560, 0xf001, 0xf3fd, 0xf069, 0xf1fc` + * Click on Convert, and download the file `jetbrains_mono_bold_20.c` and copy it in `src/DisplayApp/Fonts` + +Add new symbols: + * Browse the [cheatsheet](https://fontawesome.com/cheatsheet/free/solid) and find your new symbols + * For each symbol, add its hex code (0xf641 for the 'Ad' icon, for example) to the *Range* list + * Convert this hex value into a UTF-8 code using [this site](http://www.ltg.ed.ac.uk/~richard/utf-8.cgi?input=f185&mode=hex) + * Define the new symbols in `src/DisplayApp/Screens/Symbols.h`: +``` +static constex char* newSymbol = "\xEF\x86\x85"; +``` diff --git a/src/displayapp/fonts/jetbrains_mono_bold_20.c b/src/displayapp/fonts/jetbrains_mono_bold_20.c new file mode 100644 index 00000000..27ad0055 --- /dev/null +++ b/src/displayapp/fonts/jetbrains_mono_bold_20.c @@ -0,0 +1,766 @@ +#include "lvgl/lvgl.h" + +/******************************************************************************* + * Size: 20 px + * Bpp: 1 + * Opts: + ******************************************************************************/ + +#ifndef JETBRAINS_MONO_BOLD_20 +#define JETBRAINS_MONO_BOLD_20 1 +#endif + +#if JETBRAINS_MONO_BOLD_20 + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t gylph_bitmap[] = { + /* U+20 " " */ + 0x0, + + /* U+21 "!" */ + 0xff, 0xff, 0xff, 0xe0, 0xf, 0xc0, + + /* U+22 "\"" */ + 0xef, 0xdf, 0xbf, 0x7e, 0xfd, 0xc0, + + /* U+23 "#" */ + 0x8, 0xc3, 0x10, 0x62, 0x3f, 0xf7, 0xfe, 0x23, + 0x4, 0x61, 0x88, 0x31, 0x1f, 0xfb, 0xff, 0x19, + 0x82, 0x30, 0xc4, 0x0, + + /* U+24 "$" */ + 0x8, 0x2, 0x1, 0xc1, 0xfe, 0xeb, 0xf2, 0x7c, + 0x83, 0xa0, 0x7c, 0xf, 0xc0, 0xf8, 0x27, 0x9, + 0xf2, 0x7f, 0xf9, 0xfc, 0x8, 0x2, 0x0, 0x80, + + /* U+25 "%" */ + 0x78, 0x1f, 0x83, 0x30, 0x66, 0x1f, 0xcc, 0xf2, + 0x1, 0x80, 0xde, 0x67, 0xf8, 0xcc, 0x19, 0x83, + 0x30, 0x7e, 0x7, 0x80, + + /* U+26 "&" */ + 0x1e, 0x7, 0xe1, 0xce, 0x38, 0x7, 0x0, 0x70, + 0x1e, 0x7, 0x66, 0xed, 0xdc, 0xf3, 0x9c, 0x73, + 0xcf, 0xfc, 0xf9, 0x80, + + /* U+27 "'" */ + 0xff, 0xff, 0xc0, + + /* U+28 "(" */ + 0x2, 0x1c, 0xfb, 0xc7, 0x1e, 0x38, 0x70, 0xe1, + 0xc3, 0x87, 0xe, 0x1c, 0x3c, 0x38, 0x38, 0x7c, + 0x38, + + /* U+29 ")" */ + 0x1, 0xc3, 0xc1, 0xc1, 0xc3, 0xc3, 0x87, 0xe, + 0x1c, 0x38, 0x70, 0xe1, 0xc7, 0x8e, 0x79, 0xe3, + 0x80, + + /* U+2A "*" */ + 0xc, 0x3, 0x8, 0xc7, 0xb7, 0x7f, 0x83, 0x1, + 0xe0, 0xcc, 0x73, 0x80, 0x0, + + /* U+2B "+" */ + 0x1c, 0x7, 0x1, 0xc3, 0xff, 0xff, 0xc7, 0x1, + 0xc0, 0x70, 0x1c, 0x0, + + /* U+2C "," */ + 0x7b, 0x9c, 0xce, 0x60, + + /* U+2D "-" */ + 0xff, 0xff, + + /* U+2E "." */ + 0x6f, 0xf6, + + /* U+2F "/" */ + 0x1, 0xc0, 0x60, 0x38, 0xe, 0x3, 0x1, 0xc0, + 0x70, 0x18, 0xe, 0x3, 0x1, 0xc0, 0x70, 0x18, + 0xe, 0x3, 0x80, 0xc0, 0x70, 0x18, 0xe, 0x0, + + /* U+30 "0" */ + 0x3f, 0x1f, 0xef, 0x3f, 0x87, 0xed, 0xfb, 0x7e, + 0xdf, 0xb7, 0xed, 0xf8, 0x7e, 0x1f, 0xcf, 0x7f, + 0x8f, 0x80, + + /* U+31 "1" */ + 0x3c, 0x3e, 0x3f, 0x13, 0x81, 0xc0, 0xe0, 0x70, + 0x38, 0x1c, 0xe, 0x7, 0x3, 0x8f, 0xff, 0xfc, + + /* U+32 "2" */ + 0x1f, 0x1f, 0xef, 0x3f, 0x87, 0x1, 0xc0, 0x70, + 0x38, 0x1e, 0xf, 0x7, 0x87, 0x83, 0xc0, 0xff, + 0xff, 0xf0, + + /* U+33 "3" */ + 0x7f, 0xdf, 0xf0, 0x3c, 0x1c, 0x1c, 0x7, 0xc1, + 0xf8, 0xf, 0x1, 0xc0, 0x7e, 0x1d, 0x8f, 0x7f, + 0x87, 0xc0, + + /* U+34 "4" */ + 0x7, 0x7, 0x3, 0x83, 0x83, 0x81, 0xc1, 0xcf, + 0xe7, 0xe3, 0xff, 0xff, 0xe0, 0x70, 0x38, 0x1c, + + /* U+35 "5" */ + 0xff, 0x7f, 0xb8, 0x1c, 0xe, 0x7, 0x73, 0xfd, + 0xcf, 0x3, 0x81, 0xc0, 0xfc, 0xff, 0xf1, 0xf0, + + /* U+36 "6" */ + 0x6, 0x3, 0x1, 0xc0, 0x60, 0x30, 0x1b, 0xc7, + 0xfb, 0xcf, 0xe1, 0xf8, 0x7e, 0x1f, 0xcf, 0x7f, + 0x87, 0x80, + + /* U+37 "7" */ + 0xff, 0xff, 0xfe, 0xb, 0x86, 0x1, 0x80, 0xc0, + 0x30, 0x18, 0x6, 0x3, 0x80, 0xc0, 0x70, 0x18, + 0xe, 0x0, + + /* U+38 "8" */ + 0x3e, 0x1f, 0xce, 0x3b, 0x6, 0xe3, 0x9f, 0xc7, + 0xf1, 0x8e, 0xc1, 0xf0, 0x7c, 0x1f, 0x8f, 0x7f, + 0x8f, 0x80, + + /* U+39 "9" */ + 0x1e, 0x1f, 0xef, 0x3f, 0x87, 0xe1, 0xf8, 0x7f, + 0x3d, 0xfe, 0x3d, 0x80, 0xc0, 0x60, 0x38, 0xc, + 0x6, 0x0, + + /* U+3A ":" */ + 0xff, 0x80, 0x0, 0xff, 0x80, + + /* U+3B ";" */ + 0x7b, 0xde, 0x0, 0x0, 0x0, 0x7b, 0x9c, 0xce, + 0x60, + + /* U+3C "<" */ + 0x0, 0x81, 0xc3, 0xe7, 0xcf, 0x6, 0x3, 0xc0, + 0x7c, 0xf, 0x81, 0xc0, 0x20, + + /* U+3D "=" */ + 0xff, 0xff, 0xc0, 0x0, 0x0, 0x7, 0xff, 0xfe, + + /* U+3E ">" */ + 0x0, 0x70, 0x3e, 0x7, 0xc0, 0xf8, 0xc, 0x1e, + 0x7c, 0xf8, 0x70, 0x20, 0x0, + + /* U+3F "?" */ + 0xfc, 0xfe, 0xf, 0x7, 0x7, 0xf, 0x3e, 0x3c, + 0x30, 0x30, 0x0, 0x0, 0x70, 0x70, + + /* U+40 "@" */ + 0x1f, 0x87, 0xf9, 0xc3, 0xf0, 0x3c, 0x77, 0x9f, + 0xf3, 0x1e, 0x63, 0xcc, 0x79, 0x8f, 0x31, 0xe7, + 0xfc, 0x77, 0xc0, 0x1c, 0x1, 0xf0, 0x1e, 0x0, + + /* U+41 "A" */ + 0xf, 0x0, 0xf0, 0xf, 0x1, 0xf8, 0x19, 0x81, + 0x98, 0x19, 0x83, 0x9c, 0x3f, 0xc3, 0xfc, 0x70, + 0xe7, 0xe, 0x60, 0x66, 0x6, + + /* U+42 "B" */ + 0xfe, 0x3f, 0xce, 0x3b, 0x8e, 0xe3, 0xb8, 0xcf, + 0xe3, 0xfc, 0xe3, 0xb8, 0x7e, 0x1f, 0x8f, 0xff, + 0xbf, 0xc0, + + /* U+43 "C" */ + 0x3f, 0x1f, 0xef, 0x3f, 0x87, 0xe0, 0x38, 0xe, + 0x3, 0x80, 0xe0, 0x38, 0xe, 0x1f, 0xcf, 0x7f, + 0x8f, 0xc0, + + /* U+44 "D" */ + 0xfe, 0x3f, 0xee, 0x3f, 0x87, 0xe1, 0xf8, 0x7e, + 0x1f, 0x87, 0xe1, 0xf8, 0x7e, 0x1f, 0x8f, 0xff, + 0xbf, 0x80, + + /* U+45 "E" */ + 0xff, 0xff, 0xf8, 0x1c, 0xe, 0x7, 0x3, 0xfd, + 0xfe, 0xe0, 0x70, 0x38, 0x1c, 0xf, 0xff, 0xfc, + + /* U+46 "F" */ + 0xff, 0xff, 0xf8, 0x1c, 0xe, 0x7, 0x3, 0xff, + 0xff, 0xe0, 0x70, 0x38, 0x1c, 0xe, 0x7, 0x0, + + /* U+47 "G" */ + 0x3f, 0x1f, 0xef, 0x3f, 0x87, 0xe0, 0x38, 0xe, + 0x7f, 0x9f, 0xe1, 0xf8, 0x7e, 0x1f, 0xcf, 0x7f, + 0x87, 0x80, + + /* U+48 "H" */ + 0xe3, 0xf1, 0xf8, 0xfc, 0x7e, 0x3f, 0x1f, 0xff, + 0xff, 0xe3, 0xf1, 0xf8, 0xfc, 0x7e, 0x3f, 0x1c, + + /* U+49 "I" */ + 0xff, 0xff, 0xc7, 0x3, 0x81, 0xc0, 0xe0, 0x70, + 0x38, 0x1c, 0xe, 0x7, 0x3, 0x8f, 0xff, 0xfc, + + /* U+4A "J" */ + 0x3f, 0xcf, 0xf0, 0x1c, 0x7, 0x1, 0xc0, 0x70, + 0x1c, 0x7, 0x1, 0xc0, 0x7e, 0x1f, 0x8f, 0x7f, + 0x8f, 0xc0, + + /* U+4B "K" */ + 0xe1, 0xdc, 0x3b, 0x8e, 0x71, 0xce, 0x31, 0xce, + 0x3f, 0x87, 0xf0, 0xe7, 0x1c, 0x63, 0x8e, 0x70, + 0xce, 0x1d, 0xc3, 0x80, + + /* U+4C "L" */ + 0xe0, 0x70, 0x38, 0x1c, 0xe, 0x7, 0x3, 0x81, + 0xc0, 0xe0, 0x70, 0x38, 0x1c, 0xf, 0xff, 0xfc, + + /* U+4D "M" */ + 0xe1, 0xf8, 0x7f, 0x3f, 0xcf, 0xda, 0xf7, 0xbd, + 0xef, 0x33, 0xc0, 0xf0, 0x3c, 0xf, 0x3, 0xc0, + 0xf0, 0x30, + + /* U+4E "N" */ + 0xe1, 0xf0, 0xfc, 0x7e, 0x3d, 0x9e, 0xcf, 0x67, + 0x9b, 0xcd, 0xe6, 0xf1, 0xf8, 0xfc, 0x3e, 0x1c, + + /* U+4F "O" */ + 0x3f, 0x1f, 0xef, 0x3f, 0x87, 0xe1, 0xf8, 0x7e, + 0x1f, 0x87, 0xe1, 0xf8, 0x7e, 0x1f, 0xcf, 0x7f, + 0x8f, 0x80, + + /* U+50 "P" */ + 0xff, 0x3f, 0xee, 0x3f, 0x87, 0xe1, 0xf8, 0xff, + 0xfb, 0xfc, 0xe0, 0x38, 0xe, 0x3, 0x80, 0xe0, + 0x38, 0x0, + + /* U+51 "Q" */ + 0x3f, 0x1f, 0xef, 0x3f, 0x87, 0xe1, 0xf8, 0x7e, + 0x1f, 0x87, 0xe1, 0xf8, 0x7e, 0x1f, 0xcf, 0x7f, + 0x8f, 0x80, 0x70, 0xe, 0x1, 0xc0, + + /* U+52 "R" */ + 0xff, 0x3f, 0xee, 0x3f, 0x87, 0xe1, 0xf8, 0xff, + 0xfb, 0xf8, 0xe6, 0x39, 0xce, 0x33, 0x8e, 0xe3, + 0xb8, 0x70, + + /* U+53 "S" */ + 0x3f, 0x1f, 0xee, 0x1f, 0x87, 0xe0, 0x3e, 0x7, + 0xf0, 0x7e, 0x3, 0xc0, 0x7e, 0x1f, 0xcf, 0x7f, + 0x8f, 0xc0, + + /* U+54 "T" */ + 0xff, 0xff, 0xf0, 0xe0, 0x38, 0xe, 0x3, 0x80, + 0xe0, 0x38, 0xe, 0x3, 0x80, 0xe0, 0x38, 0xe, + 0x3, 0x80, + + /* U+55 "U" */ + 0xe3, 0xf1, 0xf8, 0xfc, 0x7e, 0x3f, 0x1f, 0x8f, + 0xc7, 0xe3, 0xf1, 0xf8, 0xfc, 0x77, 0xf1, 0xf0, + + /* U+56 "V" */ + 0x60, 0x66, 0x6, 0x70, 0xe7, 0xe, 0x30, 0xc3, + 0xc, 0x39, 0xc1, 0x98, 0x19, 0x81, 0x98, 0x1f, + 0x80, 0xf0, 0xf, 0x0, 0xf0, + + /* U+57 "W" */ + 0xc6, 0x78, 0xcf, 0x39, 0xe7, 0x3e, 0xa6, 0xd6, + 0xda, 0xdb, 0x5b, 0x6b, 0x6d, 0x2d, 0xe7, 0x3c, + 0xe7, 0x9c, 0xe3, 0x80, + + /* U+58 "X" */ + 0xe1, 0xd8, 0x67, 0x38, 0xcc, 0x3f, 0x7, 0x81, + 0xe0, 0x78, 0x1e, 0xf, 0xc3, 0x31, 0xce, 0xe1, + 0xf8, 0x70, + + /* U+59 "Y" */ + 0xe0, 0xfc, 0x1d, 0xc7, 0x38, 0xe3, 0x98, 0x77, + 0x6, 0xc0, 0xf8, 0xe, 0x1, 0xc0, 0x38, 0x7, + 0x0, 0xe0, 0x1c, 0x0, + + /* U+5A "Z" */ + 0xff, 0xff, 0xc0, 0xe0, 0xe0, 0x60, 0x70, 0x70, + 0x38, 0x38, 0x38, 0x1c, 0x1c, 0xf, 0xff, 0xfc, + + /* U+5B "[" */ + 0xff, 0xfe, 0x38, 0xe3, 0x8e, 0x38, 0xe3, 0x8e, + 0x38, 0xe3, 0x8e, 0x38, 0xff, 0xf0, + + /* U+5C "\\" */ + 0xe0, 0x18, 0x7, 0x1, 0xc0, 0x30, 0xe, 0x3, + 0x80, 0x60, 0x1c, 0x3, 0x0, 0xe0, 0x38, 0x6, + 0x1, 0xc0, 0x70, 0xc, 0x3, 0x80, 0x60, 0x1c, + + /* U+5D "]" */ + 0xff, 0xf1, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, + 0xc7, 0x1c, 0x71, 0xc7, 0xff, 0xf0, + + /* U+5E "^" */ + 0xc, 0x7, 0x81, 0xe0, 0xfc, 0x33, 0x1c, 0xe6, + 0x19, 0x86, + + /* U+5F "_" */ + 0xff, 0xff, 0xf0, + + /* U+60 "`" */ + 0x63, 0x8e, + + /* U+61 "a" */ + 0x3f, 0x1f, 0xee, 0x1c, 0x7, 0x3f, 0xdf, 0xfe, + 0x1f, 0x87, 0xe3, 0xff, 0xf7, 0xdc, + + /* U+62 "b" */ + 0xe0, 0x38, 0xe, 0x3, 0xbc, 0xff, 0xbc, 0xfe, + 0x1f, 0x87, 0xe1, 0xf8, 0x7e, 0x1f, 0xcf, 0xff, + 0xbb, 0xc0, + + /* U+63 "c" */ + 0x3f, 0x1f, 0xef, 0x1f, 0x83, 0xe0, 0x38, 0xe, + 0x3, 0x87, 0xf1, 0xdf, 0xe3, 0xe0, + + /* U+64 "d" */ + 0x1, 0xc0, 0x70, 0x1c, 0xf7, 0x7f, 0xfc, 0xfe, + 0x1f, 0x87, 0xe1, 0xf8, 0x7e, 0x1f, 0xcf, 0x7f, + 0xcf, 0x70, + + /* U+65 "e" */ + 0x3f, 0x1f, 0xef, 0x3f, 0x87, 0xff, 0xff, 0xfe, + 0x3, 0x80, 0xf1, 0xdf, 0xe3, 0xf0, + + /* U+66 "f" */ + 0xf, 0xc7, 0xf1, 0xc0, 0x70, 0xff, 0xff, 0xf1, + 0xc0, 0x70, 0x1c, 0x7, 0x1, 0xc0, 0x70, 0x1c, + 0x7, 0x0, + + /* U+67 "g" */ + 0x3d, 0xdf, 0xff, 0x3f, 0x87, 0xe1, 0xf8, 0x7e, + 0x1f, 0xcf, 0x7f, 0xcf, 0x70, 0x1c, 0xf, 0x3f, + 0x8f, 0xc0, + + /* U+68 "h" */ + 0xe0, 0x70, 0x38, 0x1d, 0xcf, 0xf7, 0x9f, 0x8f, + 0xc7, 0xe3, 0xf1, 0xf8, 0xfc, 0x7e, 0x3f, 0x1c, + + /* U+69 "i" */ + 0x1c, 0x7, 0x0, 0x0, 0x0, 0xfc, 0x3f, 0x1, + 0xc0, 0x70, 0x1c, 0x7, 0x1, 0xc0, 0x70, 0x1c, + 0x3f, 0xff, 0xfc, + + /* U+6A "j" */ + 0x7, 0x7, 0x0, 0x0, 0x7f, 0x7f, 0x7, 0x7, + 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0xf, + 0xfe, 0xfc, + + /* U+6B "k" */ + 0xe0, 0x38, 0xe, 0x3, 0x87, 0xe1, 0xb8, 0xee, + 0x33, 0x9c, 0xfe, 0x3f, 0x8e, 0x73, 0x8e, 0xe3, + 0xb8, 0x70, + + /* U+6C "l" */ + 0xfe, 0x1f, 0xc0, 0x38, 0x7, 0x0, 0xe0, 0x1c, + 0x3, 0x80, 0x70, 0xe, 0x1, 0xc0, 0x38, 0x7, + 0x0, 0xfe, 0xf, 0xc0, + + /* U+6D "m" */ + 0xd9, 0xbf, 0xfc, 0xcf, 0x33, 0xcc, 0xf3, 0x3c, + 0xcf, 0x33, 0xcc, 0xf3, 0x3c, 0xcc, + + /* U+6E "n" */ + 0xee, 0x7f, 0xbc, 0xfc, 0x7e, 0x3f, 0x1f, 0x8f, + 0xc7, 0xe3, 0xf1, 0xf8, 0xe0, + + /* U+6F "o" */ + 0x3f, 0x1f, 0xef, 0x3f, 0x87, 0xe1, 0xf8, 0x7e, + 0x1f, 0x87, 0xf3, 0xdf, 0xe3, 0xf0, + + /* U+70 "p" */ + 0xef, 0x3f, 0xef, 0x3f, 0x87, 0xe1, 0xf8, 0x7e, + 0x1f, 0x87, 0xf3, 0xff, 0xee, 0xf3, 0x80, 0xe0, + 0x38, 0x0, + + /* U+71 "q" */ + 0x3d, 0xdf, 0xff, 0x3f, 0x87, 0xe1, 0xf8, 0x7e, + 0x1f, 0x87, 0xf3, 0xdf, 0xf3, 0xdc, 0x7, 0x1, + 0xc0, 0x70, + + /* U+72 "r" */ + 0xef, 0x3f, 0xef, 0x3f, 0x87, 0xe1, 0xf8, 0xe, + 0x3, 0x80, 0xe0, 0x38, 0xe, 0x0, + + /* U+73 "s" */ + 0x3f, 0x3f, 0xee, 0x1f, 0x80, 0xfc, 0x1f, 0xe0, + 0x3c, 0x7, 0xe1, 0xff, 0xe3, 0xf0, + + /* U+74 "t" */ + 0x1c, 0x7, 0x1, 0xc3, 0xff, 0xff, 0xc7, 0x1, + 0xc0, 0x70, 0x1c, 0x7, 0x1, 0xc0, 0x70, 0xf, + 0xc1, 0xf0, + + /* U+75 "u" */ + 0xe3, 0xf1, 0xf8, 0xfc, 0x7e, 0x3f, 0x1f, 0x8f, + 0xc7, 0xe3, 0xbf, 0x8f, 0x80, + + /* U+76 "v" */ + 0xc0, 0xf8, 0x76, 0x19, 0x86, 0x73, 0x8c, 0xc3, + 0x30, 0xfc, 0x1e, 0x7, 0x81, 0xe0, + + /* U+77 "w" */ + 0xc6, 0x79, 0xcf, 0x39, 0xb5, 0x36, 0xa6, 0xd6, + 0xda, 0xdb, 0x4e, 0x79, 0xcf, 0x38, 0xc7, 0x0, + + /* U+78 "x" */ + 0xe1, 0xdc, 0xe3, 0x30, 0xfc, 0x1e, 0x7, 0x81, + 0xe0, 0xfc, 0x73, 0x9c, 0x6e, 0x1c, + + /* U+79 "y" */ + 0xe1, 0xf8, 0x76, 0x19, 0xce, 0x33, 0x8e, 0xc3, + 0xf0, 0x7c, 0x1e, 0x3, 0x80, 0xc0, 0x70, 0x1c, + 0x6, 0x0, + + /* U+7A "z" */ + 0xff, 0xff, 0xc1, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, + 0xe0, 0xe0, 0x7f, 0xff, 0xe0, + + /* U+7B "{" */ + 0x7, 0x87, 0xc3, 0x81, 0xc0, 0xe0, 0x70, 0x38, + 0x1c, 0xfc, 0x7e, 0x3, 0x81, 0xc0, 0xe0, 0x70, + 0x38, 0x1c, 0xf, 0x83, 0xc0, + + /* U+7C "|" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, + + /* U+7D "}" */ + 0xf0, 0x3f, 0x1, 0xc0, 0x70, 0x1c, 0x7, 0x1, + 0xc0, 0x70, 0xf, 0xc3, 0xf1, 0xc0, 0x70, 0x1c, + 0x7, 0x1, 0xc0, 0x70, 0xf8, 0x3c, 0x0, + + /* U+7E "~" */ + 0x78, 0xff, 0x3c, 0xff, 0x1e, + + /* U+F001 "" */ + 0x0, 0x0, 0x70, 0x0, 0x7f, 0x0, 0x3f, 0xf0, + 0x1f, 0xff, 0x7, 0xff, 0xf0, 0x7f, 0xff, 0x7, + 0xfc, 0x70, 0x7e, 0x7, 0x7, 0x0, 0x70, 0x70, + 0x7, 0x7, 0x0, 0x70, 0x70, 0x7, 0x7, 0x0, + 0x70, 0x70, 0x7f, 0x7, 0xf, 0xf7, 0xf0, 0xff, + 0xff, 0x7, 0xef, 0xf0, 0x0, 0xff, 0x0, 0x3, + 0xc0, 0x0, + + /* U+F017 "" */ + 0x3, 0xf8, 0x1, 0xff, 0xc0, 0x7f, 0xfc, 0x1f, + 0xff, 0xc7, 0xf1, 0xfc, 0xfe, 0x3f, 0x9f, 0xc7, + 0xf7, 0xf8, 0xff, 0xff, 0x1f, 0xff, 0xe3, 0xff, + 0xfc, 0x3f, 0xff, 0x83, 0xff, 0xfc, 0x7e, 0xff, + 0xcf, 0x9f, 0xff, 0xf1, 0xff, 0xfc, 0x1f, 0xff, + 0x1, 0xff, 0xc0, 0x1f, 0xf0, 0x0, 0x70, 0x0, + + /* U+F03A "" */ + 0xf0, 0x0, 0xf, 0x3f, 0xff, 0xf3, 0xff, 0xff, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0xf, 0x0, 0x0, 0xf3, 0xff, 0xff, 0x3f, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0xf, 0x0, 0x0, 0xf3, 0xff, 0xff, 0x3f, 0xff, + 0xf0, 0x0, 0x0, + + /* U+F069 "" */ + 0x0, 0xe0, 0x0, 0x1c, 0x0, 0x3, 0x80, 0x0, + 0x70, 0x6, 0xe, 0xc, 0xf1, 0xc7, 0x9f, 0xbb, + 0xf1, 0xff, 0xfc, 0xf, 0xfe, 0x0, 0x7f, 0x0, + 0xf, 0xe0, 0x7, 0xff, 0x3, 0xff, 0xf8, 0xfd, + 0xdf, 0x9e, 0x38, 0xf3, 0x7, 0x6, 0x0, 0xe0, + 0x0, 0x1c, 0x0, 0x3, 0x80, 0x0, 0x70, 0x0, + + /* U+F129 "" */ + 0x3c, 0x7e, 0x7e, 0x7e, 0x3c, 0x0, 0x0, 0xfc, + 0xfc, 0xfc, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, + 0xff, 0xff, 0xff, + + /* U+F185 "" */ + 0x0, 0x60, 0x0, 0x6, 0x0, 0x0, 0xf0, 0x1, + 0xcf, 0x38, 0x1f, 0xff, 0x81, 0xf0, 0xf8, 0xc, + 0xf3, 0x1, 0xdf, 0xb8, 0x7b, 0xfd, 0xef, 0xbf, + 0xdf, 0x7b, 0xfd, 0xe1, 0x9f, 0x98, 0xc, 0xf3, + 0x0, 0xc0, 0x30, 0x1f, 0xf, 0x81, 0xff, 0xf8, + 0x1c, 0xf3, 0x80, 0xf, 0x0, 0x0, 0x60, 0x0, + 0x6, 0x0, + + /* U+F1E6 "" */ + 0x18, 0x30, 0x70, 0x70, 0xe0, 0xe1, 0xc1, 0xc3, + 0x83, 0x80, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x7f, + 0xfc, 0xff, 0xf9, 0xff, 0xf1, 0xff, 0xc3, 0xff, + 0x83, 0xfe, 0x3, 0xf8, 0x1, 0xc0, 0x3, 0x80, + 0x7, 0x0, 0xe, 0x0, + + /* U+F1FC "" */ + 0x0, 0x0, 0xf0, 0x0, 0x1f, 0x0, 0x3, 0xf0, + 0x0, 0x7e, 0x0, 0xf, 0xe0, 0x3, 0xfc, 0x0, + 0x7f, 0xc0, 0xf, 0xf8, 0x0, 0xff, 0x80, 0x1f, + 0xf0, 0x0, 0xfe, 0x0, 0xf, 0xe0, 0xe, 0x7c, + 0x1, 0xf8, 0x0, 0x9f, 0xc0, 0xf, 0xfc, 0x0, + 0x7f, 0xc0, 0x7, 0xf8, 0x0, 0x1f, 0x0, 0x0, + + /* U+F21E "" */ + 0x1e, 0x7, 0x83, 0xf9, 0xfe, 0x7f, 0xff, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xfc, + 0xf7, 0xf7, 0xd6, 0x3e, 0x79, 0x6b, 0xe0, 0x34, + 0x80, 0x1f, 0x9f, 0x80, 0xf9, 0xf0, 0x7, 0xfe, + 0x0, 0x3f, 0xc0, 0x1, 0xf8, 0x0, 0xf, 0x0, + 0x0, 0x60, 0x0, + + /* U+F240 "" */ + 0x7f, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xb8, 0x0, + 0x1, 0xfd, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0x7f, + 0x7f, 0xff, 0x9f, 0xbf, 0xff, 0xcf, 0xdf, 0xff, + 0xe7, 0xe0, 0x0, 0x7, 0xf0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xcf, 0xff, 0xff, 0xe0, + + /* U+F241 "" */ + 0x7f, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xb8, 0x0, + 0x1, 0xfd, 0xff, 0xe0, 0xfe, 0xff, 0xf0, 0x7f, + 0x7f, 0xf8, 0x1f, 0xbf, 0xfc, 0xf, 0xdf, 0xfe, + 0x7, 0xe0, 0x0, 0x7, 0xf0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xcf, 0xff, 0xff, 0xe0, + + /* U+F242 "" */ + 0x7f, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xb8, 0x0, + 0x1, 0xfd, 0xfe, 0x0, 0xfe, 0xff, 0x0, 0x7f, + 0x7f, 0x80, 0x1f, 0xbf, 0xc0, 0xf, 0xdf, 0xe0, + 0x7, 0xe0, 0x0, 0x7, 0xf0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xcf, 0xff, 0xff, 0xe0, + + /* U+F243 "" */ + 0x7f, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xb8, 0x0, + 0x1, 0xfd, 0xf0, 0x0, 0xfe, 0xf8, 0x0, 0x7f, + 0x7c, 0x0, 0x1f, 0xbe, 0x0, 0xf, 0xdf, 0x0, + 0x7, 0xe0, 0x0, 0x7, 0xf0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xcf, 0xff, 0xff, 0xe0, + + /* U+F244 "" */ + 0x7f, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xb8, 0x0, + 0x1, 0xfc, 0x0, 0x0, 0xfe, 0x0, 0x0, 0x7f, + 0x0, 0x0, 0x1f, 0x80, 0x0, 0xf, 0xc0, 0x0, + 0x7, 0xe0, 0x0, 0x7, 0xf0, 0x0, 0x3, 0xff, + 0xff, 0xff, 0xcf, 0xff, 0xff, 0xe0, + + /* U+F293 "" */ + 0x7, 0xe0, 0x3f, 0xe0, 0xfb, 0xe3, 0xf3, 0xe7, + 0xe3, 0xdf, 0xd3, 0xf9, 0xb3, 0xf9, 0x4f, 0xf8, + 0x3f, 0xf8, 0xff, 0xf1, 0xff, 0xc1, 0xff, 0x29, + 0xfc, 0xd9, 0xff, 0xa7, 0xbf, 0x1e, 0x7e, 0x7c, + 0x7d, 0xf0, 0x7f, 0xe0, 0x7f, 0x0, + + /* U+F294 "" */ + 0x0, 0x0, 0x80, 0x18, 0x3, 0x80, 0x78, 0x8d, + 0xb9, 0x9b, 0xb6, 0x3f, 0x83, 0xe0, 0x38, 0x7, + 0x81, 0xf8, 0x6d, 0x99, 0x9a, 0x36, 0x7, 0x80, + 0xe0, 0x18, 0x2, 0x0, 0x0, + + /* U+F3FD "" */ + 0x0, 0xfe, 0x0, 0x7, 0xff, 0x0, 0x3f, 0xbf, + 0x80, 0xfe, 0x2f, 0x83, 0xfe, 0xcf, 0x8f, 0x3f, + 0x27, 0x9e, 0x7e, 0x4f, 0x3f, 0xfc, 0xfe, 0xff, + 0xf3, 0xff, 0xff, 0xe7, 0xff, 0xff, 0xcf, 0xff, + 0xfe, 0x3f, 0xfe, 0x78, 0x3c, 0xff, 0xf0, 0x7f, + 0xdf, 0xe0, 0xff, 0x3f, 0xff, 0xfe, 0x3f, 0xff, + 0xf8, + + /* U+F54B "" */ + 0x0, 0xf, 0xf8, 0x1, 0xdf, 0xff, 0x1, 0xef, + 0xff, 0xc0, 0xf7, 0xff, 0xf0, 0x7b, 0xff, 0xf8, + 0x1d, 0xff, 0xfc, 0x0, 0x1f, 0xfc, 0x0, 0x3, + 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x7, 0xf8, 0x0, 0xf, 0xfe, + 0x3, 0xbf, 0xff, 0x83, 0xdf, 0xff, 0xc1, 0xef, + 0xff, 0xe0, 0xf7, 0xff, 0xe0, 0x3b, 0xff, 0xe0, + 0x0, 0x7f, 0xc0, 0x0, + + /* U+F560 "" */ + 0x0, 0x0, 0x0, 0x0, 0x60, 0x0, 0xf, 0x0, + 0x1, 0xf0, 0x8, 0x3e, 0x1, 0xc7, 0xc4, 0x1e, + 0xf8, 0xe1, 0xff, 0x1f, 0xf, 0xe3, 0xf0, 0x7c, + 0x7e, 0x23, 0x8f, 0xc7, 0x11, 0xf8, 0xf8, 0x3f, + 0xf, 0xc7, 0xe0, 0x7e, 0xfc, 0x3, 0xff, 0x80, + 0x1f, 0xf0, 0x0, 0xfe, 0x0, 0x7, 0xc0, 0x0, + 0x38, 0x0, 0x1, 0x0, 0x0 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 192, .box_w = 1, .box_h = 1, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1, .adv_w = 192, .box_w = 3, .box_h = 14, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 7, .adv_w = 192, .box_w = 7, .box_h = 6, .ofs_x = 3, .ofs_y = 8}, + {.bitmap_index = 13, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 33, .adv_w = 192, .box_w = 10, .box_h = 19, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 57, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 77, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 97, .adv_w = 192, .box_w = 3, .box_h = 6, .ofs_x = 5, .ofs_y = 8}, + {.bitmap_index = 100, .adv_w = 192, .box_w = 7, .box_h = 19, .ofs_x = 3, .ofs_y = -2}, + {.bitmap_index = 117, .adv_w = 192, .box_w = 7, .box_h = 19, .ofs_x = 2, .ofs_y = -2}, + {.bitmap_index = 134, .adv_w = 192, .box_w = 10, .box_h = 10, .ofs_x = 1, .ofs_y = 1}, + {.bitmap_index = 147, .adv_w = 192, .box_w = 10, .box_h = 9, .ofs_x = 1, .ofs_y = 2}, + {.bitmap_index = 159, .adv_w = 192, .box_w = 5, .box_h = 6, .ofs_x = 3, .ofs_y = -3}, + {.bitmap_index = 163, .adv_w = 192, .box_w = 8, .box_h = 2, .ofs_x = 2, .ofs_y = 5}, + {.bitmap_index = 165, .adv_w = 192, .box_w = 4, .box_h = 4, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 167, .adv_w = 192, .box_w = 10, .box_h = 19, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 191, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 209, .adv_w = 192, .box_w = 9, .box_h = 14, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 225, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 243, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 261, .adv_w = 192, .box_w = 9, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 277, .adv_w = 192, .box_w = 9, .box_h = 14, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 293, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 311, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 329, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 347, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 365, .adv_w = 192, .box_w = 3, .box_h = 11, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 370, .adv_w = 192, .box_w = 5, .box_h = 14, .ofs_x = 3, .ofs_y = -3}, + {.bitmap_index = 379, .adv_w = 192, .box_w = 9, .box_h = 11, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 392, .adv_w = 192, .box_w = 9, .box_h = 7, .ofs_x = 2, .ofs_y = 3}, + {.bitmap_index = 400, .adv_w = 192, .box_w = 9, .box_h = 11, .ofs_x = 2, .ofs_y = 1}, + {.bitmap_index = 413, .adv_w = 192, .box_w = 8, .box_h = 14, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 427, .adv_w = 192, .box_w = 11, .box_h = 17, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 451, .adv_w = 192, .box_w = 12, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 472, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 490, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 508, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 526, .adv_w = 192, .box_w = 9, .box_h = 14, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 542, .adv_w = 192, .box_w = 9, .box_h = 14, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 558, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 576, .adv_w = 192, .box_w = 9, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 592, .adv_w = 192, .box_w = 9, .box_h = 14, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 608, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 626, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 646, .adv_w = 192, .box_w = 9, .box_h = 14, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 662, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 680, .adv_w = 192, .box_w = 9, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 696, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 714, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 732, .adv_w = 192, .box_w = 10, .box_h = 17, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 754, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 772, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 790, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 808, .adv_w = 192, .box_w = 9, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 824, .adv_w = 192, .box_w = 12, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 845, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 865, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 883, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 903, .adv_w = 192, .box_w = 9, .box_h = 14, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 919, .adv_w = 192, .box_w = 6, .box_h = 18, .ofs_x = 4, .ofs_y = -2}, + {.bitmap_index = 933, .adv_w = 192, .box_w = 10, .box_h = 19, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 957, .adv_w = 192, .box_w = 6, .box_h = 18, .ofs_x = 3, .ofs_y = -2}, + {.bitmap_index = 971, .adv_w = 192, .box_w = 10, .box_h = 8, .ofs_x = 1, .ofs_y = 6}, + {.bitmap_index = 981, .adv_w = 192, .box_w = 10, .box_h = 2, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 984, .adv_w = 192, .box_w = 5, .box_h = 3, .ofs_x = 3, .ofs_y = 13}, + {.bitmap_index = 986, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1000, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1018, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1032, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1050, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1064, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1082, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 1100, .adv_w = 192, .box_w = 9, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1116, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 1135, .adv_w = 192, .box_w = 8, .box_h = 18, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 1153, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 1171, .adv_w = 192, .box_w = 11, .box_h = 14, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1191, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1205, .adv_w = 192, .box_w = 9, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1218, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1232, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 1250, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 1268, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 1282, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1296, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1314, .adv_w = 192, .box_w = 9, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1327, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1341, .adv_w = 192, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 0}, + {.bitmap_index = 1357, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0}, + {.bitmap_index = 1371, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 1389, .adv_w = 192, .box_w = 9, .box_h = 11, .ofs_x = 2, .ofs_y = 0}, + {.bitmap_index = 1402, .adv_w = 192, .box_w = 9, .box_h = 18, .ofs_x = 2, .ofs_y = -2}, + {.bitmap_index = 1423, .adv_w = 192, .box_w = 3, .box_h = 18, .ofs_x = 5, .ofs_y = -2}, + {.bitmap_index = 1430, .adv_w = 192, .box_w = 10, .box_h = 18, .ofs_x = 1, .ofs_y = -2}, + {.bitmap_index = 1453, .adv_w = 192, .box_w = 10, .box_h = 4, .ofs_x = 1, .ofs_y = 5}, + {.bitmap_index = 1458, .adv_w = 320, .box_w = 20, .box_h = 20, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 1508, .adv_w = 320, .box_w = 19, .box_h = 20, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 1556, .adv_w = 320, .box_w = 20, .box_h = 17, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1599, .adv_w = 320, .box_w = 19, .box_h = 20, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 1647, .adv_w = 120, .box_w = 8, .box_h = 19, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1666, .adv_w = 320, .box_w = 20, .box_h = 20, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 1716, .adv_w = 240, .box_w = 15, .box_h = 19, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1752, .adv_w = 320, .box_w = 20, .box_h = 19, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 1800, .adv_w = 320, .box_w = 20, .box_h = 17, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 1843, .adv_w = 400, .box_w = 25, .box_h = 12, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 1881, .adv_w = 400, .box_w = 25, .box_h = 12, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 1919, .adv_w = 400, .box_w = 25, .box_h = 12, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 1957, .adv_w = 400, .box_w = 25, .box_h = 12, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 1995, .adv_w = 400, .box_w = 25, .box_h = 12, .ofs_x = 0, .ofs_y = 1}, + {.bitmap_index = 2033, .adv_w = 280, .box_w = 15, .box_h = 20, .ofs_x = 1, .ofs_y = -3}, + {.bitmap_index = 2071, .adv_w = 200, .box_w = 11, .box_h = 21, .ofs_x = 0, .ofs_y = -3}, + {.bitmap_index = 2100, .adv_w = 360, .box_w = 23, .box_h = 17, .ofs_x = 0, .ofs_y = -1}, + {.bitmap_index = 2149, .adv_w = 400, .box_w = 25, .box_h = 19, .ofs_x = 0, .ofs_y = -2}, + {.bitmap_index = 2209, .adv_w = 320, .box_w = 20, .box_h = 21, .ofs_x = 0, .ofs_y = -3} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + +static const uint16_t unicode_list_1[] = { + 0x0, 0x16, 0x39, 0x68, 0x128, 0x184, 0x1e5, 0x1fb, + 0x21d, 0x23f, 0x240, 0x241, 0x242, 0x243, 0x292, 0x293, + 0x3fc, 0x54a, 0x55f +}; + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 32, .range_length = 95, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + }, + { + .range_start = 61441, .range_length = 1376, .glyph_id_start = 96, + .unicode_list = unicode_list_1, .glyph_id_ofs_list = NULL, .list_length = 19, .type = LV_FONT_FMT_TXT_CMAP_SPARSE_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_dsc_t font_dsc = { + .glyph_bitmap = gylph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 2, + .bpp = 1, + .kern_classes = 0, + .bitmap_format = 0 +}; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +lv_font_t jetbrains_mono_bold_20 = { + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 21, /*The maximum line height required by the font*/ + .base_line = 3, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif + .dsc = &font_dsc /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +}; + +#endif /*#if JETBRAINS_MONO_BOLD_20*/ + diff --git a/src/displayapp/fonts/jetbrains_mono_extrabold_compressed.c b/src/displayapp/fonts/jetbrains_mono_extrabold_compressed.c new file mode 100644 index 00000000..c9917e40 --- /dev/null +++ b/src/displayapp/fonts/jetbrains_mono_extrabold_compressed.c @@ -0,0 +1,507 @@ +#include "lvgl/lvgl.h" + +/******************************************************************************* + * Size: 80 px + * Bpp: 1 + * Opts: + ******************************************************************************/ + +#ifndef JETBRAINS_MONO_EXTRABOLD_COMPRESSED +#define JETBRAINS_MONO_EXTRABOLD_COMPRESSED 1 +#endif + +#if JETBRAINS_MONO_EXTRABOLD_COMPRESSED + +/*----------------- + * BITMAPS + *----------------*/ + +/*Store the image of the glyphs*/ +static LV_ATTRIBUTE_LARGE_CONST const uint8_t gylph_bitmap[] = { + /* U+30 "0" */ + 0x0, 0x1, 0xff, 0xc0, 0x0, 0x0, 0xf, 0xff, + 0xfe, 0x0, 0x0, 0x1f, 0xff, 0xff, 0xc0, 0x0, + 0x3f, 0xff, 0xff, 0xf8, 0x0, 0x3f, 0xff, 0xff, + 0xfe, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x80, 0x3f, + 0xff, 0xff, 0xff, 0xe0, 0x3f, 0xff, 0xff, 0xff, + 0xf8, 0x1f, 0xff, 0xff, 0xff, 0xfc, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0x1f, 0xff, 0xe0, 0x3f, 0xff, + 0xcf, 0xff, 0xc0, 0x7, 0xff, 0xe7, 0xff, 0xc0, + 0x1, 0xff, 0xf7, 0xff, 0xc0, 0x0, 0x7f, 0xff, + 0xff, 0xe0, 0x0, 0x3f, 0xff, 0xff, 0xe0, 0x0, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x7, 0xff, 0xff, + 0xf8, 0x0, 0x3, 0xff, 0xff, 0xfc, 0x0, 0x1, + 0xff, 0xff, 0xfe, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x7f, 0xff, 0xff, 0x80, 0x0, 0x3f, + 0xff, 0xff, 0xc0, 0x70, 0x1f, 0xff, 0xff, 0xe0, + 0x7c, 0xf, 0xff, 0xff, 0xf0, 0x7f, 0x7, 0xff, + 0xff, 0xf8, 0x3f, 0x83, 0xff, 0xff, 0xfc, 0x1f, + 0xc1, 0xff, 0xff, 0xfe, 0xf, 0xe0, 0xff, 0xff, + 0xff, 0x7, 0xf0, 0x7f, 0xff, 0xff, 0x83, 0xf8, + 0x3f, 0xff, 0xff, 0xc1, 0xfc, 0x1f, 0xff, 0xff, + 0xe0, 0xfe, 0xf, 0xff, 0xff, 0xf0, 0x7f, 0x7, + 0xff, 0xff, 0xf8, 0x3f, 0x83, 0xff, 0xff, 0xfc, + 0x1f, 0xc1, 0xff, 0xff, 0xfe, 0xf, 0xe0, 0xff, + 0xff, 0xff, 0x3, 0xe0, 0x7f, 0xff, 0xff, 0x80, + 0xe0, 0x3f, 0xff, 0xff, 0xc0, 0x0, 0x1f, 0xff, + 0xff, 0xe0, 0x0, 0xf, 0xff, 0xff, 0xf0, 0x0, + 0x7, 0xff, 0xff, 0xf8, 0x0, 0x3, 0xff, 0xff, + 0xfc, 0x0, 0x1, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x80, 0x0, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x7f, 0xf9, 0xff, 0xf0, 0x0, 0x7f, + 0xfc, 0xff, 0xfc, 0x0, 0x7f, 0xfe, 0x7f, 0xff, + 0x80, 0xff, 0xfe, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0x7, 0xff, 0xff, 0xff, 0xff, 0x3, 0xff, 0xff, + 0xff, 0xff, 0x80, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x3f, 0xff, 0xff, 0xff, 0x80, 0xf, 0xff, 0xff, + 0xff, 0x80, 0x3, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x0, 0x0, 0xf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x7f, 0xf0, 0x0, 0x0, + + /* U+31 "1" */ + 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0xf, 0xff, + 0xe0, 0x0, 0x0, 0x3f, 0xff, 0xe0, 0x0, 0x0, + 0x7f, 0xff, 0xe0, 0x0, 0x1, 0xff, 0xff, 0xe0, + 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, 0x7, 0xff, + 0xff, 0xe0, 0x0, 0x1f, 0xff, 0xff, 0xe0, 0x0, + 0x3f, 0xff, 0xff, 0xe0, 0x0, 0x7f, 0xff, 0xff, + 0xe0, 0x0, 0x7f, 0xff, 0xff, 0xe0, 0x0, 0x7f, + 0xfd, 0xff, 0xe0, 0x0, 0x7f, 0xf9, 0xff, 0xe0, + 0x0, 0x7f, 0xf1, 0xff, 0xe0, 0x0, 0x7f, 0xe1, + 0xff, 0xe0, 0x0, 0x7f, 0x81, 0xff, 0xe0, 0x0, + 0x7f, 0x1, 0xff, 0xe0, 0x0, 0x7c, 0x1, 0xff, + 0xe0, 0x0, 0x78, 0x1, 0xff, 0xe0, 0x0, 0x60, + 0x1, 0xff, 0xe0, 0x0, 0x40, 0x1, 0xff, 0xe0, + 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x1, + 0xff, 0xe0, 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, + 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x1, 0xff, + 0xe0, 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, + 0x1, 0xff, 0xe0, 0x0, 0x0, 0x1, 0xff, 0xe0, + 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x1, + 0xff, 0xe0, 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, + 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x1, 0xff, + 0xe0, 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, + 0x1, 0xff, 0xe0, 0x0, 0x0, 0x1, 0xff, 0xe0, + 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x1, + 0xff, 0xe0, 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, + 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x1, 0xff, + 0xe0, 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, + 0x1, 0xff, 0xe0, 0x0, 0x0, 0x1, 0xff, 0xe0, + 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x1, + 0xff, 0xe0, 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, + + /* U+32 "2" */ + 0x0, 0x1, 0xff, 0xc0, 0x0, 0x0, 0xf, 0xff, + 0xfc, 0x0, 0x0, 0x1f, 0xff, 0xff, 0x80, 0x0, + 0x3f, 0xff, 0xff, 0xf0, 0x0, 0x3f, 0xff, 0xff, + 0xfc, 0x0, 0x3f, 0xff, 0xff, 0xff, 0x0, 0x3f, + 0xff, 0xff, 0xff, 0xc0, 0x3f, 0xff, 0xff, 0xff, + 0xf0, 0x3f, 0xff, 0xff, 0xff, 0xfc, 0x1f, 0xff, + 0xff, 0xff, 0xfe, 0x1f, 0xff, 0xe0, 0x7f, 0xff, + 0x8f, 0xff, 0xc0, 0xf, 0xff, 0xc7, 0xff, 0xc0, + 0x3, 0xff, 0xe7, 0xff, 0xc0, 0x0, 0xff, 0xfb, + 0xff, 0xc0, 0x0, 0x7f, 0xfd, 0xff, 0xe0, 0x0, + 0x1f, 0xfe, 0xff, 0xf0, 0x0, 0xf, 0xff, 0x0, + 0x0, 0x0, 0x7, 0xff, 0x80, 0x0, 0x0, 0x3, + 0xff, 0xc0, 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, + 0x0, 0x0, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x7f, 0xf8, 0x0, 0x0, + 0x0, 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x3f, 0xfe, + 0x0, 0x0, 0x0, 0x3f, 0xfe, 0x0, 0x0, 0x0, + 0x3f, 0xff, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, + 0x0, 0x0, 0x3f, 0xff, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x80, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, + 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, 0x7f, 0xff, + 0x80, 0x0, 0x0, 0x7f, 0xff, 0x80, 0x0, 0x0, + 0xff, 0xff, 0x80, 0x0, 0x0, 0xff, 0xff, 0x80, + 0x0, 0x0, 0xff, 0xff, 0x80, 0x0, 0x0, 0xff, + 0xff, 0x80, 0x0, 0x1, 0xff, 0xff, 0x0, 0x0, + 0x1, 0xff, 0xff, 0x0, 0x0, 0x1, 0xff, 0xff, + 0x0, 0x0, 0x1, 0xff, 0xfe, 0x0, 0x0, 0x3, + 0xff, 0xfe, 0x0, 0x0, 0x3, 0xff, 0xfe, 0x0, + 0x0, 0x3, 0xff, 0xfc, 0x0, 0x0, 0x3, 0xff, + 0xfc, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xfb, + 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, + 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, + 0xff, 0xc0, + + /* U+33 "3" */ + 0x1f, 0xff, 0xff, 0xff, 0xfe, 0xf, 0xff, 0xff, + 0xff, 0xff, 0x7, 0xff, 0xff, 0xff, 0xff, 0x83, + 0xff, 0xff, 0xff, 0xff, 0xc1, 0xff, 0xff, 0xff, + 0xff, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x7f, + 0xff, 0xff, 0xff, 0xf8, 0x3f, 0xff, 0xff, 0xff, + 0xfc, 0x1f, 0xff, 0xff, 0xff, 0xfe, 0xf, 0xff, + 0xff, 0x8f, 0xff, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x80, 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, 0x0, + 0x1f, 0xff, 0x80, 0x0, 0x0, 0x3f, 0xff, 0x80, + 0x0, 0x0, 0x3f, 0xff, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, 0x0, + 0x0, 0x3f, 0xff, 0x0, 0x0, 0x0, 0x3f, 0xfe, + 0x0, 0x0, 0x0, 0x3f, 0xfe, 0x0, 0x0, 0x0, + 0x3f, 0xfe, 0x0, 0x0, 0x0, 0x3f, 0xfc, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, 0x0, 0xf, + 0xff, 0xf8, 0x0, 0x0, 0x7, 0xff, 0xff, 0x0, + 0x0, 0x3, 0xff, 0xff, 0xe0, 0x0, 0x1, 0xff, + 0xff, 0xf8, 0x0, 0x0, 0xff, 0xff, 0xfe, 0x0, + 0x0, 0x7f, 0xff, 0xff, 0x80, 0x0, 0x3f, 0xff, + 0xff, 0xe0, 0x0, 0x1f, 0xff, 0xff, 0xf0, 0x0, + 0xf, 0xff, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xff, + 0xfe, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x80, 0x0, + 0x0, 0x7, 0xff, 0xc0, 0x0, 0x0, 0x1, 0xff, + 0xe0, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x0, 0x0, + 0x0, 0x3f, 0xfc, 0x0, 0x0, 0x0, 0x1f, 0xfe, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x80, 0x0, 0x0, 0x3, 0xff, 0xc0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0xff, 0xff, 0xff, 0x80, 0x0, 0xff, 0xff, 0xff, + 0xc0, 0x0, 0x7f, 0xf9, 0xff, 0xf0, 0x0, 0x7f, + 0xfc, 0xff, 0xfc, 0x0, 0x7f, 0xfe, 0x7f, 0xff, + 0x80, 0xff, 0xfe, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0xf, 0xff, 0xff, 0xff, 0xff, 0x3, 0xff, 0xff, + 0xff, 0xff, 0x80, 0xff, 0xff, 0xff, 0xff, 0x80, + 0x3f, 0xff, 0xff, 0xff, 0x80, 0xf, 0xff, 0xff, + 0xff, 0x80, 0x3, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x7f, 0xff, 0xff, 0x0, 0x0, 0xf, 0xff, 0xfc, + 0x0, 0x0, 0x0, 0x7f, 0xf0, 0x0, 0x0, + + /* U+34 "4" */ + 0x0, 0x0, 0x3, 0xff, 0xf0, 0x0, 0x0, 0x1f, + 0xff, 0x80, 0x0, 0x0, 0x7f, 0xfc, 0x0, 0x0, + 0x3, 0xff, 0xe0, 0x0, 0x0, 0x1f, 0xff, 0x80, + 0x0, 0x0, 0xff, 0xfc, 0x0, 0x0, 0x3, 0xff, + 0xe0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, + 0xff, 0xfc, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0xff, 0xfc, + 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x3f, + 0xff, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x0, 0x0, + 0x7, 0xff, 0xe0, 0x0, 0x0, 0x3f, 0xff, 0x0, + 0x0, 0x0, 0xff, 0xf8, 0x0, 0x0, 0x7, 0xff, + 0xc0, 0x0, 0x0, 0x3f, 0xff, 0x0, 0x0, 0x1, + 0xff, 0xf8, 0x0, 0x0, 0x7, 0xff, 0xc0, 0x0, + 0x0, 0x3f, 0xfe, 0x0, 0x0, 0x1, 0xff, 0xf8, + 0x0, 0x0, 0xf, 0xff, 0xc0, 0x0, 0x0, 0x3f, + 0xfe, 0x0, 0xff, 0xf1, 0xff, 0xf0, 0x3, 0xff, + 0xcf, 0xff, 0xc0, 0xf, 0xff, 0x7f, 0xfe, 0x0, + 0x3f, 0xfd, 0xff, 0xf0, 0x0, 0xff, 0xff, 0xff, + 0xc0, 0x3, 0xff, 0xff, 0xfe, 0x0, 0xf, 0xff, + 0xff, 0xf0, 0x0, 0x3f, 0xff, 0xff, 0x80, 0x0, + 0xff, 0xff, 0xfe, 0x0, 0x3, 0xff, 0xff, 0xf8, + 0x0, 0xf, 0xff, 0xff, 0xe0, 0x0, 0x3f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, + 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, 0x3f, + 0xfc, 0x0, 0x0, 0x0, 0xff, 0xf0, 0x0, 0x0, + 0x3, 0xff, 0xc0, 0x0, 0x0, 0xf, 0xff, 0x0, + 0x0, 0x0, 0x3f, 0xfc, 0x0, 0x0, 0x0, 0xff, + 0xf0, 0x0, 0x0, 0x3, 0xff, 0xc0, 0x0, 0x0, + 0xf, 0xff, 0x0, 0x0, 0x0, 0x3f, 0xfc, 0x0, + 0x0, 0x0, 0xff, 0xf0, + + /* U+35 "5" */ + 0x3f, 0xff, 0xff, 0xff, 0xfe, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xf, 0xff, 0xff, 0xff, 0xff, 0x87, + 0xff, 0xff, 0xff, 0xff, 0xc3, 0xff, 0xff, 0xff, + 0xff, 0xe1, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xff, + 0xff, 0xff, 0xff, 0xf8, 0x7f, 0xff, 0xff, 0xff, + 0xfc, 0x3f, 0xff, 0xff, 0xff, 0xfe, 0x1f, 0xff, + 0xff, 0xff, 0xff, 0xf, 0xff, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x80, 0x0, 0x0, 0x3, 0xff, 0xc0, + 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x0, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0x7f, 0xf8, 0x0, + 0x0, 0x0, 0x3f, 0xfc, 0x0, 0x0, 0x0, 0x1f, + 0xfe, 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, + 0x0, 0x7, 0xff, 0x80, 0x0, 0x0, 0x3, 0xff, + 0xc0, 0x7f, 0x80, 0x1, 0xff, 0xe1, 0xff, 0xf8, + 0x0, 0xff, 0xf1, 0xff, 0xff, 0x0, 0x7f, 0xf9, + 0xff, 0xff, 0xc0, 0x3f, 0xfd, 0xff, 0xff, 0xf0, + 0x1f, 0xff, 0xff, 0xff, 0xfc, 0xf, 0xff, 0xff, + 0xff, 0xff, 0x7, 0xff, 0xff, 0xff, 0xff, 0xc3, + 0xff, 0xff, 0xff, 0xff, 0xe1, 0xff, 0xfc, 0x7, + 0xff, 0xf8, 0xff, 0xf8, 0x0, 0xff, 0xfc, 0x0, + 0x0, 0x0, 0x3f, 0xfe, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x80, 0x0, 0x0, 0x7, 0xff, 0xc0, 0x0, + 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x0, 0xff, + 0xf0, 0x0, 0x0, 0x0, 0x7f, 0xf8, 0x0, 0x0, + 0x0, 0x3f, 0xfc, 0x0, 0x0, 0x0, 0x1f, 0xfe, + 0x0, 0x0, 0x0, 0xf, 0xff, 0x0, 0x0, 0x0, + 0x7, 0xff, 0x80, 0x0, 0x0, 0x3, 0xff, 0xc0, + 0x0, 0x0, 0x1, 0xff, 0xff, 0xff, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x80, 0x0, 0xff, 0xfb, 0xff, + 0xe0, 0x0, 0xff, 0xf9, 0xff, 0xf8, 0x0, 0xff, + 0xfc, 0xff, 0xff, 0x81, 0xff, 0xfe, 0x3f, 0xff, + 0xff, 0xff, 0xfe, 0x1f, 0xff, 0xff, 0xff, 0xff, + 0x7, 0xff, 0xff, 0xff, 0xff, 0x1, 0xff, 0xff, + 0xff, 0xff, 0x0, 0x7f, 0xff, 0xff, 0xff, 0x0, + 0x1f, 0xff, 0xff, 0xff, 0x0, 0x7, 0xff, 0xff, + 0xff, 0x0, 0x0, 0xff, 0xff, 0xfe, 0x0, 0x0, + 0x1f, 0xff, 0xfc, 0x0, 0x0, 0x0, 0xff, 0xe0, + 0x0, 0x0, + + /* U+36 "6" */ + 0x0, 0x0, 0xf, 0xff, 0x80, 0x0, 0x0, 0x7, + 0xff, 0xe0, 0x0, 0x0, 0x3, 0xff, 0xf0, 0x0, + 0x0, 0x0, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x7f, + 0xfe, 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, 0x0, + 0x0, 0xf, 0xff, 0x80, 0x0, 0x0, 0x7, 0xff, + 0xc0, 0x0, 0x0, 0x3, 0xff, 0xf0, 0x0, 0x0, + 0x0, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x7f, 0xfc, + 0x0, 0x0, 0x0, 0x3f, 0xff, 0x0, 0x0, 0x0, + 0xf, 0xff, 0x80, 0x0, 0x0, 0x7, 0xff, 0xc0, + 0x0, 0x0, 0x3, 0xff, 0xf0, 0x0, 0x0, 0x1, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x7f, 0xfc, 0x0, + 0x0, 0x0, 0x3f, 0xfe, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x80, 0x0, 0x0, 0x7, 0xff, 0xc0, 0x0, + 0x0, 0x3, 0xff, 0xe0, 0x0, 0x0, 0x0, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x7f, 0xfc, 0x3f, 0xc0, + 0x0, 0x1f, 0xfe, 0x3f, 0xfe, 0x0, 0xf, 0xff, + 0xbf, 0xff, 0xe0, 0x3, 0xff, 0xdf, 0xff, 0xfc, + 0x1, 0xff, 0xef, 0xff, 0xff, 0x80, 0x7f, 0xff, + 0xff, 0xff, 0xf0, 0x3f, 0xff, 0xff, 0xff, 0xfe, + 0xf, 0xff, 0xff, 0xff, 0xff, 0x87, 0xff, 0xff, + 0xff, 0xff, 0xf1, 0xff, 0xff, 0x3, 0xff, 0xfc, + 0x7f, 0xff, 0x0, 0x3f, 0xff, 0x9f, 0xff, 0x0, + 0x3, 0xff, 0xef, 0xff, 0xc0, 0x0, 0xff, 0xfb, + 0xff, 0xe0, 0x0, 0x1f, 0xff, 0xff, 0xf8, 0x0, + 0x7, 0xff, 0xff, 0xfc, 0x0, 0x0, 0xff, 0xff, + 0xff, 0x0, 0x0, 0x3f, 0xff, 0xff, 0xc0, 0x0, + 0xf, 0xff, 0xff, 0xf0, 0x0, 0x3, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xe0, 0x0, 0x1f, 0xff, 0x7f, + 0xf8, 0x0, 0x7, 0xff, 0xdf, 0xfe, 0x0, 0x3, + 0xff, 0xe7, 0xff, 0xc0, 0x0, 0xff, 0xf9, 0xff, + 0xfc, 0x0, 0xff, 0xfe, 0x3f, 0xff, 0xc0, 0xff, + 0xff, 0xf, 0xff, 0xff, 0xff, 0xff, 0xc1, 0xff, + 0xff, 0xff, 0xff, 0xe0, 0x3f, 0xff, 0xff, 0xff, + 0xf0, 0x7, 0xff, 0xff, 0xff, 0xf8, 0x0, 0xff, + 0xff, 0xff, 0xfe, 0x0, 0x1f, 0xff, 0xff, 0xfe, + 0x0, 0x3, 0xff, 0xff, 0xff, 0x0, 0x0, 0x3f, + 0xff, 0xff, 0x0, 0x0, 0x3, 0xff, 0xff, 0x0, + 0x0, 0x0, 0xf, 0xfc, 0x0, 0x0, + + /* U+37 "7" */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe0, 0x0, 0xf, 0xff, 0xff, 0xe0, 0x0, 0x1f, + 0xfe, 0xff, 0xe0, 0x0, 0x1f, 0xfe, 0xff, 0xe0, + 0x0, 0x3f, 0xfc, 0xff, 0xe0, 0x0, 0x3f, 0xfc, + 0xff, 0xe0, 0x0, 0x7f, 0xf8, 0xff, 0xe0, 0x0, + 0x7f, 0xf8, 0xff, 0xe0, 0x0, 0xff, 0xf8, 0xff, + 0xe0, 0x0, 0xff, 0xf0, 0x0, 0x0, 0x1, 0xff, + 0xf0, 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, + 0x3, 0xff, 0xe0, 0x0, 0x0, 0x3, 0xff, 0xc0, + 0x0, 0x0, 0x7, 0xff, 0xc0, 0x0, 0x0, 0x7, + 0xff, 0x80, 0x0, 0x0, 0x7, 0xff, 0x80, 0x0, + 0x0, 0xf, 0xff, 0x80, 0x0, 0x0, 0xf, 0xff, + 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, + 0x1f, 0xfe, 0x0, 0x0, 0x0, 0x3f, 0xfe, 0x0, + 0x0, 0x0, 0x3f, 0xfc, 0x0, 0x0, 0x0, 0x7f, + 0xfc, 0x0, 0x0, 0x0, 0x7f, 0xf8, 0x0, 0x0, + 0x0, 0xff, 0xf8, 0x0, 0x0, 0x0, 0xff, 0xf8, + 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x1, + 0xff, 0xf0, 0x0, 0x0, 0x1, 0xff, 0xe0, 0x0, + 0x0, 0x3, 0xff, 0xe0, 0x0, 0x0, 0x3, 0xff, + 0xc0, 0x0, 0x0, 0x7, 0xff, 0xc0, 0x0, 0x0, + 0x7, 0xff, 0x80, 0x0, 0x0, 0xf, 0xff, 0x80, + 0x0, 0x0, 0xf, 0xff, 0x80, 0x0, 0x0, 0x1f, + 0xff, 0x0, 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, + 0x0, 0x3f, 0xfe, 0x0, 0x0, 0x0, 0x3f, 0xfe, + 0x0, 0x0, 0x0, 0x7f, 0xfc, 0x0, 0x0, 0x0, + 0x7f, 0xfc, 0x0, 0x0, 0x0, 0x7f, 0xf8, 0x0, + 0x0, 0x0, 0xff, 0xf8, 0x0, 0x0, 0x0, 0xff, + 0xf8, 0x0, 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, + 0x1, 0xff, 0xf0, 0x0, 0x0, 0x3, 0xff, 0xe0, + 0x0, 0x0, + + /* U+38 "8" */ + 0x0, 0x1, 0xff, 0xe0, 0x0, 0x0, 0x7, 0xff, + 0xff, 0x80, 0x0, 0x7, 0xff, 0xff, 0xf8, 0x0, + 0x7, 0xff, 0xff, 0xff, 0x80, 0x3, 0xff, 0xff, + 0xff, 0xf0, 0x1, 0xff, 0xff, 0xff, 0xfe, 0x0, + 0xff, 0xff, 0xff, 0xff, 0xc0, 0x7f, 0xff, 0xff, + 0xff, 0xf8, 0x1f, 0xff, 0xff, 0xff, 0xfe, 0xf, + 0xff, 0xe0, 0x3f, 0xff, 0xc3, 0xff, 0xe0, 0x3, + 0xff, 0xf0, 0xff, 0xf0, 0x0, 0x7f, 0xfc, 0x7f, + 0xf8, 0x0, 0xf, 0xff, 0x9f, 0xfe, 0x0, 0x3, + 0xff, 0xe7, 0xff, 0x0, 0x0, 0x7f, 0xf9, 0xff, + 0xc0, 0x0, 0x1f, 0xfe, 0x7f, 0xf0, 0x0, 0x7, + 0xff, 0x9f, 0xfc, 0x0, 0x1, 0xff, 0xe7, 0xff, + 0x0, 0x0, 0x7f, 0xf9, 0xff, 0xc0, 0x0, 0x1f, + 0xfe, 0x3f, 0xf8, 0x0, 0xf, 0xff, 0xf, 0xfe, + 0x0, 0x3, 0xff, 0xc3, 0xff, 0xc0, 0x1, 0xff, + 0xe0, 0x7f, 0xf8, 0x0, 0xff, 0xf8, 0xf, 0xff, + 0x80, 0xff, 0xfc, 0x1, 0xff, 0xff, 0xff, 0xfe, + 0x0, 0x3f, 0xff, 0xff, 0xff, 0x0, 0x7, 0xff, + 0xff, 0xff, 0x0, 0x0, 0x7f, 0xff, 0xff, 0x0, + 0x0, 0x3, 0xff, 0xfe, 0x0, 0x0, 0x7, 0xff, + 0xff, 0xf0, 0x0, 0x7, 0xff, 0xff, 0xff, 0x80, + 0x7, 0xff, 0xff, 0xff, 0xf0, 0x3, 0xff, 0xff, + 0xff, 0xff, 0x1, 0xff, 0xf8, 0xf, 0xff, 0xe0, + 0xff, 0xf8, 0x0, 0x7f, 0xf8, 0x3f, 0xfc, 0x0, + 0xf, 0xff, 0x1f, 0xfe, 0x0, 0x1, 0xff, 0xe7, + 0xff, 0x80, 0x0, 0x7f, 0xfb, 0xff, 0xc0, 0x0, + 0xf, 0xfe, 0xff, 0xf0, 0x0, 0x3, 0xff, 0xff, + 0xfc, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, + 0x3f, 0xff, 0xff, 0xc0, 0x0, 0xf, 0xff, 0xff, + 0xf0, 0x0, 0x3, 0xff, 0xff, 0xfe, 0x0, 0x1, + 0xff, 0xff, 0xff, 0x80, 0x0, 0x7f, 0xff, 0xff, + 0xf0, 0x0, 0x3f, 0xff, 0x7f, 0xfe, 0x0, 0x1f, + 0xff, 0x9f, 0xff, 0xe0, 0x3f, 0xff, 0xe3, 0xff, + 0xff, 0xff, 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0x1f, 0xff, 0xff, 0xff, 0xfe, 0x3, 0xff, + 0xff, 0xff, 0xff, 0x0, 0x7f, 0xff, 0xff, 0xff, + 0x80, 0xf, 0xff, 0xff, 0xff, 0xc0, 0x1, 0xff, + 0xff, 0xff, 0xe0, 0x0, 0x1f, 0xff, 0xff, 0xe0, + 0x0, 0x1, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x7, + 0xff, 0x80, 0x0, + + /* U+39 "9" */ + 0x0, 0x0, 0xff, 0xc0, 0x0, 0x0, 0x3, 0xff, + 0xff, 0x0, 0x0, 0x3, 0xff, 0xff, 0xf0, 0x0, + 0x3, 0xff, 0xff, 0xff, 0x0, 0x1, 0xff, 0xff, + 0xff, 0xe0, 0x1, 0xff, 0xff, 0xff, 0xfc, 0x0, + 0x7f, 0xff, 0xff, 0xff, 0x80, 0x3f, 0xff, 0xff, + 0xff, 0xf0, 0x1f, 0xff, 0xff, 0xff, 0xfe, 0xf, + 0xff, 0xff, 0xff, 0xff, 0x83, 0xff, 0xfc, 0xf, + 0xff, 0xf1, 0xff, 0xf8, 0x0, 0xff, 0xfc, 0x7f, + 0xfc, 0x0, 0xf, 0xff, 0x9f, 0xff, 0x0, 0x3, + 0xff, 0xef, 0xff, 0x80, 0x0, 0x7f, 0xfb, 0xff, + 0xe0, 0x0, 0x1f, 0xff, 0xff, 0xf0, 0x0, 0x3, + 0xff, 0xff, 0xfc, 0x0, 0x0, 0xff, 0xff, 0xff, + 0x0, 0x0, 0x3f, 0xff, 0xff, 0xc0, 0x0, 0xf, + 0xff, 0xff, 0xf0, 0x0, 0x3, 0xff, 0xff, 0xfc, + 0x0, 0x0, 0xff, 0xff, 0xff, 0x80, 0x0, 0x7f, + 0xff, 0xff, 0xe0, 0x0, 0x1f, 0xff, 0x7f, 0xf8, + 0x0, 0xf, 0xff, 0xdf, 0xff, 0x0, 0x3, 0xff, + 0xe7, 0xff, 0xf0, 0x3, 0xff, 0xf8, 0xff, 0xff, + 0x3, 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0x87, 0xff, 0xff, 0xff, 0xff, 0xc1, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x3f, 0xff, 0xff, 0xff, 0xf8, + 0x7, 0xff, 0xff, 0xdf, 0xfe, 0x0, 0xff, 0xff, + 0xef, 0xff, 0x80, 0x1f, 0xff, 0xf7, 0xff, 0xc0, + 0x1, 0xff, 0xf1, 0xff, 0xf0, 0x0, 0xf, 0xf0, + 0xff, 0xf8, 0x0, 0x0, 0x0, 0x7f, 0xfc, 0x0, + 0x0, 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0xf, + 0xff, 0x80, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, + 0x0, 0x1, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xff, + 0xf8, 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, + 0x0, 0x1f, 0xff, 0x0, 0x0, 0x0, 0xf, 0xff, + 0x80, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, + 0x1, 0xff, 0xf0, 0x0, 0x0, 0x0, 0xff, 0xf8, + 0x0, 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, + 0x1f, 0xff, 0x0, 0x0, 0x0, 0xf, 0xff, 0x80, + 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x3, + 0xff, 0xf0, 0x0, 0x0, 0x0, 0xff, 0xf8, 0x0, + 0x0, 0x0, 0x7f, 0xfe, 0x0, 0x0, 0x0, 0x3f, + 0xff, 0x0, 0x0, 0x0, 0xf, 0xff, 0x80, 0x0, + 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, + + /* U+3A ":" */ + 0x7, 0xe0, 0x1f, 0xf8, 0x3f, 0xfc, 0x7f, 0xfe, + 0x7f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xfe, + 0x7f, 0xfe, 0x3f, 0xfc, 0x1f, 0xf8, 0x7, 0xe0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x7, 0xe0, 0x1f, 0xf8, + 0x3f, 0xfc, 0x7f, 0xfe, 0x7f, 0xfe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x7f, 0xfe, 0x7f, 0xfe, 0x3f, 0xfc, + 0x1f, 0xf8, 0x7, 0xe0 +}; + + +/*--------------------- + * GLYPH DESCRIPTION + *--------------------*/ + +static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = { + {.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */, + {.bitmap_index = 0, .adv_w = 768, .box_w = 41, .box_h = 59, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 303, .adv_w = 768, .box_w = 40, .box_h = 58, .ofs_x = 6, .ofs_y = 0}, + {.bitmap_index = 593, .adv_w = 768, .box_w = 41, .box_h = 58, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 891, .adv_w = 768, .box_w = 41, .box_h = 59, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 1194, .adv_w = 768, .box_w = 38, .box_h = 58, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 1470, .adv_w = 768, .box_w = 41, .box_h = 58, .ofs_x = 4, .ofs_y = -1}, + {.bitmap_index = 1768, .adv_w = 768, .box_w = 42, .box_h = 59, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 2078, .adv_w = 768, .box_w = 40, .box_h = 58, .ofs_x = 4, .ofs_y = 0}, + {.bitmap_index = 2368, .adv_w = 768, .box_w = 42, .box_h = 60, .ofs_x = 3, .ofs_y = -1}, + {.bitmap_index = 2683, .adv_w = 768, .box_w = 42, .box_h = 59, .ofs_x = 3, .ofs_y = 0}, + {.bitmap_index = 2993, .adv_w = 768, .box_w = 16, .box_h = 46, .ofs_x = 16, .ofs_y = -1} +}; + +/*--------------------- + * CHARACTER MAPPING + *--------------------*/ + + + +/*Collect the unicode lists and glyph_id offsets*/ +static const lv_font_fmt_txt_cmap_t cmaps[] = +{ + { + .range_start = 48, .range_length = 11, .glyph_id_start = 1, + .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY + } +}; + + + +/*-------------------- + * ALL CUSTOM DATA + *--------------------*/ + +/*Store all the custom data of the font*/ +static lv_font_fmt_txt_dsc_t font_dsc = { + .glyph_bitmap = gylph_bitmap, + .glyph_dsc = glyph_dsc, + .cmaps = cmaps, + .kern_dsc = NULL, + .kern_scale = 0, + .cmap_num = 1, + .bpp = 1, + .kern_classes = 0, + .bitmap_format = 0 +}; + + +/*----------------- + * PUBLIC FONT + *----------------*/ + +/*Initialize a public general font descriptor*/ +lv_font_t jetbrains_mono_extrabold_compressed = { + .get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/ + .get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/ + .line_height = 60, /*The maximum line height required by the font*/ + .base_line = 1, /*Baseline measured from the bottom of the line*/ +#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0) + .subpx = LV_FONT_SUBPX_NONE, +#endif + .dsc = &font_dsc /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */ +}; + +#endif /*#if JETBRAINS_MONO_EXTRABOLD_COMPRESSED*/ + diff --git a/src/displayapp/icons/battery/os_battery_005.c b/src/displayapp/icons/battery/os_battery_005.c new file mode 100644 index 00000000..64832b5c --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_005.c @@ -0,0 +1,56 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERY_005 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERY_005 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERY_005 uint8_t ck_os_battery_005_map[] = { + 0x04, 0x02, 0xcc, 0xff, /*Color of index 0*/ + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 1*/ + + 0xfc, 0x00, 0x3f, + 0xf8, 0x00, 0x1f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0x00, 0xff, 0x00, + 0x00, 0xff, 0x00, + 0x00, 0xff, 0x00, + 0x00, 0xff, 0x00, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, +}; + +const lv_img_dsc_t ck_os_battery_005 = { + .header.always_zero = 0, + .header.w = 24, + .header.h = 32, + .data_size = 104, + .header.cf = LV_IMG_CF_INDEXED_1BIT, + .data = ck_os_battery_005_map, +}; diff --git a/src/displayapp/icons/battery/os_battery_005.png b/src/displayapp/icons/battery/os_battery_005.png Binary files differnew file mode 100644 index 00000000..963767be --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_005.png diff --git a/src/displayapp/icons/battery/os_battery_010.c b/src/displayapp/icons/battery/os_battery_010.c new file mode 100644 index 00000000..f36b684b --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_010.c @@ -0,0 +1,58 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERY_010 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERY_010 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERY_010 uint8_t ck_os_battery_010_map[] = { + 0x04, 0x02, 0xcc, 0xff, /*Color of index 0*/ + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 1*/ + 0x04, 0x7a, 0xf4, 0xff, /*Color of index 2*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 3*/ + + 0x55, 0x5f, 0xff, 0xff, 0xf5, 0x55, 0x55, + 0x55, 0x7f, 0xff, 0xff, 0xfd, 0x55, 0x55, + 0x55, 0xff, 0xff, 0xff, 0xff, 0x55, 0x55, + 0x55, 0xff, 0xff, 0xff, 0xff, 0x55, 0x55, + 0xff, 0xff, 0x55, 0x55, 0xff, 0xff, 0x55, + 0xff, 0xff, 0x55, 0x55, 0xff, 0xff, 0x55, + 0xff, 0xff, 0x55, 0x55, 0xff, 0xff, 0x55, + 0xff, 0xff, 0x55, 0x55, 0xff, 0xff, 0x55, + 0xff, 0x55, 0x55, 0x55, 0x55, 0xff, 0x55, + 0xff, 0x55, 0x55, 0x55, 0x55, 0xff, 0x55, + 0xff, 0x55, 0x55, 0x55, 0x55, 0xff, 0x55, + 0xff, 0x55, 0x55, 0x55, 0x55, 0xff, 0x55, + 0xff, 0x55, 0x55, 0x55, 0x55, 0xff, 0x55, + 0xff, 0x55, 0x55, 0x55, 0x55, 0xff, 0x55, + 0xff, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0xff, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0xff, 0x55, 0x55, 0x6a, 0xaa, 0xaa, 0xa9, + 0xff, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, + 0xff, 0x55, 0x55, 0xaa, 0xa5, 0x5a, 0xaa, + 0xff, 0x55, 0x55, 0xaa, 0xa5, 0x5a, 0xaa, + 0xff, 0x55, 0x55, 0xaa, 0xa5, 0x5a, 0xaa, + 0xff, 0x55, 0x55, 0xaa, 0xa5, 0x5a, 0xaa, + 0xff, 0x55, 0x55, 0xaa, 0xa5, 0x5a, 0xaa, + 0xff, 0x55, 0x55, 0xaa, 0xa5, 0x5a, 0xaa, + 0xff, 0x50, 0x05, 0xaa, 0xaa, 0xaa, 0xaa, + 0xff, 0x50, 0x05, 0xaa, 0xaa, 0xaa, 0xaa, + 0xff, 0x55, 0x55, 0xaa, 0xa5, 0x5a, 0xaa, + 0xff, 0x55, 0x55, 0xaa, 0xa5, 0x5a, 0xaa, + 0xff, 0xff, 0xf5, 0xaa, 0xa5, 0x5a, 0xaa, + 0xff, 0xff, 0xf5, 0xaa, 0xa5, 0x5a, 0xaa, + 0xff, 0xff, 0xf5, 0xaa, 0xaa, 0xaa, 0xaa, + 0xff, 0xff, 0xf5, 0x6a, 0xaa, 0xaa, 0xa9, +}; + +const lv_img_dsc_t ck_os_battery_010 = { + .header.always_zero = 0, + .header.w = 28, + .header.h = 32, + .data_size = 240, + .header.cf = LV_IMG_CF_INDEXED_2BIT, + .data = ck_os_battery_010_map, +}; diff --git a/src/displayapp/icons/battery/os_battery_010.png b/src/displayapp/icons/battery/os_battery_010.png Binary files differnew file mode 100644 index 00000000..68a9f406 --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_010.png diff --git a/src/displayapp/icons/battery/os_battery_020.c b/src/displayapp/icons/battery/os_battery_020.c new file mode 100644 index 00000000..3f648fb9 --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_020.c @@ -0,0 +1,58 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERY_020 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERY_020 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERY_020 uint8_t ck_os_battery_020_map[] = { + 0x04, 0x02, 0xcc, 0xff, /*Color of index 0*/ + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 1*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 2*/ + 0xff, 0xff, 0xff, 0xff, /*Color of index 3*/ + + 0x55, 0x5a, 0xaa, 0xaa, 0xa5, 0x55, + 0x55, 0x6a, 0xaa, 0xaa, 0xa9, 0x55, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x50, 0x00, 0x00, 0x05, 0xaa, + 0xaa, 0x50, 0x00, 0x00, 0x05, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, +}; + +const lv_img_dsc_t ck_os_battery_020 = { + .header.always_zero = 0, + .header.w = 24, + .header.h = 32, + .data_size = 208, + .header.cf = LV_IMG_CF_INDEXED_2BIT, + .data = ck_os_battery_020_map, +}; diff --git a/src/displayapp/icons/battery/os_battery_020.png b/src/displayapp/icons/battery/os_battery_020.png Binary files differnew file mode 100644 index 00000000..32eca651 --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_020.png diff --git a/src/displayapp/icons/battery/os_battery_030.c b/src/displayapp/icons/battery/os_battery_030.c new file mode 100644 index 00000000..4d5719b7 --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_030.c @@ -0,0 +1,58 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERY_030 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERY_030 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERY_030 uint8_t ck_os_battery_030_map[] = { + 0x04, 0x7a, 0xf4, 0xff, /*Color of index 0*/ + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 1*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 2*/ + 0xff, 0xff, 0xff, 0xff, /*Color of index 3*/ + + 0x55, 0x5a, 0xaa, 0xaa, 0xa5, 0x55, + 0x55, 0x6a, 0xaa, 0xaa, 0xa9, 0x55, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x50, 0x00, 0x00, 0x05, 0xaa, + 0xaa, 0x50, 0x00, 0x00, 0x05, 0xaa, + 0xaa, 0x50, 0x00, 0x00, 0x05, 0xaa, + 0xaa, 0x50, 0x00, 0x00, 0x05, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, +}; + +const lv_img_dsc_t ck_os_battery_030 = { + .header.always_zero = 0, + .header.w = 24, + .header.h = 32, + .data_size = 208, + .header.cf = LV_IMG_CF_INDEXED_2BIT, + .data = ck_os_battery_030_map, +}; diff --git a/src/displayapp/icons/battery/os_battery_030.png b/src/displayapp/icons/battery/os_battery_030.png Binary files differnew file mode 100644 index 00000000..aeb5eb1f --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_030.png diff --git a/src/displayapp/icons/battery/os_battery_040.c b/src/displayapp/icons/battery/os_battery_040.c new file mode 100644 index 00000000..0606fc35 --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_040.c @@ -0,0 +1,56 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERY_040 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERY_040 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERY_040 uint8_t ck_os_battery_040_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + + 0x03, 0xff, 0xc0, + 0x07, 0xff, 0xe0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, +}; + +const lv_img_dsc_t ck_os_battery_040 = { + .header.always_zero = 0, + .header.w = 24, + .header.h = 32, + .data_size = 104, + .header.cf = LV_IMG_CF_INDEXED_1BIT, + .data = ck_os_battery_040_map, +}; diff --git a/src/displayapp/icons/battery/os_battery_040.png b/src/displayapp/icons/battery/os_battery_040.png Binary files differnew file mode 100644 index 00000000..d84fda40 --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_040.png diff --git a/src/displayapp/icons/battery/os_battery_050.c b/src/displayapp/icons/battery/os_battery_050.c new file mode 100644 index 00000000..8732dc7a --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_050.c @@ -0,0 +1,56 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERY_050 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERY_050 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERY_050 uint8_t ck_os_battery_050_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + + 0x03, 0xff, 0xc0, + 0x07, 0xff, 0xe0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, +}; + +const lv_img_dsc_t ck_os_battery_050 = { + .header.always_zero = 0, + .header.w = 24, + .header.h = 32, + .data_size = 104, + .header.cf = LV_IMG_CF_INDEXED_1BIT, + .data = ck_os_battery_050_map, +}; diff --git a/src/displayapp/icons/battery/os_battery_050.png b/src/displayapp/icons/battery/os_battery_050.png Binary files differnew file mode 100644 index 00000000..224d38d6 --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_050.png diff --git a/src/displayapp/icons/battery/os_battery_060.c b/src/displayapp/icons/battery/os_battery_060.c new file mode 100644 index 00000000..a65936bf --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_060.c @@ -0,0 +1,56 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERY_060 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERY_060 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERY_060 uint8_t ck_os_battery_060_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + + 0x03, 0xff, 0xc0, + 0x07, 0xff, 0xe0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, +}; + +const lv_img_dsc_t ck_os_battery_060 = { + .header.always_zero = 0, + .header.w = 24, + .header.h = 32, + .data_size = 104, + .header.cf = LV_IMG_CF_INDEXED_1BIT, + .data = ck_os_battery_060_map, +}; diff --git a/src/displayapp/icons/battery/os_battery_060.png b/src/displayapp/icons/battery/os_battery_060.png Binary files differnew file mode 100644 index 00000000..e5e00eda --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_060.png diff --git a/src/displayapp/icons/battery/os_battery_070.c b/src/displayapp/icons/battery/os_battery_070.c new file mode 100644 index 00000000..949c0b8b --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_070.c @@ -0,0 +1,56 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERY_070 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERY_070 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERY_070 uint8_t ck_os_battery_070_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + + 0x03, 0xff, 0xc0, + 0x07, 0xff, 0xe0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, +}; + +const lv_img_dsc_t ck_os_battery_070 = { + .header.always_zero = 0, + .header.w = 24, + .header.h = 32, + .data_size = 104, + .header.cf = LV_IMG_CF_INDEXED_1BIT, + .data = ck_os_battery_070_map, +}; diff --git a/src/displayapp/icons/battery/os_battery_070.png b/src/displayapp/icons/battery/os_battery_070.png Binary files differnew file mode 100644 index 00000000..dee969b8 --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_070.png diff --git a/src/displayapp/icons/battery/os_battery_080.c b/src/displayapp/icons/battery/os_battery_080.c new file mode 100644 index 00000000..f447370e --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_080.c @@ -0,0 +1,56 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERY_080 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERY_080 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERY_080 uint8_t ck_os_battery_080_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + + 0x03, 0xff, 0xc0, + 0x07, 0xff, 0xe0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, +}; + +const lv_img_dsc_t ck_os_battery_080 = { + .header.always_zero = 0, + .header.w = 24, + .header.h = 32, + .data_size = 104, + .header.cf = LV_IMG_CF_INDEXED_1BIT, + .data = ck_os_battery_080_map, +}; diff --git a/src/displayapp/icons/battery/os_battery_080.png b/src/displayapp/icons/battery/os_battery_080.png Binary files differnew file mode 100644 index 00000000..3b13fbb2 --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_080.png diff --git a/src/displayapp/icons/battery/os_battery_090.c b/src/displayapp/icons/battery/os_battery_090.c new file mode 100644 index 00000000..6fa41b20 --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_090.c @@ -0,0 +1,56 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERY_090 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERY_090 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERY_090 uint8_t ck_os_battery_090_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + + 0x03, 0xff, 0xc0, + 0x07, 0xff, 0xe0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, +}; + +const lv_img_dsc_t ck_os_battery_090 = { + .header.always_zero = 0, + .header.w = 24, + .header.h = 32, + .data_size = 104, + .header.cf = LV_IMG_CF_INDEXED_1BIT, + .data = ck_os_battery_090_map, +}; diff --git a/src/displayapp/icons/battery/os_battery_090.png b/src/displayapp/icons/battery/os_battery_090.png Binary files differnew file mode 100644 index 00000000..d79f396b --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_090.png diff --git a/src/displayapp/icons/battery/os_battery_100.c b/src/displayapp/icons/battery/os_battery_100.c new file mode 100644 index 00000000..92cf9a41 --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_100.c @@ -0,0 +1,58 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERY_100 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERY_100 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERY_100 uint8_t ck_os_battery_100_map[] = { + 0x7c, 0xd2, 0x34, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 2*/ + 0xff, 0xff, 0xff, 0xff, /*Color of index 3*/ + + 0xaa, 0xa5, 0x55, 0x55, 0x5a, 0xaa, + 0xaa, 0x95, 0x55, 0x55, 0x56, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, + 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, + 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, + 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, + 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, +}; + +const lv_img_dsc_t ck_os_battery_100 = { + .header.always_zero = 0, + .header.w = 24, + .header.h = 32, + .data_size = 208, + .header.cf = LV_IMG_CF_INDEXED_2BIT, + .data = ck_os_battery_100_map, +}; diff --git a/src/displayapp/icons/battery/os_battery_100.png b/src/displayapp/icons/battery/os_battery_100.png Binary files differnew file mode 100644 index 00000000..dd0d306f --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_100.png diff --git a/src/displayapp/icons/battery/os_battery_error.c b/src/displayapp/icons/battery/os_battery_error.c new file mode 100644 index 00000000..af6aba5d --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_error.c @@ -0,0 +1,58 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERY_ERROR +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERY_ERROR +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERY_ERROR uint8_t ck_os_battery_error_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xc4, 0xc2, 0xc4, 0xff, /*Color of index 1*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 2*/ + 0xff, 0xff, 0xff, 0xff, /*Color of index 3*/ + + 0x00, 0x05, 0x55, 0x55, 0x50, 0x00, + 0x00, 0x15, 0x55, 0x55, 0x54, 0x00, + 0x00, 0x55, 0x55, 0x55, 0x55, 0x00, + 0x00, 0x55, 0x55, 0x55, 0x55, 0x00, + 0x55, 0x55, 0x00, 0x00, 0x55, 0x55, + 0x55, 0x55, 0x00, 0x00, 0x55, 0x55, + 0x55, 0x55, 0x00, 0x00, 0x55, 0x55, + 0x55, 0x54, 0x00, 0x00, 0x15, 0x55, + 0x55, 0x00, 0x0a, 0xa0, 0x00, 0x55, + 0x55, 0x00, 0xaa, 0xaa, 0x00, 0x55, + 0x55, 0x02, 0xaa, 0xaa, 0x80, 0x55, + 0x55, 0x02, 0xaa, 0xaa, 0x80, 0x55, + 0x55, 0x0a, 0xa8, 0x2a, 0xa0, 0x55, + 0x55, 0x0a, 0xa0, 0x0a, 0xa0, 0x55, + 0x55, 0x00, 0x00, 0x0a, 0xa0, 0x55, + 0x55, 0x00, 0x00, 0x2a, 0xa0, 0x55, + 0x55, 0x00, 0x02, 0xaa, 0x80, 0x55, + 0x55, 0x00, 0x0a, 0xaa, 0x80, 0x55, + 0x55, 0x00, 0x0a, 0xaa, 0x00, 0x55, + 0x55, 0x00, 0x0a, 0xa0, 0x00, 0x55, + 0x55, 0x00, 0x0a, 0xa0, 0x00, 0x55, + 0x55, 0x00, 0x0a, 0xa0, 0x00, 0x55, + 0x55, 0x00, 0x00, 0x00, 0x00, 0x55, + 0x55, 0x00, 0x00, 0x00, 0x00, 0x55, + 0x55, 0x00, 0x02, 0x80, 0x00, 0x55, + 0x55, 0x00, 0x0a, 0xa0, 0x00, 0x55, + 0x55, 0x00, 0x0a, 0xa0, 0x00, 0x55, + 0x55, 0x00, 0x02, 0x80, 0x00, 0x55, + 0x55, 0x55, 0x40, 0x01, 0x55, 0x55, + 0x55, 0x55, 0x50, 0x05, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, +}; + +const lv_img_dsc_t ck_os_battery_error = { + .header.always_zero = 0, + .header.w = 24, + .header.h = 32, + .data_size = 208, + .header.cf = LV_IMG_CF_INDEXED_2BIT, + .data = ck_os_battery_error_map, +}; diff --git a/src/displayapp/icons/battery/os_battery_error.png b/src/displayapp/icons/battery/os_battery_error.png Binary files differnew file mode 100644 index 00000000..4c7632fe --- /dev/null +++ b/src/displayapp/icons/battery/os_battery_error.png diff --git a/src/displayapp/icons/battery/os_batterycharging_005.c b/src/displayapp/icons/battery/os_batterycharging_005.c new file mode 100644 index 00000000..1b0c71df --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_005.c @@ -0,0 +1,56 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_005 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_005 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_005 uint8_t ck_os_batterycharging_005_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + + 0x03, 0xff, 0xc0, 0x00, + 0x07, 0xff, 0xe0, 0x00, + 0x0f, 0xff, 0xf0, 0x00, + 0x0f, 0xff, 0xf0, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x00, 0x00, + 0xf0, 0x00, 0x00, 0x00, + 0xf0, 0x00, 0x07, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x1f, 0x00, + 0xf0, 0x00, 0x3e, 0x00, + 0xf0, 0x00, 0x7e, 0x00, + 0xf0, 0x00, 0xfc, 0x00, + 0xf0, 0x01, 0xff, 0xf0, + 0xf0, 0x03, 0xff, 0xf0, + 0xf0, 0x03, 0xff, 0xf0, + 0xf0, 0x03, 0xff, 0xe0, + 0xf0, 0x00, 0x0f, 0xc0, + 0xf0, 0x00, 0x1f, 0x80, + 0xff, 0xff, 0x3f, 0x00, + 0xff, 0xff, 0x3e, 0x00, + 0xff, 0xff, 0x3c, 0x00, + 0xff, 0xff, 0x38, 0x00, +}; + +const lv_img_dsc_t ck_os_batterycharging_005 = { + .header.always_zero = 0, + .header.w = 28, + .header.h = 32, + .data_size = 136, + .header.cf = LV_IMG_CF_INDEXED_1BIT, + .data = ck_os_batterycharging_005_map, +}; diff --git a/src/displayapp/icons/battery/os_batterycharging_005.png b/src/displayapp/icons/battery/os_batterycharging_005.png Binary files differnew file mode 100644 index 00000000..f9545bc1 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_005.png diff --git a/src/displayapp/icons/battery/os_batterycharging_010.c b/src/displayapp/icons/battery/os_batterycharging_010.c new file mode 100644 index 00000000..304c0184 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_010.c @@ -0,0 +1,58 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_010 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_010 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_010 uint8_t ck_os_batterycharging_010_map[] = { + 0x04, 0x02, 0xcc, 0xff, /*Color of index 0*/ + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 1*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 2*/ + 0xff, 0xff, 0xff, 0xff, /*Color of index 3*/ + + 0x55, 0x5a, 0xaa, 0xaa, 0xa5, 0x55, 0x55, + 0x55, 0x6a, 0xaa, 0xaa, 0xa9, 0x55, 0x55, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0x6a, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x56, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x5a, 0xa9, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x6a, 0xa9, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0xaa, 0xa5, 0x55, + 0xaa, 0x55, 0x55, 0x56, 0xaa, 0xaa, 0xaa, + 0xaa, 0x55, 0x55, 0x5a, 0xaa, 0xaa, 0xaa, + 0xaa, 0x50, 0x00, 0x5a, 0xaa, 0xaa, 0xaa, + 0xaa, 0x50, 0x00, 0x5a, 0xaa, 0xaa, 0xa9, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xa5, + 0xaa, 0x55, 0x55, 0x55, 0x56, 0xaa, 0x95, + 0xaa, 0xaa, 0xaa, 0xaa, 0x5a, 0xaa, 0x55, + 0xaa, 0xaa, 0xaa, 0xaa, 0x5a, 0xa9, 0x55, + 0xaa, 0xaa, 0xaa, 0xaa, 0x5a, 0xa5, 0x55, + 0xaa, 0xaa, 0xaa, 0xaa, 0x5a, 0x95, 0x55, +}; + +const lv_img_dsc_t ck_os_batterycharging_010 = { + .header.always_zero = 0, + .header.w = 28, + .header.h = 32, + .data_size = 240, + .header.cf = LV_IMG_CF_INDEXED_2BIT, + .data = ck_os_batterycharging_010_map, +}; diff --git a/src/displayapp/icons/battery/os_batterycharging_010.png b/src/displayapp/icons/battery/os_batterycharging_010.png Binary files differnew file mode 100644 index 00000000..04d5f820 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_010.png diff --git a/src/displayapp/icons/battery/os_batterycharging_020.c b/src/displayapp/icons/battery/os_batterycharging_020.c new file mode 100644 index 00000000..1721be15 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_020.c @@ -0,0 +1,58 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_020 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_020 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_020 uint8_t ck_os_batterycharging_020_map[] = { + 0x04, 0x02, 0xcc, 0xff, /*Color of index 0*/ + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 1*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 2*/ + 0xff, 0xff, 0xff, 0xff, /*Color of index 3*/ + + 0x55, 0x5a, 0xaa, 0xaa, 0xa5, 0x55, 0x55, + 0x55, 0x6a, 0xaa, 0xaa, 0xa9, 0x55, 0x55, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0x6a, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x56, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x5a, 0xa9, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x6a, 0xa9, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0xaa, 0xa5, 0x55, + 0xaa, 0x55, 0x55, 0x56, 0xaa, 0xaa, 0xaa, + 0xaa, 0x55, 0x55, 0x5a, 0xaa, 0xaa, 0xaa, + 0xaa, 0x50, 0x00, 0x5a, 0xaa, 0xaa, 0xaa, + 0xaa, 0x50, 0x00, 0x5a, 0xaa, 0xaa, 0xa9, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xa5, + 0xaa, 0x55, 0x55, 0x55, 0x56, 0xaa, 0x95, + 0xaa, 0xaa, 0xaa, 0xaa, 0x5a, 0xaa, 0x55, + 0xaa, 0xaa, 0xaa, 0xaa, 0x5a, 0xa9, 0x55, + 0xaa, 0xaa, 0xaa, 0xaa, 0x5a, 0xa5, 0x55, + 0xaa, 0xaa, 0xaa, 0xaa, 0x5a, 0x95, 0x55, +}; + +const lv_img_dsc_t ck_os_batterycharging_020 = { + .header.always_zero = 0, + .header.w = 28, + .header.h = 32, + .data_size = 240, + .header.cf = LV_IMG_CF_INDEXED_2BIT, + .data = ck_os_batterycharging_020_map, +}; diff --git a/src/displayapp/icons/battery/os_batterycharging_020.png b/src/displayapp/icons/battery/os_batterycharging_020.png Binary files differnew file mode 100644 index 00000000..6416e1e6 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_020.png diff --git a/src/displayapp/icons/battery/os_batterycharging_030.c b/src/displayapp/icons/battery/os_batterycharging_030.c new file mode 100644 index 00000000..83101fd9 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_030.c @@ -0,0 +1,58 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_030 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_030 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_030 uint8_t ck_os_batterycharging_030_map[] = { + 0x04, 0x7a, 0xf4, 0xff, /*Color of index 0*/ + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 1*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 2*/ + 0xff, 0xff, 0xff, 0xff, /*Color of index 3*/ + + 0x55, 0x5a, 0xaa, 0xaa, 0xa5, 0x55, 0x55, + 0x55, 0x6a, 0xaa, 0xaa, 0xa9, 0x55, 0x55, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, + 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0x6a, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x56, 0xaa, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x5a, 0xa9, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0x6a, 0xa9, 0x55, + 0xaa, 0x55, 0x55, 0x55, 0xaa, 0xa5, 0x55, + 0xaa, 0x50, 0x00, 0x56, 0xaa, 0xaa, 0xaa, + 0xaa, 0x50, 0x00, 0x5a, 0xaa, 0xaa, 0xaa, + 0xaa, 0x50, 0x00, 0x5a, 0xaa, 0xaa, 0xaa, + 0xaa, 0x50, 0x00, 0x5a, 0xaa, 0xaa, 0xa9, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xa5, + 0xaa, 0x55, 0x55, 0x55, 0x56, 0xaa, 0x95, + 0xaa, 0xaa, 0xaa, 0xaa, 0x5a, 0xaa, 0x55, + 0xaa, 0xaa, 0xaa, 0xaa, 0x5a, 0xa9, 0x55, + 0xaa, 0xaa, 0xaa, 0xaa, 0x5a, 0xa5, 0x55, + 0xaa, 0xaa, 0xaa, 0xaa, 0x5a, 0x95, 0x55, +}; + +const lv_img_dsc_t ck_os_batterycharging_030 = { + .header.always_zero = 0, + .header.w = 28, + .header.h = 32, + .data_size = 240, + .header.cf = LV_IMG_CF_INDEXED_2BIT, + .data = ck_os_batterycharging_030_map, +}; diff --git a/src/displayapp/icons/battery/os_batterycharging_030.png b/src/displayapp/icons/battery/os_batterycharging_030.png Binary files differnew file mode 100644 index 00000000..96b44d2e --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_030.png diff --git a/src/displayapp/icons/battery/os_batterycharging_040.c b/src/displayapp/icons/battery/os_batterycharging_040.c new file mode 100644 index 00000000..02af00e5 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_040.c @@ -0,0 +1,56 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_040 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_040 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_040 uint8_t ck_os_batterycharging_040_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + + 0x03, 0xff, 0xc0, 0x00, + 0x07, 0xff, 0xe0, 0x00, + 0x0f, 0xff, 0xf0, 0x00, + 0x0f, 0xff, 0xf0, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x00, 0x00, + 0xf0, 0x00, 0x00, 0x00, + 0xf0, 0x00, 0x07, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x1f, 0x00, + 0xf0, 0x00, 0x3e, 0x00, + 0xf3, 0xf8, 0x7e, 0x00, + 0xf3, 0xf0, 0xfc, 0x00, + 0xf3, 0xf1, 0xff, 0xf0, + 0xf3, 0xf3, 0xff, 0xf0, + 0xf3, 0xf3, 0xff, 0xf0, + 0xf3, 0xf3, 0xff, 0xe0, + 0xf0, 0x00, 0x0f, 0xc0, + 0xf0, 0x00, 0x1f, 0x80, + 0xff, 0xff, 0x3f, 0x00, + 0xff, 0xff, 0x3e, 0x00, + 0xff, 0xff, 0x3c, 0x00, + 0xff, 0xff, 0x38, 0x00, +}; + +const lv_img_dsc_t ck_os_batterycharging_040 = { + .header.always_zero = 0, + .header.w = 28, + .header.h = 32, + .data_size = 136, + .header.cf = LV_IMG_CF_INDEXED_1BIT, + .data = ck_os_batterycharging_040_map, +}; diff --git a/src/displayapp/icons/battery/os_batterycharging_040.png b/src/displayapp/icons/battery/os_batterycharging_040.png Binary files differnew file mode 100644 index 00000000..5a42caf2 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_040.png diff --git a/src/displayapp/icons/battery/os_batterycharging_050.c b/src/displayapp/icons/battery/os_batterycharging_050.c new file mode 100644 index 00000000..d2eea829 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_050.c @@ -0,0 +1,56 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_050 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_050 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_050 uint8_t ck_os_batterycharging_050_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + + 0x03, 0xff, 0xc0, 0x00, + 0x07, 0xff, 0xe0, 0x00, + 0x0f, 0xff, 0xf0, 0x00, + 0x0f, 0xff, 0xf0, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x00, 0x00, + 0xf0, 0x00, 0x00, 0x00, + 0xf0, 0x00, 0x07, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf3, 0xfe, 0x1f, 0x00, + 0xf3, 0xfc, 0x3e, 0x00, + 0xf3, 0xf8, 0x7e, 0x00, + 0xf3, 0xf0, 0xfc, 0x00, + 0xf3, 0xf1, 0xff, 0xf0, + 0xf3, 0xf3, 0xff, 0xf0, + 0xf3, 0xf3, 0xff, 0xf0, + 0xf3, 0xf3, 0xff, 0xe0, + 0xf0, 0x00, 0x0f, 0xc0, + 0xf0, 0x00, 0x1f, 0x80, + 0xff, 0xff, 0x3f, 0x00, + 0xff, 0xff, 0x3e, 0x00, + 0xff, 0xff, 0x3c, 0x00, + 0xff, 0xff, 0x38, 0x00, +}; + +const lv_img_dsc_t ck_os_batterycharging_050 = { + .header.always_zero = 0, + .header.w = 28, + .header.h = 32, + .data_size = 136, + .header.cf = LV_IMG_CF_INDEXED_1BIT, + .data = ck_os_batterycharging_050_map, +}; diff --git a/src/displayapp/icons/battery/os_batterycharging_050.png b/src/displayapp/icons/battery/os_batterycharging_050.png Binary files differnew file mode 100644 index 00000000..ca0e04dd --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_050.png diff --git a/src/displayapp/icons/battery/os_batterycharging_060.c b/src/displayapp/icons/battery/os_batterycharging_060.c new file mode 100644 index 00000000..05f8b975 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_060.c @@ -0,0 +1,56 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_060 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_060 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_060 uint8_t ck_os_batterycharging_060_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + + 0x03, 0xff, 0xc0, 0x00, + 0x07, 0xff, 0xe0, 0x00, + 0x0f, 0xff, 0xf0, 0x00, + 0x0f, 0xff, 0xf0, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x00, 0x00, + 0xf0, 0x00, 0x00, 0x00, + 0xf3, 0xff, 0x87, 0x00, + 0xf3, 0xff, 0x0f, 0x00, + 0xf3, 0xfe, 0x1f, 0x00, + 0xf3, 0xfc, 0x3e, 0x00, + 0xf3, 0xf8, 0x7e, 0x00, + 0xf3, 0xf0, 0xfc, 0x00, + 0xf3, 0xf1, 0xff, 0xf0, + 0xf3, 0xf3, 0xff, 0xf0, + 0xf3, 0xf3, 0xff, 0xf0, + 0xf3, 0xf3, 0xff, 0xe0, + 0xf0, 0x00, 0x0f, 0xc0, + 0xf0, 0x00, 0x1f, 0x80, + 0xff, 0xff, 0x3f, 0x00, + 0xff, 0xff, 0x3e, 0x00, + 0xff, 0xff, 0x3c, 0x00, + 0xff, 0xff, 0x38, 0x00, +}; + +const lv_img_dsc_t ck_os_batterycharging_060 = { + .header.always_zero = 0, + .header.w = 28, + .header.h = 32, + .data_size = 136, + .header.cf = LV_IMG_CF_INDEXED_1BIT, + .data = ck_os_batterycharging_060_map, +}; diff --git a/src/displayapp/icons/battery/os_batterycharging_060.png b/src/displayapp/icons/battery/os_batterycharging_060.png Binary files differnew file mode 100644 index 00000000..2930068a --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_060.png diff --git a/src/displayapp/icons/battery/os_batterycharging_070.c b/src/displayapp/icons/battery/os_batterycharging_070.c new file mode 100644 index 00000000..ac3e319c --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_070.c @@ -0,0 +1,56 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_070 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_070 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_070 uint8_t ck_os_batterycharging_070_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + + 0x03, 0xff, 0xc0, 0x00, + 0x07, 0xff, 0xe0, 0x00, + 0x0f, 0xff, 0xf0, 0x00, + 0x0f, 0xff, 0xf0, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf0, 0x00, 0x0f, 0x00, + 0xf3, 0xff, 0xc0, 0x00, + 0xf3, 0xff, 0xc0, 0x00, + 0xf3, 0xff, 0x87, 0x00, + 0xf3, 0xff, 0x0f, 0x00, + 0xf3, 0xfe, 0x1f, 0x00, + 0xf3, 0xfc, 0x3e, 0x00, + 0xf3, 0xf8, 0x7e, 0x00, + 0xf3, 0xf0, 0xfc, 0x00, + 0xf3, 0xf1, 0xff, 0xf0, + 0xf3, 0xf3, 0xff, 0xf0, + 0xf3, 0xf3, 0xff, 0xf0, + 0xf3, 0xf3, 0xff, 0xe0, + 0xf0, 0x00, 0x0f, 0xc0, + 0xf0, 0x00, 0x1f, 0x80, + 0xff, 0xff, 0x3f, 0x00, + 0xff, 0xff, 0x3e, 0x00, + 0xff, 0xff, 0x3c, 0x00, + 0xff, 0xff, 0x38, 0x00, +}; + +const lv_img_dsc_t ck_os_batterycharging_070 = { + .header.always_zero = 0, + .header.w = 28, + .header.h = 32, + .data_size = 136, + .header.cf = LV_IMG_CF_INDEXED_1BIT, + .data = ck_os_batterycharging_070_map, +}; diff --git a/src/displayapp/icons/battery/os_batterycharging_070.png b/src/displayapp/icons/battery/os_batterycharging_070.png Binary files differnew file mode 100644 index 00000000..7d5f55d7 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_070.png diff --git a/src/displayapp/icons/battery/os_batterycharging_080.c b/src/displayapp/icons/battery/os_batterycharging_080.c new file mode 100644 index 00000000..cc1c1d23 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_080.c @@ -0,0 +1,58 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_080 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_080 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_080 uint8_t ck_os_batterycharging_080_map[] = { + 0x7c, 0xd2, 0x34, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 2*/ + 0xff, 0xff, 0xff, 0xff, /*Color of index 3*/ + + 0xaa, 0xa5, 0x55, 0x55, 0x5a, 0xaa, 0xaa, + 0xaa, 0x95, 0x55, 0x55, 0x56, 0xaa, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, + 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, + 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, + 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, + 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0xaa, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0xaa, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0xaa, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0xaa, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, 0xaa, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, 0xaa, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0xaa, 0xaa, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0xaa, 0xaa, + 0x55, 0xa0, 0x00, 0x00, 0x2a, 0x95, 0xaa, + 0x55, 0xa0, 0x00, 0x00, 0xaa, 0x55, 0xaa, + 0x55, 0xa0, 0x00, 0x02, 0xa9, 0x55, 0xaa, + 0x55, 0xa0, 0x00, 0x0a, 0xa5, 0x56, 0xaa, + 0x55, 0xa0, 0x00, 0x2a, 0x95, 0x56, 0xaa, + 0x55, 0xa0, 0x00, 0xaa, 0x55, 0x5a, 0xaa, + 0x55, 0xa0, 0x00, 0xa9, 0x55, 0x55, 0x55, + 0x55, 0xa0, 0x00, 0xa5, 0x55, 0x55, 0x55, + 0x55, 0xa0, 0x00, 0xa5, 0x55, 0x55, 0x55, + 0x55, 0xa0, 0x00, 0xa5, 0x55, 0x55, 0x56, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x5a, + 0x55, 0xaa, 0xaa, 0xaa, 0xa9, 0x55, 0x6a, + 0x55, 0x55, 0x55, 0x55, 0xa5, 0x55, 0xaa, + 0x55, 0x55, 0x55, 0x55, 0xa5, 0x56, 0xaa, + 0x55, 0x55, 0x55, 0x55, 0xa5, 0x5a, 0xaa, + 0x55, 0x55, 0x55, 0x55, 0xa5, 0x6a, 0xaa, +}; + +const lv_img_dsc_t ck_os_batterycharging_080 = { + .header.always_zero = 0, + .header.w = 28, + .header.h = 32, + .data_size = 240, + .header.cf = LV_IMG_CF_INDEXED_2BIT, + .data = ck_os_batterycharging_080_map, +}; diff --git a/src/displayapp/icons/battery/os_batterycharging_080.png b/src/displayapp/icons/battery/os_batterycharging_080.png Binary files differnew file mode 100644 index 00000000..cce5052f --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_080.png diff --git a/src/displayapp/icons/battery/os_batterycharging_090.c b/src/displayapp/icons/battery/os_batterycharging_090.c new file mode 100644 index 00000000..85e1c260 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_090.c @@ -0,0 +1,58 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_090 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_090 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_090 uint8_t ck_os_batterycharging_090_map[] = { + 0x7c, 0xd2, 0x34, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 2*/ + 0xff, 0xff, 0xff, 0xff, /*Color of index 3*/ + + 0xaa, 0xa5, 0x55, 0x55, 0x5a, 0xaa, 0xaa, + 0xaa, 0x95, 0x55, 0x55, 0x56, 0xaa, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, + 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, + 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, + 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, + 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, + 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0xaa, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0xaa, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, 0xaa, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, 0xaa, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, 0xaa, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0x55, 0xaa, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0xaa, 0xaa, + 0x55, 0xa0, 0x00, 0x00, 0x0a, 0xaa, 0xaa, + 0x55, 0xa0, 0x00, 0x00, 0x2a, 0x95, 0xaa, + 0x55, 0xa0, 0x00, 0x00, 0xaa, 0x55, 0xaa, + 0x55, 0xa0, 0x00, 0x02, 0xa9, 0x55, 0xaa, + 0x55, 0xa0, 0x00, 0x0a, 0xa5, 0x56, 0xaa, + 0x55, 0xa0, 0x00, 0x2a, 0x95, 0x56, 0xaa, + 0x55, 0xa0, 0x00, 0xaa, 0x55, 0x5a, 0xaa, + 0x55, 0xa0, 0x00, 0xa9, 0x55, 0x55, 0x55, + 0x55, 0xa0, 0x00, 0xa5, 0x55, 0x55, 0x55, + 0x55, 0xa0, 0x00, 0xa5, 0x55, 0x55, 0x55, + 0x55, 0xa0, 0x00, 0xa5, 0x55, 0x55, 0x56, + 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x5a, + 0x55, 0xaa, 0xaa, 0xaa, 0xa9, 0x55, 0x6a, + 0x55, 0x55, 0x55, 0x55, 0xa5, 0x55, 0xaa, + 0x55, 0x55, 0x55, 0x55, 0xa5, 0x56, 0xaa, + 0x55, 0x55, 0x55, 0x55, 0xa5, 0x5a, 0xaa, + 0x55, 0x55, 0x55, 0x55, 0xa5, 0x6a, 0xaa, +}; + +const lv_img_dsc_t ck_os_batterycharging_090 = { + .header.always_zero = 0, + .header.w = 28, + .header.h = 32, + .data_size = 240, + .header.cf = LV_IMG_CF_INDEXED_2BIT, + .data = ck_os_batterycharging_090_map, +}; diff --git a/src/displayapp/icons/battery/os_batterycharging_090.png b/src/displayapp/icons/battery/os_batterycharging_090.png Binary files differnew file mode 100644 index 00000000..fc7b443d --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_090.png diff --git a/src/displayapp/icons/battery/os_batterycharging_100.c b/src/displayapp/icons/battery/os_batterycharging_100.c new file mode 100644 index 00000000..8dec0cb5 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_100.c @@ -0,0 +1,56 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_100 +#define LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_100 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BATTERYCHARGING_100 uint8_t ck_os_batterycharging_100_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + + 0x03, 0xff, 0xc0, + 0x07, 0xff, 0xe0, + 0x0f, 0xff, 0xf0, + 0x0f, 0xff, 0xf0, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x07, 0x0f, + 0xf0, 0x0f, 0x0f, + 0xf0, 0x1f, 0x0f, + 0xf0, 0x3e, 0x0f, + 0xf0, 0x7e, 0x0f, + 0xf0, 0xfc, 0x0f, + 0xf1, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0xcf, + 0xf3, 0xff, 0x8f, + 0xf0, 0x3f, 0x0f, + 0xf0, 0x7e, 0x0f, + 0xf0, 0x7c, 0x0f, + 0xf0, 0xf8, 0x0f, + 0xf0, 0xf0, 0x0f, + 0xf0, 0xe0, 0x0f, + 0xf0, 0x00, 0x0f, + 0xf0, 0x00, 0x0f, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, +}; + +const lv_img_dsc_t ck_os_batterycharging_100 = { + .header.always_zero = 0, + .header.w = 24, + .header.h = 32, + .data_size = 104, + .header.cf = LV_IMG_CF_INDEXED_1BIT, + .data = ck_os_batterycharging_100_map, +}; diff --git a/src/displayapp/icons/battery/os_batterycharging_100.png b/src/displayapp/icons/battery/os_batterycharging_100.png Binary files differnew file mode 100644 index 00000000..7c8ce0c4 --- /dev/null +++ b/src/displayapp/icons/battery/os_batterycharging_100.png diff --git a/src/displayapp/icons/bluetooth/ck_os_bt_connected.png b/src/displayapp/icons/bluetooth/ck_os_bt_connected.png Binary files differnew file mode 100644 index 00000000..53716115 --- /dev/null +++ b/src/displayapp/icons/bluetooth/ck_os_bt_connected.png diff --git a/src/displayapp/icons/bluetooth/ck_os_bt_disconnected.png b/src/displayapp/icons/bluetooth/ck_os_bt_disconnected.png Binary files differnew file mode 100644 index 00000000..3275895d --- /dev/null +++ b/src/displayapp/icons/bluetooth/ck_os_bt_disconnected.png diff --git a/src/displayapp/icons/bluetooth/os_bt_connected.c b/src/displayapp/icons/bluetooth/os_bt_connected.c new file mode 100644 index 00000000..d30dc9d0 --- /dev/null +++ b/src/displayapp/icons/bluetooth/os_bt_connected.c @@ -0,0 +1,56 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BT_CONNECTED +#define LV_ATTRIBUTE_IMG_CK_OS_BT_CONNECTED +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BT_CONNECTED uint8_t ck_os_bt_connected_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 1*/ + + 0x00, 0x0e, 0x00, 0x00, + 0x00, 0x0f, 0x00, 0x00, + 0x00, 0x0f, 0x80, 0x00, + 0x00, 0x0f, 0xc0, 0x00, + 0x00, 0x0f, 0xe0, 0x00, + 0x00, 0x0f, 0xf0, 0x00, + 0x03, 0x8f, 0xf8, 0x00, + 0x03, 0xcf, 0x7c, 0x00, + 0x03, 0xef, 0x3e, 0x00, + 0x01, 0xff, 0x1f, 0x00, + 0x00, 0xff, 0x1f, 0x00, + 0x00, 0x7f, 0x3e, 0x00, + 0x00, 0x3f, 0x7c, 0x00, + 0x00, 0x1f, 0xf8, 0x00, + 0x00, 0x0f, 0xf0, 0x00, + 0x00, 0x0f, 0xe0, 0x00, + 0x00, 0x0f, 0xe0, 0x00, + 0x00, 0x0f, 0xf0, 0x00, + 0x00, 0x1f, 0xf8, 0x00, + 0x00, 0x3f, 0x7c, 0x00, + 0x00, 0x7f, 0x3e, 0x00, + 0x00, 0xff, 0x1f, 0x00, + 0x01, 0xff, 0x1f, 0x00, + 0x03, 0xef, 0x3e, 0x00, + 0x03, 0xcf, 0x7c, 0x00, + 0x03, 0x8f, 0xf8, 0x00, + 0x00, 0x0f, 0xf0, 0x00, + 0x00, 0x0f, 0xe0, 0x00, + 0x00, 0x0f, 0xc0, 0x00, + 0x00, 0x0f, 0x80, 0x00, + 0x00, 0x0f, 0x00, 0x00, + 0x00, 0x0e, 0x00, 0x00, +}; + +const lv_img_dsc_t ck_os_bt_connected = { + .header.always_zero = 0, + .header.w = 32, + .header.h = 32, + .data_size = 136, + .header.cf = LV_IMG_CF_INDEXED_1BIT, + .data = ck_os_bt_connected_map, +}; diff --git a/src/displayapp/icons/bluetooth/os_bt_connected.png b/src/displayapp/icons/bluetooth/os_bt_connected.png Binary files differnew file mode 100644 index 00000000..53716115 --- /dev/null +++ b/src/displayapp/icons/bluetooth/os_bt_connected.png diff --git a/src/displayapp/icons/bluetooth/os_bt_disconnected.c b/src/displayapp/icons/bluetooth/os_bt_disconnected.c new file mode 100644 index 00000000..930179b6 --- /dev/null +++ b/src/displayapp/icons/bluetooth/os_bt_disconnected.c @@ -0,0 +1,58 @@ +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_CK_OS_BT_DISCONNECTED +#define LV_ATTRIBUTE_IMG_CK_OS_BT_DISCONNECTED +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_CK_OS_BT_DISCONNECTED uint8_t ck_os_bt_disconnected_map[] = { + 0x6c, 0xfe, 0x6c, 0xff, /*Color of index 0*/ + 0xc4, 0xc2, 0xc4, 0xff, /*Color of index 1*/ + 0xe4, 0xe6, 0xe4, 0xff, /*Color of index 2*/ + 0xff, 0xff, 0xff, 0xff, /*Color of index 3*/ + + 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x00, + 0x2a, 0x80, 0x00, 0x55, 0x40, 0x00, 0x00, 0x00, + 0x2a, 0xa0, 0x00, 0x55, 0x50, 0x00, 0x00, 0x00, + 0x0a, 0xa8, 0x00, 0x55, 0x54, 0x00, 0x00, 0x00, + 0x02, 0xaa, 0x00, 0x55, 0x55, 0x00, 0x00, 0x00, + 0x00, 0xaa, 0x80, 0x55, 0x55, 0x40, 0x00, 0x00, + 0x00, 0x2a, 0xa0, 0x55, 0x15, 0x50, 0x00, 0x00, + 0x00, 0x0a, 0xa8, 0x15, 0x05, 0x54, 0x00, 0x00, + 0x00, 0x02, 0xaa, 0x05, 0x01, 0x55, 0x00, 0x00, + 0x00, 0x00, 0xaa, 0x81, 0x01, 0x55, 0x00, 0x00, + 0x00, 0x00, 0x2a, 0xa0, 0x05, 0x54, 0x00, 0x00, + 0x00, 0x00, 0x0a, 0xa8, 0x15, 0x50, 0x00, 0x00, + 0x00, 0x00, 0x02, 0xaa, 0x05, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xaa, 0x81, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x2a, 0xa0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x0a, 0xa8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x42, 0xaa, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x50, 0xaa, 0x80, 0x00, 0x00, + 0x00, 0x00, 0x05, 0x54, 0x2a, 0xa0, 0x00, 0x00, + 0x00, 0x00, 0x15, 0x55, 0x0a, 0xa8, 0x00, 0x00, + 0x00, 0x00, 0x55, 0x55, 0x02, 0xaa, 0x00, 0x00, + 0x00, 0x01, 0x55, 0x55, 0x00, 0xaa, 0x80, 0x00, + 0x00, 0x05, 0x54, 0x55, 0x04, 0x2a, 0xa0, 0x00, + 0x00, 0x05, 0x50, 0x55, 0x15, 0x0a, 0xa8, 0x00, + 0x00, 0x05, 0x40, 0x55, 0x55, 0x42, 0xaa, 0x00, + 0x00, 0x00, 0x00, 0x55, 0x55, 0x00, 0xaa, 0x80, + 0x00, 0x00, 0x00, 0x55, 0x54, 0x00, 0x2a, 0xa0, + 0x00, 0x00, 0x00, 0x55, 0x50, 0x00, 0x0a, 0xa8, + 0x00, 0x00, 0x00, 0x55, 0x40, 0x00, 0x02, 0xa8, + 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0xa0, + 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x00, +}; + +const lv_img_dsc_t ck_os_bt_disconnected = { + .header.always_zero = 0, + .header.w = 32, + .header.h = 32, + .data_size = 272, + .header.cf = LV_IMG_CF_INDEXED_2BIT, + .data = ck_os_bt_disconnected_map, +}; diff --git a/src/displayapp/icons/bluetooth/os_bt_disconnected.png b/src/displayapp/icons/bluetooth/os_bt_disconnected.png Binary files differnew file mode 100644 index 00000000..3275895d --- /dev/null +++ b/src/displayapp/icons/bluetooth/os_bt_disconnected.png diff --git a/src/displayapp/icons/music/disc.cpp b/src/displayapp/icons/music/disc.cpp new file mode 100644 index 00000000..0957873f --- /dev/null +++ b/src/displayapp/icons/music/disc.cpp @@ -0,0 +1,110 @@ +/* Copyright (C) 2020 Avamander + + This file is part of InfiniTime. + + InfiniTime is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + InfiniTime is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <https://www.gnu.org/licenses/>. +*/ +#pragma once + +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_DISC +#define LV_ATTRIBUTE_IMG_DISC +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_DISC uint8_t disc_map[] = { + 0xbd, 0xc1, 0xbe, 0xff, /* Color of index 0: foreground */ + 0x00, 0x00, 0x00, 0x00, /* Color of index 1: background */ + + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x01, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x00, 0x00, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x0f, 0xf8, 0x07, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0xff, 0xff, 0x81, 0xff, 0xff, + 0xff, 0xff, 0x07, 0xff, 0xff, 0xf0, 0x7f, 0xff, + 0xff, 0xfc, 0x1f, 0xff, 0xff, 0xfc, 0x1f, 0xff, + 0xff, 0xf8, 0x7f, 0xff, 0xff, 0xff, 0x0f, 0xff, + 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x87, 0xff, + 0xff, 0xe3, 0xff, 0xff, 0xff, 0xff, 0xe3, 0xff, + 0xff, 0xc7, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xff, + 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, + 0xff, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x7f, + 0xfe, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x3f, + 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, + 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, + 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, + 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, + 0xf1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, + 0xf3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, + 0xe3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, + 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0xc7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xc7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x8f, 0xff, 0xff, 0xf8, 0x0f, 0xff, 0xff, 0xf8, + 0x9f, 0xff, 0xff, 0xf0, 0x07, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xe3, 0xe3, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xe7, 0xf3, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xe7, 0xf3, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xe7, 0xf3, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xe7, 0xf3, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xe7, 0xf3, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xe3, 0xe3, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xf0, 0x07, 0xff, 0xff, 0xfc, + 0x8f, 0xff, 0xff, 0xf8, 0x0f, 0xff, 0xff, 0xf8, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xc7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xc7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0xe3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, + 0xf3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, + 0xf1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, + 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, + 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, + 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, + 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, + 0xfe, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x3f, + 0xff, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x7f, + 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, + 0xff, 0xc7, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xff, + 0xff, 0xe3, 0xff, 0xff, 0xff, 0xff, 0xe3, 0xff, + 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x87, 0xff, + 0xff, 0xf8, 0x7f, 0xff, 0xff, 0xff, 0x0f, 0xff, + 0xff, 0xfc, 0x1f, 0xff, 0xff, 0xfc, 0x1f, 0xff, + 0xff, 0xff, 0x07, 0xff, 0xff, 0xf0, 0x7f, 0xff, + 0xff, 0xff, 0xc0, 0xff, 0xff, 0x81, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x0f, 0xf8, 0x07, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x00, 0x00, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x01, 0xff, 0xff, 0xff, +}; + +const lv_img_dsc_t disc = { + { + LV_IMG_CF_INDEXED_1BIT, + 0, + 0, + 64, + 64 + }, + 520, + disc_map +};
\ No newline at end of file diff --git a/src/displayapp/icons/music/disc.png b/src/displayapp/icons/music/disc.png Binary files differnew file mode 100644 index 00000000..699734fb --- /dev/null +++ b/src/displayapp/icons/music/disc.png diff --git a/src/displayapp/icons/music/disc_f_1.cpp b/src/displayapp/icons/music/disc_f_1.cpp new file mode 100644 index 00000000..9b6b7417 --- /dev/null +++ b/src/displayapp/icons/music/disc_f_1.cpp @@ -0,0 +1,79 @@ +/* Copyright (C) 2020 Avamander + + This file is part of InfiniTime. + + InfiniTime is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + InfiniTime is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <https://www.gnu.org/licenses/>. +*/ +#pragma once + +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_DISC_F_1 +#define LV_ATTRIBUTE_IMG_DISC_F_1 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_DISC_F_1 uint8_t disc_f_1_map[] = { + 0xbd, 0xc1, 0xbe, 0xff, /* Color of index 0: foreground */ + 0x00, 0x00, 0x00, 0x00, /* Color of index 1: background */ + + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, + 0xff, 0xff, 0xfc, 0x00, + 0xff, 0xff, 0xf0, 0x0f, + 0xff, 0xff, 0xc0, 0xff, + 0xff, 0xff, 0x07, 0xff, + 0xff, 0xfc, 0x1f, 0xff, + 0xff, 0xf8, 0x7f, 0xff, + 0xff, 0xf0, 0xff, 0xff, + 0xff, 0xe3, 0xff, 0xff, + 0xff, 0xc7, 0xf3, 0xff, + 0xff, 0x8f, 0xc3, 0xff, + 0xff, 0x1f, 0x87, 0xff, + 0xfe, 0x3f, 0x0f, 0xff, + 0xfc, 0x7e, 0x1f, 0xff, + 0xfc, 0x7c, 0x3f, 0xff, + 0xf8, 0xfc, 0x7f, 0xff, + 0xf9, 0xfc, 0xff, 0xff, + 0xf1, 0xff, 0xff, 0xff, + 0xf3, 0xff, 0xff, 0xff, + 0xe3, 0xff, 0xff, 0xff, + 0xe7, 0xff, 0xff, 0xff, + 0xc7, 0xff, 0xff, 0xff, + 0xc7, 0xff, 0xff, 0xff, + 0xcf, 0xff, 0xff, 0xff, + 0xcf, 0xff, 0xff, 0xff, + 0x8f, 0xff, 0xff, 0xff, + 0x8f, 0xff, 0xff, 0xf8, + 0x9f, 0xff, 0xff, 0xf0, + 0x9f, 0xff, 0xff, 0xe3, + 0x9f, 0xff, 0xff, 0xe7, + 0x9f, 0xff, 0xff, 0xe7, +}; + +const lv_img_dsc_t disc_f_1 = { + { + LV_IMG_CF_INDEXED_1BIT, + 0, + 0, + 32, + 32 + }, + 136, + disc_f_1_map +}; + diff --git a/src/displayapp/icons/music/disc_f_1.png b/src/displayapp/icons/music/disc_f_1.png Binary files differnew file mode 100644 index 00000000..94657734 --- /dev/null +++ b/src/displayapp/icons/music/disc_f_1.png diff --git a/src/displayapp/icons/music/disc_f_2.cpp b/src/displayapp/icons/music/disc_f_2.cpp new file mode 100644 index 00000000..3d2331d1 --- /dev/null +++ b/src/displayapp/icons/music/disc_f_2.cpp @@ -0,0 +1,79 @@ +/* Copyright (C) 2020 Avamander + + This file is part of InfiniTime. + + InfiniTime is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + InfiniTime is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <https://www.gnu.org/licenses/>. +*/ +#pragma once + +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_DISC_F_2 +#define LV_ATTRIBUTE_IMG_DISC_F_2 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_DISC_F_2 uint8_t disc_f_2_map[] = { + 0xbd, 0xc1, 0xbe, 0xff, /* Color of index 0: foreground */ + 0x00, 0x00, 0x00, 0x00, /* Color of index 1: background */ + + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, + 0xff, 0xff, 0xfc, 0x00, + 0xff, 0xff, 0xf0, 0x0f, + 0xff, 0xff, 0xc0, 0xff, + 0xff, 0xff, 0x07, 0xff, + 0xff, 0xfc, 0x1f, 0xff, + 0xff, 0xf8, 0x7f, 0xf1, + 0xff, 0xf0, 0xff, 0x00, + 0xff, 0xe3, 0xfc, 0x03, + 0xff, 0xc7, 0xf0, 0x3f, + 0xff, 0x8f, 0xf0, 0xff, + 0xff, 0x1f, 0xf3, 0xff, + 0xfe, 0x3f, 0xff, 0xff, + 0xfc, 0x7f, 0xff, 0xff, + 0xfc, 0x7f, 0xff, 0xff, + 0xf8, 0xff, 0xff, 0xff, + 0xf9, 0xff, 0xff, 0xff, + 0xf1, 0xff, 0xff, 0xff, + 0xf3, 0xff, 0xff, 0xff, + 0xe3, 0xff, 0xff, 0xff, + 0xe7, 0xff, 0xff, 0xff, + 0xc7, 0xff, 0xff, 0xff, + 0xc7, 0xff, 0xff, 0xff, + 0xcf, 0xff, 0xff, 0xff, + 0xcf, 0xff, 0xff, 0xff, + 0x8f, 0xff, 0xff, 0xff, + 0x8f, 0xff, 0xff, 0xf8, + 0x9f, 0xff, 0xff, 0xf0, + 0x9f, 0xff, 0xff, 0xe3, + 0x9f, 0xff, 0xff, 0xe7, + 0x9f, 0xff, 0xff, 0xe7, +}; + +const lv_img_dsc_t disc_f_2 = { + { + LV_IMG_CF_INDEXED_1BIT, + 0, + 0, + 32, + 32 + }, + 136, + disc_f_2_map +}; + diff --git a/src/displayapp/icons/music/disc_f_2.png b/src/displayapp/icons/music/disc_f_2.png Binary files differnew file mode 100644 index 00000000..4d9a4a38 --- /dev/null +++ b/src/displayapp/icons/music/disc_f_2.png diff --git a/src/displayapp/screens/ApplicationList.cpp b/src/displayapp/screens/ApplicationList.cpp new file mode 100644 index 00000000..7eb97188 --- /dev/null +++ b/src/displayapp/screens/ApplicationList.cpp @@ -0,0 +1,82 @@ +#include <libs/lvgl/lvgl.h> +#include <displayapp/DisplayApp.h> +#include <functional> +#include "ApplicationList.h" +#include "Tile.h" +#include "Symbols.h" + +using namespace Pinetime::Applications::Screens; + +ApplicationList::ApplicationList(Pinetime::Applications::DisplayApp *app) : + Screen(app), + screens{app, { + [this]() -> std::unique_ptr<Screen> { return CreateScreen1(); }, + [this]() -> std::unique_ptr<Screen> { return CreateScreen2(); }, + //[this]() -> std::unique_ptr<Screen> { return CreateScreen3(); } + } + } {} + + +ApplicationList::~ApplicationList() { + lv_obj_clean(lv_scr_act()); +} + +bool ApplicationList::Refresh() { + if(running) + running = screens.Refresh(); + return running; +} + +bool ApplicationList::OnButtonPushed() { + running = false; + app->StartApp(Apps::Clock); + return true; +} + +bool ApplicationList::OnTouchEvent(Pinetime::Applications::TouchEvents event) { + return screens.OnTouchEvent(event); +} + +std::unique_ptr<Screen> ApplicationList::CreateScreen1() { + std::array<Screens::Tile::Applications, 6> applications { + {{Symbols::clock, Apps::Clock}, + {Symbols::music, Apps::Music}, + {Symbols::sun, Apps::Brightness}, + {Symbols::list, Apps::SysInfo}, + {Symbols::check, Apps::FirmwareValidation}, + {Symbols::none, Apps::None} + } + + + }; + + return std::unique_ptr<Screen>(new Screens::Tile(app, applications)); +} + +std::unique_ptr<Screen> ApplicationList::CreateScreen2() { + std::array<Screens::Tile::Applications, 6> applications { + {{Symbols::tachometer, Apps::Gauge}, + {Symbols::asterisk, Apps::Meter}, + {Symbols::paintbrush, Apps::Paint}, + {Symbols::info, Apps::Notifications}, + {Symbols::none, Apps::None}, + {Symbols::none, Apps::None} + } + }; + + return std::unique_ptr<Screen>(new Screens::Tile(app, applications)); +} + +std::unique_ptr<Screen> ApplicationList::CreateScreen3() { + std::array<Screens::Tile::Applications, 6> applications { + {{"A", Apps::Meter}, + {"B", Apps::Gauge}, + {"C", Apps::Clock}, + {"D", Apps::Music}, + {"E", Apps::SysInfo}, + {"F", Apps::Brightness} + } + }; + + return std::unique_ptr<Screen>(new Screens::Tile(app, applications)); +} diff --git a/src/displayapp/screens/ApplicationList.h b/src/displayapp/screens/ApplicationList.h new file mode 100644 index 00000000..9c95acb8 --- /dev/null +++ b/src/displayapp/screens/ApplicationList.h @@ -0,0 +1,33 @@ +#pragma once + +#include <functional> +#include <vector> + +#include "components/ble/NimbleController.h" +#include "Screen.h" +#include "Label.h" +#include "ScreenList.h" +#include "Gauge.h" +#include "Meter.h" + +namespace Pinetime { + namespace Applications { + namespace Screens { + class ApplicationList : public Screen { + public: + explicit ApplicationList(DisplayApp* app); + ~ApplicationList() override; + bool Refresh() override; + bool OnButtonPushed() override; + bool OnTouchEvent(TouchEvents event) override; + private: + bool running = true; + + ScreenList<2> screens; + std::unique_ptr<Screen> CreateScreen1(); + std::unique_ptr<Screen> CreateScreen2(); + std::unique_ptr<Screen> CreateScreen3(); + }; + } + } +}
\ No newline at end of file diff --git a/src/displayapp/screens/BatteryIcon.cpp b/src/displayapp/screens/BatteryIcon.cpp new file mode 100644 index 00000000..26939d18 --- /dev/null +++ b/src/displayapp/screens/BatteryIcon.cpp @@ -0,0 +1,21 @@ +#include "BatteryIcon.h" +#include "Symbols.h" +using namespace Pinetime::Applications::Screens; + +const char* BatteryIcon::GetBatteryIcon(float batteryPercent) { + if(batteryPercent > 90.0f) return Symbols::batteryFull; + if(batteryPercent > 75.0f) return Symbols::batteryThreeQuarter; + if(batteryPercent > 50.0f) return Symbols::batteryHalf; + if(batteryPercent > 25.0f) return Symbols::batteryOneQuarter; + return Symbols::batteryEmpty; +} + +const char* BatteryIcon::GetUnknownIcon() { + return Symbols::batteryEmpty; +} + +const char *BatteryIcon::GetPlugIcon(bool isCharging) { + if(isCharging) + return Symbols::plug; + else return ""; +} diff --git a/src/displayapp/screens/BatteryIcon.h b/src/displayapp/screens/BatteryIcon.h new file mode 100644 index 00000000..58f04a87 --- /dev/null +++ b/src/displayapp/screens/BatteryIcon.h @@ -0,0 +1,16 @@ +#pragma once + +#include <libs/lvgl/src/lv_draw/lv_img_decoder.h> + +namespace Pinetime { + namespace Applications { + namespace Screens { + class BatteryIcon { + public: + static const char* GetUnknownIcon(); + static const char* GetBatteryIcon(float batteryPercent); + static const char* GetPlugIcon(bool isCharging); + }; + } + } +}
\ No newline at end of file diff --git a/src/displayapp/screens/BleIcon.cpp b/src/displayapp/screens/BleIcon.cpp new file mode 100644 index 00000000..1bbbd053 --- /dev/null +++ b/src/displayapp/screens/BleIcon.cpp @@ -0,0 +1,8 @@ +#include "BleIcon.h" +#include "Symbols.h" +using namespace Pinetime::Applications::Screens; + +const char* BleIcon::GetIcon(bool isConnected) { + if(isConnected) return Symbols::bluetooth; + else return ""; +}
\ No newline at end of file diff --git a/src/displayapp/screens/BleIcon.h b/src/displayapp/screens/BleIcon.h new file mode 100644 index 00000000..c1398d2a --- /dev/null +++ b/src/displayapp/screens/BleIcon.h @@ -0,0 +1,12 @@ +#pragma once + +namespace Pinetime { + namespace Applications { + namespace Screens { + class BleIcon { + public: + static const char* GetIcon(bool isConnected); + }; + } + } +}
\ No newline at end of file diff --git a/src/displayapp/screens/Brightness.cpp b/src/displayapp/screens/Brightness.cpp new file mode 100644 index 00000000..8ea9a771 --- /dev/null +++ b/src/displayapp/screens/Brightness.cpp @@ -0,0 +1,92 @@ +#include <libs/lvgl/lvgl.h> +#include "Brightness.h" + +using namespace Pinetime::Applications::Screens; + +void slider_event_cb(lv_obj_t * slider, lv_event_t event) { + if(event == LV_EVENT_VALUE_CHANGED) { + auto* brightnessSlider = static_cast<Brightness*>(slider->user_data); + brightnessSlider->OnValueChanged(); + } +} + +Brightness::Brightness(Pinetime::Applications::DisplayApp *app, Controllers::BrightnessController& brightness) : Screen(app), brightness{brightness} { + slider = lv_slider_create(lv_scr_act(), nullptr); + lv_obj_set_user_data(slider, this); + lv_obj_set_width(slider, LV_DPI * 2); + lv_obj_align(slider, nullptr, LV_ALIGN_CENTER, 0, 0); + lv_obj_set_event_cb(slider, slider_event_cb); + lv_slider_set_range(slider, 0, 2); + lv_slider_set_value(slider, LevelToInt(brightness.Level()), LV_ANIM_OFF); + + slider_label = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_text(slider_label, LevelToString(brightness.Level())); + lv_obj_set_auto_realign(slider_label, true); + lv_obj_align(slider_label, slider, LV_ALIGN_OUT_BOTTOM_MID, 0, 10); +} + +Brightness::~Brightness() { + lv_obj_clean(lv_scr_act()); +} + +bool Brightness::Refresh() { + return running; +} + +bool Brightness::OnButtonPushed() { + running = false; + return true; +} + +const char *Brightness::LevelToString(Pinetime::Controllers::BrightnessController::Levels level) { + switch(level) { + case Pinetime::Controllers::BrightnessController::Levels::Off: return "Off"; + case Pinetime::Controllers::BrightnessController::Levels::Low: return "Low"; + case Pinetime::Controllers::BrightnessController::Levels::Medium: return "Medium"; + case Pinetime::Controllers::BrightnessController::Levels::High: return "High"; + default : return "???"; + } +} + +void Brightness::OnValueChanged() { + SetValue(lv_slider_get_value(slider)); +} + +void Brightness::SetValue(uint8_t value) { + switch(value) { + case 0: brightness.Set(Controllers::BrightnessController::Levels::Low); break; + case 1: brightness.Set(Controllers::BrightnessController::Levels::Medium); break; + case 2: brightness.Set(Controllers::BrightnessController::Levels::High); break; + } + lv_label_set_text(slider_label, LevelToString(brightness.Level())); +} + +uint8_t Brightness::LevelToInt(Pinetime::Controllers::BrightnessController::Levels level) { + switch(level) { + case Pinetime::Controllers::BrightnessController::Levels::Off: return 0; + case Pinetime::Controllers::BrightnessController::Levels::Low: return 0; + case Pinetime::Controllers::BrightnessController::Levels::Medium: return 1; + case Pinetime::Controllers::BrightnessController::Levels::High: return 2; + default : return 0; + } +} + +bool Brightness::OnTouchEvent(Pinetime::Applications::TouchEvents event) { + switch(event) { + case TouchEvents::SwipeLeft: + brightness.Lower(); + SetValue(); + return true; + case TouchEvents::SwipeRight: + brightness.Higher(); + SetValue(); + return true; + default: + return false; + } +} + +void Brightness::SetValue() { + lv_slider_set_value(slider, LevelToInt(brightness.Level()), LV_ANIM_OFF); + lv_label_set_text(slider_label, LevelToString(brightness.Level())); +} diff --git a/src/displayapp/screens/Brightness.h b/src/displayapp/screens/Brightness.h new file mode 100644 index 00000000..7d599acf --- /dev/null +++ b/src/displayapp/screens/Brightness.h @@ -0,0 +1,33 @@ +#pragma once + +#include <libs/lvgl/src/lv_core/lv_obj.h> +#include "components/brightness/BrightnessController.h" +#include "Screen.h" + +namespace Pinetime { + namespace Applications { + namespace Screens { + class Brightness : public Screen { + public: + Brightness(DisplayApp* app, Controllers::BrightnessController& brightness); + ~Brightness() override; + bool Refresh() override; + bool OnButtonPushed() override; + bool OnTouchEvent(TouchEvents event) override; + + void OnValueChanged(); + private: + bool running = true; + Controllers::BrightnessController& brightness; + + lv_obj_t * slider_label; + lv_obj_t * slider; + + const char* LevelToString(Controllers::BrightnessController::Levels level); + uint8_t LevelToInt(Controllers::BrightnessController::Levels level); + void SetValue(uint8_t value); + void SetValue(); + }; + } + } +}
\ No newline at end of file diff --git a/src/displayapp/screens/Clock.cpp b/src/displayapp/screens/Clock.cpp new file mode 100644 index 00000000..977321c1 --- /dev/null +++ b/src/displayapp/screens/Clock.cpp @@ -0,0 +1,244 @@ +#include <cstdio> + +#include <libs/date/includes/date/date.h> +#include "components/datetime/DateTimeController.h" +#include <libs/lvgl/lvgl.h> +#include "Clock.h" +#include "../DisplayApp.h" +#include "BatteryIcon.h" +#include "BleIcon.h" +#include "Symbols.h" +#include "components/ble/NotificationManager.h" +#include "NotificationIcon.h" + +using namespace Pinetime::Applications::Screens; +extern lv_font_t jetbrains_mono_extrabold_compressed; +extern lv_font_t jetbrains_mono_bold_20; +extern lv_style_t* LabelBigStyle; + +static void event_handler(lv_obj_t * obj, lv_event_t event) { + Clock* screen = static_cast<Clock *>(obj->user_data); + screen->OnObjectEvent(obj, event); +} + +Clock::Clock(DisplayApp* app, + Controllers::DateTime& dateTimeController, + Controllers::Battery& batteryController, + Controllers::Ble& bleController, + Controllers::NotificationManager& notificatioManager) : Screen(app), currentDateTime{{}}, + dateTimeController{dateTimeController}, batteryController{batteryController}, + bleController{bleController}, notificatioManager{notificatioManager} { + displayedChar[0] = 0; + displayedChar[1] = 0; + displayedChar[2] = 0; + displayedChar[3] = 0; + displayedChar[4] = 0; + + batteryIcon = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_text(batteryIcon, Symbols::batteryFull); + lv_obj_align(batteryIcon, lv_scr_act(), LV_ALIGN_IN_TOP_RIGHT, -5, 2); + + batteryPlug = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_text(batteryPlug, Symbols::plug); + lv_obj_align(batteryPlug, batteryIcon, LV_ALIGN_OUT_LEFT_MID, -5, 0); + + bleIcon = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_text(bleIcon, Symbols::bluetooth); + lv_obj_align(bleIcon, batteryPlug, LV_ALIGN_OUT_LEFT_MID, -5, 0); + + notificationIcon = lv_label_create(lv_scr_act(), NULL); + lv_label_set_text(notificationIcon, NotificationIcon::GetIcon(false)); + lv_obj_align(notificationIcon, nullptr, LV_ALIGN_IN_TOP_LEFT, 10, 0); + + label_date = lv_label_create(lv_scr_act(), nullptr); + + lv_obj_align(label_date, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 0, 60); + + label_time = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_style(label_time, LV_LABEL_STYLE_MAIN, LabelBigStyle); + lv_obj_align(label_time, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 0, 0); + + backgroundLabel = lv_label_create(lv_scr_act(), nullptr); + backgroundLabel->user_data = this; + lv_obj_set_click(backgroundLabel, true); + lv_obj_set_event_cb(backgroundLabel, event_handler); + 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(backgroundLabel, ""); + + + heartbeatIcon = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_text(heartbeatIcon, Symbols::heartBeat); + lv_obj_align(heartbeatIcon, lv_scr_act(), LV_ALIGN_IN_BOTTOM_LEFT, 5, -2); + + heartbeatValue = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_text(heartbeatValue, "0"); + lv_obj_align(heartbeatValue, heartbeatIcon, LV_ALIGN_OUT_RIGHT_MID, 5, 0); + + heartbeatBpm = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_text(heartbeatBpm, "BPM"); + lv_obj_align(heartbeatBpm, heartbeatValue, LV_ALIGN_OUT_RIGHT_MID, 5, 0); + + stepValue = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_text(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_label_set_text(stepIcon, Symbols::shoe); + lv_obj_align(stepIcon, stepValue, LV_ALIGN_OUT_LEFT_MID, -5, 0); +} + +Clock::~Clock() { + lv_obj_clean(lv_scr_act()); +} + +bool Clock::Refresh() { + batteryPercentRemaining = batteryController.PercentRemaining(); + if (batteryPercentRemaining.IsUpdated()) { + auto batteryPercent = batteryPercentRemaining.Get(); + lv_label_set_text(batteryIcon, BatteryIcon::GetBatteryIcon(batteryPercent)); + auto isCharging = batteryController.IsCharging() || batteryController.IsPowerPresent(); + lv_label_set_text(batteryPlug, BatteryIcon::GetPlugIcon(isCharging)); + } + + bleState = bleController.IsConnected(); + if (bleState.IsUpdated()) { + if(bleState.Get() == true) { + lv_label_set_text(bleIcon, BleIcon::GetIcon(true)); + } else { + lv_label_set_text(bleIcon, BleIcon::GetIcon(false)); + } + } + lv_obj_align(batteryIcon, lv_scr_act(), LV_ALIGN_IN_TOP_RIGHT, -5, 5); + lv_obj_align(batteryPlug, batteryIcon, LV_ALIGN_OUT_LEFT_MID, -5, 0); + lv_obj_align(bleIcon, batteryPlug, LV_ALIGN_OUT_LEFT_MID, -5, 0); + + notificationState = notificatioManager.AreNewNotificationsAvailable(); + if(notificationState.IsUpdated()) { + if(notificationState.Get() == true) + lv_label_set_text(notificationIcon, NotificationIcon::GetIcon(true)); + else + lv_label_set_text(notificationIcon, NotificationIcon::GetIcon(false)); + } + + currentDateTime = dateTimeController.CurrentDateTime(); + + if(currentDateTime.IsUpdated()) { + auto newDateTime = currentDateTime.Get(); + + auto dp = date::floor<date::days>(newDateTime); + auto time = date::make_time(newDateTime-dp); + auto yearMonthDay = date::year_month_day(dp); + + auto year = (int)yearMonthDay.year(); + auto month = static_cast<Pinetime::Controllers::DateTime::Months>((unsigned)yearMonthDay.month()); + auto day = (unsigned)yearMonthDay.day(); + auto dayOfWeek = static_cast<Pinetime::Controllers::DateTime::Days>(date::weekday(yearMonthDay).iso_encoding()); + + auto hour = time.hours().count(); + auto minute = time.minutes().count(); + + char minutesChar[3]; + sprintf(minutesChar, "%02d", static_cast<int>(minute)); + + char hoursChar[3]; + sprintf(hoursChar, "%02d", static_cast<int>(hour)); + + char timeStr[6]; + sprintf(timeStr, "%c%c:%c%c", hoursChar[0],hoursChar[1],minutesChar[0], minutesChar[1]); + + if(hoursChar[0] != displayedChar[0] || hoursChar[1] != displayedChar[1] || minutesChar[0] != displayedChar[2] || minutesChar[1] != displayedChar[3]) { + displayedChar[0] = hoursChar[0]; + displayedChar[1] = hoursChar[1]; + displayedChar[2] = minutesChar[0]; + displayedChar[3] = minutesChar[1]; + + lv_label_set_text(label_time, timeStr); + } + + if ((year != currentYear) || (month != currentMonth) || (dayOfWeek != currentDayOfWeek) || (day != currentDay)) { + char dateStr[22]; + sprintf(dateStr, "%s %d %s %d", DayOfWeekToString(dayOfWeek), day, MonthToString(month), year); + lv_label_set_text(label_date, dateStr); + + + currentYear = year; + currentMonth = month; + currentDayOfWeek = dayOfWeek; + currentDay = day; + } + } + + // TODO heartbeat = heartBeatController.GetValue(); + if(heartbeat.IsUpdated()) { + char heartbeatBuffer[4]; + sprintf(heartbeatBuffer, "%d", heartbeat.Get()); + lv_label_set_text(heartbeatValue, heartbeatBuffer); + lv_obj_align(heartbeatIcon, lv_scr_act(), LV_ALIGN_IN_BOTTOM_LEFT, 5, -2); + lv_obj_align(heartbeatValue, heartbeatIcon, LV_ALIGN_OUT_RIGHT_MID, 5, 0); + lv_obj_align(heartbeatBpm, heartbeatValue, LV_ALIGN_OUT_RIGHT_MID, 5, 0); + } + + // TODO stepCount = stepController.GetValue(); + if(stepCount.IsUpdated()) { + char stepBuffer[5]; + sprintf(stepBuffer, "%lu", stepCount.Get()); + lv_label_set_text(stepValue, stepBuffer); + lv_obj_align(stepValue, lv_scr_act(), LV_ALIGN_IN_BOTTOM_RIGHT, -5, -2); + lv_obj_align(stepIcon, stepValue, LV_ALIGN_OUT_LEFT_MID, -5, 0); + } + + return running; +} + +const char *Clock::MonthToString(Pinetime::Controllers::DateTime::Months month) { + return Clock::MonthsString[static_cast<uint8_t>(month)]; +} + +const char *Clock::DayOfWeekToString(Pinetime::Controllers::DateTime::Days dayOfWeek) { + return Clock::DaysString[static_cast<uint8_t>(dayOfWeek)]; +} + +char const *Clock::DaysString[] = { + "", + "MONDAY", + "TUESDAY", + "WEDNESDAY", + "THURSDAY", + "FRIDAY", + "SATURDAY", + "SUNDAY" +}; + +char const *Clock::MonthsString[] = { + "", + "JAN", + "FEB", + "MAR", + "APR", + "MAY", + "JUN", + "JUL", + "AUG", + "SEP", + "OCT", + "NOV", + "DEC" +}; + +void Clock::OnObjectEvent(lv_obj_t *obj, lv_event_t event) { + if(obj == backgroundLabel) { + if (event == LV_EVENT_CLICKED) { + + running = false; + } + } +} + +bool Clock::OnButtonPushed() { + running = false; + return false; +} + + diff --git a/src/displayapp/screens/Clock.h b/src/displayapp/screens/Clock.h new file mode 100644 index 00000000..58149a79 --- /dev/null +++ b/src/displayapp/screens/Clock.h @@ -0,0 +1,93 @@ +#pragma once + +#include <cstdint> +#include <chrono> + +#include "Screen.h" +#include <bits/unique_ptr.h> +#include <libs/lvgl/src/lv_core/lv_style.h> +#include <libs/lvgl/src/lv_core/lv_obj.h> +#include "components/ble/NotificationManager.h" +#include "components/battery/BatteryController.h" +#include "components/ble/BleController.h" + +namespace Pinetime { + namespace Applications { + namespace Screens { + + template <class T> + class DirtyValue { + public: + explicit DirtyValue(T v) { value = v; } + explicit DirtyValue(T& v) { value = v; } + bool IsUpdated() const { return isUpdated; } + T& Get() { this->isUpdated = false; return value; } + + DirtyValue& operator=(const T& other) { + if (this->value != other) { + this->value = other; + this->isUpdated = true; + } + return *this; + } + private: + T value; + bool isUpdated = true; + }; + class Clock : public Screen{ + public: + Clock(DisplayApp* app, + Controllers::DateTime& dateTimeController, + Controllers::Battery& batteryController, + Controllers::Ble& bleController, + Controllers::NotificationManager& notificatioManager); + ~Clock() override; + + bool Refresh() override; + bool OnButtonPushed() override; + + void OnObjectEvent(lv_obj_t *pObj, lv_event_t i); + private: + static const char* MonthToString(Pinetime::Controllers::DateTime::Months month); + static const char* DayOfWeekToString(Pinetime::Controllers::DateTime::Days dayOfWeek); + static char const *DaysString[]; + static char const *MonthsString[]; + + char displayedChar[5]; + + uint16_t currentYear = 1970; + Pinetime::Controllers::DateTime::Months currentMonth = Pinetime::Controllers::DateTime::Months::Unknown; + Pinetime::Controllers::DateTime::Days currentDayOfWeek = Pinetime::Controllers::DateTime::Days::Unknown; + uint8_t currentDay = 0; + + DirtyValue<float> batteryPercentRemaining {0}; + DirtyValue<bool> bleState {false}; + DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds>> currentDateTime; + DirtyValue<uint32_t> stepCount {0}; + DirtyValue<uint8_t> heartbeat {0}; + DirtyValue<bool> notificationState {false}; + + lv_obj_t* label_time; + lv_obj_t* label_date; + lv_obj_t* backgroundLabel; + lv_obj_t* batteryIcon; + lv_obj_t* bleIcon; + lv_obj_t* batteryPlug; + lv_obj_t* heartbeatIcon; + lv_obj_t* heartbeatValue; + lv_obj_t* heartbeatBpm; + lv_obj_t* stepIcon; + lv_obj_t* stepValue; + lv_obj_t* notificationIcon; + + Controllers::DateTime& dateTimeController; + Controllers::Battery& batteryController; + Controllers::Ble& bleController; + Controllers::NotificationManager& notificatioManager; + + bool running = true; + + }; + } + } +} diff --git a/src/displayapp/screens/DropDownDemo.cpp b/src/displayapp/screens/DropDownDemo.cpp new file mode 100644 index 00000000..ce3acd53 --- /dev/null +++ b/src/displayapp/screens/DropDownDemo.cpp @@ -0,0 +1,64 @@ +#include <libs/lvgl/lvgl.h> +#include <libraries/log/nrf_log.h> +#include "DropDownDemo.h" +#include "../DisplayApp.h" + +using namespace Pinetime::Applications::Screens; +extern lv_font_t jetbrains_mono_extrabold_compressed; +extern lv_font_t jetbrains_mono_bold_20; + +DropDownDemo::DropDownDemo(Pinetime::Applications::DisplayApp *app) : Screen(app) { + // Create the dropdown object, with many item, and fix its height + ddlist = lv_ddlist_create(lv_scr_act(), nullptr); + lv_ddlist_set_options(ddlist, "Apple\n" + "Banana\n" + "Orange\n" + "Melon\n" + "Grape\n" + "Raspberry\n" + "A\n" + "B\n" + "C\n" + "D\n" + "E"); + lv_ddlist_set_fix_width(ddlist, 150); + lv_ddlist_set_draw_arrow(ddlist, true); + lv_ddlist_set_fix_height(ddlist, 150); + lv_obj_align(ddlist, nullptr, LV_ALIGN_IN_TOP_MID, 0, 20); +} + +DropDownDemo::~DropDownDemo() { + // Reset the touchmode + app->SetTouchMode(DisplayApp::TouchModes::Gestures); + lv_obj_clean(lv_scr_act()); +} + +bool DropDownDemo::Refresh() { + auto* list = static_cast<lv_ddlist_ext_t *>(ddlist->ext_attr); + + // Switch touchmode to Polling if the dropdown is opened. This will allow to scroll inside the + // dropdown while it is opened. + // Disable the polling mode when the dropdown is closed to be able to handle the gestures. + if(list->opened) + app->SetTouchMode(DisplayApp::TouchModes::Polling); + else + app->SetTouchMode(DisplayApp::TouchModes::Gestures); + return running; +} + +bool DropDownDemo::OnButtonPushed() { + running = false; + return true; +} + +bool DropDownDemo::OnTouchEvent(Pinetime::Applications::TouchEvents event) { + // If the dropdown is opened, notify Display app that it doesn't need to handle the event + // (this will prevent displayApp from going back to the menu or clock scree). + auto* list = static_cast<lv_ddlist_ext_t *>(ddlist->ext_attr); + if(list->opened) { + return true; + } else { + return false; + } +} + diff --git a/src/displayapp/screens/DropDownDemo.h b/src/displayapp/screens/DropDownDemo.h new file mode 100644 index 00000000..7c75efc0 --- /dev/null +++ b/src/displayapp/screens/DropDownDemo.h @@ -0,0 +1,29 @@ +#pragma once + +#include <cstdint> +#include "Screen.h" +#include <bits/unique_ptr.h> +#include <libs/lvgl/src/lv_core/lv_style.h> +#include <libs/lvgl/src/lv_core/lv_obj.h> + +namespace Pinetime { + namespace Applications { + namespace Screens { + + class DropDownDemo : public Screen{ + public: + DropDownDemo(DisplayApp* app); + ~DropDownDemo() override; + + bool Refresh() override; + bool OnButtonPushed() override; + bool OnTouchEvent(TouchEvents event) override; + + private: + lv_obj_t * ddlist; + bool running = true; + bool isDropDownOpened = false; + }; + } + } +} diff --git a/src/displayapp/screens/FirmwareUpdate.cpp b/src/displayapp/screens/FirmwareUpdate.cpp new file mode 100644 index 00000000..778409eb --- /dev/null +++ b/src/displayapp/screens/FirmwareUpdate.cpp @@ -0,0 +1,82 @@ +#include <libs/lvgl/lvgl.h> +#include "FirmwareUpdate.h" +#include "../DisplayApp.h" + +using namespace Pinetime::Applications::Screens; +extern lv_font_t jetbrains_mono_extrabold_compressed; +extern lv_font_t jetbrains_mono_bold_20; + + +FirmwareUpdate::FirmwareUpdate(Pinetime::Applications::DisplayApp *app, Pinetime::Controllers::Ble& bleController) : + Screen(app), bleController{bleController} { + + titleLabel = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_text(titleLabel, "Firmware update"); + lv_obj_set_auto_realign(titleLabel, true); + lv_obj_align(titleLabel, nullptr, LV_ALIGN_IN_TOP_MID, 0, 50); + + bar1 = lv_bar_create(lv_scr_act(), nullptr); + lv_obj_set_size(bar1, 200, 30); + lv_obj_align(bar1, nullptr, LV_ALIGN_CENTER, 0, 0); + lv_bar_set_anim_time(bar1, 10); + lv_bar_set_range(bar1, 0, 100); + lv_bar_set_value(bar1, 0, LV_ANIM_OFF); + + percentLabel = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_text(percentLabel, ""); + lv_obj_set_auto_realign(percentLabel, true); + lv_obj_align(percentLabel, bar1, LV_ALIGN_OUT_TOP_MID, 0, 60); +} + +FirmwareUpdate::~FirmwareUpdate() { + lv_obj_clean(lv_scr_act()); +} + +bool FirmwareUpdate::Refresh() { + switch(bleController.State()) { + default: + case Pinetime::Controllers::Ble::FirmwareUpdateStates::Idle: + case Pinetime::Controllers::Ble::FirmwareUpdateStates::Running: + if(state != States::Running) + state = States::Running; + return DisplayProgression(); + case Pinetime::Controllers::Ble::FirmwareUpdateStates::Validated: + if(state != States::Validated) { + UpdateValidated(); + state = States::Validated; + } + return running; + case Pinetime::Controllers::Ble::FirmwareUpdateStates::Error: + if(state != States::Error) { + UpdateError(); + state = States::Error; + } + return running; + } +} + +bool FirmwareUpdate::DisplayProgression() const { + float current = bleController.FirmwareUpdateCurrentBytes() / 1024.0f; + float total = bleController.FirmwareUpdateTotalBytes() / 1024.0f; + int16_t pc = (current / total) * 100.0f; + sprintf(percentStr, "%d %%", pc); + lv_label_set_text(percentLabel, percentStr); + + lv_bar_set_value(bar1, pc, LV_ANIM_OFF); + return running; +} + +bool FirmwareUpdate::OnButtonPushed() { + running = false; + return true; +} + +void FirmwareUpdate::UpdateValidated() { + lv_label_set_recolor(percentLabel, true); + lv_label_set_text(percentLabel, "#00ff00 Image Ok!#"); +} + +void FirmwareUpdate::UpdateError() { + lv_label_set_recolor(percentLabel, true); + lv_label_set_text(percentLabel, "#ff0000 Error!#"); +} diff --git a/src/displayapp/screens/FirmwareUpdate.h b/src/displayapp/screens/FirmwareUpdate.h new file mode 100644 index 00000000..893fe68c --- /dev/null +++ b/src/displayapp/screens/FirmwareUpdate.h @@ -0,0 +1,42 @@ +#pragma once + +#include <cstdint> +#include <chrono> + +#include "Screen.h" +#include <bits/unique_ptr.h> +#include <libs/lvgl/src/lv_core/lv_style.h> +#include <libs/lvgl/src/lv_core/lv_obj.h> +#include "components/ble/BleController.h" + +namespace Pinetime { + namespace Applications { + namespace Screens { + + class FirmwareUpdate : public Screen{ + public: + FirmwareUpdate(DisplayApp* app, Pinetime::Controllers::Ble& bleController); + ~FirmwareUpdate() override; + + bool Refresh() override; + bool OnButtonPushed() override; + + private: + enum class States { Idle, Running, Validated, Error }; + Pinetime::Controllers::Ble& bleController; + lv_obj_t* bar1; + lv_obj_t* percentLabel; + lv_obj_t* titleLabel; + mutable char percentStr[10]; + bool running = true; + States state; + + bool DisplayProgression() const; + + void UpdateValidated(); + + void UpdateError(); + }; + } + } +} diff --git a/src/displayapp/screens/FirmwareValidation.cpp b/src/displayapp/screens/FirmwareValidation.cpp new file mode 100644 index 00000000..4ac399ff --- /dev/null +++ b/src/displayapp/screens/FirmwareValidation.cpp @@ -0,0 +1,91 @@ +#include <libs/lvgl/lvgl.h> +#include "FirmwareValidation.h" +#include "../DisplayApp.h" +#include "../../Version.h" +#include "components/firmwarevalidator/FirmwareValidator.h" + +using namespace Pinetime::Applications::Screens; +extern lv_font_t jetbrains_mono_extrabold_compressed; +extern lv_font_t jetbrains_mono_bold_20; + +namespace { + static void ButtonEventHandler(lv_obj_t * obj, lv_event_t event) + { + FirmwareValidation* screen = static_cast<FirmwareValidation *>(obj->user_data); + screen->OnButtonEvent(obj, event); + } + +} + +FirmwareValidation::FirmwareValidation(Pinetime::Applications::DisplayApp *app, + Pinetime::Controllers::FirmwareValidator &validator) + : Screen{app}, validator{validator} { + labelVersionInfo = lv_label_create(lv_scr_act(), nullptr); + lv_obj_align(labelVersionInfo, nullptr, LV_ALIGN_IN_TOP_LEFT, 0, 0); + lv_label_set_text(labelVersionInfo, "Version : "); + lv_label_set_align(labelVersionInfo, LV_LABEL_ALIGN_LEFT); + + + labelVersionValue = lv_label_create(lv_scr_act(), nullptr); + lv_obj_align(labelVersionValue, labelVersionInfo, LV_ALIGN_OUT_RIGHT_MID, 0, 0); + lv_label_set_recolor(labelVersionValue, true); + sprintf(version, "%ld.%ld.%ld", Version::Major(), Version::Minor(), Version::Patch()); + lv_label_set_text(labelVersionValue, version); + + labelIsValidated = lv_label_create(lv_scr_act(), nullptr); + lv_obj_align(labelIsValidated, nullptr, LV_ALIGN_IN_TOP_LEFT, 0, 50); + lv_label_set_recolor(labelIsValidated, true); + lv_label_set_long_mode(labelIsValidated, LV_LABEL_LONG_BREAK); + lv_obj_set_width(labelIsValidated, 240); + + if(validator.IsValidated()) + lv_label_set_text(labelIsValidated, "You have already\n#00ff00 validated# this firmware#"); + else { + lv_label_set_text(labelIsValidated, + "Please #00ff00 Validate# this version or\n#ff0000 Reset# to rollback to the previous version."); + + buttonValidate = lv_btn_create(lv_scr_act(), nullptr); + lv_obj_align(buttonValidate, NULL, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0); + buttonValidate->user_data = this; + lv_obj_set_event_cb(buttonValidate, ButtonEventHandler); + + labelButtonValidate = lv_label_create(buttonValidate, nullptr); + lv_label_set_recolor(labelButtonValidate, true); + lv_label_set_text(labelButtonValidate, "#00ff00 Validate#"); + + buttonReset = lv_btn_create(lv_scr_act(), nullptr); + buttonReset->user_data = this; + lv_obj_align(buttonReset, nullptr, LV_ALIGN_IN_BOTTOM_RIGHT, 0, 0); + lv_obj_set_event_cb(buttonReset, ButtonEventHandler); + + labelButtonReset = lv_label_create(buttonReset, nullptr); + lv_label_set_recolor(labelButtonReset, true); + lv_label_set_text(labelButtonReset, "#ff0000 Reset#"); + } +} + + +FirmwareValidation::~FirmwareValidation() { + lv_obj_clean(lv_scr_act()); +} + +bool FirmwareValidation::Refresh() { + return running; +} + +bool FirmwareValidation::OnButtonPushed() { + running = false; + return true; +} + +void FirmwareValidation::OnButtonEvent(lv_obj_t *object, lv_event_t event) { + if(object == buttonValidate && event == LV_EVENT_PRESSED) { + validator.Validate(); + running = false; + } else if(object == buttonReset && event == LV_EVENT_PRESSED) { + validator.Reset(); + } + +} + + diff --git a/src/displayapp/screens/FirmwareValidation.h b/src/displayapp/screens/FirmwareValidation.h new file mode 100644 index 00000000..947f5575 --- /dev/null +++ b/src/displayapp/screens/FirmwareValidation.h @@ -0,0 +1,42 @@ +#pragma once + +#include <cstdint> +#include "Screen.h" +#include <bits/unique_ptr.h> +#include <libs/lvgl/src/lv_core/lv_style.h> +#include <libs/lvgl/src/lv_core/lv_obj.h> + +namespace Pinetime { + namespace Controllers { + class FirmwareValidator; + } + + namespace Applications { + namespace Screens { + + class FirmwareValidation : public Screen{ + public: + FirmwareValidation(DisplayApp* app, Pinetime::Controllers::FirmwareValidator& validator); + ~FirmwareValidation() override; + + bool Refresh() override; + bool OnButtonPushed() override; + + void OnButtonEvent(lv_obj_t *object, lv_event_t event); + + private: + Pinetime::Controllers::FirmwareValidator& validator; + + lv_obj_t* labelVersionInfo; + lv_obj_t* labelVersionValue; + char version[9]; + lv_obj_t* labelIsValidated; + lv_obj_t* buttonValidate; + lv_obj_t* labelButtonValidate; + lv_obj_t* buttonReset; + lv_obj_t* labelButtonReset; + bool running = true; + }; + } + } +} diff --git a/src/displayapp/screens/Gauge.cpp b/src/displayapp/screens/Gauge.cpp new file mode 100644 index 00000000..81c283ca --- /dev/null +++ b/src/displayapp/screens/Gauge.cpp @@ -0,0 +1,58 @@ +#include <libs/lvgl/lvgl.h> +#include "Gauge.h" +#include "../DisplayApp.h" + +using namespace Pinetime::Applications::Screens; +extern lv_font_t jetbrains_mono_extrabold_compressed; +extern lv_font_t jetbrains_mono_bold_20; + + +Gauge::Gauge(Pinetime::Applications::DisplayApp *app) : Screen(app) { + /*Create a style*/ + lv_style_copy(&style, &lv_style_pretty_color); + style.body.main_color = LV_COLOR_CYAN; /*Line color at the beginning*/ + style.body.grad_color = LV_COLOR_RED; /*Line color at the end*/ + style.body.padding.left = 10; /*Scale line length*/ + style.body.padding.inner = 8 ; /*Scale label padding*/ + style.body.border.color = lv_color_hex3(0x333); /*Needle middle circle color*/ + style.line.width = 3; + style.text.color = LV_COLOR_WHITE; + style.line.color = LV_COLOR_RED; /*Line color after the critical value*/ + + + /*Describe the color for the needles*/ + + needle_colors[0] = LV_COLOR_ORANGE; + + /*Create a gauge*/ + gauge1 = lv_gauge_create(lv_scr_act(), nullptr); + lv_gauge_set_style(gauge1, LV_GAUGE_STYLE_MAIN, &style); + lv_gauge_set_needle_count(gauge1, 1, needle_colors); + lv_obj_set_size(gauge1, 180, 180); + lv_obj_align(gauge1, nullptr, LV_ALIGN_CENTER, 0, 0); + lv_gauge_set_scale(gauge1, 360, 60, 0); + lv_gauge_set_range(gauge1, 0, 59); + + /*Set the values*/ + lv_gauge_set_value(gauge1, 0, value); +} + +Gauge::~Gauge() { + + + lv_obj_clean(lv_scr_act()); +} + +bool Gauge::Refresh() { +// lv_lmeter_set_value(lmeter, value++); /*Set the current value*/ +// if(value>=60) value = 0; + + lv_gauge_set_value(gauge1, 0, value++); + if(value == 59) value = 0; + return running; +} + +bool Gauge::OnButtonPushed() { + running = false; + return true; +} diff --git a/src/displayapp/screens/Gauge.h b/src/displayapp/screens/Gauge.h new file mode 100644 index 00000000..03c06bed --- /dev/null +++ b/src/displayapp/screens/Gauge.h @@ -0,0 +1,32 @@ +#pragma once + +#include <cstdint> +#include "Screen.h" +#include <bits/unique_ptr.h> +#include <libs/lvgl/src/lv_core/lv_style.h> +#include <libs/lvgl/src/lv_core/lv_obj.h> + +namespace Pinetime { + namespace Applications { + namespace Screens { + + class Gauge : public Screen{ + public: + Gauge(DisplayApp* app); + ~Gauge() override; + + bool Refresh() override; + bool OnButtonPushed() override; + + private: + lv_style_t style; + lv_color_t needle_colors[3]; + lv_obj_t * gauge1; + + uint32_t value=30; + bool running = true; + + }; + } + } +} diff --git a/src/displayapp/screens/InfiniPaint.cpp b/src/displayapp/screens/InfiniPaint.cpp new file mode 100644 index 00000000..3ea75e9e --- /dev/null +++ b/src/displayapp/screens/InfiniPaint.cpp @@ -0,0 +1,44 @@ +#include <libs/lvgl/lvgl.h> +#include <libraries/log/nrf_log.h> +#include "InfiniPaint.h" +#include "../DisplayApp.h" + +using namespace Pinetime::Applications::Screens; +extern lv_font_t jetbrains_mono_extrabold_compressed; +extern lv_font_t jetbrains_mono_bold_20; + +InfiniPaint::InfiniPaint(Pinetime::Applications::DisplayApp* app, Pinetime::Components::LittleVgl& lvgl) : Screen(app), lvgl{lvgl} { + app->SetTouchMode(DisplayApp::TouchModes::Polling); + std::fill(b, b + bufferSize, LV_COLOR_WHITE); +} + +InfiniPaint::~InfiniPaint() { + // Reset the touchmode + app->SetTouchMode(DisplayApp::TouchModes::Gestures); + lv_obj_clean(lv_scr_act()); +} + +bool InfiniPaint::Refresh() { + return running; +} + +bool InfiniPaint::OnButtonPushed() { + running = false; + return true; +} + +bool InfiniPaint::OnTouchEvent(Pinetime::Applications::TouchEvents event) { + return true; +} + +bool InfiniPaint::OnTouchEvent(uint16_t x, uint16_t y) { + lv_area_t area; + area.x1 = x - (width / 2); + area.y1 = y - (height / 2); + area.x2 = x + (width / 2) - 1; + area.y2 = y + (height / 2) - 1; + lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::None); + lvgl.FlushDisplay(&area, b); + return true; +} + diff --git a/src/displayapp/screens/InfiniPaint.h b/src/displayapp/screens/InfiniPaint.h new file mode 100644 index 00000000..f29135d5 --- /dev/null +++ b/src/displayapp/screens/InfiniPaint.h @@ -0,0 +1,39 @@ +#pragma once + +#include <cstdint> +#include "Screen.h" +#include <bits/unique_ptr.h> +#include <libs/lvgl/src/lv_core/lv_style.h> +#include <libs/lvgl/src/lv_core/lv_obj.h> +#include <drivers/St7789.h> +#include "displayapp/LittleVgl.h" + +namespace Pinetime { + namespace Applications { + namespace Screens { + + class InfiniPaint : public Screen { + public: + InfiniPaint(DisplayApp* app, Pinetime::Components::LittleVgl& lvgl); + + ~InfiniPaint() override; + + bool Refresh() override; + + bool OnButtonPushed() override; + + bool OnTouchEvent(TouchEvents event) override; + + bool OnTouchEvent(uint16_t x, uint16_t y) override; + + private: + Pinetime::Components::LittleVgl& lvgl; + static constexpr uint16_t width = 10; + static constexpr uint16_t height = 10; + static constexpr uint16_t bufferSize = width * height; + lv_color_t b[bufferSize]; + bool running = true; + }; + } + } +} diff --git a/src/displayapp/screens/Label.cpp b/src/displayapp/screens/Label.cpp new file mode 100644 index 00000000..540776cc --- /dev/null +++ b/src/displayapp/screens/Label.cpp @@ -0,0 +1,15 @@ +#include <libs/lvgl/lvgl.h> +#include "Label.h" + +using namespace Pinetime::Applications::Screens; + +Label::Label(Pinetime::Applications::DisplayApp *app, const char *text) : Screen(app), text{text} { + label = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_align(label, LV_LABEL_ALIGN_LEFT); + lv_obj_set_size(label, 240, 240); + lv_label_set_text(label, text); +} + +Label::~Label() { + lv_obj_clean(lv_scr_act()); +} diff --git a/src/displayapp/screens/Label.h b/src/displayapp/screens/Label.h new file mode 100644 index 00000000..3e7b3797 --- /dev/null +++ b/src/displayapp/screens/Label.h @@ -0,0 +1,23 @@ +#pragma once + +#include <vector> +#include "Screen.h" +#include <lvgl/lvgl.h> + +namespace Pinetime { + namespace Applications { + namespace Screens { + + class Label : public Screen { + public: + Label(DisplayApp* app, const char* text); + ~Label() override; + bool Refresh() override {return false;} + + private: + lv_obj_t * label = nullptr; + const char* text = nullptr; + }; + } + } +}
\ No newline at end of file diff --git a/src/displayapp/screens/Meter.cpp b/src/displayapp/screens/Meter.cpp new file mode 100644 index 00000000..273e111d --- /dev/null +++ b/src/displayapp/screens/Meter.cpp @@ -0,0 +1,47 @@ +#include <libs/lvgl/lvgl.h> +#include "Meter.h" +#include "../DisplayApp.h" + +using namespace Pinetime::Applications::Screens; +extern lv_font_t jetbrains_mono_extrabold_compressed; +extern lv_font_t jetbrains_mono_bold_20; + + +Meter::Meter(Pinetime::Applications::DisplayApp *app) : Screen(app) { + + lv_style_copy(&style_lmeter, &lv_style_pretty_color); + style_lmeter.line.width = 2; + style_lmeter.line.color = LV_COLOR_SILVER; + style_lmeter.body.main_color = lv_color_make(255,0,0); + style_lmeter.body.grad_color = lv_color_make(160,0,0); + style_lmeter.body.padding.left = 16; /*Line length*/ + + /*Create a line meter */ + lmeter = lv_lmeter_create(lv_scr_act(), nullptr); + lv_lmeter_set_range(lmeter, 0, 60); /*Set the range*/ + lv_lmeter_set_value(lmeter, value); /*Set the current value*/ + lv_lmeter_set_angle_offset(lmeter, 180); + lv_lmeter_set_scale(lmeter, 360, 60); /*Set the angle and number of lines*/ + lv_lmeter_set_style(lmeter, LV_LMETER_STYLE_MAIN, &style_lmeter); /*Apply the new style*/ + lv_obj_set_size(lmeter, 150, 150); + lv_obj_align(lmeter, nullptr, LV_ALIGN_CENTER, 0, 0); + +} + +Meter::~Meter() { + + + lv_obj_clean(lv_scr_act()); +} + +bool Meter::Refresh() { + lv_lmeter_set_value(lmeter, value++); /*Set the current value*/ + if(value>=60) value = 0; + + return running; +} + +bool Meter::OnButtonPushed() { + running = false; + return true; +} diff --git a/src/displayapp/screens/Meter.h b/src/displayapp/screens/Meter.h new file mode 100644 index 00000000..ddf8be8d --- /dev/null +++ b/src/displayapp/screens/Meter.h @@ -0,0 +1,32 @@ +#pragma once + +#include <cstdint> +#include <chrono> +#include "Screen.h" +#include <bits/unique_ptr.h> +#include <libs/lvgl/src/lv_core/lv_style.h> +#include <libs/lvgl/src/lv_core/lv_obj.h> + +namespace Pinetime { + namespace Applications { + namespace Screens { + + class Meter : public Screen{ + public: + Meter(DisplayApp* app); + ~Meter() override; + + bool Refresh() override; + bool OnButtonPushed() override; + + private: + lv_style_t style_lmeter; + lv_obj_t * lmeter; + + uint32_t value=0; + bool running = true; + + }; + } + } +} diff --git a/src/displayapp/screens/Modal.cpp b/src/displayapp/screens/Modal.cpp new file mode 100644 index 00000000..29f7bfa7 --- /dev/null +++ b/src/displayapp/screens/Modal.cpp @@ -0,0 +1,81 @@ +#include <libs/lvgl/lvgl.h> +#include "Modal.h" +#include "../DisplayApp.h" + +using namespace Pinetime::Applications::Screens; +extern lv_font_t jetbrains_mono_extrabold_compressed; +extern lv_font_t jetbrains_mono_bold_20; + +Modal::Modal(Pinetime::Applications::DisplayApp *app) : Screen(app) { + + +} + +Modal::~Modal() { + lv_obj_clean(lv_scr_act()); +} + +bool Modal::Refresh() { + + return running; +} + +bool Modal::OnButtonPushed() { + running = false; + return true; +} + +void Modal::Hide() { + /* Delete the parent modal background */ + lv_obj_del_async(lv_obj_get_parent(mbox)); + mbox = NULL; /* happens before object is actually deleted! */ + isVisible = false; +} + +void Modal::mbox_event_cb(lv_obj_t *obj, lv_event_t evt) { + auto* m = static_cast<Modal *>(obj->user_data); + m->OnEvent(obj, evt); +} + +void Modal::OnEvent(lv_obj_t *event_obj, lv_event_t evt) { + if(evt == LV_EVENT_DELETE && event_obj == mbox) { + Hide(); + } else if(evt == LV_EVENT_VALUE_CHANGED) { + /* A button was clicked */ + lv_mbox_start_auto_close(mbox, 0); +// Hide(); + } +} + +void Modal::Show(const char* msg) { + if(isVisible) return; + isVisible = true; + lv_style_copy(&modal_style, &lv_style_plain_color); + modal_style.body.main_color = modal_style.body.grad_color = LV_COLOR_BLACK; + modal_style.body.opa = LV_OPA_50; + + obj = lv_obj_create(lv_scr_act(), nullptr); + lv_obj_set_style(obj, &modal_style); + lv_obj_set_pos(obj, 0, 0); + lv_obj_set_size(obj, LV_HOR_RES, LV_VER_RES); + lv_obj_set_opa_scale_enable(obj, true); /* Enable opacity scaling for the animation */ + + static const char * btns2[] = {"Ok", ""}; + + /* Create the message box as a child of the modal background */ + mbox = lv_mbox_create(obj, nullptr); + lv_mbox_add_btns(mbox, btns2); + lv_mbox_set_text(mbox, msg); + lv_obj_align(mbox, nullptr, LV_ALIGN_CENTER, 0, 0); + lv_obj_set_event_cb(mbox, Modal::mbox_event_cb); + + mbox->user_data = this; + + /* Fade the message box in with an animation */ + lv_anim_t a; + lv_anim_init(&a); + lv_anim_set_time(&a, 500, 0); + lv_anim_set_values(&a, LV_OPA_TRANSP, LV_OPA_COVER); + lv_anim_set_exec_cb(&a, obj, (lv_anim_exec_xcb_t)lv_obj_set_opa_scale); + lv_anim_create(&a); +} diff --git a/src/displayapp/screens/Modal.h b/src/displayapp/screens/Modal.h new file mode 100644 index 00000000..c616c294 --- /dev/null +++ b/src/displayapp/screens/Modal.h @@ -0,0 +1,39 @@ +#pragma once + +#include <cstdint> +#include <chrono> +#include "Screen.h" +#include <bits/unique_ptr.h> +#include <libs/lvgl/src/lv_core/lv_style.h> +#include <libs/lvgl/src/lv_core/lv_obj.h> + +namespace Pinetime { + namespace Applications { + namespace Screens { + + class Modal : public Screen{ + public: + Modal(DisplayApp* app); + ~Modal() override; + + void Show(const char* msg); + void Hide(); + + bool Refresh() override; + bool OnButtonPushed() override; + + static void mbox_event_cb(lv_obj_t *obj, lv_event_t evt); + private: + void OnEvent(lv_obj_t *event_obj, lv_event_t evt); + + lv_style_t modal_style; + lv_obj_t *obj; + lv_obj_t *mbox; + lv_obj_t *info; + bool running = true; + bool isVisible = false; + + }; + } + } +} diff --git a/src/displayapp/screens/Music.cpp b/src/displayapp/screens/Music.cpp new file mode 100644 index 00000000..225a15a4 --- /dev/null +++ b/src/displayapp/screens/Music.cpp @@ -0,0 +1,292 @@ +/* Copyright (C) 2020 JF, Adam Pigg, Avamander + + This file is part of InfiniTime. + + InfiniTime is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + InfiniTime is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <https://www.gnu.org/licenses/>. +*/ +#include <libs/lvgl/lvgl.h> + +#include "Music.h" + +using namespace Pinetime::Applications::Screens; + +extern lv_font_t jetbrains_mono_extrabold_compressed; +extern lv_font_t jetbrains_mono_bold_20; + +static void event_handler(lv_obj_t *obj, lv_event_t event) { + Music *screen = static_cast<Music *>(obj->user_data); + screen->OnObjectEvent(obj, event); +} + +/** + * Set the pixel array to display by the image + * This just calls lv_img_set_src but adds type safety + * + * @param img pointer to an image object + * @param data the image array + */ +inline void lv_img_set_src_arr(lv_obj_t *img, const lv_img_dsc_t *src_img) { + lv_img_set_src(img, src_img); +} + +/** + * Music control watchapp + * + * TODO: Investigate Apple Media Service and AVRCPv1.6 support for seamless integration + */ +Music::Music(Pinetime::Applications::DisplayApp *app, Pinetime::Controllers::MusicService &music) : Screen(app), musicService(music) { + lv_obj_t *label; + + btnVolDown = lv_btn_create(lv_scr_act(), nullptr); + btnVolDown->user_data = this; + lv_obj_set_event_cb(btnVolDown, event_handler); + lv_obj_set_size(btnVolDown, LV_HOR_RES / 3, 80); + lv_obj_align(btnVolDown, nullptr, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0); + label = lv_label_create(btnVolDown, nullptr); + lv_label_set_text(label, "V-"); + lv_obj_set_hidden(btnVolDown, !displayVolumeButtons); + + btnVolUp = lv_btn_create(lv_scr_act(), nullptr); + btnVolUp->user_data = this; + lv_obj_set_event_cb(btnVolUp, event_handler); + lv_obj_set_size(btnVolUp, LV_HOR_RES / 3, 80); + lv_obj_align(btnVolUp, nullptr, LV_ALIGN_IN_BOTTOM_RIGHT, 0, 0); + label = lv_label_create(btnVolUp, nullptr); + lv_label_set_text(label, "V+"); + lv_obj_set_hidden(btnVolDown, !displayVolumeButtons); + + btnPrev = lv_btn_create(lv_scr_act(), nullptr); + btnPrev->user_data = this; + lv_obj_set_event_cb(btnPrev, event_handler); + lv_obj_set_size(btnPrev, LV_HOR_RES / 3, 80); + lv_obj_align(btnPrev, nullptr, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0); + label = lv_label_create(btnPrev, nullptr); + lv_label_set_text(label, "<<"); + + btnNext = lv_btn_create(lv_scr_act(), nullptr); + btnNext->user_data = this; + lv_obj_set_event_cb(btnNext, event_handler); + lv_obj_set_size(btnNext, LV_HOR_RES / 3, 80); + lv_obj_align(btnNext, nullptr, LV_ALIGN_IN_BOTTOM_RIGHT, 0, 0); + label = lv_label_create(btnNext, nullptr); + lv_label_set_text(label, ">>"); + + btnPlayPause = lv_btn_create(lv_scr_act(), nullptr); + btnPlayPause->user_data = this; + lv_obj_set_event_cb(btnPlayPause, event_handler); + lv_obj_set_size(btnPlayPause, LV_HOR_RES / 3, 80); + lv_obj_align(btnPlayPause, nullptr, LV_ALIGN_IN_BOTTOM_MID, 0, 0); + txtPlayPause = lv_label_create(btnPlayPause, nullptr); + lv_label_set_text(txtPlayPause, ">"); + + txtTrackDuration = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_long_mode(txtTrackDuration, LV_LABEL_LONG_SROLL); + lv_obj_align(txtTrackDuration, nullptr, LV_ALIGN_IN_TOP_LEFT, 12, 20); + lv_label_set_text(txtTrackDuration, "--:--/--:--"); + lv_label_set_align(txtTrackDuration, LV_ALIGN_IN_LEFT_MID); + lv_obj_set_width(txtTrackDuration, LV_HOR_RES); + + constexpr uint8_t FONT_HEIGHT = 12; + constexpr uint8_t LINE_PAD = 15; + constexpr int8_t MIDDLE_OFFSET = -25; + txtArtist = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_long_mode(txtArtist, LV_LABEL_LONG_SROLL); + lv_obj_align(txtArtist, nullptr, LV_ALIGN_IN_LEFT_MID, 12, MIDDLE_OFFSET + 1 * FONT_HEIGHT); + lv_label_set_text(txtArtist, "Artist Name"); + lv_label_set_align(txtArtist, LV_ALIGN_IN_LEFT_MID); + lv_obj_set_width(txtArtist, LV_HOR_RES); + + txtTrack = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_long_mode(txtTrack, LV_LABEL_LONG_SROLL); + lv_obj_align(txtTrack, nullptr, LV_ALIGN_IN_LEFT_MID, 12, MIDDLE_OFFSET + 2 * FONT_HEIGHT + LINE_PAD); + lv_label_set_text(txtTrack, "This is a very long getTrack name"); + lv_label_set_align(txtTrack, LV_ALIGN_IN_LEFT_MID); + lv_obj_set_width(txtTrack, LV_HOR_RES); + + /** Init animation */ + imgDisc = lv_img_create(lv_scr_act(), nullptr); + lv_img_set_src_arr(imgDisc, &disc); + lv_obj_align(imgDisc, nullptr, LV_ALIGN_IN_TOP_RIGHT, -15, 15); + + imgDiscAnim = lv_img_create(lv_scr_act(), nullptr); + lv_img_set_src_arr(imgDiscAnim, &disc_f_1); + lv_obj_align(imgDiscAnim, nullptr, LV_ALIGN_IN_TOP_RIGHT, -15 - 32, 15); + + frameB = false; + + musicService.event(Controllers::MusicService::EVENT_MUSIC_OPEN); +} + +Music::~Music() { + lv_obj_clean(lv_scr_act()); +} + +bool Music::OnButtonPushed() { + running = false; + return true; +} + +bool Music::Refresh() { + if (artist != musicService.getArtist()) { + artist = musicService.getArtist(); + currentLength = 0; + lv_label_set_text(txtArtist, artist.data()); + } + + if (track != musicService.getTrack()) { + track = musicService.getTrack(); + currentLength = 0; + lv_label_set_text(txtTrack, track.data()); + } + + if (album != musicService.getAlbum()) { + album = musicService.getAlbum(); + currentLength = 0; + } + + if (playing != musicService.isPlaying()) { + playing = musicService.isPlaying(); + } + + // Because we increment this ourselves, + // we can't compare with the old data directly + // have to update it when there's actually new data + // just to avoid unnecessary draws that make UI choppy + if (lastLength != musicService.getProgress()) { + currentLength = musicService.getProgress(); + lastLength = currentLength; + UpdateLength(); + } + + if (totalLength != musicService.getTrackLength()) { + totalLength = musicService.getTrackLength(); + UpdateLength(); + } + + if (playing == Pinetime::Controllers::MusicService::MusicStatus::Playing) { + lv_label_set_text(txtPlayPause, "||"); + if (xTaskGetTickCount() - 1024 >= lastIncrement) { + + if (frameB) { + lv_img_set_src(imgDiscAnim, &disc_f_1); + } else { + lv_img_set_src(imgDiscAnim, &disc_f_2); + } + frameB = !frameB; + + if (currentLength < totalLength) { + currentLength += static_cast<int>((static_cast<float>(xTaskGetTickCount() - lastIncrement) / 1024.0f) * + musicService.getPlaybackSpeed()); + } else { + // Let's assume the getTrack finished, paused when the timer ends + // and there's no new getTrack being sent to us + // TODO: ideally this would be configurable + playing = false; + } + lastIncrement = xTaskGetTickCount(); + + UpdateLength(); + } + } else { + lv_label_set_text(txtPlayPause, ">"); + } + + return running; +} + +void Music::UpdateLength() { + if (totalLength > (99 * 60 * 60)) { + lv_label_set_text(txtTrackDuration, "Inf/Inf"); + } else if (totalLength > (99 * 60)) { + char timer[12]; + sprintf(timer, "%02d:%02d/%02d:%02d", + (currentLength / (60 * 60)) % 100, + ((currentLength % (60 * 60)) / 60) % 100, + (totalLength / (60 * 60)) % 100, + ((totalLength % (60 * 60)) / 60) % 100 + ); + lv_label_set_text(txtTrackDuration, timer); + } else { + char timer[12]; + sprintf(timer, "%02d:%02d/%02d:%02d", + (currentLength / 60) % 100, + (currentLength % 60) % 100, + (totalLength / 60) % 100, + (totalLength % 60) % 100 + ); + lv_label_set_text(txtTrackDuration, timer); + } +} + +void Music::OnObjectEvent(lv_obj_t *obj, lv_event_t event) { + if (event == LV_EVENT_CLICKED) { + if (obj == btnVolDown) { + musicService.event(Controllers::MusicService::EVENT_MUSIC_VOLDOWN); + } else if (obj == btnVolUp) { + musicService.event(Controllers::MusicService::EVENT_MUSIC_VOLUP); + } else if (obj == btnPrev) { + musicService.event(Controllers::MusicService::EVENT_MUSIC_PREV); + } else if (obj == btnPlayPause) { + if (playing == Pinetime::Controllers::MusicService::MusicStatus::Playing) { + musicService.event(Controllers::MusicService::EVENT_MUSIC_PAUSE); + + // Let's assume it stops playing instantly + playing = Controllers::MusicService::NotPlaying; + } else { + musicService.event(Controllers::MusicService::EVENT_MUSIC_PLAY); + + // Let's assume it starts playing instantly + // TODO: In the future should check for BT connection for better UX + playing = Controllers::MusicService::Playing; + } + } else if (obj == btnNext) { + musicService.event(Controllers::MusicService::EVENT_MUSIC_NEXT); + } + } +} + + +bool Music::OnTouchEvent(Pinetime::Applications::TouchEvents event) { + switch (event) { + case TouchEvents::SwipeUp: { + displayVolumeButtons = true; + lv_obj_set_hidden(btnVolDown, !displayVolumeButtons); + lv_obj_set_hidden(btnVolUp, !displayVolumeButtons); + + lv_obj_set_hidden(btnNext, displayVolumeButtons); + lv_obj_set_hidden(btnPrev, displayVolumeButtons); + return true; + } + case TouchEvents::SwipeDown: { + displayVolumeButtons = false; + lv_obj_set_hidden(btnNext, displayVolumeButtons); + lv_obj_set_hidden(btnPrev, displayVolumeButtons); + + lv_obj_set_hidden(btnVolDown, !displayVolumeButtons); + lv_obj_set_hidden(btnVolUp, !displayVolumeButtons); + return true; + } + case TouchEvents::SwipeLeft: { + musicService.event(Controllers::MusicService::EVENT_MUSIC_NEXT); + return true; + } + case TouchEvents::SwipeRight: { + musicService.event(Controllers::MusicService::EVENT_MUSIC_PREV); + return true; + } + default: { + return true; + } + } +}
\ No newline at end of file diff --git a/src/displayapp/screens/Music.h b/src/displayapp/screens/Music.h new file mode 100644 index 00000000..81ba7935 --- /dev/null +++ b/src/displayapp/screens/Music.h @@ -0,0 +1,96 @@ +/* Copyright (C) 2020 JF, Adam Pigg, Avamander + + This file is part of InfiniTime. + + InfiniTime is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + InfiniTime is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <https://www.gnu.org/licenses/>. +*/ +#pragma once + +#include <cstdint> +#include <chrono> +#include <string> + +#include "components/gfx/Gfx.h" +#include "components/battery/BatteryController.h" +#include "components/ble/BleController.h" +#include "components/ble/MusicService.h" +#include "Screen.h" +#include <bits/unique_ptr.h> +#include <libs/lvgl/src/lv_core/lv_style.h> +#include <libs/lvgl/src/lv_core/lv_obj.h> +#include "../../Version.h" +#include "displayapp/icons/music/disc.cpp" +#include "displayapp/icons/music/disc_f_1.cpp" +#include "displayapp/icons/music/disc_f_2.cpp" + +namespace Pinetime { + namespace Applications { + namespace Screens { + class Music : public Screen { + public: + Music(DisplayApp *app, Pinetime::Controllers::MusicService &music); + + ~Music() override; + + bool Refresh() override; + + bool OnButtonPushed() override; + + void OnObjectEvent(lv_obj_t *obj, lv_event_t event); + + private: + bool OnTouchEvent(TouchEvents event); + + void UpdateLength(); + + lv_obj_t *btnPrev; + lv_obj_t *btnPlayPause; + lv_obj_t *btnNext; + lv_obj_t *btnVolDown; + lv_obj_t *btnVolUp; + lv_obj_t *txtArtist; + lv_obj_t *txtTrack; + lv_obj_t *txtPlayPause; + + lv_obj_t *imgDisc; + lv_obj_t *imgDiscAnim; + lv_obj_t *txtTrackDuration; + + /** For the spinning disc animation */ + bool frameB; + + bool displayVolumeButtons = false; + Pinetime::Controllers::MusicService &musicService; + + std::string artist; + std::string album; + std::string track; + + /** Total length in seconds */ + int totalLength; + /** Current length in seconds */ + int currentLength; + /** Last length */ + int lastLength; + /** Last time an animation update or timer was incremented */ + TickType_t lastIncrement; + + bool playing; + + /** Watchapp */ + bool running = true; + }; + } + } +} diff --git a/src/displayapp/screens/NotificationIcon.cpp b/src/displayapp/screens/NotificationIcon.cpp new file mode 100644 index 00000000..64898c2c --- /dev/null +++ b/src/displayapp/screens/NotificationIcon.cpp @@ -0,0 +1,8 @@ +#include "NotificationIcon.h" +#include "Symbols.h" +using namespace Pinetime::Applications::Screens; + +const char* NotificationIcon::GetIcon(bool newNotificationAvailable) { + if(newNotificationAvailable) return Symbols::info; + else return ""; +}
\ No newline at end of file diff --git a/src/displayapp/screens/NotificationIcon.h b/src/displayapp/screens/NotificationIcon.h new file mode 100644 index 00000000..dc34c3f0 --- /dev/null +++ b/src/displayapp/screens/NotificationIcon.h @@ -0,0 +1,12 @@ +#pragma once + +namespace Pinetime { + namespace Applications { + namespace Screens { + class NotificationIcon { + public: + static const char* GetIcon(bool newNotificationAvailable); + }; + } + } +}
\ No newline at end of file diff --git a/src/displayapp/screens/Notifications.cpp b/src/displayapp/screens/Notifications.cpp new file mode 100644 index 00000000..85848b2f --- /dev/null +++ b/src/displayapp/screens/Notifications.cpp @@ -0,0 +1,174 @@ +#include <libs/lvgl/lvgl.h> +#include <displayapp/DisplayApp.h> +#include <functional> +#include "Notifications.h" + +using namespace Pinetime::Applications::Screens; + +Notifications::Notifications(DisplayApp *app, Pinetime::Controllers::NotificationManager ¬ificationManager, Modes mode) : + Screen(app), notificationManager{notificationManager}, mode{mode} { + notificationManager.ClearNewNotificationFlag(); + auto notification = notificationManager.GetLastNotification(); + if(notification.valid) { + currentId = notification.id; + currentItem.reset(new NotificationItem("\nNotification", notification.message.data(), notification.index, notificationManager.NbNotifications(), mode)); + validDisplay = true; + } else { + currentItem.reset(new NotificationItem("\nNotification", "No notification to display", 0, notificationManager.NbNotifications(), Modes::Preview)); + } + + if(mode == Modes::Preview) { + static lv_style_t style_line; + lv_style_copy(&style_line, &lv_style_plain); + style_line.line.color = LV_COLOR_WHITE; + style_line.line.width = 3; + style_line.line.rounded = 0; + + + timeoutLine = lv_line_create(lv_scr_act(), nullptr); + lv_line_set_style(timeoutLine, LV_LINE_STYLE_MAIN, &style_line); + lv_line_set_points(timeoutLine, timeoutLinePoints, 2); + timeoutTickCountStart = xTaskGetTickCount(); + timeoutTickCountEnd = timeoutTickCountStart + (5*1024); + } +} + +Notifications::~Notifications() { + lv_obj_clean(lv_scr_act()); +} + +bool Notifications::Refresh() { + if (mode == Modes::Preview) { + auto tick = xTaskGetTickCount(); + int32_t pos = 240 - ((tick - timeoutTickCountStart) / ((timeoutTickCountEnd - timeoutTickCountStart) / 240)); + if (pos < 0) + running = false; + + timeoutLinePoints[1].x = pos; + lv_line_set_points(timeoutLine, timeoutLinePoints, 2); + + if (!running) { + // Start clock app when exiting this one + app->StartApp(Apps::Clock); + } + } + + return running; +} + +bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) { + switch (event) { + case Pinetime::Applications::TouchEvents::SwipeUp: { + Controllers::NotificationManager::Notification previousNotification; + if(validDisplay) + previousNotification = notificationManager.GetPrevious(currentId); + else + previousNotification = notificationManager.GetLastNotification(); + + if (!previousNotification.valid) return true; + + validDisplay = true; + currentId = previousNotification.id; + currentItem.reset(nullptr); + app->SetFullRefresh(DisplayApp::FullRefreshDirections::Up); + currentItem.reset(new NotificationItem("\nNotification", previousNotification.message.data(), previousNotification.index, notificationManager.NbNotifications(), mode)); + } + return true; + case Pinetime::Applications::TouchEvents::SwipeDown: { + Controllers::NotificationManager::Notification nextNotification; + if(validDisplay) + nextNotification = notificationManager.GetNext(currentId); + else + nextNotification = notificationManager.GetLastNotification(); + + if (!nextNotification.valid) return true; + + validDisplay = true; + currentId = nextNotification.id; + currentItem.reset(nullptr); + app->SetFullRefresh(DisplayApp::FullRefreshDirections::Down); + currentItem.reset(new NotificationItem("\nNotification", nextNotification.message.data(), nextNotification.index, notificationManager.NbNotifications(), mode)); + } + return true; + default: + return false; + } +} + + +bool Notifications::OnButtonPushed() { + running = false; + return true; +} + + +Notifications::NotificationItem::NotificationItem(const char *title, const char *msg, uint8_t notifNr, uint8_t notifNb, Modes mode) + : notifNr{notifNr}, notifNb{notifNb}, mode{mode} { + container1 = lv_cont_create(lv_scr_act(), nullptr); + static lv_style_t contStyle; + lv_style_copy(&contStyle, lv_cont_get_style(container1, LV_CONT_STYLE_MAIN)); + contStyle.body.padding.inner = 20; + lv_cont_set_style(container1, LV_CONT_STYLE_MAIN, &contStyle); + lv_obj_set_width(container1, LV_HOR_RES); + lv_obj_set_height(container1, LV_VER_RES); + lv_obj_set_pos(container1, 0, 0); + lv_cont_set_layout(container1, LV_LAYOUT_OFF); + lv_cont_set_fit2(container1, LV_FIT_FLOOD, LV_FIT_FLOOD); + + t1 = lv_label_create(container1, nullptr); + static lv_style_t titleStyle; + static lv_style_t textStyle; + static lv_style_t bottomStyle; + lv_style_copy(&titleStyle, lv_label_get_style(t1, LV_LABEL_STYLE_MAIN)); + lv_style_copy(&textStyle, lv_label_get_style(t1, LV_LABEL_STYLE_MAIN)); + lv_style_copy(&bottomStyle, lv_label_get_style(t1, LV_LABEL_STYLE_MAIN)); + titleStyle.body.padding.inner = 5; + titleStyle.body.grad_color = LV_COLOR_GRAY; + titleStyle.body.main_color = LV_COLOR_GRAY; + titleStyle.body.radius = 20; + textStyle.body.border.part = LV_BORDER_NONE; + textStyle.body.padding.inner = 5; + + bottomStyle.body.main_color = LV_COLOR_GREEN; + bottomStyle.body.grad_color = LV_COLOR_GREEN; + bottomStyle.body.border.part = LV_BORDER_TOP; + bottomStyle.body.border.color = LV_COLOR_RED; + + lv_label_set_style(t1, LV_LABEL_STYLE_MAIN, &titleStyle); + lv_label_set_long_mode(t1, LV_LABEL_LONG_BREAK); + lv_label_set_body_draw(t1, true); + lv_obj_set_width(t1, LV_HOR_RES - (titleStyle.body.padding.left + titleStyle.body.padding.right)); + lv_label_set_text(t1, title); + static constexpr int16_t offscreenOffset = -20 ; + lv_obj_set_pos(t1, titleStyle.body.padding.left, offscreenOffset); + + auto titleHeight = lv_obj_get_height(t1); + + l1 = lv_label_create(container1, nullptr); + lv_label_set_style(l1, LV_LABEL_STYLE_MAIN, &textStyle); + lv_obj_set_pos(l1, textStyle.body.padding.left, + titleHeight + offscreenOffset + textStyle.body.padding.bottom + + textStyle.body.padding.top); + + lv_label_set_long_mode(l1, LV_LABEL_LONG_BREAK); + lv_label_set_body_draw(l1, true); + lv_obj_set_width(l1, LV_HOR_RES - (textStyle.body.padding.left + textStyle.body.padding.right)); + lv_label_set_text(l1, msg); + + if(mode == Modes::Normal) { + if(notifNr < notifNb) { + bottomPlaceholder = lv_label_create(container1, nullptr); + lv_label_set_style(bottomPlaceholder, LV_LABEL_STYLE_MAIN, &titleStyle); + lv_label_set_long_mode(bottomPlaceholder, LV_LABEL_LONG_BREAK); + lv_label_set_body_draw(bottomPlaceholder, true); + lv_obj_set_width(bottomPlaceholder, LV_HOR_RES - (titleStyle.body.padding.left + titleStyle.body.padding.right)); + lv_label_set_text(bottomPlaceholder, " "); + lv_obj_set_pos(bottomPlaceholder, titleStyle.body.padding.left, LV_VER_RES - 5); + } + } +} + + +Notifications::NotificationItem::~NotificationItem() { + lv_obj_clean(lv_scr_act()); +} diff --git a/src/displayapp/screens/Notifications.h b/src/displayapp/screens/Notifications.h new file mode 100644 index 00000000..fb4e1ef2 --- /dev/null +++ b/src/displayapp/screens/Notifications.h @@ -0,0 +1,61 @@ +#pragma once + +#include <functional> +#include <vector> + +#include "Screen.h" +#include "ScreenList.h" + + +namespace Pinetime { + namespace Applications { + namespace Screens { + class Notifications : public Screen { + public: + enum class Modes {Normal, Preview}; + explicit Notifications(DisplayApp* app, Pinetime::Controllers::NotificationManager& notificationManager, Modes mode); + ~Notifications() override; + + bool Refresh() override; + bool OnButtonPushed() override; + bool OnTouchEvent(Pinetime::Applications::TouchEvents event) override; + + private: + bool running = true; + + class NotificationItem { + public: + NotificationItem(const char* title, const char* msg, uint8_t notifNr, uint8_t notifNb, Modes mode); + ~NotificationItem(); + bool Refresh() {return false;} + + private: + uint8_t notifNr = 0; + uint8_t notifNb = 0; + char pageText[4]; + + lv_obj_t* container1; + lv_obj_t* t1; + lv_obj_t* l1; + lv_obj_t* bottomPlaceholder; + Modes mode; + }; + + struct NotificationData { + const char* title; + const char* text; + }; + Pinetime::Controllers::NotificationManager& notificationManager; + Modes mode = Modes::Normal; + std::unique_ptr<NotificationItem> currentItem; + Controllers::NotificationManager::Notification::Id currentId; + bool validDisplay = false; + + lv_point_t timeoutLinePoints[2] { {0, 237}, {239, 237} }; + lv_obj_t* timeoutLine; + uint32_t timeoutTickCountStart; + uint32_t timeoutTickCountEnd; + }; + } + } +} diff --git a/src/displayapp/screens/Screen.cpp b/src/displayapp/screens/Screen.cpp new file mode 100644 index 00000000..1467df33 --- /dev/null +++ b/src/displayapp/screens/Screen.cpp @@ -0,0 +1,2 @@ +#include "Screen.h" +using namespace Pinetime::Applications::Screens;
\ No newline at end of file diff --git a/src/displayapp/screens/Screen.h b/src/displayapp/screens/Screen.h new file mode 100644 index 00000000..6b1d0eec --- /dev/null +++ b/src/displayapp/screens/Screen.h @@ -0,0 +1,42 @@ +#pragma once + +#include <cstdint> +#include "../TouchEvents.h" + +namespace Pinetime { + namespace Applications { + class DisplayApp; + namespace Screens { + class Screen { + public: + explicit Screen(DisplayApp* app) : app{app} {} + virtual ~Screen() = default; + + /** + * Most of the time, apps only react to events (touch events, for example). + * In this case you don't need to do anything in this method. + * + * For example, InfiniPaint does nothing in Refresh(). + * But, if you want to update your display periodically, draw an animation... + * you cannot do it in a touch event handler because these handlers are not + * called if the user does not touch the screen. + * + * That's why Refresh() is there: update the display periodically. + * + * @return false if the app can be closed, true if it must continue to run + **/ + virtual bool Refresh() = 0; + + /** @return false if the button hasn't been handled by the app, true if it has been handled */ + virtual bool OnButtonPushed() { return false; } + + /** @return false if the event hasn't been handled by the app, true if it has been handled */ + virtual bool OnTouchEvent(TouchEvents event) { return false; } + virtual bool OnTouchEvent(uint16_t x, uint16_t y) { return false; } + + protected: + DisplayApp* app; + }; + } + } +} diff --git a/src/displayapp/screens/ScreenList.h b/src/displayapp/screens/ScreenList.h new file mode 100644 index 00000000..b198634f --- /dev/null +++ b/src/displayapp/screens/ScreenList.h @@ -0,0 +1,66 @@ +#pragma once + +#include <vector> +#include <functional> +#include "components/ble/NimbleController.h" +#include "Screen.h" +#include "Label.h" + +namespace Pinetime { + namespace Applications { + namespace Screens { + template <size_t N> + class ScreenList : public Screen { + public: + ScreenList(DisplayApp* app, std::array<std::function<std::unique_ptr<Screen>()>, N>&& screens) + : Screen(app), screens{std::move(screens)}, current{this->screens[0]()} { + + } + + ~ScreenList() override { + + } + + bool Refresh() override { + running = current->Refresh(); + return running; + } + + bool OnButtonPushed() override { + running = false; + return true; + } + + bool OnTouchEvent(TouchEvents event) override { + switch (event) { + case TouchEvents::SwipeDown: + if (screenIndex > 0) { + current.reset(nullptr); + app->SetFullRefresh(DisplayApp::FullRefreshDirections::Down); + screenIndex--; + current = screens[screenIndex](); + } + return true; + case TouchEvents::SwipeUp: + if (screenIndex < screens.size() - 1) { + current.reset(nullptr); + app->SetFullRefresh(DisplayApp::FullRefreshDirections::Up); + screenIndex++; + current = screens[screenIndex](); + } + return true; + default: + return false; + } + return false; + } + + private: + bool running = true; + uint8_t screenIndex = 0; + std::array<std::function<std::unique_ptr<Screen>()>, N> screens; + std::unique_ptr<Screen> current; + }; + } + } +}
\ No newline at end of file diff --git a/src/displayapp/screens/Symbols.h b/src/displayapp/screens/Symbols.h new file mode 100644 index 00000000..aeea3243 --- /dev/null +++ b/src/displayapp/screens/Symbols.h @@ -0,0 +1,30 @@ +#pragma once + +namespace Pinetime { + namespace Applications { + namespace Screens { + namespace Symbols { + static constexpr const char* none = ""; + static constexpr const char* batteryFull = "\xEF\x89\x80"; + static constexpr const char* batteryEmpty = "\xEF\x89\x84"; + static constexpr const char* batteryThreeQuarter = "\xEF\x89\x81"; + static constexpr const char* batteryHalf = "\xEF\x89\x82"; + static constexpr const char* batteryOneQuarter = "\xEF\x89\x83"; + static constexpr const char* heartBeat = "\xEF\x88\x9E"; + static constexpr const char* bluetoothFull = "\xEF\x8A\x93"; + static constexpr const char* bluetooth = "\xEF\x8A\x94"; + static constexpr const char* plug = "\xEF\x87\xA6"; + static constexpr const char* shoe = "\xEF\x95\x8B"; + static constexpr const char* clock = "\xEF\x80\x97"; + static constexpr const char* info = "\xEF\x84\xA9"; + static constexpr const char* list = "\xEF\x80\xBA"; + static constexpr const char* sun = "\xEF\x86\x85"; + static constexpr const char* check = "\xEF\x95\xA0"; + static constexpr const char* music = "\xEF\x80\x81"; + static constexpr const char* tachometer = "\xEF\x8F\xBD"; + static constexpr const char* asterisk = "\xEF\x81\xA9"; + static constexpr const char* paintbrush = "\xEF\x87\xBC"; + } + } + } +}
\ No newline at end of file diff --git a/src/displayapp/screens/SystemInfo.cpp b/src/displayapp/screens/SystemInfo.cpp new file mode 100644 index 00000000..867fdaeb --- /dev/null +++ b/src/displayapp/screens/SystemInfo.cpp @@ -0,0 +1,116 @@ +#include <libs/lvgl/lvgl.h> +#include <displayapp/DisplayApp.h> +#include <functional> +#include "SystemInfo.h" +#include "../../Version.h" +#include "Tile.h" + +using namespace Pinetime::Applications::Screens; + +SystemInfo::SystemInfo(Pinetime::Applications::DisplayApp *app, + Pinetime::Controllers::DateTime &dateTimeController, + Pinetime::Controllers::Battery& batteryController, + Pinetime::Controllers::BrightnessController& brightnessController, + Pinetime::Controllers::Ble& bleController, + Pinetime::Drivers::WatchdogView& watchdog) : + Screen(app), + dateTimeController{dateTimeController}, batteryController{batteryController}, + brightnessController{brightnessController}, bleController{bleController}, watchdog{watchdog}, + screens{app, { + [this]() -> std::unique_ptr<Screen> { return CreateScreen1(); }, + [this]() -> std::unique_ptr<Screen> { return CreateScreen2(); }, + [this]() -> std::unique_ptr<Screen> { return CreateScreen3(); } + } + } {} + + +SystemInfo::~SystemInfo() { + lv_obj_clean(lv_scr_act()); +} + +bool SystemInfo::Refresh() { + screens.Refresh(); + return running; +} + +bool SystemInfo::OnButtonPushed() { + running = false; + return true; +} + +bool SystemInfo::OnTouchEvent(Pinetime::Applications::TouchEvents event) { + return screens.OnTouchEvent(event); +} + +std::unique_ptr<Screen> SystemInfo::CreateScreen1() { + auto batteryPercentF = batteryController.PercentRemaining(); + uint16_t batteryPercent = 0; + if(batteryPercentF > 100.0f) batteryPercent = 100; + else if(batteryPercentF < 0.0f) batteryPercent = 0; + + uint8_t brightness = 0; + switch(brightnessController.Level()) { + case Controllers::BrightnessController::Levels::Off: brightness = 0; break; + case Controllers::BrightnessController::Levels::Low: brightness = 1; break; + case Controllers::BrightnessController::Levels::Medium: brightness = 2; break; + case Controllers::BrightnessController::Levels::High: brightness = 3; break; + } + auto resetReason = [this]() { + switch (watchdog.ResetReason()) { + case Drivers::Watchdog::ResetReasons::Watchdog: return "wtdg"; + case Drivers::Watchdog::ResetReasons::HardReset: return "hardr"; + case Drivers::Watchdog::ResetReasons::NFC: return "nfc"; + case Drivers::Watchdog::ResetReasons::SoftReset: return "softr"; + case Drivers::Watchdog::ResetReasons::CpuLockup: return "cpulock"; + case Drivers::Watchdog::ResetReasons::SystemOff: return "off"; + case Drivers::Watchdog::ResetReasons::LpComp: return "lpcomp"; + case Drivers::Watchdog::ResetReasons::DebugInterface: return "dbg"; + case Drivers::Watchdog::ResetReasons::ResetPin: return "rst"; + default: return "?"; + } + }(); + + // uptime + static constexpr uint32_t secondsInADay = 60*60*24; + static constexpr uint32_t secondsInAnHour = 60*60; + static constexpr uint32_t secondsInAMinute = 60; + uint32_t uptimeSeconds = dateTimeController.Uptime().count(); + uint32_t uptimeDays = (uptimeSeconds / secondsInADay); + uptimeSeconds = uptimeSeconds % secondsInADay; + uint32_t uptimeHours = uptimeSeconds / secondsInAnHour; + uptimeSeconds = uptimeSeconds % secondsInAnHour; + uint32_t uptimeMinutes = uptimeSeconds / secondsInAMinute; + uptimeSeconds = uptimeSeconds % secondsInAMinute; + // TODO handle more than 100 days of uptime + + sprintf(t1, "Pinetime\n" + "Version:%ld.%ld.%ld\n" + "Build: %s\n" + " %s\n" + "Date: %02d/%02d/%04d\n" + "Time: %02d:%02d:%02d\n" + "Uptime: %02lud %02lu:%02lu:%02lu\n" + "Battery: %d%%\n" + "Backlight: %d/3\n" + "Last reset: %s\n", + Version::Major(), Version::Minor(), Version::Patch(), + __DATE__, __TIME__, + dateTimeController.Day(), static_cast<uint8_t>(dateTimeController.Month()), dateTimeController.Year(), + dateTimeController.Hours(), dateTimeController.Minutes(), dateTimeController.Seconds(), + uptimeDays, uptimeHours, uptimeMinutes, uptimeSeconds, + batteryPercent, brightness, resetReason); + + return std::unique_ptr<Screen>(new Screens::Label(app, t1)); +} + +std::unique_ptr<Screen> SystemInfo::CreateScreen2() { + auto& bleAddr = bleController.Address(); + sprintf(t2, "BLE MAC: \n %02x:%02x:%02x:%02x:%02x:%02x", + bleAddr[5], bleAddr[4], bleAddr[3], bleAddr[2], bleAddr[1], bleAddr[0]); + return std::unique_ptr<Screen>(new Screens::Label(app, t2)); +} + +std::unique_ptr<Screen> SystemInfo::CreateScreen3() { + strncpy(t3, "Hello from\nthe developer!", 27); + return std::unique_ptr<Screen>(new Screens::Label(app, t3)); +} diff --git a/src/displayapp/screens/SystemInfo.h b/src/displayapp/screens/SystemInfo.h new file mode 100644 index 00000000..987a584b --- /dev/null +++ b/src/displayapp/screens/SystemInfo.h @@ -0,0 +1,48 @@ +#pragma once + +#include <functional> +#include <vector> + +#include "components/ble/NimbleController.h" +#include "Screen.h" +#include "Label.h" +#include "ScreenList.h" +#include "Gauge.h" +#include "Meter.h" + +namespace Pinetime { + namespace Applications { + namespace Screens { + class SystemInfo : public Screen { + public: + explicit SystemInfo(DisplayApp* app, + Pinetime::Controllers::DateTime& dateTimeController, + Pinetime::Controllers::Battery& batteryController, + Pinetime::Controllers::BrightnessController& brightnessController, + Pinetime::Controllers::Ble& bleController, + Pinetime::Drivers::WatchdogView& watchdog); + ~SystemInfo() override; + bool Refresh() override; + bool OnButtonPushed() override; + bool OnTouchEvent(TouchEvents event) override; + private: + bool running = true; + + Pinetime::Controllers::DateTime& dateTimeController; + Pinetime::Controllers::Battery& batteryController; + Pinetime::Controllers::BrightnessController& brightnessController; + Pinetime::Controllers::Ble& bleController; + Pinetime::Drivers::WatchdogView& watchdog; + + char t1[200]; + char t2[200]; + char t3[30]; + + ScreenList<3> screens; + std::unique_ptr<Screen> CreateScreen1(); + std::unique_ptr<Screen> CreateScreen2(); + std::unique_ptr<Screen> CreateScreen3(); + }; + } + } +}
\ No newline at end of file diff --git a/src/displayapp/screens/Tab.cpp b/src/displayapp/screens/Tab.cpp new file mode 100644 index 00000000..44b806c0 --- /dev/null +++ b/src/displayapp/screens/Tab.cpp @@ -0,0 +1,67 @@ +#include <cstdio> +#include <libs/date/includes/date/date.h> +#include "components/datetime/DateTimeController.h" +#include <Version.h> +#include <libs/lvgl/src/lv_core/lv_obj.h> +#include <libs/lvgl/src/lv_font/lv_font.h> +#include <libs/lvgl/lvgl.h> +#include <libraries/log/nrf_log.h> +#include "Tab.h" +#include "displayapp/DisplayApp.h" + + +using namespace Pinetime::Applications::Screens; + +extern lv_font_t jetbrains_mono_bold_20; + +//static void event_handler(lv_obj_t * obj, lv_event_t event) { +// Tile* screen = static_cast<Tile *>(obj->user_data); +// screen->OnObjectEvent(obj, event); +//} + +Tab::Tab(DisplayApp* app, Pinetime::Components::Gfx &gfx) : Screen(app, gfx) { +/*Create a Tab view object*/ + lv_obj_t *tabview; + tabview = lv_tabview_create(lv_scr_act(), NULL); + + /*Add 3 tabs (the tabs are page (lv_page) and can be scrolled*/ + lv_obj_t *tab1 = lv_tabview_add_tab(tabview, "Tab 1"); + lv_obj_t *tab2 = lv_tabview_add_tab(tabview, "Tab 2"); + lv_obj_t *tab3 = lv_tabview_add_tab(tabview, "Tab 3"); + + + /*Add content to the tabs*/ + lv_obj_t * label = lv_label_create(tab1, NULL); + lv_label_set_text(label, "This the first tab\n\n" + "If the content\n" + "of a tab\n" + "become too long\n" + "the it \n" + "automatically\n" + "become\n" + "scrollable."); + + label = lv_label_create(tab2, NULL); + lv_label_set_text(label, "Second tab"); + + label = lv_label_create(tab3, NULL); + lv_label_set_text(label, "Third tab"); + +} + +Tab::~Tab() { + lv_obj_clean(lv_scr_act()); +} + +void Tab::Refresh(bool fullRefresh) { + +} + +void Tab::OnObjectEvent(lv_obj_t *obj, lv_event_t event) { + if(event == LV_EVENT_CLICKED) { + NRF_LOG_INFO("Clicked"); + } + else if(event == LV_EVENT_VALUE_CHANGED) { + NRF_LOG_INFO("Toggled"); + } +} diff --git a/src/displayapp/screens/Tab.h b/src/displayapp/screens/Tab.h new file mode 100644 index 00000000..e16dbb96 --- /dev/null +++ b/src/displayapp/screens/Tab.h @@ -0,0 +1,23 @@ +#pragma once + +#include <cstdint> +#include "Screen.h" +#include <bits/unique_ptr.h> +#include <lvgl/src/lv_core/lv_style.h> + +namespace Pinetime { + namespace Applications { + namespace Screens { + class Tab : public Screen { + public: + explicit Tab(DisplayApp* app, Components::Gfx& gfx); + ~Tab() override; + void Refresh(bool fullRefresh) override; + void OnObjectEvent(lv_obj_t* obj, lv_event_t event); + + private: + + }; + } + } +} diff --git a/src/displayapp/screens/Tile.cpp b/src/displayapp/screens/Tile.cpp new file mode 100644 index 00000000..75fa6ef5 --- /dev/null +++ b/src/displayapp/screens/Tile.cpp @@ -0,0 +1,62 @@ +#include <libs/lvgl/src/lv_core/lv_obj.h> +#include <libs/lvgl/src/lv_font/lv_font.h> +#include <libs/lvgl/lvgl.h> + +#include "Tile.h" +#include "displayapp/DisplayApp.h" +#include "Symbols.h" +#include "../../Version.h" + +using namespace Pinetime::Applications::Screens; + +extern lv_font_t jetbrains_mono_bold_20; + +static void event_handler(lv_obj_t * obj, lv_event_t event) { + Tile* screen = static_cast<Tile *>(obj->user_data); + uint32_t* eventDataPtr = (uint32_t*) lv_event_get_data(); + uint32_t eventData = *eventDataPtr; + screen->OnObjectEvent(obj, event, eventData); +} + +Tile::Tile(DisplayApp* app, std::array<Applications, 6>& applications) : Screen(app) { + for(int i = 0, appIndex = 0; i < 8; i++) { + if(i == 3) btnm_map1[i] = "\n"; + else if(i == 7) btnm_map1[i] = ""; + else { + btnm_map1[i] = applications[appIndex].icon; + apps[appIndex] = applications[appIndex].application; + appIndex++; + } + } + modal.reset(new Modal(app)); + + btnm1 = lv_btnm_create(lv_scr_act(), nullptr); + lv_btnm_set_map(btnm1, btnm_map1); + lv_obj_set_size(btnm1, LV_HOR_RES, LV_VER_RES); + + btnm1->user_data = this; + lv_obj_set_event_cb(btnm1, event_handler); +} + +Tile::~Tile() { + lv_obj_clean(lv_scr_act()); +} + +bool Tile::Refresh() { + return running; +} + +void Tile::OnObjectEvent(lv_obj_t *obj, lv_event_t event, uint32_t buttonId) { + if(event == LV_EVENT_VALUE_CHANGED) { + app->StartApp(apps[buttonId]); + running = false; + } +} + +bool Tile::OnButtonPushed() { + app->StartApp(Apps::Clock); + running = false; + return true; +} + + diff --git a/src/displayapp/screens/Tile.h b/src/displayapp/screens/Tile.h new file mode 100644 index 00000000..cf5fcf15 --- /dev/null +++ b/src/displayapp/screens/Tile.h @@ -0,0 +1,39 @@ +#pragma once + +#include <cstdint> +#include "Screen.h" +#include <bits/unique_ptr.h> +#include "Modal.h" +#include <lvgl/src/lv_core/lv_style.h> +#include <displayapp/Apps.h> + +namespace Pinetime { + namespace Applications { + namespace Screens { + class Tile : public Screen { + public: + struct Applications { + const char* icon; + Pinetime::Applications::Apps application; + }; + + explicit Tile(DisplayApp* app, std::array<Applications, 6>& applications); + ~Tile() override; + + bool Refresh() override; + bool OnButtonPushed() override; + + void OnObjectEvent(lv_obj_t* obj, lv_event_t event, uint32_t buttonId); + + private: + lv_obj_t * btnm1; + bool running = true; + + std::unique_ptr<Modal> modal; + + const char* btnm_map1[8]; + Pinetime::Applications::Apps apps[6]; + }; + } + } +} |