From eb1dcb4743275171d79463229be3ca0e4d57ece2 Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Thu, 1 Jun 2023 19:13:33 -0500 Subject: [PATCH] lowercase method names --- .../lcd/extui/dgus_e3s1pro/DGUSDisplay.cpp | 68 +++--- .../src/lcd/extui/dgus_e3s1pro/DGUSDisplay.h | 56 ++--- .../dgus_e3s1pro/DGUSReturnKeyCodeHandler.cpp | 172 +++++++-------- .../lcd/extui/dgus_e3s1pro/DGUSRxHandler.cpp | 32 +-- .../lcd/extui/dgus_e3s1pro/DGUSRxHandler.h | 30 +-- .../DGUSSDCardHandler_Advanced.cpp | 4 +- .../dgus_e3s1pro/DGUSSDCardHandler_Basic.cpp | 2 +- .../extui/dgus_e3s1pro/DGUSScreenHandler.cpp | 208 +++++++++--------- .../extui/dgus_e3s1pro/DGUSScreenHandler.h | 100 ++++----- .../extui/dgus_e3s1pro/DGUSSetupHandler.cpp | 52 ++--- .../lcd/extui/dgus_e3s1pro/DGUSTxHandler.cpp | 126 +++++------ .../lcd/extui/dgus_e3s1pro/DGUSTxHandler.h | 95 ++++---- .../dgus_e3s1pro/definition/DGUS_VPList.cpp | 14 +- .../extui/dgus_e3s1pro/dgus_e3s1pro_extui.cpp | 52 ++--- 14 files changed, 505 insertions(+), 506 deletions(-) diff --git a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSDisplay.cpp b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSDisplay.cpp index 099b761dc90c..9759e518170e 100644 --- a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSDisplay.cpp +++ b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSDisplay.cpp @@ -50,36 +50,36 @@ uint8_t DGUSDisplay::rx_datagram_len = 0; bool DGUSDisplay::initialized = false; -void DGUSDisplay::Loop() { - ProcessRx(); +void DGUSDisplay::loop() { + processRx(); } -void DGUSDisplay::Init() { +void DGUSDisplay::init() { LCD_SERIAL.begin(LCD_BAUDRATE); - ReadVersions(); + readVersions(); } -void DGUSDisplay::Read(uint16_t addr, uint8_t size) { - WriteHeader(addr, DGUS_READVAR, size); +void DGUSDisplay::read(uint16_t addr, uint8_t size) { + writeHeader(addr, DGUS_READVAR, size); LCD_SERIAL.write(size); } -void DGUSDisplay::Write(uint16_t addr, const void* data_ptr, uint8_t size) { +void DGUSDisplay::write(uint16_t addr, const void* data_ptr, uint8_t size) { if (!data_ptr) return; - WriteHeader(addr, DGUS_WRITEVAR, size); + writeHeader(addr, DGUS_WRITEVAR, size); const char* data = static_cast(data_ptr); while (size--) LCD_SERIAL.write(*data++); } -void DGUSDisplay::WriteString(uint16_t addr, const void* data_ptr, uint8_t size, bool left, bool right, bool use_space) { +void DGUSDisplay::writeString(uint16_t addr, const void* data_ptr, uint8_t size, bool left, bool right, bool use_space) { if (!data_ptr) return; - WriteHeader(addr, DGUS_WRITEVAR, size); + writeHeader(addr, DGUS_WRITEVAR, size); const char* data = static_cast(data_ptr); size_t len = strlen(data); @@ -111,10 +111,10 @@ void DGUSDisplay::WriteString(uint16_t addr, const void* data_ptr, uint8_t size, while (right_spaces--) LCD_SERIAL.write(use_space ? ' ' : '\0'); } -void DGUSDisplay::WriteStringPGM(uint16_t addr, const void* data_ptr, uint8_t size, bool left, bool right, bool use_space) { +void DGUSDisplay::writeStringPGM(uint16_t addr, const void* data_ptr, uint8_t size, bool left, bool right, bool use_space) { if (!data_ptr) return; - WriteHeader(addr, DGUS_WRITEVAR, size); + writeHeader(addr, DGUS_WRITEVAR, size); const char* data = static_cast(data_ptr); size_t len = strlen_P(data); @@ -144,63 +144,63 @@ void DGUSDisplay::WriteStringPGM(uint16_t addr, const void* data_ptr, uint8_t si while (right_spaces--) LCD_SERIAL.write(use_space ? ' ' : '\0'); } -void DGUSDisplay::ReadVersions() { +void DGUSDisplay::readVersions() { if (gui_version != 0 && os_version != 0) return; - Read(DGUS_VERSION, 1); + read(DGUS_VERSION, 1); } -void DGUSDisplay::SwitchScreen(DGUS_Screen screen) { +void DGUSDisplay::switchScreen(DGUS_Screen screen) { const uint8_t command[] = { 0x5A, 0x01, 0x00, (uint8_t)screen }; - Write(0x84, command, sizeof(command)); + write(0x84, command, sizeof(command)); } -void DGUSDisplay::PlaySound(uint8_t start, uint8_t len, uint8_t volume) { +void DGUSDisplay::playSound(uint8_t start, uint8_t len, uint8_t volume) { if (volume == 0) volume = DGUSDisplay::volume; else volume = map_precise(constrain(volume, 0, 100), 0, 100, 0, 0x40); if (volume == 0) return; const uint8_t command[] = { start, len, volume, 0x00 }; - Write(0xA0, command, sizeof(command)); + write(0xA0, command, sizeof(command)); } -void DGUSDisplay::EnableControl(DGUS_Screen screen, DGUS_ControlType type, DGUS_Control control) { +void DGUSDisplay::enableControl(DGUS_Screen screen, DGUS_ControlType type, DGUS_Control control) { const uint8_t command[] = { 0x5A, 0xA5, 0x00, (uint8_t)screen, (uint8_t)control, type, 0x00, 0x01 }; - Write(0xB0, command, sizeof(command)); + write(0xB0, command, sizeof(command)); - FlushTx(); + flushTx(); delay(50); } -void DGUSDisplay::DisableControl(DGUS_Screen screen, DGUS_ControlType type, DGUS_Control control) { +void DGUSDisplay::disableControl(DGUS_Screen screen, DGUS_ControlType type, DGUS_Control control) { const uint8_t command[] = { 0x5A, 0xA5, 0x00, (uint8_t)screen, (uint8_t)control, type, 0x00, 0x00 }; - Write(0xB0, command, sizeof(command)); + write(0xB0, command, sizeof(command)); - FlushTx(); + flushTx(); delay(50); } -uint8_t DGUSDisplay::GetBrightness() { +uint8_t DGUSDisplay::getBrightness() { return brightness; } -uint8_t DGUSDisplay::GetVolume() { +uint8_t DGUSDisplay::getVolume() { return map_precise(volume, 0, 0x40, 0, 100); } -void DGUSDisplay::SetBrightness(uint8_t new_brightness) { +void DGUSDisplay::setBrightness(uint8_t new_brightness) { brightness = constrain(new_brightness, 0, 100); new_brightness = map_precise(brightness, 0, 100, 5, 100); const uint8_t command[] = { new_brightness, new_brightness }; - Write(0x82, command, sizeof(command)); + write(0x82, command, sizeof(command)); } -void DGUSDisplay::SetVolume(uint8_t new_volume) { +void DGUSDisplay::setVolume(uint8_t new_volume) { volume = map_precise(constrain(new_volume, 0, 100), 0, 100, 0, 0x40); const uint8_t command[] = { volume, 0x00 }; - Write(0xA1, command, sizeof(command)); + write(0xA1, command, sizeof(command)); } -void DGUSDisplay::ProcessRx() { +void DGUSDisplay::processRx() { #if ENABLED(LCD_SERIAL_STATS_RX_BUFFER_OVERRUNS) if (!LCD_SERIAL.available() && LCD_SERIAL.buffer_overruns()) { @@ -344,7 +344,7 @@ void DGUSDisplay::ProcessRx() { } } -size_t DGUSDisplay::GetFreeTxBuffer() { +size_t DGUSDisplay::getFreeTxBuffer() { return ( #ifdef LCD_SERIAL_GET_TX_BUFFER_FREE LCD_SERIAL_GET_TX_BUFFER_FREE() @@ -354,11 +354,11 @@ size_t DGUSDisplay::GetFreeTxBuffer() { ); } -void DGUSDisplay::FlushTx() { +void DGUSDisplay::flushTx() { TERN(ARDUINO_ARCH_STM32, LCD_SERIAL.flush(), LCD_SERIAL.flushTX()); } -void DGUSDisplay::WriteHeader(uint16_t addr, uint8_t command, uint8_t len) { +void DGUSDisplay::writeHeader(uint16_t addr, uint8_t command, uint8_t len) { LCD_SERIAL.write(DGUS_HEADER1); LCD_SERIAL.write(DGUS_HEADER2); LCD_SERIAL.write(len + 3); diff --git a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSDisplay.h b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSDisplay.h index 36fd6dc93769..5c080292c37a 100644 --- a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSDisplay.h +++ b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSDisplay.h @@ -61,58 +61,58 @@ class DGUSDisplay { DGUSDisplay() = default; - static void Init(); + static void init(); - static void Read(uint16_t addr, uint8_t size); - static void Write(uint16_t addr, const void* data_ptr, uint8_t size); + static void read(uint16_t addr, uint8_t size); + static void write(uint16_t addr, const void* data_ptr, uint8_t size); - static void WriteString(uint16_t addr, const void* data_ptr, uint8_t size, bool left=true, bool right=false, bool use_space=true); - static void WriteStringPGM(uint16_t addr, const void* data_ptr, uint8_t size, bool left=true, bool right=false, bool use_space=true); - static void WriteString(uint16_t addr, FSTR_P const fstr, uint8_t size, bool left=true, bool right=false, bool use_space=true) { - WriteStringPGM(addr, FTOP(fstr), size, left, right, use_space); + static void writeString(uint16_t addr, const void* data_ptr, uint8_t size, bool left=true, bool right=false, bool use_space=true); + static void writeStringPGM(uint16_t addr, const void* data_ptr, uint8_t size, bool left=true, bool right=false, bool use_space=true); + static void writeString(uint16_t addr, FSTR_P const fstr, uint8_t size, bool left=true, bool right=false, bool use_space=true) { + writeStringPGM(addr, FTOP(fstr), size, left, right, use_space); } template - static void Write(uint16_t addr, T data) { - Write(addr, static_cast(&data), sizeof(T)); + static void write(uint16_t addr, T data) { + write(addr, static_cast(&data), sizeof(T)); } // Until now I did not need to actively read from the display. That's why there is no ReadVariable // (I extensively use the auto upload of the display) // Read GUI and OS version from screen - static void ReadVersions(); + static void readVersions(); // Force display into another screen. - static void SwitchScreen(DGUS_Screen screen); + static void switchScreen(DGUS_Screen screen); // Play sounds using the display speaker. // start: position at which the sound was stored on the display. // len: how many sounds to play. Sounds will play consecutively from start to start+len-1. // volume: playback volume. 0 keeps the current volume. - static void PlaySound(uint8_t start, uint8_t len=1, uint8_t volume=0); + static void playSound(uint8_t start, uint8_t len=1, uint8_t volume=0); // Enable/disable a specific touch control. // type: control type. // control: index of the control on the page (set during screen development). - static void EnableControl(DGUS_Screen screen, DGUS_ControlType type, DGUS_Control control); - static void DisableControl(DGUS_Screen screen, DGUS_ControlType type, DGUS_Control control); + static void enableControl(DGUS_Screen screen, DGUS_ControlType type, DGUS_Control control); + static void disableControl(DGUS_Screen screen, DGUS_ControlType type, DGUS_Control control); - static uint8_t GetBrightness(); - static uint8_t GetVolume(); + static uint8_t getBrightness(); + static uint8_t getVolume(); // Set the display brightness/volume, ranging 0 - 100 - static void SetBrightness(uint8_t brightness); - static void SetVolume(uint8_t volume); + static void setBrightness(uint8_t brightness); + static void setVolume(uint8_t volume); // Periodic tasks, eg. Rx-Queue handling. - static void Loop(); + static void loop(); // Helper for users of this class to estimate if an interaction would be blocking. - static size_t GetFreeTxBuffer(); - static void FlushTx(); + static size_t getFreeTxBuffer(); + static void flushTx(); // Checks two things: Can we confirm the presence of the display and has we initialized it. // (both boils down that the display answered to our chatting) - static bool IsInitialized() { + static bool isInitialized() { return initialized; } @@ -120,7 +120,7 @@ class DGUSDisplay { static uint8_t os_version; template - static T SwapBytes(const T value) { + static T swapBytes(const T value) { union { T val; char byte[sizeof(T)]; @@ -132,12 +132,12 @@ class DGUSDisplay { } template - T_out FromFixedPoint(const T_in value) { + T_out fromFixedPoint(const T_in value) { return (T_out)((float)value / POW(10, decimals)); } template - T_out ToFixedPoint(const T_in value) { + T_out toFixedPoint(const T_in value) { return (T_out)LROUND((float)value * POW(10, decimals)); } @@ -163,8 +163,8 @@ class DGUSDisplay { DGUS_VERSION = 0x000F // OS/GUI version }; - static void WriteHeader(uint16_t addr, uint8_t command, uint8_t len); - static void ProcessRx(); + static void writeHeader(uint16_t addr, uint8_t command, uint8_t len); + static void processRx(); static uint8_t volume; static uint8_t brightness; @@ -175,7 +175,7 @@ class DGUSDisplay { static bool initialized; }; -template<> inline uint16_t DGUSDisplay::SwapBytes(const uint16_t value) { +template<> inline uint16_t DGUSDisplay::swapBytes(const uint16_t value) { return ((value << 8) | (value >> 8)); } diff --git a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSReturnKeyCodeHandler.cpp b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSReturnKeyCodeHandler.cpp index c26aeed48d0e..748aa2d692f3 100644 --- a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSReturnKeyCodeHandler.cpp +++ b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSReturnKeyCodeHandler.cpp @@ -50,7 +50,7 @@ static uint16_t absBedTempSave = 0; static DGUS_Screen GetJogScreenForSavedJogLength() { DGUS_Screen jogscreen = DGUS_Screen::MOVEAXIS_10; - switch (dgus_screen_handler.config.jogLength) { + switch (screen.config.jogLength) { case DGUS_Data::AxisControlCommand::Jog_10mm: jogscreen = DGUS_Screen::MOVEAXIS_10; break; @@ -73,47 +73,47 @@ void DGUSReturnKeyCodeHandler::Command_MenuSelect(DGUS_VP &vp, void *data) { switch (submenu) { case DGUS_Data::MenuSelectCommand::Main: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::MAIN); + screen.triggerScreenChange(DGUS_Screen::MAIN); break; case DGUS_Data::MenuSelectCommand::Print: if (ExtUI::isMediaInserted()) { dgus_sdcard_handler.Reset(); - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::FILE1); + screen.triggerScreenChange(DGUS_Screen::FILE1); } else - dgus_screen_handler.TriggerTempScreenChange(DGUS_Screen::SDCARDCHECK, dgus_screen_handler.GetCurrentScreen()); + screen.triggerTempScreenChange(DGUS_Screen::SDCARDCHECK, screen.getCurrentScreen()); break; case DGUS_Data::MenuSelectCommand::Ready: { DGUS_Screen jogscreen = GetJogScreenForSavedJogLength(); if (ExtUI::isPositionKnown()) - dgus_screen_handler.TriggerScreenChange(jogscreen); + screen.triggerScreenChange(jogscreen); else - dgus_screen_handler.HomeThenChangeScreen(jogscreen); + screen.homeThenChangeScreen(jogscreen); } break; case DGUS_Data::MenuSelectCommand::Settings: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::TEMP); + screen.triggerScreenChange(DGUS_Screen::TEMP); break; case DGUS_Data::MenuSelectCommand::StartAutoLevel: if (!ExtUI::isPositionKnown()) - dgus_screen_handler.HomeThenChangeScreen(dgus_screen_handler.GetCurrentScreen()); + screen.homeThenChangeScreen(screen.getCurrentScreen()); ExtUI::injectCommands(F("M420 S0\n" TERN(AUTO_BED_LEVELING_UBL, "G29 P1", "G29"))); break; case DGUS_Data::MenuSelectCommand::PrintFinished: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::HOME); + screen.triggerScreenChange(DGUS_Screen::HOME); break; case DGUS_Data::MenuSelectCommand::PausePrint: - dgus_screen_handler.TriggerTempScreenChange(DGUS_Screen::PAUSE_STOP, DGUS_Screen::PAUSE); + screen.triggerTempScreenChange(DGUS_Screen::PAUSE_STOP, DGUS_Screen::PAUSE); break; case DGUS_Data::MenuSelectCommand::PauseStopPrint: - dgus_screen_handler.TriggerTempScreenChange(DGUS_Screen::CONTINUE_STOP, DGUS_Screen::RESUME); + screen.triggerTempScreenChange(DGUS_Screen::CONTINUE_STOP, DGUS_Screen::RESUME); break; default: @@ -131,19 +131,19 @@ void DGUSReturnKeyCodeHandler::Command_Adjust(DGUS_VP &vp, void *data) { switch (command) { case DGUS_Data::AdjustCommand::Show_Adjust: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::ADJUST); + screen.triggerScreenChange(DGUS_Screen::ADJUST); break; case DGUS_Data::AdjustCommand::Show_PrintStatus: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::PAUSE); + screen.triggerScreenChange(DGUS_Screen::PAUSE); break; case DGUS_Data::AdjustCommand::Show_Adjust_ZOffset: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::PREPARE); + screen.triggerScreenChange(DGUS_Screen::PREPARE); break; case DGUS_Data::AdjustCommand::Validate_ZOffset: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::ADJUST); + screen.triggerScreenChange(DGUS_Screen::ADJUST); break; default: @@ -169,12 +169,12 @@ void DGUSReturnKeyCodeHandler::Command_CheckKO(DGUS_VP &vp, void *data) { return; } - switch (dgus_screen_handler.GetCurrentScreen()) { + switch (screen.getCurrentScreen()) { case DGUS_Screen::CONTINUE_STOP: case DGUS_Screen::STOP_CONFIRM: case DGUS_Screen::PAUSE_STOP: ExtUI::stopPrint(); - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::FINISH); + screen.triggerScreenChange(DGUS_Screen::FINISH); break; case DGUS_Screen::FILAMENTUSEUP: @@ -185,13 +185,13 @@ void DGUSReturnKeyCodeHandler::Command_CheckKO(DGUS_VP &vp, void *data) { default: #ifdef DEBUG_DGUSLCD - DEBUG_ECHOPGM("Command_CheckKO: unknown src screen "); DEBUG_DECIMAL((uint8_t)dgus_screen_handler.GetCurrentScreen()); + DEBUG_ECHOPGM("Command_CheckKO: unknown src screen "); DEBUG_DECIMAL((uint8_t)screen.getCurrentScreen()); DEBUG_EOL(); #endif return; } - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::HOME); + screen.triggerScreenChange(DGUS_Screen::HOME); } // 100A @@ -201,7 +201,7 @@ void DGUSReturnKeyCodeHandler::Command_StopPause(DGUS_VP &vp, void *data) { switch (command) { case DGUS_Data::StopPauseCommand::Pause: ExtUI::pausePrint(); - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::RESUME); + screen.triggerScreenChange(DGUS_Screen::RESUME); break; default: @@ -220,7 +220,7 @@ void DGUSReturnKeyCodeHandler::Command_CheckOK(DGUS_VP &vp, void *data) { switch (command) { case DGUS_Data::CheckOKCommand::ContinueStop_Continue: ExtUI::resumePrint(); - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::PAUSE); + screen.triggerScreenChange(DGUS_Screen::PAUSE); break; #if HAS_FILAMENT_SENSOR @@ -229,14 +229,14 @@ void DGUSReturnKeyCodeHandler::Command_CheckOK(DGUS_VP &vp, void *data) { ExtUI::setTargetTemp_celsius(EXTRUDE_MINTEMP, ExtUI::E0); if (ExtUI::getFilamentRunoutEnabled() && ExtUI::getFilamentRunoutState()) - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::FILAMENTUSEUP); + screen.triggerScreenChange(DGUS_Screen::FILAMENTUSEUP); else - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::FILAMENTLOAD); + screen.triggerScreenChange(DGUS_Screen::FILAMENTLOAD); break; case DGUS_Data::CheckOKCommand::FilamentLoad_Yes: if (ExtUI::getFilamentRunoutEnabled() && ExtUI::getFilamentRunoutState()) - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::FILAMENTLOAD); + screen.triggerScreenChange(DGUS_Screen::FILAMENTLOAD); else { ExtUI::resumePrint(); } @@ -246,7 +246,7 @@ void DGUSReturnKeyCodeHandler::Command_CheckOK(DGUS_VP &vp, void *data) { case DGUS_Data::CheckOKCommand::SDCardCheck_Yes: if (ExtUI::isMediaInserted()) { dgus_sdcard_handler.Reset(); - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::FILE1); + screen.triggerScreenChange(DGUS_Screen::FILE1); } break; @@ -265,33 +265,33 @@ void DGUSReturnKeyCodeHandler::Command_PresetControl(DGUS_VP &vp, void *data) { switch (command) { case DGUS_Data::PresetControlCommand::Show_Ready_Manual: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::CONTROL); + screen.triggerScreenChange(DGUS_Screen::CONTROL); break; case DGUS_Data::PresetControlCommand::Show_Settings_PLA_Settings: - plaExtruderTempSave = dgus_screen_handler.config.plaExtruderTemp; - plaBedTempSave = dgus_screen_handler.config.plaBedTemp; - absExtruderTempSave = dgus_screen_handler.config.absExtruderTemp; - absBedTempSave = dgus_screen_handler.config.absBedTemp; - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::PLA_TEMP); + plaExtruderTempSave = screen.config.plaExtruderTemp; + plaBedTempSave = screen.config.plaBedTemp; + absExtruderTempSave = screen.config.absExtruderTemp; + absBedTempSave = screen.config.absBedTemp; + screen.triggerScreenChange(DGUS_Screen::PLA_TEMP); break; case DGUS_Data::PresetControlCommand::Show_Settings_ABS_Settings: - plaExtruderTempSave = dgus_screen_handler.config.plaExtruderTemp; - plaBedTempSave = dgus_screen_handler.config.plaBedTemp; - absExtruderTempSave = dgus_screen_handler.config.absExtruderTemp; - absBedTempSave = dgus_screen_handler.config.absBedTemp; - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::ABS_TEMP); + plaExtruderTempSave = screen.config.plaExtruderTemp; + plaBedTempSave = screen.config.plaBedTemp; + absExtruderTempSave = screen.config.absExtruderTemp; + absBedTempSave = screen.config.absBedTemp; + screen.triggerScreenChange(DGUS_Screen::ABS_TEMP); break; case DGUS_Data::PresetControlCommand::Apply_PLA_Settings: - ExtUI::setTargetTemp_celsius(dgus_screen_handler.config.plaExtruderTemp, ExtUI::E0); - ExtUI::setTargetTemp_celsius(dgus_screen_handler.config.plaBedTemp, ExtUI::BED); + ExtUI::setTargetTemp_celsius(screen.config.plaExtruderTemp, ExtUI::E0); + ExtUI::setTargetTemp_celsius(screen.config.plaBedTemp, ExtUI::BED); break; case DGUS_Data::PresetControlCommand::Apply_ABS_Settings: - ExtUI::setTargetTemp_celsius(dgus_screen_handler.config.absExtruderTemp, ExtUI::E0); - ExtUI::setTargetTemp_celsius(dgus_screen_handler.config.absBedTemp, ExtUI::BED); + ExtUI::setTargetTemp_celsius(screen.config.absExtruderTemp, ExtUI::E0); + ExtUI::setTargetTemp_celsius(screen.config.absBedTemp, ExtUI::BED); break; default: @@ -313,11 +313,11 @@ void DGUSReturnKeyCodeHandler::Control_TemperatureCommand(DGUS_VP &vp, void *dat break; case DGUS_Data::TemperatureControlCommand::Exit_Temperature_Preset_And_Discard_Temperature: - dgus_screen_handler.config.plaExtruderTemp = plaExtruderTempSave; - dgus_screen_handler.config.plaBedTemp = plaBedTempSave; - dgus_screen_handler.config.absExtruderTemp = absExtruderTempSave; - dgus_screen_handler.config.absBedTemp = absBedTempSave; - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::TEMP); + screen.config.plaExtruderTemp = plaExtruderTempSave; + screen.config.plaBedTemp = plaBedTempSave; + screen.config.absExtruderTemp = absExtruderTempSave; + screen.config.absBedTemp = absBedTempSave; + screen.triggerScreenChange(DGUS_Screen::TEMP); break; default: @@ -343,53 +343,53 @@ void DGUSReturnKeyCodeHandler::Command_SettingsMenu(DGUS_VP &vp, void *data) { } break; case DGUS_Data::SettingsMenuCommand::Reset_All_Settings: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::FACTORYRESET_CONFIRM); + screen.triggerScreenChange(DGUS_Screen::FACTORYRESET_CONFIRM); break; case DGUS_Data::SettingsMenuCommand::FactoryReset_Validate: ExtUI::injectCommands(F("M502")); case DGUS_Data::SettingsMenuCommand::FactoryReset_Cancel: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::CONTROL_DEVICE); + screen.triggerScreenChange(DGUS_Screen::CONTROL_DEVICE); break; case DGUS_Data::SettingsMenuCommand::Show_Settings_Device_and_Save_Temperatures: - dgus_screen_handler.TriggerEEPROMSave(); - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::TEMP); + screen.triggerEEPROMSave(); + screen.triggerScreenChange(DGUS_Screen::TEMP); break; case DGUS_Data::SettingsMenuCommand::Show_Settings_Device_and_Discard_Temperatures: - dgus_screen_handler.config.plaExtruderTemp = plaExtruderTempSave; - dgus_screen_handler.config.plaBedTemp = plaBedTempSave; - dgus_screen_handler.config.absExtruderTemp = absExtruderTempSave; - dgus_screen_handler.config.absBedTemp = absBedTempSave; - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::TEMP); + screen.config.plaExtruderTemp = plaExtruderTempSave; + screen.config.plaBedTemp = plaBedTempSave; + screen.config.absExtruderTemp = absExtruderTempSave; + screen.config.absBedTemp = absBedTempSave; + screen.triggerScreenChange(DGUS_Screen::TEMP); break; case DGUS_Data::SettingsMenuCommand::Show_Settings_Device_Language: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::LANGUAGE); + screen.triggerScreenChange(DGUS_Screen::LANGUAGE); break; case DGUS_Data::SettingsMenuCommand::Show_Settings_About: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::INFORMATION); + screen.triggerScreenChange(DGUS_Screen::INFORMATION); break; case DGUS_Data::SettingsMenuCommand::Show_Settings_Advanced: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::CONTROL_DEVICE); + screen.triggerScreenChange(DGUS_Screen::CONTROL_DEVICE); break; case DGUS_Data::SettingsMenuCommand::Show_Ready_Jog: - dgus_screen_handler.TriggerScreenChange(GetJogScreenForSavedJogLength()); + screen.triggerScreenChange(GetJogScreenForSavedJogLength()); break; case DGUS_Data::SettingsMenuCommand::Exit_Settings_Tramming: - dgus_screen_handler.TriggerEEPROMSave(); - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::TEMP); + screen.triggerEEPROMSave(); + screen.triggerScreenChange(DGUS_Screen::TEMP); break; case DGUS_Data::SettingsMenuCommand::Exit_Settings_Leveling: - dgus_screen_handler.TriggerEEPROMSave(); - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::TEMP); + screen.triggerEEPROMSave(); + screen.triggerScreenChange(DGUS_Screen::TEMP); break; default: @@ -445,13 +445,13 @@ void DGUSReturnKeyCodeHandler::Command_Leveling(DGUS_VP &vp, void *data) { switch (command) { case DGUS_Data::LevelingCommand::Show_AuxLeveling: if (ExtUI::isPositionKnown()) - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::LEVELINGMODE); + screen.triggerScreenChange(DGUS_Screen::LEVELINGMODE); _GotoTrammingPoint(1); break; case DGUS_Data::LevelingCommand::Show_Settings_Leveling: case DGUS_Data::LevelingCommand::Show_AutoLeveling: - dgus_screen_handler.HomeThenChangeScreen(DGUS_Screen::LEVELING); + screen.homeThenChangeScreen(DGUS_Screen::LEVELING); break; case DGUS_Data::LevelingCommand::Goto_Center: @@ -491,7 +491,7 @@ void DGUSReturnKeyCodeHandler::Command_AxisControl(DGUS_VP &vp, void *data) { case DGUS_Data::AxisControlCommand::Jog_10mm: case DGUS_Data::AxisControlCommand::Jog_1mm: case DGUS_Data::AxisControlCommand::Jog_0_1mm: - dgus_screen_handler.config.jogLength = control; + screen.config.jogLength = control; break; case DGUS_Data::AxisControlCommand::Home_XY: @@ -517,7 +517,7 @@ void DGUSReturnKeyCodeHandler::Command_AxisIO(DGUS_VP &vp, void *data) { switch (command) { case DGUS_Data::AxisIoCommand::Show_Ready_IO: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::FEEDRETURN); + screen.triggerScreenChange(DGUS_Screen::FEEDRETURN); break; default: @@ -535,39 +535,39 @@ void DGUSReturnKeyCodeHandler::Command_AdvancedSettings(DGUS_VP &vp, void *data) switch (command) { case DGUS_Data::AdvancedSettingsCommand::Show_AdvSettings_Movement: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::MOTION); + screen.triggerScreenChange(DGUS_Screen::MOTION); break; case DGUS_Data::AdvancedSettingsCommand::Show_AdvSettings_PID: #if !ENABLED(PIDTEMP) && !ENABLED(PIDBEDTEMP) - dgus_screen_handler.AngryBeeps(2); + screen.angryBeeps(2); #else - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::PIDCONTROL); + screen.triggerScreenChange(DGUS_Screen::PIDCONTROL); #endif break; case DGUS_Data::AdvancedSettingsCommand::Show_AdvSettings_Movement_MaxFeedrate: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::MAX_FEEDRATE); + screen.triggerScreenChange(DGUS_Screen::MAX_FEEDRATE); break; case DGUS_Data::AdvancedSettingsCommand::Show_AdvSettings_Movement_Acceleration: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::ACCELERATION); + screen.triggerScreenChange(DGUS_Screen::ACCELERATION); break; case DGUS_Data::AdvancedSettingsCommand::Show_AdvSettings_Movement_Jerk: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::JERK); + screen.triggerScreenChange(DGUS_Screen::JERK); break; case DGUS_Data::AdvancedSettingsCommand::Show_AdvSettings_Movement_StepsPerMm: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::STEPSMM); + screen.triggerScreenChange(DGUS_Screen::STEPSMM); break; case DGUS_Data::AdvancedSettingsCommand::Exit_AdvSettings_Movement_Submenu: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::MOTION); + screen.triggerScreenChange(DGUS_Screen::MOTION); break; case DGUS_Data::AdvancedSettingsCommand::Show_AdvSettings: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::CONTROL_DEVICE); + screen.triggerScreenChange(DGUS_Screen::CONTROL_DEVICE); break; default: @@ -586,12 +586,12 @@ void DGUSReturnKeyCodeHandler::Command_FilelistControl(DGUS_VP &vp, void *data) switch (control) { case DGUS_Data::FilelistControlCommand::Start_Print: - if (!dgus_screen_handler.GetSDCardPrintFilename()[0]) { - dgus_screen_handler.TriggerTempScreenChange(DGUS_Screen::PAUSE_STOP, DGUS_Screen::PAUSE); + if (!screen.getSDCardPrintFilename()[0]) { + screen.triggerTempScreenChange(DGUS_Screen::PAUSE_STOP, DGUS_Screen::PAUSE); } - ExtUI::printFile(dgus_screen_handler.GetSDCardPrintFilename()); - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::PAUSE); + ExtUI::printFile(screen.getSDCardPrintFilename()); + screen.triggerScreenChange(DGUS_Screen::PAUSE); return; case DGUS_Data::FilelistControlCommand::F1_Up: @@ -624,7 +624,7 @@ void DGUSReturnKeyCodeHandler::Command_FilelistControl(DGUS_VP &vp, void *data) return; } - dgus_screen_handler.TriggerScreenChange(DGUS_PAGE_TO_SCREEN(newPage)); + screen.triggerScreenChange(DGUS_PAGE_TO_SCREEN(newPage)); } // 2201 @@ -633,27 +633,27 @@ void DGUSReturnKeyCodeHandler::Command_LaserControl(DGUS_VP &vp, void *data) { switch (control) { case DGUS_Data::LaserControlCommand::Mode_FDM: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::SW_FDM_TIPS); + screen.triggerScreenChange(DGUS_Screen::SW_FDM_TIPS); break; case DGUS_Data::LaserControlCommand::Mode_FDM_Confirm: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::SW_FDM_TIPS); + screen.triggerScreenChange(DGUS_Screen::SW_FDM_TIPS); break; #if HAS_CUTTER case DGUS_Data::LaserControlCommand::Mode_Cutter: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::SW_LASER_TIPS); + screen.triggerScreenChange(DGUS_Screen::SW_LASER_TIPS); break; case DGUS_Data::LaserControlCommand::Mode_Cutter_Confirm: - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::SW_LASER_TIPS); + screen.triggerScreenChange(DGUS_Screen::SW_LASER_TIPS); break; #endif case DGUS_Data::LaserControlCommand::Mode_Change: #if HAS_CUTTER - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::LASER_FDM); + screen.triggerScreenChange(DGUS_Screen::LASER_FDM); #else - dgus_screen_handler.AngryBeeps(2); + screen.angryBeeps(2); #endif default: diff --git a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSRxHandler.cpp b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSRxHandler.cpp index 06a9490a0795..df4471fdc67e 100644 --- a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSRxHandler.cpp +++ b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSRxHandler.cpp @@ -33,12 +33,12 @@ #include "../../../core/language.h" #include "../../../module/stepper.h" -void DGUSRxHandler::PrintSpeedPercentage(DGUS_VP &vp, void *data) { +void DGUSRxHandler::printSpeedPercentage(DGUS_VP &vp, void *data) { const_float_t feedratePercentage = dgus_display.FromFixedPoint(BE16_P(data)); ExtUI::setFeedrate_percent(feedratePercentage); } -void DGUSRxHandler::ZOffset(DGUS_VP &vp, void *data) { +void DGUSRxHandler::zOffset(DGUS_VP &vp, void *data) { const_float_t zoffset = dgus_display.FromFixedPoint(BE16_P(data)); const_float_t currentzOffset = ExtUI::getZOffset_mm(); const_float_t zStepsPerMm = ExtUI::getAxisSteps_per_mm(ExtUI::Z); @@ -48,27 +48,27 @@ void DGUSRxHandler::ZOffset(DGUS_VP &vp, void *data) { ExtUI::setZOffset_mm(zoffset); } -void DGUSRxHandler::ExtruderTargetTemp(DGUS_VP &vp, void *data) { +void DGUSRxHandler::extruderTargetTemp(DGUS_VP &vp, void *data) { const_float_t temperature = BE16_P(data); ExtUI::setTargetTemp_celsius(temperature, ExtUI::H0); } -void DGUSRxHandler::BedTargetTemp(DGUS_VP &vp, void *data) { +void DGUSRxHandler::bedTargetTemp(DGUS_VP &vp, void *data) { const_float_t temperature = BE16_P(data); ExtUI::setTargetTemp_celsius(temperature, ExtUI::BED); } -void DGUSRxHandler::Axis_X(DGUS_VP &vp, void *data) { +void DGUSRxHandler::axis_X(DGUS_VP &vp, void *data) { const_float_t axisValue = dgus_display.FromFixedPoint(BE16_P(data)); ExtUI::setAxisPosition_mm(axisValue, ExtUI::X); } -void DGUSRxHandler::Axis_Y(DGUS_VP &vp, void *data) { +void DGUSRxHandler::axis_Y(DGUS_VP &vp, void *data) { const_float_t axisValue = dgus_display.FromFixedPoint(BE16_P(data)); ExtUI::setAxisPosition_mm(axisValue, ExtUI::Y); } -void DGUSRxHandler::Axis_Z(DGUS_VP &vp, void *data) { +void DGUSRxHandler::axis_Z(DGUS_VP &vp, void *data) { const_float_t axisValue = dgus_display.FromFixedPoint(BE16_P(data)); ExtUI::setAxisPosition_mm(axisValue, ExtUI::Z); } @@ -87,13 +87,13 @@ void DGUSRxHandler::RetractLength(DGUS_VP &vp, void *data) { void DGUSRxHandler::Language_SetLanguage(DGUS_VP &vp, void *data) { DGUS_Data::Language language = (DGUS_Data::Language)BE16_P(data); - dgus_screen_handler.config.language = language; - dgus_screen_handler.TriggerEEPROMSave(); - dgus_screen_handler.TriggerFullUpdate(); + screen.config.language = language; + screen.triggerEEPROMSave(); + screen.triggerFullUpdate(); } #if ENABLED(PIDTEMPBED) - void DGUSRxHandler::Bed_PID_P(DGUS_VP &vp, void *data) { + void DGUSRxHandler::bed_PID_P(DGUS_VP &vp, void *data) { float pidValue = dgus_display.FromFixedPoint(BE16_P(data)); ExtUI::setBedPID( pidValue, @@ -102,7 +102,7 @@ void DGUSRxHandler::Language_SetLanguage(DGUS_VP &vp, void *data) { ); } - void DGUSRxHandler::Bed_PID_I(DGUS_VP &vp, void *data) { + void DGUSRxHandler::bed_PID_I(DGUS_VP &vp, void *data) { float pidValue = dgus_display.FromFixedPoint(BE16_P(data)); ExtUI::setBedPID( ExtUI::getBedPID_Kp(), @@ -111,7 +111,7 @@ void DGUSRxHandler::Language_SetLanguage(DGUS_VP &vp, void *data) { ); } - void DGUSRxHandler::Bed_PID_D(DGUS_VP &vp, void *data) { + void DGUSRxHandler::bed_PID_D(DGUS_VP &vp, void *data) { float pidValue = dgus_display.FromFixedPoint(BE16_P(data)); ExtUI::setBedPID( ExtUI::getBedPID_Kp(), @@ -130,8 +130,8 @@ void DGUSRxHandler::SDCard_FileSelection(DGUS_VP &vp, void *data) { uint8_t sdFileIndex = BE16_P(data) - 1; #if ENABLED(DGUS_USERCONFIRM) - if (dgus_screen_handler.IsOnUserConfirmationScreen()) { - dgus_screen_handler.UserConfirmation(); + if (screen.isOnUserConfirmationScreen()) { + screen.userConfirmation(); return; } #endif @@ -146,7 +146,7 @@ void DGUSRxHandler::StringToExtra(DGUS_VP &vp, void *data_ptr) { void DGUSRxHandler::Disabled(DGUS_VP &vp, void *data_ptr) { UNUSED(vp); UNUSED(data_ptr); - dgus_screen_handler.AngryBeeps(2); + screen.angryBeeps(2); } #endif // DGUS_LCD_UI_RELOADED diff --git a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSRxHandler.h b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSRxHandler.h index 364e42174c12..6dcdde72ae31 100644 --- a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSRxHandler.h +++ b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSRxHandler.h @@ -25,34 +25,34 @@ #include "definition/DGUS_VP.h" namespace DGUSRxHandler { - void PrintSpeedPercentage(DGUS_VP &vp, void *data); - void ZOffset(DGUS_VP &vp, void *data); - void ExtruderTargetTemp(DGUS_VP &vp, void *data); - void BedTargetTemp(DGUS_VP &vp, void *data); - void Axis_X(DGUS_VP &vp, void *data); - void Axis_Y(DGUS_VP &vp, void *data); - void Axis_Z(DGUS_VP &vp, void *data); + void printSpeedPercentage(DGUS_VP &vp, void *data); + void zOffset(DGUS_VP &vp, void *data); + void extruderTargetTemp(DGUS_VP &vp, void *data); + void bedTargetTemp(DGUS_VP &vp, void *data); + void axis_X(DGUS_VP &vp, void *data); + void axis_Y(DGUS_VP &vp, void *data); + void axis_Z(DGUS_VP &vp, void *data); void ExtrudeLength(DGUS_VP &vp, void *data); void RetractLength(DGUS_VP &vp, void *data); void Language_SetLanguage(DGUS_VP &vp, void *data); template - void MaxFeedrate(DGUS_VP &vp, void *data) { + void maxFeedrate(DGUS_VP &vp, void *data) { feedRate_t maxSpeed = (float)BE16_P(data); ExtUI::setAxisMaxFeedrate_mm_s(maxSpeed, axis); } template - void MaxAcceleration(DGUS_VP &vp, void *data) { + void maxAcceleration(DGUS_VP &vp, void *data) { float maxAcceleration = (float)BE16_P(data); ExtUI::setAxisMaxAcceleration_mm_s2(maxAcceleration, axis); } template - void MaxJerk(DGUS_VP &vp, void *data) { + void maxJerk(DGUS_VP &vp, void *data) { float maxJerk = dgus_display.FromFixedPoint(BE16_P(data)); ExtUI::setAxisMaxJerk_mm_s(maxJerk, axis); } template - void StepsPerMm(DGUS_VP &vp, void *data) { + void stepsPerMM(DGUS_VP &vp, void *data) { float stepsPerMm = dgus_display.FromFixedPoint(BE16_P(data)); ExtUI::setAxisSteps_per_mm(stepsPerMm, axis); } @@ -91,9 +91,9 @@ namespace DGUSRxHandler { #endif // PIDTEMP #if ENABLED(PIDTEMPBED) - void Bed_PID_P(DGUS_VP &vp, void *data); - void Bed_PID_I(DGUS_VP &vp, void *data); - void Bed_PID_D(DGUS_VP &vp, void *data); + void bed_PID_P(DGUS_VP &vp, void *data); + void bed_PID_I(DGUS_VP &vp, void *data); + void bed_PID_D(DGUS_VP &vp, void *data); #endif void Control_SetFanSpeed(DGUS_VP &vp, void *data); @@ -118,7 +118,7 @@ namespace DGUSRxHandler { break; } case 4: { - const uint32_t data = dgus_display.SwapBytes(*(uint32_t*)data_ptr); + const uint32_t data = dgus_display.swapBytes(*(uint32_t*)data_ptr); *(T*)vp.extra = (T)data; break; } diff --git a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSDCardHandler_Advanced.cpp b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSDCardHandler_Advanced.cpp index 79076b18f8ba..ad5bec3eae11 100644 --- a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSDCardHandler_Advanced.cpp +++ b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSDCardHandler_Advanced.cpp @@ -102,11 +102,11 @@ bool DGUS_SDCardHandler::onFileSelect(DGUS_SDCardHandler::file_t file) { if (currentPage == page_t::PAGE_1) onPageLoad(page_t::PAGE_1); else - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::FILE1); + screen.triggerScreenChange(DGUS_Screen::FILE1); return true; } - dgus_screen_handler.StartPrintFromSD(filenames[fileIndex]); + screen.startPrintFromSD(filenames[fileIndex]); return true; } diff --git a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSDCardHandler_Basic.cpp b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSDCardHandler_Basic.cpp index a905a7d107a1..5972935e02b2 100644 --- a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSDCardHandler_Basic.cpp +++ b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSDCardHandler_Basic.cpp @@ -114,7 +114,7 @@ bool DGUS_SDCardHandler::onFileSelect(DGUS_SDCardHandler::file_t file) { if (!filenames[fileIndex][0]) return false; - dgus_screen_handler.StartPrintFromSD(filenames[fileIndex]); + screen.startPrintFromSD(filenames[fileIndex]); return true; } diff --git a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSScreenHandler.cpp b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSScreenHandler.cpp index a3357deabcfd..1dc46c222f29 100644 --- a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSScreenHandler.cpp +++ b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSScreenHandler.cpp @@ -58,16 +58,16 @@ bool DGUSScreenHandler::isLeveling = false; millis_t DGUSScreenHandler::status_expire = 0; millis_t DGUSScreenHandler::eeprom_save = 0; -void DGUSScreenHandler::Init() { - dgus_display.Init(); - MoveToScreen(DGUS_Screen::BOOT, true); +void DGUSScreenHandler::init() { + dgus_display.init(); + moveToScreen(DGUS_Screen::BOOT, true); } -void DGUSScreenHandler::Ready() { - dgus_display.PlaySound(1); +void DGUSScreenHandler::ready() { + dgus_display.playSound(1); } -void DGUSScreenHandler::Loop() { +void DGUSScreenHandler::loop() { const millis_t ms = ExtUI::safe_millis(); static millis_t next_event_ms = 0, next_beep_ms = 0; static bool wasLeveling = isLeveling; @@ -83,16 +83,16 @@ void DGUSScreenHandler::Loop() { #endif if (current_screen == screen) - TriggerFullUpdate(); + triggerFullUpdate(); else - MoveToScreen(screen); + moveToScreen(screen); return; } if (!booted && current_screen == DGUS_Screen::HOME) { // Boot complete booted = true; - dgus_display.ReadVersions(); + dgus_display.readVersions(); return; } @@ -107,10 +107,10 @@ void DGUSScreenHandler::Loop() { if (angry_beeps) { --angry_beeps; - dgus_display.PlaySound(3); + dgus_display.playSound(3); } - if (!SendScreenVPData(current_screen, full_update)) + if (!sendScreenVPData(current_screen, full_update)) DEBUG_ECHOLNPGM("SendScreenVPData failed"); return; @@ -121,7 +121,7 @@ void DGUSScreenHandler::Loop() { if (angry_beeps) { --angry_beeps; - dgus_display.PlaySound(0, 500/8, 100); + dgus_display.playSound(0, 500/8, 100); } } @@ -135,36 +135,36 @@ void DGUSScreenHandler::Loop() { config.levelingEnabled = ExtUI::getMeshValid(); ExtUI::setLevelingActive(config.levelingEnabled); - TriggerEEPROMSave(); + triggerEEPROMSave(); } wasLeveling = isLeveling; if (!settings_ready && booted) return; if (status_expire > 0 && ELAPSED(ms, status_expire)) { - SetStatusMessage(FPSTR(NUL_STR), 0); + setStatusMessage(FPSTR(NUL_STR), 0); return; } - if (eeprom_save > 0 && ELAPSED(ms, eeprom_save) && IsPrinterIdle()) { + if (eeprom_save > 0 && ELAPSED(ms, eeprom_save) && isPrinterIdle()) { eeprom_save = 0; ExtUI::injectCommands(F("M500")); return; } - dgus_display.Loop(); + dgus_display.loop(); } void DGUSScreenHandler::printerKilled(FSTR_P const error, FSTR_P const component) { - dgus_display.PlaySound(0, (uint8_t)(3000/8), 100); - SetStatusMessage(error); - MoveToScreen(DGUS_Screen::ABNORMAL); + dgus_display.playSound(0, (uint8_t)(3000/8), 100); + setStatusMessage(error); + moveToScreen(DGUS_Screen::ABNORMAL); } -void DGUSScreenHandler::UserConfirmRequired(const char * const msg) { +void DGUSScreenHandler::userConfirmRequired(const char * const msg) { #if ENABLED(DGUS_USERCONFIRM) if (confirm_return_screen == DGUS_Screen::BOOT) - confirm_return_screen = GetCurrentScreen(); + confirm_return_screen = getCurrentScreen(); strcpy(dgus_sdcard_handler.filenames[0], msg); strcpy(dgus_sdcard_handler.filenames[1], ""); @@ -188,7 +188,7 @@ void DGUSScreenHandler::UserConfirmRequired(const char * const msg) { #endif } -void DGUSScreenHandler::UserConfirmation() { +void DGUSScreenHandler::userConfirmation() { #if ENABLED(DGUS_USERCONFIRM) if (confirm_return_screen == DGUS_Screen::BOOT) { DEBUG_ECHOLNPGM("DGUS: User confirmation triggered but no return screen"); @@ -210,7 +210,7 @@ void DGUSScreenHandler::UserConfirmation() { #endif } -void DGUSScreenHandler::SettingsReset() { +void DGUSScreenHandler::settingsReset() { config.initialized = true; config.volume = DGUS_DEFAULT_VOLUME; config.brightness = DGUS_DEFAULT_BRIGHTNESS; @@ -224,23 +224,23 @@ void DGUSScreenHandler::SettingsReset() { if (!settings_ready) { settings_ready = true; - Ready(); + ready(); } - SetStatusMessage(GET_TEXT_F(DGUS_MSG_RESET_EEPROM)); + setStatusMessage(GET_TEXT_F(DGUS_MSG_RESET_EEPROM)); } -void DGUSScreenHandler::StoreSettings(char *buff) { +void DGUSScreenHandler::storeSettings(char *buff) { static_assert(sizeof(config) <= ExtUI::eeprom_data_size, "sizeof(eeprom_data_t) > eeprom_data_size."); config.initialized = true; - config.volume = dgus_display.GetVolume(); - config.brightness = dgus_display.GetBrightness(); + config.volume = dgus_display.getVolume(); + config.brightness = dgus_display.getBrightness(); memcpy(buff, &config, sizeof(config)); } -void DGUSScreenHandler::LoadSettings(const char *buff) { +void DGUSScreenHandler::loadSettings(const char *buff) { static_assert(sizeof(config) <= ExtUI::eeprom_data_size, "sizeof(eeprom_data_t) > eeprom_data_size."); memcpy(&config, buff, sizeof(config)); @@ -250,98 +250,98 @@ void DGUSScreenHandler::LoadSettings(const char *buff) { || config.jogLength < DGUS_Data::AxisControlCommand::Jog_10mm || config.jogLength > DGUS_Data::AxisControlCommand::Jog_0_1mm) { DEBUG_ECHOLNPGM("invalid DGUS settings, resetting"); - SettingsReset(); + settingsReset(); } ExtUI::setLevelingActive(config.levelingEnabled); - dgus_display.SetVolume(config.volume); - dgus_display.SetBrightness(config.brightness); + dgus_display.setVolume(config.volume); + dgus_display.setBrightness(config.brightness); } -void DGUSScreenHandler::ConfigurationStoreWritten(bool success) { +void DGUSScreenHandler::configurationStoreWritten(bool success) { if (!success) - SetStatusMessage(GET_TEXT_F(DGUS_MSG_WRITE_EEPROM_FAILED)); + setStatusMessage(GET_TEXT_F(DGUS_MSG_WRITE_EEPROM_FAILED)); } -void DGUSScreenHandler::ConfigurationStoreRead(bool success) { +void DGUSScreenHandler::configurationStoreRead(bool success) { if (!success) { - SetStatusMessage(GET_TEXT_F(DGUS_MSG_READ_EEPROM_FAILED)); + setStatusMessage(GET_TEXT_F(DGUS_MSG_READ_EEPROM_FAILED)); } else if (!settings_ready) { settings_ready = true; - Ready(); + ready(); } } -void DGUSScreenHandler::PlayTone(const uint16_t frequency, const uint16_t duration) { +void DGUSScreenHandler::playTone(const uint16_t frequency, const uint16_t duration) { UNUSED(duration); if (frequency >= 1 && frequency <= 255) { if (duration >= 1 && duration <= 255) - dgus_display.PlaySound((uint8_t)frequency, (uint8_t)duration); + dgus_display.playSound((uint8_t)frequency, (uint8_t)duration); else - dgus_display.PlaySound((uint8_t)frequency); + dgus_display.playSound((uint8_t)frequency); } } -void DGUSScreenHandler::AngryBeeps(const uint8_t beepCount) { +void DGUSScreenHandler::angryBeeps(const uint8_t beepCount) { angry_beeps = beepCount; } -void DGUSScreenHandler::LevelingStart() { +void DGUSScreenHandler::levelingStart() { #ifdef DEBUG_DGUSLCD - DEBUG_ECHOLNPGM("LevelingStart()"); + DEBUG_ECHOLNPGM("levelingStart()"); #endif isLeveling = true; currentMeshPointIndex = 0; - TriggerFullUpdate(); + triggerFullUpdate(); } -void DGUSScreenHandler::LevelingEnd() { +void DGUSScreenHandler::levelingEnd() { if (!isLeveling) return; #ifdef DEBUG_DGUSLCD - DEBUG_ECHOPGM("LevelingEnd(), valid="); + DEBUG_ECHOPGM("levelingEnd(), valid="); DEBUG_DECIMAL(ExtUI::getMeshValid()); DEBUG_EOL(); #endif isLeveling = false; currentMeshPointIndex = 0; - TriggerFullUpdate(); + triggerFullUpdate(); } -void DGUSScreenHandler::MeshUpdate(const int8_t xpos, const int8_t ypos) { +void DGUSScreenHandler::meshUpdate(const int8_t xpos, const int8_t ypos) { if (!isLeveling) return; currentMeshPointIndex++; - TriggerFullUpdate(); + triggerFullUpdate(); } -void DGUSScreenHandler::PrintTimerStarted() { - TriggerScreenChange(DGUS_Screen::PAUSE); +void DGUSScreenHandler::printTimerStarted() { + triggerScreenChange(DGUS_Screen::PAUSE); } -void DGUSScreenHandler::PrintTimerPaused() { - dgus_display.PlaySound(3); - TriggerScreenChange(DGUS_Screen::RESUME); +void DGUSScreenHandler::printTimerPaused() { + dgus_display.playSound(3); + triggerScreenChange(DGUS_Screen::RESUME); } -void DGUSScreenHandler::PrintTimerStopped() { - dgus_display.PlaySound(3); - TriggerScreenChange(DGUS_Screen::FINISH); +void DGUSScreenHandler::printTimerStopped() { + dgus_display.playSound(3); + triggerScreenChange(DGUS_Screen::FINISH); } void DGUSScreenHandler::filamentRunout(const ExtUI::extruder_t extruder) { - TriggerScreenChange(DGUS_Screen::FILAMENTUSEUP); - dgus_display.PlaySound(3); + triggerScreenChange(DGUS_Screen::FILAMENTUSEUP); + dgus_display.playSound(3); } -ssize_t DGUSScreenHandler::GetScrollIndex() { +ssize_t DGUSScreenHandler::getScrollIndex() { return currentScrollIndex; } -void DGUSScreenHandler::AddCurrentPageStringLength(size_t stringLength, size_t textControlLength) { +void DGUSScreenHandler::addCurrentPageStringLength(size_t stringLength, size_t textControlLength) { if (stringLength > pageMaxStringLen) pageMaxStringLen = stringLength; if (textControlLength > pageMaxControlLen) @@ -349,52 +349,52 @@ void DGUSScreenHandler::AddCurrentPageStringLength(size_t stringLength, size_t t } #if HAS_MEDIA - void DGUSScreenHandler::SDCardInserted() { + void DGUSScreenHandler::sdCardInserted() { } - void DGUSScreenHandler::SDCardRemoved() { - if (GetCurrentScreen() >= DGUS_Screen::FILE1 - && GetCurrentScreen() <= DGUS_Screen::FILE4) { - TriggerTempScreenChange(DGUS_Screen::SDCARDCHECK, DGUS_Screen::HOME); + void DGUSScreenHandler::sdCardRemoved() { + if (getCurrentScreen() >= DGUS_Screen::FILE1 + && getCurrentScreen() <= DGUS_Screen::FILE4) { + triggerTempScreenChange(DGUS_Screen::SDCARDCHECK, DGUS_Screen::HOME); } } - void DGUSScreenHandler::SDCardError() { + void DGUSScreenHandler::sdCardError() { } #endif // HAS_MEDIA #if ENABLED(POWER_LOSS_RECOVERY) - void DGUSScreenHandler::PowerLossResume() { - //MoveToScreen(DGUS_Screen::POWERLOSS, true); + void DGUSScreenHandler::powerLossResume() { + //moveToScreen(DGUS_Screen::POWERLOSS, true); } #endif #if HAS_PID_HEATING - void DGUSScreenHandler::PidTuning(const ExtUI::result_t rst) { - dgus_display.PlaySound(3); + void DGUSScreenHandler::pidTuning(const ExtUI::result_t rst) { + dgus_display.playSound(3); } #endif -void DGUSScreenHandler::SteppersStatusChanged(bool steppersEnabled) { - RefreshVP(DGUS_Addr::AXIS_StepperStatus); +void DGUSScreenHandler::steppersStatusChanged(bool steppersEnabled) { + refreshVP(DGUS_Addr::AXIS_StepperStatus); } -void DGUSScreenHandler::HomingDone() { - if (IsOnTempScreen(DGUS_Screen::AUTOHOME)) - TriggerReturnScreen(); +void DGUSScreenHandler::homingDone() { + if (isOnTempScreen(DGUS_Screen::AUTOHOME)) + triggerReturnScreen(); } -void DGUSScreenHandler::StartPrintFromSD(const char* const filename) { - TriggerScreenChange(DGUS_Screen::HOME); +void DGUSScreenHandler::startPrintFromSD(const char* const filename) { + triggerScreenChange(DGUS_Screen::HOME); sdPrintFilename = filename; - SetStatusMessage(sdPrintFilename, 0); + setStatusMessage(sdPrintFilename, 0); } -void DGUSScreenHandler::SetStatusMessage(FSTR_P msg, const millis_t duration) { - SetStatusMessage(FTOP(msg), duration); +void DGUSScreenHandler::setStatusMessage(FSTR_P msg, const millis_t duration) { + setStatusMessage(FTOP(msg), duration); } -void DGUSScreenHandler::SetStatusMessage(const char* msg, const millis_t duration) { +void DGUSScreenHandler::setStatusMessage(const char* msg, const millis_t duration) { homeStatusMessage[0] = '\0'; strncat(homeStatusMessage, msg, sizeof(homeStatusMessage)/sizeof(char)-1); @@ -404,16 +404,16 @@ void DGUSScreenHandler::SetStatusMessage(const char* msg, const millis_t duratio status_expire = 0; } -DGUS_Screen DGUSScreenHandler::GetCurrentScreen() { +DGUS_Screen DGUSScreenHandler::getCurrentScreen() { return current_screen; } -void DGUSScreenHandler::HomeThenChangeScreen(DGUS_Screen screen) { - TriggerTempScreenChange(DGUS_Screen::AUTOHOME, screen); +void DGUSScreenHandler::homeThenChangeScreen(DGUS_Screen screen) { + triggerTempScreenChange(DGUS_Screen::AUTOHOME, screen); ExtUI::injectCommands(F("G28")); } -void DGUSScreenHandler::TriggerScreenChange(DGUS_Screen screen) { +void DGUSScreenHandler::triggerScreenChange(DGUS_Screen screen) { if (confirm_return_screen != DGUS_Screen::BOOT) confirm_return_screen = screen; else @@ -427,7 +427,7 @@ void DGUSScreenHandler::TriggerScreenChange(DGUS_Screen screen) { #endif } -void DGUSScreenHandler::TriggerTempScreenChange(DGUS_Screen screen, DGUS_Screen returnScreen) { +void DGUSScreenHandler::triggerTempScreenChange(DGUS_Screen screen, DGUS_Screen returnScreen) { if (confirm_return_screen != DGUS_Screen::BOOT) confirm_return_screen = screen; else @@ -443,7 +443,7 @@ void DGUSScreenHandler::TriggerTempScreenChange(DGUS_Screen screen, DGUS_Screen #endif } -void DGUSScreenHandler::TriggerReturnScreen() { +void DGUSScreenHandler::triggerReturnScreen() { new_screen = wait_return_screen; wait_return_screen = DGUS_Screen::BOOT; #ifdef DEBUG_DGUSLCD @@ -452,24 +452,24 @@ void DGUSScreenHandler::TriggerReturnScreen() { #endif } -bool DGUSScreenHandler::IsOnTempScreen(DGUS_Screen screen) { +bool DGUSScreenHandler::isOnTempScreen(DGUS_Screen screen) { return wait_return_screen != DGUS_Screen::BOOT && (screen == DGUS_Screen::BOOT || current_screen == screen); } -void DGUSScreenHandler::TriggerFullUpdate() { +void DGUSScreenHandler::triggerFullUpdate() { full_update = true; } -void DGUSScreenHandler::TriggerEEPROMSave() { +void DGUSScreenHandler::triggerEEPROMSave() { eeprom_save = ExtUI::safe_millis() + 500; } -bool DGUSScreenHandler::IsPrinterIdle() { +bool DGUSScreenHandler::isPrinterIdle() { return (!ExtUI::commandsInQueue() && !ExtUI::isMoving()); } -const DGUS_Addr* DGUSScreenHandler::FindScreenAddrList(DGUS_Screen screen) { +const DGUS_Addr* DGUSScreenHandler::findScreenAddrList(DGUS_Screen screen) { DGUS_ScreenAddrList list; const DGUS_ScreenAddrList *map = screen_addr_list_map; @@ -484,7 +484,7 @@ const DGUS_Addr* DGUSScreenHandler::FindScreenAddrList(DGUS_Screen screen) { return nullptr; } -bool DGUSScreenHandler::CallScreenSetup(DGUS_Screen screen) { +bool DGUSScreenHandler::callScreenSetup(DGUS_Screen screen) { DGUS_ScreenSetup setup; const DGUS_ScreenSetup *list = screen_setup_list; @@ -497,19 +497,19 @@ bool DGUSScreenHandler::CallScreenSetup(DGUS_Screen screen) { return true; } -void DGUSScreenHandler::MoveToScreen(DGUS_Screen screen, bool abort_wait) { +void DGUSScreenHandler::moveToScreen(DGUS_Screen screen, bool abort_wait) { current_screen = screen; - if (!CallScreenSetup(screen)) return; - if (!SendScreenVPData(screen, true)) return; + if (!callScreenSetup(screen)) return; + if (!sendScreenVPData(screen, true)) return; - dgus_display.SwitchScreen(current_screen); + dgus_display.switchScreen(current_screen); } -bool DGUSScreenHandler::SendScreenVPData(DGUS_Screen screen, bool complete_update) { +bool DGUSScreenHandler::sendScreenVPData(DGUS_Screen screen, bool complete_update) { if (complete_update) full_update = false; - const DGUS_Addr *list = FindScreenAddrList(screen); + const DGUS_Addr *list = findScreenAddrList(screen); while (true) { if (!list) return true; // Nothing left to send @@ -528,10 +528,10 @@ bool DGUSScreenHandler::SendScreenVPData(DGUS_Screen screen, bool complete_updat uint8_t expected_tx = 6 + vp.size; // 6 bytes header + payload. const millis_t try_until = ExtUI::safe_millis() + 1000; - while (expected_tx > dgus_display.GetFreeTxBuffer()) { + while (expected_tx > dgus_display.getFreeTxBuffer()) { if (ELAPSED(ExtUI::safe_millis(), try_until)) return false; // Stop trying after 1 second - dgus_display.FlushTx(); // Flush the TX buffer + dgus_display.flushTx(); // Flush the TX buffer delay(50); } @@ -539,8 +539,8 @@ bool DGUSScreenHandler::SendScreenVPData(DGUS_Screen screen, bool complete_updat } } -bool DGUSScreenHandler::RefreshVP(DGUS_Addr vpAddr) { - const DGUS_Addr *list = FindScreenAddrList(current_screen); +bool DGUSScreenHandler::refreshVP(DGUS_Addr vpAddr) { + const DGUS_Addr *list = findScreenAddrList(current_screen); while (list && (uint16_t)*list) { if (*list == vpAddr) { diff --git a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSScreenHandler.h b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSScreenHandler.h index f7e0cd1e1d21..e62d3e591cf7 100644 --- a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSScreenHandler.h +++ b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSScreenHandler.h @@ -79,82 +79,82 @@ class DGUSScreenHandler { public: DGUSScreenHandler() = default; - static void Init(); - static void Ready(); - static void Loop(); + static void init(); + static void ready(); + static void loop(); static void printerKilled(FSTR_P const error, FSTR_P const component); - static bool IsOnUserConfirmationScreen() { return confirm_return_screen != DGUS_Screen::BOOT; } - static void UserConfirmRequired(const char * const msg); - static void UserConfirmation(); - static void SettingsReset(); - static void StoreSettings(char *buff); - static void LoadSettings(const char *buff); - static void ConfigurationStoreWritten(bool success); - static void ConfigurationStoreRead(bool success); - - static void PlayTone(const uint16_t frequency, const uint16_t duration); - static void AngryBeeps(const uint8_t beepCount); - - static void LevelingStart(); - static void LevelingEnd(); - static void MeshUpdate(const int8_t xpos, const int8_t ypos); - - static void PrintTimerStarted(); - static void PrintTimerPaused(); - static void PrintTimerStopped(); + static bool isOnUserConfirmationScreen() { return confirm_return_screen != DGUS_Screen::BOOT; } + static void userConfirmRequired(const char * const msg); + static void userConfirmation(); + static void settingsReset(); + static void storeSettings(char *buff); + static void loadSettings(const char *buff); + static void configurationStoreWritten(bool success); + static void configurationStoreRead(bool success); + + static void playTone(const uint16_t frequency, const uint16_t duration); + static void angryBeeps(const uint8_t beepCount); + + static void levelingStart(); + static void levelingEnd(); + static void meshUpdate(const int8_t xpos, const int8_t ypos); + + static void printTimerStarted(); + static void printTimerPaused(); + static void printTimerStopped(); static void filamentRunout(const ExtUI::extruder_t extruder); #if ENABLED(DGUS_SOFTWARE_AUTOSCROLL) - static ssize_t GetScrollIndex(); - static void AddCurrentPageStringLength(size_t stringLength, size_t textControlLength); + static ssize_t getScrollIndex(); + static void addCurrentPageStringLength(size_t stringLength, size_t textControlLength); #endif #if HAS_MEDIA /// Marlin informed us that a new SD has been inserted. - static void SDCardInserted(); + static void sdCardInserted(); /// Marlin informed us that the SD Card has been removed(). - static void SDCardRemoved(); + static void sdCardRemoved(); /// Marlin informed us about a bad SD Card. - static void SDCardError(); + static void sdCardError(); - static const char* GetSDCardPrintFilename() { return sdPrintFilename; } + static const char* getSDCardPrintFilename() { return sdPrintFilename; } #endif #if ENABLED(POWER_LOSS_RECOVERY) - static void PowerLossResume(); + static void powerLossResume(); #endif #if HAS_PID_HEATING - static void PidTuning(const ExtUI::result_t rst); + static void pidTuning(const ExtUI::result_t rst); #endif - static void SteppersStatusChanged(bool steppersEnabled); - static void HomingDone(); + static void steppersStatusChanged(bool steppersEnabled); + static void homingDone(); - static void StartPrintFromSD(const char* const filename); - static void SetStatusMessage(FSTR_P msg, const millis_t duration=DGUS_STATUS_EXPIRATION_MS); - static void SetStatusMessage(const char* msg, const millis_t duration=DGUS_STATUS_EXPIRATION_MS); + static void startPrintFromSD(const char* const filename); + static void setStatusMessage(FSTR_P msg, const millis_t duration=DGUS_STATUS_EXPIRATION_MS); + static void setStatusMessage(const char* msg, const millis_t duration=DGUS_STATUS_EXPIRATION_MS); - static DGUS_Screen GetCurrentScreen(); - static void HomeThenChangeScreen(DGUS_Screen screen); - static void TriggerScreenChange(DGUS_Screen screen); - static void TriggerTempScreenChange(DGUS_Screen screen, DGUS_Screen returnScreen); - static void TriggerReturnScreen(); - static bool IsOnTempScreen(DGUS_Screen screen = DGUS_Screen::BOOT); - static void TriggerFullUpdate(); + static DGUS_Screen getCurrentScreen(); + static void homeThenChangeScreen(DGUS_Screen screen); + static void triggerScreenChange(DGUS_Screen screen); + static void triggerTempScreenChange(DGUS_Screen screen, DGUS_Screen returnScreen); + static void triggerReturnScreen(); + static bool isOnTempScreen(DGUS_Screen screen = DGUS_Screen::BOOT); + static void triggerFullUpdate(); - static void TriggerEEPROMSave(); + static void triggerEEPROMSave(); - static bool IsPrinterIdle(); + static bool isPrinterIdle(); private: - static const DGUS_Addr* FindScreenAddrList(DGUS_Screen screen); - static bool CallScreenSetup(DGUS_Screen screen); + static const DGUS_Addr* findScreenAddrList(DGUS_Screen screen); + static bool callScreenSetup(DGUS_Screen screen); - static void MoveToScreen(DGUS_Screen screen, bool abort_wait=false); - static bool SendScreenVPData(DGUS_Screen screen, bool complete_update); - static bool RefreshVP(DGUS_Addr vpAddr); + static void moveToScreen(DGUS_Screen screen, bool abort_wait=false); + static bool sendScreenVPData(DGUS_Screen screen, bool complete_update); + static bool refreshVP(DGUS_Addr vpAddr); }; -extern DGUSScreenHandler dgus_screen_handler; +extern DGUSScreenHandler screen; diff --git a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSetupHandler.cpp b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSetupHandler.cpp index d1d42976ba65..a2b414c41781 100644 --- a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSetupHandler.cpp +++ b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSetupHandler.cpp @@ -31,40 +31,40 @@ bool DGUSSetupHandler::SDCardPrepare() { #if ENABLED(DGUS_USERCONFIRM) - if (dgus_screen_handler.IsOnUserConfirmationScreen()) { + if (screen.isOnUserConfirmationScreen()) { // Only allow the fifth line used as the confirm button to be clicked - dgus_display.DisableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File1); - dgus_display.DisableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File2); - dgus_display.DisableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File3); - dgus_display.DisableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File4); - dgus_display.DisableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Start); - dgus_display.DisableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_End); - dgus_display.DisableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Prev); - dgus_display.DisableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Next); - dgus_display.DisableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Home); - dgus_display.DisableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Print); - dgus_display.DisableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Ready); - dgus_display.DisableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Settings); + dgus_display.disableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File1); + dgus_display.disableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File2); + dgus_display.disableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File3); + dgus_display.disableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File4); + dgus_display.disableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Start); + dgus_display.disableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_End); + dgus_display.disableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Prev); + dgus_display.disableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Next); + dgus_display.disableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Home); + dgus_display.disableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Print); + dgus_display.disableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Ready); + dgus_display.disableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Settings); return true; // skip the file update } else { - dgus_display.EnableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File1); - dgus_display.EnableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File2); - dgus_display.EnableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File3); - dgus_display.EnableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File4); - dgus_display.EnableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Start); - dgus_display.EnableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_End); - dgus_display.EnableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Prev); - dgus_display.EnableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Next); - dgus_display.EnableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Home); - dgus_display.EnableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Print); - dgus_display.EnableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Ready); - dgus_display.EnableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Settings); + dgus_display.enableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File1); + dgus_display.enableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File2); + dgus_display.enableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File3); + dgus_display.enableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File4); + dgus_display.enableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Start); + dgus_display.enableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_End); + dgus_display.enableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Prev); + dgus_display.enableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Next); + dgus_display.enableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Home); + dgus_display.enableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Print); + dgus_display.enableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Ready); + dgus_display.enableControl(DGUS_Screen::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Settings); } #endif - dgus_sdcard_handler.onPageLoad(DGUS_SCREEN_TO_PAGE(dgus_screen_handler.GetCurrentScreen())); + dgus_sdcard_handler.onPageLoad(DGUS_SCREEN_TO_PAGE(screen.getCurrentScreen())); return true; } diff --git a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSTxHandler.cpp b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSTxHandler.cpp index aecdc4818133..532de603ee4c 100644 --- a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSTxHandler.cpp +++ b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSTxHandler.cpp @@ -31,74 +31,74 @@ #include "../../../module/stepper.h" -void DGUSTxHandler::BootAnimation(DGUS_VP &vp) { +void DGUSTxHandler::bootAnimation(DGUS_VP &vp) { static uint16_t bootIcon = 0; - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(bootIcon)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(bootIcon)); if (++bootIcon > 100) { bootIcon = 0; - dgus_screen_handler.TriggerScreenChange(DGUS_Screen::HOME); + screen.triggerScreenChange(DGUS_Screen::HOME); } } -void DGUSTxHandler::ZOffset(DGUS_VP &vp) { +void DGUSTxHandler::zOffset(DGUS_VP &vp) { const float position = ExtUI::getZOffset_mm(); const int16_t data = dgus_display.ToFixedPoint(position); // Round to 0.01 - dgus_display.Write((int16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((int16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::ElapsedHours(DGUS_VP &vp) { +void DGUSTxHandler::elapsedHours(DGUS_VP &vp) { duration_t elapsedtime = ExtUI::getProgress_seconds_elapsed(); int16_t data = elapsedtime.hour(); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::ElapsedMinutes(DGUS_VP &vp) { +void DGUSTxHandler::elapsedMinutes(DGUS_VP &vp) { duration_t elapsedtime = ExtUI::getProgress_seconds_elapsed(); int16_t data = elapsedtime.minute() % 60; - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::Leveling_Progress(DGUS_VP &vp) { - uint16_t data = (100 * dgus_screen_handler.currentMeshPointIndex) / GRID_MAX_POINTS; - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); +void DGUSTxHandler::levelingProgress(DGUS_VP &vp) { + uint16_t data = (100 * screen.currentMeshPointIndex) / GRID_MAX_POINTS; + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::FanSpeed(DGUS_VP &vp) { +void DGUSTxHandler::fanSpeed(DGUS_VP &vp) { uint16_t data = (uint16_t)ExtUI::getActualFan_percent(ExtUI::FAN0); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::Leveling_ProgressIcon(DGUS_VP &vp) { - uint16_t data = 1 + (50 * dgus_screen_handler.currentMeshPointIndex) / GRID_MAX_POINTS; - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); +void DGUSTxHandler::levelingProgressIcon(DGUS_VP &vp) { + uint16_t data = 1 + (50 * screen.currentMeshPointIndex) / GRID_MAX_POINTS; + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::Filament_InsertionStatus(DGUS_VP &vp) { +void DGUSTxHandler::filamentInsertionStatus(DGUS_VP &vp) { uint16_t data = ExtUI::getFilamentRunoutState() ? 1 : 0; - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::SDCard_InsertionStatus(DGUS_VP &vp) { +void DGUSTxHandler::sdCardInsertionStatus(DGUS_VP &vp) { uint16_t data = ExtUI::isMediaInserted() ? 1 : 0; - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } #if ENABLED(PIDTEMPBED) - void DGUSTxHandler::Bed_PID_P(DGUS_VP &vp) { + void DGUSTxHandler::bed_PID_P(DGUS_VP &vp) { uint16_t data = dgus_display.ToFixedPoint(ExtUI::getBedPID_Kp()); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } - void DGUSTxHandler::Bed_PID_I(DGUS_VP &vp) { + void DGUSTxHandler::bed_PID_I(DGUS_VP &vp) { uint16_t data = dgus_display.ToFixedPoint(ExtUI::getBedPID_Ki()); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } - void DGUSTxHandler::Bed_PID_D(DGUS_VP &vp) { + void DGUSTxHandler::bed_PID_D(DGUS_VP &vp) { uint16_t data = dgus_display.ToFixedPoint(ExtUI::getBedPID_Kd()); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } #endif // PIDTEMPBED @@ -116,104 +116,104 @@ static duration_t _PrintRemainingDurationEstimate() { return remainingDuration; } -void DGUSTxHandler::PrintRemainingHours(DGUS_VP &vp) { +void DGUSTxHandler::printRemainingHours(DGUS_VP &vp) { int16_t data = _PrintRemainingDurationEstimate().hour(); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::PrintRemainingMinutes(DGUS_VP &vp) { +void DGUSTxHandler::printRemainingMinutes(DGUS_VP &vp) { int16_t data = _PrintRemainingDurationEstimate().minute() % 60; - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::PrintPercentage(DGUS_VP &vp) { +void DGUSTxHandler::printPercentage(DGUS_VP &vp) { int16_t data = ExtUI::getProgress_percent(); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::PrintSpeedPercentage(DGUS_VP &vp) { +void DGUSTxHandler::printSpeedPercentage(DGUS_VP &vp) { int16_t data = ExtUI::getFeedrate_percent(); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::ExtruderTargetTemp(DGUS_VP &vp) { +void DGUSTxHandler::extruderTargetTemp(DGUS_VP &vp) { int16_t data = ExtUI::getTargetTemp_celsius(ExtUI::H0); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::ExtruderCurrentTemp(DGUS_VP &vp) { +void DGUSTxHandler::extruderCurrentTemp(DGUS_VP &vp) { int16_t data = ExtUI::getActualTemp_celsius(ExtUI::H0); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::BedTargetTemp(DGUS_VP &vp) { +void DGUSTxHandler::bedTargetTemp(DGUS_VP &vp) { int16_t data = ExtUI::getTargetTemp_celsius(ExtUI::BED); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::BedCurrentTemp(DGUS_VP &vp) { +void DGUSTxHandler::bedCurrentTemp(DGUS_VP &vp) { int16_t data = ExtUI::getActualTemp_celsius(ExtUI::BED); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::Axis_X(DGUS_VP &vp) { +void DGUSTxHandler::axis_X(DGUS_VP &vp) { int16_t data = dgus_display.ToFixedPoint(ExtUI::getAxisPosition_mm(ExtUI::X)); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::Axis_Y(DGUS_VP &vp) { +void DGUSTxHandler::axis_Y(DGUS_VP &vp) { int16_t data = dgus_display.ToFixedPoint(ExtUI::getAxisPosition_mm(ExtUI::Y)); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::Axis_Z(DGUS_VP &vp) { +void DGUSTxHandler::axis_Z(DGUS_VP &vp) { int16_t data = dgus_display.ToFixedPoint(ExtUI::getAxisPosition_mm(ExtUI::Z)); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::StepperStatus(DGUS_VP &vp) { +void DGUSTxHandler::stepperStatus(DGUS_VP &vp) { const bool areSteppersEnabled = stepper.axis_enabled.bits & (_BV(NUM_AXES) - 1); uint16_t data = areSteppersEnabled ? 1 : 0; - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::EnableIfLanguageMatchesExtra(DGUS_VP &vp) { +void DGUSTxHandler::enableIfLanguageMatchesExtra(DGUS_VP &vp) { DGUS_Data::Language targetLanguage = (DGUS_Data::Language)reinterpret_cast(vp.extra); - uint16_t data = targetLanguage == dgus_screen_handler.config.language ? 1 : 0; - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + uint16_t data = targetLanguage == screen.config.language ? 1 : 0; + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } -void DGUSTxHandler::ExtraToString(DGUS_VP &vp) { +void DGUSTxHandler::extraToString(DGUS_VP &vp) { if (!vp.size || !vp.extra) return; #if ENABLED(DGUS_SOFTWARE_AUTOSCROLL) if (vp.flags & VPFLAG_TXSTRING_AUTOSCROLL) { const char* stringStart = (const char*)vp.extra; size_t stringLength = strlen(stringStart); - dgus_screen_handler.AddCurrentPageStringLength(stringLength, vp.size); + screen.addCurrentPageStringLength(stringLength, vp.size); - if (stringLength <= vp.size || dgus_screen_handler.GetScrollIndex() <= 0) { + if (stringLength <= vp.size || screen.getScrollIndex() <= 0) { // no scroll needed } - else if ((ssize_t)stringLength - dgus_screen_handler.GetScrollIndex() <= vp.size) { + else if ((ssize_t)stringLength - screen.getScrollIndex() <= vp.size) { stringStart += (stringLength - vp.size); } else - stringStart += dgus_screen_handler.GetScrollIndex(); + stringStart += screen.getScrollIndex(); - dgus_display.WriteString((uint16_t)vp.addr, + dgus_display.writeString((uint16_t)vp.addr, stringStart, vp.size, true, false, false); } else #endif // DGUS_SOFTWARE_AUTOSCROLL - dgus_display.WriteString((uint16_t)vp.addr, vp.extra, vp.size, true, false, false); + dgus_display.writeString((uint16_t)vp.addr, vp.extra, vp.size, true, false, false); } -void DGUSTxHandler::ExtraPGMToString(DGUS_VP &vp) { +void DGUSTxHandler::extraPGMToString(DGUS_VP &vp) { if (!vp.size || !vp.extra) return; - dgus_display.WriteStringPGM((uint16_t)vp.addr, vp.extra, vp.size, true, false, false); + dgus_display.writeStringPGM((uint16_t)vp.addr, vp.extra, vp.size, true, false, false); } #endif // DGUS_LCD_UI_RELOADED diff --git a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSTxHandler.h b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSTxHandler.h index f2c60e6318f1..6b77150ac85b 100644 --- a/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSTxHandler.h +++ b/Marlin/src/lcd/extui/dgus_e3s1pro/DGUSTxHandler.h @@ -27,121 +27,120 @@ #define Swap16(val) (uint16_t((uint16_t(val) >> 8) | (uint16_t(val) << 8))) namespace DGUSTxHandler { - void BootAnimation(DGUS_VP &); - - void ZOffset(DGUS_VP &); - void ElapsedHours(DGUS_VP &); - void ElapsedMinutes(DGUS_VP &); - void Leveling_Progress(DGUS_VP &vp); - void FanSpeed(DGUS_VP &vp); - void Leveling_ProgressIcon(DGUS_VP &vp); - void Filament_InsertionStatus(DGUS_VP &vp); - void SDCard_InsertionStatus(DGUS_VP &vp); + void bootAnimation(DGUS_VP &); + void zOffset(DGUS_VP &); + void elapsedHours(DGUS_VP &); + void elapsedMinutes(DGUS_VP &); + void levelingProgress(DGUS_VP &vp); + void fanSpeed(DGUS_VP &vp); + void levelingProgressIcon(DGUS_VP &vp); + void filamentInsertionStatus(DGUS_VP &vp); + void sdCardInsertionStatus(DGUS_VP &vp); template - void MaxFeedrate(DGUS_VP &vp) { + void maxFeedrate(DGUS_VP &vp) { uint16_t data = (uint16_t)ExtUI::getAxisMaxFeedrate_mm_s(axis); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } template - void MaxAcceleration(DGUS_VP &vp) { + void maxAcceleration(DGUS_VP &vp) { uint16_t data = (uint16_t)ExtUI::getAxisMaxAcceleration_mm_s2(axis); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } template - void MaxJerk(DGUS_VP &vp) { + void maxJerk(DGUS_VP &vp) { uint16_t data = dgus_display.ToFixedPoint(ExtUI::getAxisMaxJerk_mm_s(axis)); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } template - void StepsPerMm(DGUS_VP &vp) { + void stepsPerMM(DGUS_VP &vp) { uint16_t data = dgus_display.ToFixedPoint(ExtUI::getAxisSteps_per_mm(axis)); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } #if ENABLED(PIDTEMP) template void PID_P(DGUS_VP &vp) { uint16_t data = dgus_display.ToFixedPoint(ExtUI::getPID_Kp(extruder)); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } template void PID_I(DGUS_VP &vp) { uint16_t data = dgus_display.ToFixedPoint(ExtUI::getPID_Ki(extruder)); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } template void PID_D(DGUS_VP &vp) { uint16_t data = dgus_display.ToFixedPoint(ExtUI::getPID_Kd(extruder)); - dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + dgus_display.write((uint16_t)vp.addr, dgus_display.swapBytes(data)); } #endif // PIDTEMP #if ENABLED(PIDTEMPBED) - void Bed_PID_P(DGUS_VP &vp); - void Bed_PID_I(DGUS_VP &vp); - void Bed_PID_D(DGUS_VP &vp); - #endif // PIDTEMPBED + void bed_PID_P(DGUS_VP &vp); + void bed_PID_I(DGUS_VP &vp); + void bed_PID_D(DGUS_VP &vp); + #endif - void PrintRemainingHours(DGUS_VP &); - void PrintRemainingMinutes(DGUS_VP &); - void PrintPercentage(DGUS_VP &); - void PrintSpeedPercentage(DGUS_VP &); - void ExtruderTargetTemp(DGUS_VP &); - void ExtruderCurrentTemp(DGUS_VP &); - void BedTargetTemp(DGUS_VP &); - void BedCurrentTemp(DGUS_VP &); - void Axis_X(DGUS_VP &); - void Axis_Y(DGUS_VP &); - void Axis_Z(DGUS_VP &); - void StepperStatus(DGUS_VP &); - void EnableIfLanguageMatchesExtra(DGUS_VP &); + void printRemainingHours(DGUS_VP &); + void printRemainingMinutes(DGUS_VP &); + void printPercentage(DGUS_VP &); + void printSpeedPercentage(DGUS_VP &); + void extruderTargetTemp(DGUS_VP &); + void extruderCurrentTemp(DGUS_VP &); + void bedTargetTemp(DGUS_VP &); + void bedCurrentTemp(DGUS_VP &); + void axis_X(DGUS_VP &); + void axis_Y(DGUS_VP &); + void axis_Z(DGUS_VP &); + void stepperStatus(DGUS_VP &); + void enableIfLanguageMatchesExtra(DGUS_VP &); - void ExtraToString(DGUS_VP &); - void ExtraPGMToString(DGUS_VP &); + void extraToString(DGUS_VP &); + void extraPGMToString(DGUS_VP &); template - void ExtraToInteger(DGUS_VP &vp) { + void extraToInteger(DGUS_VP &vp) { if (!vp.size || !vp.extra) return; switch (vp.size) { default: return; case 1: { const uint8_t data = uint8_t(*(T*)vp.extra); - dgus_display.Write(uint16_t(vp.addr), data); + dgus_display.write(uint16_t(vp.addr), data); break; } case 2: { const uint16_t data = uint16_t(*(T*)vp.extra); - dgus_display.Write(uint16_t(vp.addr), Swap16(data)); + dgus_display.write(uint16_t(vp.addr), Swap16(data)); break; } case 4: { const uint32_t data = uint32_t(*(T*)vp.extra); - dgus_display.Write(uint16_t(vp.addr), dgus_display.SwapBytes(data)); + dgus_display.write(uint16_t(vp.addr), dgus_display.swapBytes(data)); break; } } } template - void ExtraToFixedPoint(DGUS_VP &vp) { + void extraToFixedPoint(DGUS_VP &vp) { if (!vp.size || !vp.extra) return; switch (vp.size) { default: return; case 1: { const uint8_t data = dgus_display.ToFixedPoint(*(T*)vp.extra); - dgus_display.Write(uint16_t(vp.addr), data); + dgus_display.write(uint16_t(vp.addr), data); break; } case 2: { const uint16_t data = dgus_display.ToFixedPoint(*(T*)vp.extra); - dgus_display.Write(uint16_t(vp.addr), Swap16(data)); + dgus_display.write(uint16_t(vp.addr), Swap16(data)); break; } case 4: { const uint32_t data = dgus_display.ToFixedPoint(*(T*)vp.extra); - dgus_display.Write(uint16_t(vp.addr), dgus_display.SwapBytes(data)); + dgus_display.write(uint16_t(vp.addr), dgus_display.swapBytes(data)); break; } } diff --git a/Marlin/src/lcd/extui/dgus_e3s1pro/definition/DGUS_VPList.cpp b/Marlin/src/lcd/extui/dgus_e3s1pro/definition/DGUS_VPList.cpp index feb1c1c72975..13a1cdee5b10 100644 --- a/Marlin/src/lcd/extui/dgus_e3s1pro/definition/DGUS_VPList.cpp +++ b/Marlin/src/lcd/extui/dgus_e3s1pro/definition/DGUS_VPList.cpp @@ -77,7 +77,7 @@ const uint16_t DGUS_ZERO = 0; VP_HELPER_WORD(ADDR, VPFLAG_AUTOUPLOAD, EXTRA, nullptr, TXHANDLER) #define VP_HELPER_LANG_ICON(ADDR) \ - VP_HELPER_TX_EXTRA(ADDR, &dgus_screen_handler.config.language, (&DGUSTxHandler::ExtraToInteger)) + VP_HELPER_TX_EXTRA(ADDR, &screen.config.language, (&DGUSTxHandler::ExtraToInteger)) #define VP_HELPER_FILENAME(ADDR, filenameIndex) \ VP_HELPER(ADDR, DGUS_FILENAME_LEN, VPFLAG_TXSTRING_AUTOSCROLL, \ @@ -171,22 +171,22 @@ const struct DGUS_VP vp_list[] PROGMEM = { &DGUSTxHandler::Filament_InsertionStatus), VP_HELPER_WORD( DGUS_Addr::TEMP_PLA_ExtruderTemp, VPFLAG_NONE, - &dgus_screen_handler.config.plaExtruderTemp, + &screen.config.plaExtruderTemp, &DGUSRxHandler::IntegerToExtra, &DGUSTxHandler::ExtraToInteger), VP_HELPER_WORD( DGUS_Addr::TEMP_PLA_BedTemp, VPFLAG_NONE, - &dgus_screen_handler.config.plaBedTemp, + &screen.config.plaBedTemp, &DGUSRxHandler::IntegerToExtra, &DGUSTxHandler::ExtraToInteger), VP_HELPER_WORD( DGUS_Addr::TEMP_ABS_ExtruderTemp, VPFLAG_NONE, - &dgus_screen_handler.config.absExtruderTemp, + &screen.config.absExtruderTemp, &DGUSRxHandler::IntegerToExtra, &DGUSTxHandler::ExtraToInteger), VP_HELPER_WORD( DGUS_Addr::TEMP_ABS_BedTemp, VPFLAG_NONE, - &dgus_screen_handler.config.absBedTemp, + &screen.config.absBedTemp, &DGUSRxHandler::IntegerToExtra, &DGUSTxHandler::ExtraToInteger), VP_HELPER_RX( DGUS_Addr::CMD_AdvancedSettings, @@ -562,13 +562,13 @@ const struct DGUS_VP vp_list[] PROGMEM = { VP_HELPER( DGUS_Addr::MAIN_StatusMessage, DGUS_INFOSTRING_LEN, VPFLAG_TXSTRING_AUTOSCROLL, - VP_EXTRA_TO_STR(dgus_screen_handler.homeStatusMessage), + VP_EXTRA_TO_STR(screen.homeStatusMessage), nullptr, DGUSTxHandler::ExtraToString), VP_HELPER( DGUS_Addr::ABNORMAL_StatusMessage, DGUS_INFOSTRING_LEN, VPFLAG_TXSTRING_AUTOSCROLL, - VP_EXTRA_TO_STR(dgus_screen_handler.homeStatusMessage), + VP_EXTRA_TO_STR(screen.homeStatusMessage), nullptr, DGUSTxHandler::ExtraToString), VP_HELPER_RX( DGUS_Addr::CMD_LaserControl, diff --git a/Marlin/src/lcd/extui/dgus_e3s1pro/dgus_e3s1pro_extui.cpp b/Marlin/src/lcd/extui/dgus_e3s1pro/dgus_e3s1pro_extui.cpp index 946076db5337..530ce9bcf0e0 100644 --- a/Marlin/src/lcd/extui/dgus_e3s1pro/dgus_e3s1pro_extui.cpp +++ b/Marlin/src/lcd/extui/dgus_e3s1pro/dgus_e3s1pro_extui.cpp @@ -37,7 +37,7 @@ namespace ExtUI { void onStartup() { - dgus_screen_handler.Init(); + screen.init(); } void onIdle() { @@ -46,88 +46,88 @@ namespace ExtUI { // Prevent recursion if (!processing) { processing = true; - dgus_screen_handler.Loop(); + screen.loop(); processing = false; } } void onPrinterKilled(FSTR_P const error, FSTR_P const component) { - dgus_screen_handler.printerKilled(error, component); + screen.printerKilled(error, component); } - void onMediaInserted() { TERN_(HAS_MEDIA, dgus_screen_handler.SDCardInserted()); } - void onMediaError() { TERN_(HAS_MEDIA, dgus_screen_handler.SDCardError()); } - void onMediaRemoved() { TERN_(HAS_MEDIA, dgus_screen_handler.SDCardRemoved()); } + void onMediaInserted() { TERN_(HAS_MEDIA, screen.sdCardInserted()); } + void onMediaError() { TERN_(HAS_MEDIA, screen.sdCardError()); } + void onMediaRemoved() { TERN_(HAS_MEDIA, screen.sdCardRemoved()); } void onPlayTone(const uint16_t frequency, const uint16_t duration) { - dgus_screen_handler.PlayTone(frequency, duration); + screen.playTone(frequency, duration); } void onPrintTimerStarted() { - dgus_screen_handler.PrintTimerStarted(); + screen.printTimerStarted(); } void onPrintTimerPaused() { - dgus_screen_handler.PrintTimerPaused(); + screen.printTimerPaused(); } void onPrintTimerStopped() { - dgus_screen_handler.PrintTimerStopped(); + screen.printTimerStopped(); } void onFilamentRunout(const extruder_t extruder) { - dgus_screen_handler.filamentRunout(extruder); + screen.filamentRunout(extruder); } void onUserConfirmRequired(const char * const msg) { - dgus_screen_handler.UserConfirmRequired(msg); + screen.userConfirmRequired(msg); } void onStatusChanged(const char * const msg) { - dgus_screen_handler.SetStatusMessage(msg); + screen.setStatusMessage(msg); } void onHomingStart() {} void onHomingDone() { - dgus_screen_handler.HomingDone(); + screen.homingDone(); } void onPrintDone() {} void onFactoryReset() { - dgus_screen_handler.SettingsReset(); + screen.settingsReset(); } void onStoreSettings(char *buff) { - dgus_screen_handler.StoreSettings(buff); + screen.storeSettings(buff); } void onLoadSettings(const char *buff) { - dgus_screen_handler.LoadSettings(buff); + screen.loadSettings(buff); } void onPostprocessSettings() {} void onSettingsStored(const bool success) { - dgus_screen_handler.ConfigurationStoreWritten(success); + screen.configurationStoreWritten(success); } void onSettingsLoaded(const bool success) { - dgus_screen_handler.ConfigurationStoreRead(success); + screen.configurationStoreRead(success); } #if HAS_MESH void onLevelingStart() { - dgus_screen_handler.LevelingStart(); + screen.levelingStart(); } void onLevelingDone() { - dgus_screen_handler.LevelingEnd(); + screen.levelingEnd(); } void onMeshUpdate(const int8_t xpos, const int8_t ypos, const_float_t zval) { - dgus_screen_handler.MeshUpdate(xpos, ypos); + screen.meshUpdate(xpos, ypos); } void onMeshUpdate(const int8_t xpos, const int8_t ypos, const probe_state_t state) { } @@ -142,23 +142,23 @@ namespace ExtUI { } void onPowerLossResume() { // Called on resume from power-loss - dgus_screen_handler.PowerLossResume(); + screen.powerLossResume(); } #endif #if HAS_PID_HEATING void onPidTuning(const result_t rst) { // Called for temperature PID tuning result - dgus_screen_handler.PidTuning(rst); + screen.pidTuning(rst); } #endif void onSteppersDisabled() { - dgus_screen_handler.SteppersStatusChanged(false); + screen.steppersStatusChanged(false); } void onSteppersEnabled() { - dgus_screen_handler.SteppersStatusChanged(true); + screen.steppersStatusChanged(true); } }