🚸 Update Ender3 V2/S1 Pro UI (#23878)

Marlin/src/MarlinCore.cpp

   TERN_(USE_BEEPER, buzzer.tick());
 
   // Handle UI input / draw events
-  TERN(HAS_DWIN_E3V2_BASIC, DWIN_Update(), ui.update());
+  TERN(DWIN_CREALITY_LCD, DWIN_Update(), ui.update());
 
   // Run i2c Position Encoders
   #if ENABLED(I2C_POSITION_ENCODERS)
   #endif
 
   #if HAS_DWIN_E3V2_BASIC
-    SETUP_LOG("E3V2 Init");
-    Encoder_Configuration();
-    HMI_Init();
-    HMI_SetLanguageCache();
-    HMI_StartFrame(true);
+    SETUP_RUN(DWIN_InitScreen());
   #endif
 
   #if HAS_SERVICE_INTERVALS && !HAS_DWIN_E3V2_BASIC

Marlin/src/feature/pause.cpp

   #endif
 
   TERN_(HOST_PROMPT_SUPPORT, hostui.prompt_open(PROMPT_INFO, F("Pause"), FPSTR(DISMISS_STR)));
+  TERN_(DWIN_LCD_PROUI, DWIN_Print_Pause());
 
   // Indicate that the printer is paused
   ++did_pause_print;
 
   TERN_(HAS_FILAMENT_SENSOR, runout.reset());
 
-  TERN_(HAS_STATUS_MESSAGE, ui.reset_status());
+  TERN(DWIN_LCD_PROUI, DWIN_Print_Resume(), ui.reset_status());
   TERN_(HAS_MARLINUI_MENU, ui.return_to_status());
   TERN_(DWIN_LCD_PROUI, HMI_ReturnScreen());
 }

Marlin/src/gcode/bedlevel/mbl/G29.cpp

       if (!ui.wait_for_move) {
         queue.inject(parser.seen_test('N') ? F("G28" TERN(CAN_SET_LEVELING_AFTER_G28, "L0", "") "\nG29S2") : F("G29S2"));
         TERN_(EXTENSIBLE_UI, ExtUI::onMeshLevelingStart());
+        TERN_(DWIN_LCD_PROUI, DWIN_MeshLevelingStart());
         return;
       }
       state = MeshNext;
         // Save Z for the previous mesh position
         mbl.set_zigzag_z(mbl_probe_index - 1, current_position.z);
         TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(ix, iy, current_position.z));
+        TERN_(DWIN_LCD_PROUI, DWIN_MeshUpdate(_MIN(mbl_probe_index, GRID_MAX_POINTS), int(GRID_MAX_POINTS), current_position.z));
         SET_SOFT_ENDSTOP_LOOSE(false);
       }
       // If there's another point to sample, move there with optional lift.

Marlin/src/gcode/config/M302.cpp

 #include "../gcode.h"
 #include "../../module/temperature.h"
 
+#if ENABLED(DWIN_LCD_PROUI)
+  #include "../../lcd/e3v2/proui/dwin_defines.h"
+#endif
+
 /**
  * M302: Allow cold extrudes, or set the minimum extrude temperature
  *
   if (seen_S) {
     thermalManager.extrude_min_temp = parser.value_celsius();
     thermalManager.allow_cold_extrude = (thermalManager.extrude_min_temp == 0);
+    TERN_(DWIN_LCD_PROUI, HMI_data.ExtMinT = thermalManager.extrude_min_temp);
   }
 
   if (parser.seen('P'))

Marlin/src/gcode/sd/M524.cpp

 #include "../gcode.h"
 #include "../../sd/cardreader.h"
 
+#if ENABLED(DWIN_LCD_PROUI)
+  #include "../../lcd/e3v2/proui/dwin.h"
+#endif
+
 /**
  * M524: Abort the current SD print job (started with M24)
  */
 void GcodeSuite::M524() {
 
-  if (IS_SD_PRINTING())
-    card.abortFilePrintSoon();
-  else if (card.isMounted())
-    card.closefile();
+  #if ENABLED(DWIN_LCD_PROUI)
+
+    HMI_flag.abort_flag = true;    // The LCD will handle it
+
+  #else
+
+    if (IS_SD_PRINTING())
+      card.abortFilePrintSoon();
+    else if (card.isMounted())
+      card.closefile();
+
+  #endif
 
 }
 

Marlin/src/gcode/stats/M75-M78.cpp

 void GcodeSuite::M75() {
   startOrResumeJob();
   #if ENABLED(DWIN_LCD_PROUI)
-    DWIN_Print_Header(parser.string_arg && parser.string_arg[0] ? parser.string_arg : GET_TEXT(MSG_HOST_START_PRINT));
     DWIN_Print_Started(false);
+    if (!IS_SD_PRINTING()) DWIN_Print_Header(parser.string_arg && parser.string_arg[0] ? parser.string_arg : GET_TEXT(MSG_HOST_START_PRINT));
   #endif
 }
 
 void GcodeSuite::M76() {
   print_job_timer.pause();
   TERN_(HOST_PAUSE_M76, hostui.pause());
+  TERN_(DWIN_LCD_PROUI, DWIN_Print_Pause());
 }
 
 /**

Marlin/src/inc/Conditionals_LCD.h

 #if EITHER(HAS_DWIN_E3V2_BASIC, DWIN_CREALITY_LCD_JYERSUI)
   #define HAS_DWIN_E3V2 1
 #endif
+#if ENABLED(DWIN_LCD_PROUI)
+  #define DO_LIST_BIN_FILES 1
+#endif
 
 // E3V2 extras
 #if HAS_DWIN_E3V2 || IS_DWIN_MARLINUI
   #endif
 #endif
 
-#if ANY(HAS_WIRED_LCD, EXTENSIBLE_UI, DWIN_CREALITY_LCD_JYERSUI)
+#if ANY(HAS_WIRED_LCD, EXTENSIBLE_UI, DWIN_LCD_PROUI, DWIN_CREALITY_LCD_JYERSUI)
   #define HAS_DISPLAY 1
 #endif
 

Marlin/src/lcd/e3v2/common/encoder.h

   ENCODER_DIFF_ENTER = 3   // click
 } EncoderState;
 
+#define ENCODER_WAIT_MS 20
+
 // Encoder initialization
 void Encoder_Configuration();
 
 // Analyze encoder value and return state
 EncoderState Encoder_ReceiveAnalyze();
 
+inline EncoderState get_encoder_state() {
+  static millis_t Encoder_ms = 0;
+  const millis_t ms = millis();
+  if (PENDING(ms, Encoder_ms)) return ENCODER_DIFF_NO;
+  const EncoderState state = Encoder_ReceiveAnalyze();
+  if (state != ENCODER_DIFF_NO) Encoder_ms = ms + ENCODER_WAIT_MS;
+  return state;
+}
+
+template<typename T>
+inline bool Apply_Encoder(const EncoderState &encoder_diffState, T &valref) {
+  if (encoder_diffState == ENCODER_DIFF_CW)
+    valref += EncoderRate.encoderMoveValue;
+  else if (encoder_diffState == ENCODER_DIFF_CCW)
+    valref -= EncoderRate.encoderMoveValue;
+  return encoder_diffState == ENCODER_DIFF_ENTER;
+}
+
 /*********************** Encoder LED ***********************/
 
 #if PIN_EXISTS(LCD_LED)

Marlin/src/lcd/e3v2/creality/dwin.cpp

   if (is_sel) Draw_Menu_Cursor(0);
 }
 
-template <typename T>
-inline bool Apply_Encoder(const EncoderState &encoder_diffState, T &valref) {
-  if (encoder_diffState == ENCODER_DIFF_CW)
-    valref += EncoderRate.encoderMoveValue;
-  else if (encoder_diffState == ENCODER_DIFF_CCW)
-    valref -= EncoderRate.encoderMoveValue;
-  return encoder_diffState == ENCODER_DIFF_ENTER;
-}
-
 //
 // Draw Menus
 //
   TERN(HAS_ONESTEP_LEVELING, ICON_Leveling, ICON_StartInfo)();
 }
 
-inline EncoderState get_encoder_state() {
-  static millis_t Encoder_ms = 0;
-  const millis_t ms = millis();
-  if (PENDING(ms, Encoder_ms)) return ENCODER_DIFF_NO;
-  const EncoderState state = Encoder_ReceiveAnalyze();
-  if (state != ENCODER_DIFF_NO) Encoder_ms = ms + ENCODER_WAIT_MS;
-  return state;
-}
-
 void HMI_Plan_Move(const feedRate_t fr_mm_s) {
   if (!planner.is_full()) {
     planner.synchronize();
   HMI_SetLanguage();
 }
 
+void DWIN_InitScreen() {
+  Encoder_Configuration();
+  HMI_Init();
+  HMI_SetLanguageCache();
+  HMI_StartFrame(true);
+}
+
 void DWIN_Update() {
   EachMomentUpdate();   // Status update
   HMI_SDCardUpdate();   // SD card update

Marlin/src/lcd/e3v2/creality/dwin.h

 void HMI_Step();            // Transmission ratio
 
 void HMI_Init();
+void DWIN_InitScreen();
 void DWIN_Update();
 void EachMomentUpdate();
 void DWIN_HandleScreen();

Marlin/src/lcd/e3v2/proui/dwin.h

 #pragma once
 
 /**
- * Enhanced DWIN implementation
+ * DWIN Enhanced implementation for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 3.9.2
- * date: 2021/11/21
- *
- * Based on the original code provided by Creality under GPL
+ * Version: 3.15.2
+ * Date: 2022/03/01
  */
 
-#include "../../../inc/MarlinConfigPre.h"
+#include "dwin_defines.h"
 #include "dwinui.h"
 #include "../common/encoder.h"
 #include "../../../libs/BL24CXX.h"
 
-#if ANY(AUTO_BED_LEVELING_BILINEAR, AUTO_BED_LEVELING_LINEAR, AUTO_BED_LEVELING_3POINT) && DISABLED(PROBE_MANUALLY)
-  #define HAS_ONESTEP_LEVELING 1
-#endif
-
-#if !HAS_BED_PROBE && ENABLED(BABYSTEPPING)
-  #define JUST_BABYSTEP 1
-#endif
-
-#if ANY(BABYSTEPPING, HAS_BED_PROBE, HAS_WORKSPACE_OFFSET)
-  #define HAS_ZOFFSET_ITEM 1
-#endif
-
-#include "dwin_defines.h"
+#include "../../../inc/MarlinConfig.h"
 
 enum processID : uint8_t {
   // Process ID
   SetPFloat,
   SelectFile,
   PrintProcess,
-  PrintDone,
-  PwrlossRec,
-  Reboot,
-  Info,
-  ConfirmToPrint,
-
-  // Popup Windows
-  Homing,
+  Popup,
   Leveling,
-  PidProcess,
+  Locked,
+  Reboot,
+  PrintDone,
   ESDiagProcess,
-  PrintStatsProcess,
-  PauseOrStop,
-  FilamentPurge,
   WaitResponse,
-  Locked,
-  NothingToDo,
+  Homing,
+  PidProcess,
+  NothingToDo
 };
 
 enum pidresult_t : uint8_t {
 
 typedef struct {
   int8_t Color[3];                    // Color components
-  uint16_t pidgrphpoints  = 0;
   pidresult_t pidresult   = PID_DONE;
   int8_t Preheat          = 0;        // Material Select 0: PLA, 1: ABS, 2: Custom
   AxisEnum axis           = X_AXIS;   // Axis Select
-  int32_t MaxValue        = 0;        // Auxiliar max integer/scaled float value
-  int32_t MinValue        = 0;        // Auxiliar min integer/scaled float value
-  int8_t dp               = 0;        // Auxiliar decimal places
-  int32_t Value           = 0;        // Auxiliar integer / scaled float value
-  int16_t *P_Int          = nullptr;  // Auxiliar pointer to 16 bit integer variable
-  float *P_Float          = nullptr;  // Auxiliar pointer to float variable
-  void (*Apply)()         = nullptr;  // Auxiliar apply function
-  void (*LiveUpdate)()    = nullptr;  // Auxiliar live update function
 } HMI_value_t;
 
 typedef struct {
   uint8_t language;
+  bool remain_flag:1;   // remain was override by M73
   bool pause_flag:1;    // printing is paused
   bool pause_action:1;  // flag a pause action
+  bool abort_flag:1;    // printing is aborting
+  bool abort_action:1;  // flag a aborting action
   bool print_finish:1;  // print was finished
   bool select_flag:1;   // Popup button selected
   bool home_flag:1;     // homing in course
 #if HAS_HOTEND || HAS_HEATED_BED
   void DWIN_Popup_Temperature(const bool toohigh);
 #endif
-#if HAS_HOTEND
-  void Popup_Window_ETempTooLow();
-#endif
 #if ENABLED(POWER_LOSS_RECOVERY)
   void Popup_PowerLossRecovery();
 #endif
 void Goto_Info_Menu();
 void Goto_PowerLossRecovery();
 void Goto_ConfirmToPrint();
-void Draw_Status_Area(const bool with_update); // Status Area
+void DWIN_Draw_Dashboard(const bool with_update); // Status Area
 void Draw_Main_Area();      // Redraw main area;
 void DWIN_Redraw_screen();  // Redraw all screen elements
-void HMI_StartFrame(const bool with_update);   // Prepare the menu view
 void HMI_MainMenu();        // Main process screen
 void HMI_SelectFile();      // File page
 void HMI_Printing();        // Print page
 void HMI_ReturnScreen();    // Return to previous screen before popups
 void ApplyExtMinT();
 void HMI_SetLanguageCache(); // Set the languaje image cache
+void RebootPrinter();
+#if ENABLED(BAUD_RATE_GCODE)
+  void HMI_SetBaudRate();
+  void SetBaud115K();
+  void SetBaud250K();
+#endif
+#if ENABLED(EEPROM_SETTINGS)
+  void WriteEeprom();
+  void ReadEeprom();
+  void ResetEeprom();
+#endif
 
-void HMI_Init();
-void HMI_Popup();
+void HMI_WaitForUser();
 void HMI_SaveProcessID(const uint8_t id);
 void HMI_AudioFeedback(const bool success=true);
 void EachMomentUpdate();
 void update_variable();
+void DWIN_InitScreen();
 void DWIN_HandleScreen();
-void DWIN_Update();
 void DWIN_CheckStatusMessage();
 void DWIN_StartHoming();
 void DWIN_CompletedHoming();
 #if HAS_MESH
-  void DWIN_MeshUpdate(const int8_t xpos, const int8_t ypos, const float zval);
+  void DWIN_MeshUpdate(const int8_t xpos, const int8_t ypos, const_float_t zval);
 #endif
 void DWIN_MeshLevelingStart();
 void DWIN_CompletedLeveling();
 void DWIN_PidTuning(pidresult_t result);
-void DWIN_Print_Started(const bool sd = false);
+void DWIN_Print_Started(const bool sd=false);
+void DWIN_Print_Pause();
+void DWIN_Print_Resume();
 void DWIN_Print_Finished();
+void DWIN_Print_Aborted();
 #if HAS_FILAMENT_SENSOR
   void DWIN_FilamentRunout(const uint8_t extruder);
 #endif
 void DWIN_Progress_Update();
 void DWIN_Print_Header(const char *text);
 void DWIN_SetColorDefaults();
+void DWIN_ApplyColor();
 void DWIN_StoreSettings(char *buff);
 void DWIN_LoadSettings(const char *buff);
 void DWIN_SetDataDefaults();
 void DWIN_RebootScreen();
 
 #if ENABLED(ADVANCED_PAUSE_FEATURE)
+  void DWIN_Popup_Pause(FSTR_P const fmsg, uint8_t button=0);
   void Draw_Popup_FilamentPurge();
-  void DWIN_Popup_FilamentPurge();
+  void Goto_FilamentPurge();
   void HMI_FilamentPurge();
 #endif
 
   void Draw_PrintStats();
 #endif
 
-// HMI user control functions
-void HMI_Menu();
-void HMI_SetInt();
-void HMI_SetPInt();
-void HMI_SetIntNoDraw();
-void HMI_SetFloat();
-void HMI_SetPFloat();
-
 // Menu drawing functions
 void Draw_Control_Menu();
 void Draw_AdvancedSettings_Menu();

Marlin/src/lcd/e3v2/proui/dwin_defines.h

 #pragma once
 
 /**
- * DWIN general defines and data structs
+ * DWIN general defines and data structs for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 3.9.2
- * Date: 2021/11/21
- *
- * Based on the original code provided by Creality under GPL
+ * Version: 3.11.2
+ * Date: 2022/02/28
  */
 
-//#define NEED_HEX_PRINT 1
 //#define DEBUG_DWIN 1
+//#define NEED_HEX_PRINT 1
+
+#include "../../../inc/MarlinConfigPre.h"
+#include <stddef.h>
+
+#if DISABLED(INDIVIDUAL_AXIS_HOMING_SUBMENU)
+  #error "INDIVIDUAL_AXIS_HOMING_SUBMENU is required with ProUI."
+#endif
+#if DISABLED(LCD_SET_PROGRESS_MANUALLY)
+  #error "LCD_SET_PROGRESS_MANUALLY is required with ProUI."
+#endif
+#if DISABLED(STATUS_MESSAGE_SCROLLING)
+  #error "STATUS_MESSAGE_SCROLLING is required with ProUI."
+#endif
+#if DISABLED(BAUD_RATE_GCODE)
+  #error "BAUD_RATE_GCODE is required with ProUI."
+#endif
+#if DISABLED(SOUND_MENU_ITEM)
+  #error "SOUND_MENU_ITEM is required with ProUI."
+#endif
+#if DISABLED(PRINTCOUNTER)
+  #error "PRINTCOUNTER is required with ProUI."
+#endif
 
-#include "../../../core/types.h"
 #include "../common/dwin_color.h"
 #if ENABLED(LED_CONTROL_MENU)
   #include "../../../feature/leds/leds.h"
 #define Def_Barfill_Color     BarFill_Color
 #define Def_Indicator_Color   Color_White
 #define Def_Coordinate_Color  Color_White
+#define Def_Button_Color      RGB( 0, 23, 16)
 
-//#define HAS_GCODE_PREVIEW 1
 #define HAS_ESDIAG 1
 
 #if ENABLED(LED_CONTROL_MENU, HAS_COLOR_LEDS)
   #if ENABLED(PREVENT_COLD_EXTRUSION)
     int16_t ExtMinT = EXTRUDE_MINTEMP;
   #endif
+  int16_t BedLevT = PREHEAT_1_TEMP_BED;
+  TERN_(BAUD_RATE_GCODE, bool Baud115K = false);
+  bool FullManualTramming = false;
   // Led
   #if BOTH(LED_CONTROL_MENU, HAS_COLOR_LEDS)
     LEDColor Led_Color = Def_Leds_Color;
 
 static constexpr size_t eeprom_data_size = 64;
 extern HMI_data_t HMI_data;
+
+#if PREHEAT_1_TEMP_BED
+  #undef LEVELING_BED_TEMP
+  #define LEVELING_BED_TEMP HMI_data.BedLevT
+#endif

Marlin/src/lcd/e3v2/proui/dwin_lcd.cpp

  */
 
 /**
- * DWIN UI Enhanced implementation
+ * DWIN Enhanced implementation for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 3.8.1
- * Date: 2021/11/09
- *
- * Based on the original code provided by Creality under GPL
+ * Version: 3.9.1
+ * Date: 2022/02/08
  */
 
 #include "../../../inc/MarlinConfigPre.h"
 
 #include "dwin_lcd.h"
 
+/*---------------------------------------- Numeric related functions ----------------------------------------*/
+
+// Draw a numeric value
+//  bShow: true=display background color; false=don't display background color
+//  zeroFill: true=zero fill; false=no zero fill
+//  signedMode: 1=signed; 0=unsigned
+//  zeroMode: 1=leading 0 displayed as 0; 0=leading 0 displayed as a space
+//  size: Font size
+//  color: Character color
+//  bColor: Background color
+//  iNum: Number of digits
+//  fNum: Number of decimal digits
+//  x/y: Upper-left coordinate
+//  value: Integer value
+void DWIN_Draw_Value(uint8_t bShow, bool signedMode, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color,
+                          uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, int32_t value) {
+  size_t i = 0;
+  DWIN_Byte(i, 0x14);
+  // Bit 7: bshow
+  // Bit 6: 1 = signed; 0 = unsigned number;
+  // Bit 5: zeroFill
+  // Bit 4: zeroMode
+  // Bit 3-0: size
+  DWIN_Byte(i, (bShow * 0x80) | (signedMode * 0x40) | (zeroFill * 0x20) | (zeroMode * 0x10) | size);
+  DWIN_Word(i, color);
+  DWIN_Word(i, bColor);
+  DWIN_Byte(i, signedMode && (value >= 0) ? iNum + 1 : iNum);
+  DWIN_Byte(i, fNum);
+  DWIN_Word(i, x);
+  DWIN_Word(i, y);
+  // Write a big-endian 64 bit integer
+  const size_t p = i + 1;
+  for (size_t count = 8; count--;) { // 7..0
+    ++i;
+    DWIN_SendBuf[p + count] = value;
+    value >>= 8;
+  }
+  DWIN_Send(i);
+}
+
+// Draw a numeric value
+//  value: positive unscaled float value
+void DWIN_Draw_Value(uint8_t bShow, bool signedMode, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color,
+                          uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value) {
+  const int32_t val = round(value * POW(10, fNum));
+  DWIN_Draw_Value(bShow, signedMode, zeroFill, zeroMode, size, color, bColor, iNum, fNum, x, y, val);
+}
+
 /*---------------------------------------- Picture related functions ----------------------------------------*/
 
 // Display QR code

Marlin/src/lcd/e3v2/proui/dwin_lcd.h

 #pragma once
 
 /**
- * DWIN UI Enhanced implementation
+ * DWIN Enhanced implementation for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 3.8.1
- * Date: 2021/11/09
- *
- * Based on the original code provided by Creality under GPL
+ * Version: 3.9.1
+ * Date: 2022/02/08
  */
 
 #include "../common/dwin_api.h"
 
+// Draw a numeric value
+//  bShow: true=display background color; false=don't display background color
+//  zeroFill: true=zero fill; false=no zero fill
+//  signedMode: 1=signed; 0=unsigned
+//  zeroMode: 1=leading 0 displayed as 0; 0=leading 0 displayed as a space
+//  size: Font size
+//  color: Character color
+//  bColor: Background color
+//  iNum: Number of digits
+//  fNum: Number of decimal digits
+//  x/y: Upper-left coordinate
+//  value: Integer value
+void DWIN_Draw_Value(uint8_t bShow, bool signedMode, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color,
+                          uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, int32_t value);
+//  value: positive unscaled float value
+void DWIN_Draw_Value(uint8_t bShow, bool signedMode, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color,
+                          uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value);
+
 // Display QR code
 //  The size of the QR code is (46*QR_Pixel)*(46*QR_Pixel) dot matrix
 //  QR_Pixel: The pixel size occupied by each point of the QR code: 0x01-0x0F (1-16)

Marlin/src/lcd/e3v2/proui/dwin_popup.cpp

  */
 
 /**
- * DWIN UI Enhanced implementation
+ * DWIN Enhanced implementation for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 3.10.1
- * Date: 2022/01/21
- *
- * Based on the original code provided by Creality under GPL
+ * Version: 3.11.1
+ * Date: 2022/02/28
  */
 
 #include "../../../inc/MarlinConfigPre.h"
 #if ENABLED(DWIN_LCD_PROUI)
 
 #include "dwin.h"
+#include "dwinui.h"
 #include "dwin_popup.h"
 
-void Draw_Select_Highlight(const bool sel) {
+#include "../../../MarlinCore.h" // for wait_for_user
+
+popupDrawFunc_t popupDraw = nullptr;
+popupClickFunc_t popupClick = nullptr;
+popupChangeFunc_t popupChange = nullptr;
+
+uint16_t HighlightYPos = 280;
+
+void Draw_Select_Highlight(const bool sel, const uint16_t ypos) {
+  HighlightYPos = ypos;
   HMI_flag.select_flag = sel;
   const uint16_t c1 = sel ? HMI_data.Highlight_Color : HMI_data.PopupBg_color,
                  c2 = sel ? HMI_data.PopupBg_color : HMI_data.Highlight_Color;
-  DWIN_Draw_Rectangle(0, c1, 25, 279, 126, 318);
-  DWIN_Draw_Rectangle(0, c1, 24, 278, 127, 319);
-  DWIN_Draw_Rectangle(0, c2, 145, 279, 246, 318);
-  DWIN_Draw_Rectangle(0, c2, 144, 278, 247, 319);
+  DWIN_Draw_Rectangle(0, c1, 25, ypos - 1, 126, ypos + 38);
+  DWIN_Draw_Rectangle(0, c1, 24, ypos - 2, 127, ypos + 39);
+  DWIN_Draw_Rectangle(0, c2, 145, ypos - 1, 246, ypos + 38);
+  DWIN_Draw_Rectangle(0, c2, 144, ypos - 2, 247, ypos + 39);
 }
 
 void DWIN_Popup_Continue(const uint8_t icon, FSTR_P const fmsg1, FSTR_P const fmsg2) {
   HMI_SaveProcessID(WaitResponse);
-  DWIN_Draw_Popup(icon, fmsg1, fmsg2, ICON_Continue_E);  // Button Continue
+  DWIN_Draw_Popup(icon, fmsg1, fmsg2, BTN_Continue);  // Button Continue
   DWIN_UpdateLCD();
 }
 
 void DWIN_Popup_ConfirmCancel(const uint8_t icon, FSTR_P const fmsg2) {
   DWIN_Draw_Popup(ICON_BLTouch, F("Please confirm"), fmsg2);
-  DWINUI::Draw_IconWB(ICON_Confirm_E, 26, 280);
-  DWINUI::Draw_IconWB(ICON_Cancel_E, 146, 280);
-  Draw_Select_Highlight(true);
+  DWINUI::Draw_Button(BTN_Confirm, 26, 280);
+  DWINUI::Draw_Button(BTN_Cancel, 146, 280);
+  Draw_Select_Highlight(HMI_flag.select_flag);
   DWIN_UpdateLCD();
 }
 
+void Goto_Popup(const popupDrawFunc_t fnDraw, const popupClickFunc_t fnClick/*=nullptr*/, const popupChangeFunc_t fnChange/*=nullptr*/) {
+  popupDraw = fnDraw;
+  popupClick = fnClick;
+  popupChange = fnChange;
+  HMI_SaveProcessID(Popup);
+  HMI_flag.select_flag = false;
+  popupDraw();
+}
+
+void HMI_Popup() {
+  if (!wait_for_user) {
+    if (popupClick) popupClick();
+    return;
+  }
+  else {
+    EncoderState encoder_diffState = get_encoder_state();
+    if (encoder_diffState == ENCODER_DIFF_CW || encoder_diffState == ENCODER_DIFF_CCW) {
+      const bool change = encoder_diffState != ENCODER_DIFF_CW;
+      if (popupChange) popupChange(change); else Draw_Select_Highlight(change, HighlightYPos);
+      DWIN_UpdateLCD();
+    }
+  }
+}
+
 #endif // DWIN_LCD_PROUI

Marlin/src/lcd/e3v2/proui/dwin_popup.h

 #pragma once
 
 /**
- * DWIN UI Enhanced implementation
+ * DWIN Enhanced implementation for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 3.10.1
- * Date: 2022/01/21
- *
- * Based on the original code provided by Creality under GPL
+ * Version: 3.11.1
+ * Date: 2022/02/28
  */
 
 #include "dwinui.h"
 #include "dwin.h"
 
-// Popup windows
+typedef void (*popupDrawFunc_t)();
+typedef void (*popupClickFunc_t)();
+typedef void (*popupChangeFunc_t)(const bool state);
+extern popupDrawFunc_t popupDraw;
 
-void Draw_Select_Highlight(const bool sel);
+void Draw_Select_Highlight(const bool sel, const uint16_t ypos);
+inline void Draw_Select_Highlight(const bool sel) { Draw_Select_Highlight(sel, 280); };
+void DWIN_Popup_Continue(const uint8_t icon, FSTR_P const fmsg1, FSTR_P const fmsg2);
+void DWIN_Popup_ConfirmCancel(const uint8_t icon, FSTR_P const fmsg2);
+void Goto_Popup(const popupDrawFunc_t fnDraw, const popupClickFunc_t fnClick=nullptr, const popupChangeFunc_t fnChange=nullptr);
+void HMI_Popup();
 
 inline void Draw_Popup_Bkgd() {
   DWIN_Draw_Rectangle(1, HMI_data.PopupBg_color, 14, 60, 258, 330);
   if (icon) DWINUI::Draw_Icon(icon, 101, 105);
   if (amsg1) DWINUI::Draw_CenteredString(HMI_data.PopupTxt_Color, 210, amsg1);
   if (amsg2) DWINUI::Draw_CenteredString(HMI_data.PopupTxt_Color, 240, amsg2);
-  if (button) DWINUI::Draw_IconWB(button, 86, 280);
+  if (button) DWINUI::Draw_Button(button, 86, 280);
 }
 
 template<typename T, typename U>
 template<typename T, typename U>
 void DWIN_Popup_Confirm(const uint8_t icon, T amsg1, U amsg2) {
   HMI_SaveProcessID(WaitResponse);
-  DWIN_Draw_Popup(icon, amsg1, amsg2, ICON_Confirm_E);  // Button Confirm
+  DWIN_Draw_Popup(icon, amsg1, amsg2, BTN_Confirm);  // Button Confirm
   DWIN_UpdateLCD();
 }
 
-void DWIN_Popup_Continue(const uint8_t icon, FSTR_P const fmsg1, FSTR_P const fmsg2);
-
-void DWIN_Popup_ConfirmCancel(const uint8_t icon, FSTR_P const fmsg2);

Marlin/src/lcd/e3v2/proui/dwinui.cpp

  */
 
 /**
- * DWIN UI Enhanced implementation
+ * DWIN Enhanced implementation for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 3.8.2
- * Date: 2021/11/09
- *
- * Based on the original code provided by Creality under GPL
+ * Version: 3.15.1
+ * Date: 2022/02/25
  */
 
 #include "../../../inc/MarlinConfigPre.h"
 uint16_t DWINUI::pencolor = Color_White;
 uint16_t DWINUI::textcolor = Def_Text_Color;
 uint16_t DWINUI::backcolor = Def_Background_Color;
+uint16_t DWINUI::buttoncolor = Def_Button_Color;
 uint8_t  DWINUI::font = font8x16;
+FSTR_P const DWINUI::Author = F(STRING_CONFIG_H_AUTHOR);
 
 void (*DWINUI::onCursorErase)(const int8_t line)=nullptr;
 void (*DWINUI::onCursorDraw)(const int8_t line)=nullptr;
 void (*DWINUI::onMenuDraw)(MenuClass* menu)=nullptr;
 
 void DWINUI::init() {
-  DEBUG_ECHOPGM("\r\nDWIN handshake ");
-  delay(750);   // Delay here or init later in the boot process
-  const bool success = DWIN_Handshake();
-  if (success) DEBUG_ECHOLNPGM("ok."); else DEBUG_ECHOLNPGM("error.");
+  TERN_(DEBUG_DWIN, SERIAL_ECHOPGM("\r\nDWIN handshake "));
+  delay(750);   // Delay for wait to wakeup screen
+  const bool hs = DWIN_Handshake();
+  TERN(DEBUG_DWIN, SERIAL_ECHOLNF(hs ? F("ok.") : F("error.")), UNUSED(hs));
   DWIN_Frame_SetDir(1);
-  TERN(SHOW_BOOTSCREEN,,DWIN_Frame_Clear(Color_Bg_Black));
-  DWIN_UpdateLCD();
-  cursor.x = 0;
-  cursor.y = 0;
+  cursor.reset();
   pencolor = Color_White;
   textcolor = Def_Text_Color;
   backcolor = Def_Background_Color;
+  buttoncolor = Def_Button_Color;
   font = font8x16;
 }
 
 }
 
 // Set text/number color
-void DWINUI::SetColors(uint16_t fgcolor, uint16_t bgcolor) {
+void DWINUI::SetColors(uint16_t fgcolor, uint16_t bgcolor, uint16_t alcolor) {
   textcolor = fgcolor;
   backcolor = bgcolor;
+  buttoncolor = alcolor;
 }
 void DWINUI::SetTextColor(uint16_t fgcolor) {
   textcolor = fgcolor;
   cursor += point;
 }
 
-// Draw a Centered string using DWIN_WIDTH
-void DWINUI::Draw_CenteredString(bool bShow, uint8_t size, uint16_t color, uint16_t bColor, uint16_t y, const char * const string) {
-  const int8_t x = _MAX(0U, DWIN_WIDTH - strlen_P(string) * fontWidth(size)) / 2 - 1;
+// Draw a Centered string using arbitrary x1 and x2 margins
+void DWINUI::Draw_CenteredString(bool bShow, uint8_t size, uint16_t color, uint16_t bColor, uint16_t x1, uint16_t x2, uint16_t y, const char * const string) {
+  const uint16_t x = _MAX(0U, x2 + x1 - strlen_P(string) * fontWidth(size)) / 2 - 1;
   DWIN_Draw_String(bShow, size, color, bColor, x, y, string);
 }
 
+// // Draw a Centered string using DWIN_WIDTH
+// void DWINUI::Draw_CenteredString(bool bShow, uint8_t size, uint16_t color, uint16_t bColor, uint16_t y, const char * const string) {
+//   const int8_t x = _MAX(0U, DWIN_WIDTH - strlen_P(string) * fontWidth(size)) / 2 - 1;
+//   DWIN_Draw_String(bShow, size, color, bColor, x, y, string);
+// }
+
 // Draw a char at cursor position
-void DWINUI::Draw_Char(const char c) {
+void DWINUI::Draw_Char(uint16_t color, const char c) {
   const char string[2] = { c, 0};
-  DWIN_Draw_String(false, font, textcolor, backcolor, cursor.x, cursor.y, string, 1);
+  DWIN_Draw_String(false, font, color, backcolor, cursor.x, cursor.y, string, 1);
   MoveBy(fontWidth(font), 0);
 }
 
   MoveBy(strlen(string) * fontWidth(font), 0);
 }
 
-// Draw a signed floating point number
-//  bShow: true=display background color; false=don't display background color
-//  zeroFill: true=zero fill; false=no zero fill
-//  zeroMode: 1=leading 0 displayed as 0; 0=leading 0 displayed as a space
-//  size: Font size
-//  bColor: Background color
-//  iNum: Number of whole digits
-//  fNum: Number of decimal digits
-//  x/y: Upper-left point
-//  value: Float value
-void DWINUI::Draw_Signed_Float(uint8_t bShow, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color, uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value) {
-  DWIN_Draw_FloatValue(bShow, zeroFill, zeroMode, size, color, bColor, iNum, fNum, x, y, value < 0 ? -value : value);
-  DWIN_Draw_String(bShow, size, color, bColor, x - 6, y, value < 0 ? F("-") : F(" "));
+// ------------------------- Buttons ------------------------------//
+
+void DWINUI::Draw_Button(uint16_t color, uint16_t bcolor, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, const char * const caption) {
+  DWIN_Draw_Rectangle(1, bcolor, x1, y1, x2, y2);
+  Draw_CenteredString(0, font, color, bcolor, x1, x2, (y2 + y1 - fontHeight())/2, caption);
+}
+
+void DWINUI::Draw_Button(uint8_t id, uint16_t x, uint16_t y) {
+  switch (id) {
+    case BTN_Cancel  : Draw_Button(GET_TEXT_F(MSG_BUTTON_CANCEL), x, y); break;
+    case BTN_Confirm : Draw_Button(GET_TEXT_F(MSG_BUTTON_CONFIRM), x, y); break;
+    case BTN_Continue: Draw_Button(GET_TEXT_F(MSG_BUTTON_CONTINUE), x, y); break;
+    case BTN_Print   : Draw_Button(GET_TEXT_F(MSG_BUTTON_PRINT), x, y); break;
+    case BTN_Save    : Draw_Button(GET_TEXT_F(MSG_BUTTON_SAVE), x, y); break;
+    default: break;
+  }
 }
 
+// -------------------------- Extra -------------------------------//
+
 // Draw a circle
 //  color: circle color
 //  x: the abscissa of the center of the circle
 //  color1 : Start color
 //  color2 : End color
 uint16_t DWINUI::ColorInt(int16_t val, int16_t minv, int16_t maxv, uint16_t color1, uint16_t color2) {
-  uint8_t B,G,R;
-  float n;
-  n = (float)(val-minv)/(maxv-minv);
-  R = (1-n)*GetRColor(color1) + n*GetRColor(color2);
-  G = (1-n)*GetGColor(color1) + n*GetGColor(color2);
-  B = (1-n)*GetBColor(color1) + n*GetBColor(color2);
-  return RGB(R,G,B);
+  uint8_t B, G, R;
+  const float n = (float)(val - minv) / (maxv - minv);
+  R = (1 - n) * GetRColor(color1) + n * GetRColor(color2);
+  G = (1 - n) * GetGColor(color1) + n * GetGColor(color2);
+  B = (1 - n) * GetBColor(color1) + n * GetBColor(color2);
+  return RGB(R, G, B);
 }
 
 // Color Interpolator through Red->Yellow->Green->Blue
 //  minv : Minimum value
 //  maxv : Maximum value
 uint16_t DWINUI::RainbowInt(int16_t val, int16_t minv, int16_t maxv) {
-  uint8_t B,G,R;
-  const uint8_t maxB = 28;
-  const uint8_t maxR = 28;
-  const uint8_t maxG = 38;
+  uint8_t B, G, R;
+  const uint8_t maxB = 28, maxR = 28, maxG = 38;
   const int16_t limv = _MAX(abs(minv), abs(maxv));
-  float n;
-  if (minv>=0) {
-    n = (float)(val-minv)/(maxv-minv);
-  } else {
-    n = (float)val/limv;
-  }
-  n = _MIN(1, n);
-  n = _MAX(-1, n);
+  float n = minv >= 0 ? (float)(val - minv) / (maxv - minv) : (float)val / limv;
+  LIMIT(n, -1, 1);
   if (n < 0) {
     R = 0;
-    G = (1+n)*maxG;
-    B = (-n)*maxB;
-  } else if (n < 0.5) {
-    R = maxR*n*2;
+    G = (1 + n) * maxG;
+    B = (-n) * maxB;
+  }
+  else if (n < 0.5) {
+    R = maxR * n * 2;
     G = maxG;
     B = 0;
-  } else {
+  }
+  else {
     R = maxR;
-    G = maxG*(1-n);
+    G = maxG * (1 - n);
     B = 0;
   }
-  return RGB(R,G,B);
+  return RGB(R, G, B);
 }
 
 // Draw a checkbox

Marlin/src/lcd/e3v2/proui/dwinui.h

 #pragma once
 
 /**
- * DWIN UI Enhanced implementation
+ * DWIN Enhanced implementation for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 3.11.1
- * Date: 2022/01/19
- *
- * Based on the original code provided by Creality under GPL
+ * Version: 3.15.1
+ * Date: 2022/02/25
  */
 
 #include "dwin_lcd.h"
 #define ICON_CaseLight            ICON_Motion
 #define ICON_LedControl           ICON_Motion
 
+// Buttons
+#define BTN_Continue          85
+#define BTN_Cancel            87
+#define BTN_Confirm           89
+#define BTN_Print             90
+#define BTN_Save              91
+
 // Extended and default UI Colors
 #define Color_Black           0
 #define Color_Green           RGB(0,63,0)
 #define DWIN_FONT_HEAD font10x20
 #define DWIN_FONT_ALERT font10x20
 #define STATUS_Y 354
-#define LCD_WIDTH (DWIN_WIDTH / 8)
+#define LCD_WIDTH (DWIN_WIDTH / 8)  // only if the default font is font8x16
+
+// Minimum unit (0.1) : multiple (10)
+#define UNITFDIGITS 1
+#define MINUNITMULT POW(10, UNITFDIGITS)
 
 constexpr uint16_t TITLE_HEIGHT = 30,                          // Title bar height
                    MLINE = 53,                                 // Menu line height
   extern uint16_t pencolor;
   extern uint16_t textcolor;
   extern uint16_t backcolor;
+  extern uint16_t buttoncolor;
   extern uint8_t  font;
+  extern FSTR_P const Author;
 
   extern void (*onCursorErase)(const int8_t line);
   extern void (*onCursorDraw)(const int8_t line);
   uint16_t RowToY(uint8_t row);
 
   // Set text/number color
-  void SetColors(uint16_t fgcolor, uint16_t bgcolor);
+  void SetColors(uint16_t fgcolor, uint16_t bgcolor, uint16_t alcolor);
   void SetTextColor(uint16_t fgcolor);
   void SetBackgroundColor(uint16_t bgcolor);
 
     DWIN_Draw_Line(pencolor, cursor.x, cursor.y, x, y);
   }
 
+  // Extend a frame box
+  //  v: value to extend
+  inline frame_rect_t ExtendFrame(frame_rect_t frame, uint8_t v) {
+    frame_rect_t t;
+    t.x = frame.x - v;
+    t.y = frame.y - v;
+    t.w = frame.w + 2 * v;
+    t.h = frame.h + 2 * v;
+    return t;
+  }
+
   // Draw an Icon with transparent background from the library ICON
   //  icon: Icon ID
   //  x/y: Upper-left point
   //  x/y: Upper-left coordinate
   //  value: Integer value
   inline void Draw_Int(uint8_t bShow, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color, uint16_t bColor, uint8_t iNum, uint16_t x, uint16_t y, long value) {
-    DWIN_Draw_IntValue(bShow, zeroFill, zeroMode, size, color, bColor, iNum, x, y, value);
+    DWIN_Draw_Value(bShow, 0, zeroFill, zeroMode, size, color, bColor, iNum, 0, x, y, value);
   }
   inline void Draw_Int(uint8_t iNum, long value) {
-    DWIN_Draw_IntValue(false, true, 0, font, textcolor, backcolor, iNum, cursor.x, cursor.y, value);
+    DWIN_Draw_Value(false, 0, true, 0, font, textcolor, backcolor, iNum, 0, cursor.x, cursor.y, value);
     MoveBy(iNum * fontWidth(font), 0);
   }
   inline void Draw_Int(uint8_t iNum, uint16_t x, uint16_t y, long value) {
-    DWIN_Draw_IntValue(false, true, 0, font, textcolor, backcolor, iNum, x, y, value);
+    DWIN_Draw_Value(false, 0, true, 0, font, textcolor, backcolor, iNum, 0, x, y, value);
   }
   inline void Draw_Int(uint16_t color, uint8_t iNum, uint16_t x, uint16_t y, long value) {
-    DWIN_Draw_IntValue(false, true, 0, font, color, backcolor, iNum, x, y, value);
+    DWIN_Draw_Value(false, 0, true, 0, font, color, backcolor, iNum, 0, x, y, value);
   }
   inline void Draw_Int(uint16_t color, uint16_t bColor, uint8_t iNum, uint16_t x, uint16_t y, long value) {
-    DWIN_Draw_IntValue(true, true, 0, font, color, bColor, iNum, x, y, value);
+    DWIN_Draw_Value(true, 0, true, 0, font, color, bColor, iNum, 0, x, y, value);
   }
   inline void Draw_Int(uint8_t size, uint16_t color, uint16_t bColor, uint8_t iNum, uint16_t x, uint16_t y, long value) {
-    DWIN_Draw_IntValue(true, true, 0, size, color, bColor, iNum, x, y, value);
+    DWIN_Draw_Value(true, 0, true, 0, size, color, bColor, iNum, 0, x, y, value);
   }
 
-  // Draw a floating point number
+  // Draw a signed integer
+  //  bShow: true=display background color; false=don't display background color
+  //  zeroFill: true=zero fill; false=no zero fill
+  //  zeroMode: 1=leading 0 displayed as 0; 0=leading 0 displayed as a space
+  //  size: Font size
+  //  color: Character color
+  //  bColor: Background color
+  //  iNum: Number of digits
+  //  x/y: Upper-left coordinate
+  //  value: Integer value
+  inline void Draw_Signed_Int(uint8_t bShow, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color, uint16_t bColor, uint8_t iNum, uint16_t x, uint16_t y, long value) {
+    DWIN_Draw_Value(bShow, 1, zeroFill, zeroMode, size, color, bColor, iNum, 0, x, y, value);
+  }
+  inline void Draw_Signed_Int(uint8_t iNum, long value) {
+    DWIN_Draw_Value(false, 1, true, 0, font, textcolor, backcolor, iNum, 0, cursor.x, cursor.y, value);
+    MoveBy(iNum * fontWidth(font), 0);
+  }
+  inline void Draw_Signed_Int(uint8_t iNum, uint16_t x, uint16_t y, long value) {
+    DWIN_Draw_Value(false, 1, true, 0, font, textcolor, backcolor, iNum, 0, x, y, value);
+  }
+  inline void Draw_Signed_Int(uint16_t color, uint8_t iNum, uint16_t x, uint16_t y, long value) {
+    DWIN_Draw_Value(false, 1, true, 0, font, color, backcolor, iNum, 0, x, y, value);
+  }
+  inline void Draw_Signed_Int(uint16_t color, uint16_t bColor, uint8_t iNum, uint16_t x, uint16_t y, long value) {
+    DWIN_Draw_Value(true, 1, true, 0, font, color, bColor, iNum, 0, x, y, value);
+  }
+  inline void Draw_Signed_Int(uint8_t size, uint16_t color, uint16_t bColor, uint8_t iNum, uint16_t x, uint16_t y, long value) {
+    DWIN_Draw_Value(true, 1, true, 0, size, color, bColor, iNum, 0, x, y, value);
+  }
+
+  // Draw a positive floating point number
   //  bShow: true=display background color; false=don't display background color
   //  zeroFill: true=zero fill; false=no zero fill
   //  zeroMode: 1=leading 0 displayed as 0; 0=leading 0 displayed as a space
   //  x/y: Upper-left point
   //  value: Float value
   inline void Draw_Float(uint8_t bShow, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color, uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value) {
-    DWIN_Draw_FloatValue(bShow, zeroFill, zeroMode, size, color, bColor, iNum, fNum, x, y, value);
+    DWIN_Draw_Value(bShow, 0, zeroFill, zeroMode, size, color, bColor, iNum, fNum, x, y, value);
   }
   inline void Draw_Float(uint8_t iNum, uint8_t fNum, float value) {
-    DWIN_Draw_FloatValue(false, true, 0, font, textcolor, backcolor, iNum, fNum,  cursor.x, cursor.y, value);
+    DWIN_Draw_Value(false, 0, true, 0, font, textcolor, backcolor, iNum, fNum, cursor.x, cursor.y, value);
     MoveBy((iNum + fNum + 1) * fontWidth(font), 0);
   }
   inline void Draw_Float(uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value) {
-    DWIN_Draw_FloatValue(false, true, 0, font, textcolor, backcolor, iNum, fNum, x, y, value);
+    DWIN_Draw_Value(false, 0, true, 0, font, textcolor, backcolor, iNum, fNum, x, y, value);
   }
   inline void Draw_Float(uint16_t color, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value) {
-    DWIN_Draw_FloatValue(false, true, 0, font, color, backcolor, iNum, fNum, x, y, value);
+    DWIN_Draw_Value(false, 0, true, 0, font, color, backcolor, iNum, fNum, x, y, value);
   }
   inline void Draw_Float(uint16_t color, uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value) {
-    DWIN_Draw_FloatValue(true, true, 0, font, color, bColor, iNum, fNum, x, y, value);
+    DWIN_Draw_Value(true, 0, true, 0, font, color, bColor, iNum, fNum, x, y, value);
   }
   inline void Draw_Float(uint8_t size, uint16_t color, uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value) {
-    DWIN_Draw_FloatValue(true, true, 0, size, color, bColor, iNum, fNum, x, y, value);
+    DWIN_Draw_Value(true, 0, true, 0, size, color, bColor, iNum, fNum, x, y, value);
   }
 
   // Draw a signed floating point number
   //  zeroFill: true=zero fill; false=no zero fill
   //  zeroMode: 1=leading 0 displayed as 0; 0=leading 0 displayed as a space
   //  size: Font size
+  //  color: Character color
   //  bColor: Background color
   //  iNum: Number of whole digits
   //  fNum: Number of decimal digits
   //  x/y: Upper-left point
   //  value: Float value
-  void Draw_Signed_Float(uint8_t bShow, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color, uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value);
+  inline void Draw_Signed_Float(uint8_t bShow, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color, uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value) {
+    DWIN_Draw_Value(bShow, 1, zeroFill, zeroMode, size, color, bColor, iNum, fNum, x, y, value);
+  }
   inline void Draw_Signed_Float(uint8_t iNum, uint8_t fNum, float value) {
-    Draw_Signed_Float(false, true, 0, font, textcolor, backcolor, iNum, fNum, cursor.x, cursor.y, value);
+    DWIN_Draw_Value(false, 1, true, 0, font, textcolor, backcolor, iNum, fNum, cursor.x, cursor.y, value);
     MoveBy((iNum + fNum + 1) * fontWidth(font), 0);
   }
   inline void Draw_Signed_Float(uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value) {
-    Draw_Signed_Float(false, true, 0, font, textcolor, backcolor, iNum, fNum, x, y, value);
+    DWIN_Draw_Value(false, 1, true, 0, font, textcolor, backcolor, iNum, fNum, x, y, value);
   }
   inline void Draw_Signed_Float(uint8_t size, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value) {
-    Draw_Signed_Float(false, true, 0, size, textcolor, backcolor, iNum, fNum, x, y, value);
+    DWIN_Draw_Value(false, 1, true, 0, size, textcolor, backcolor, iNum, fNum, x, y, value);
   }
   inline void Draw_Signed_Float(uint16_t color, uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value) {
-    Draw_Signed_Float(true, true, 0, font, color, bColor, iNum, fNum, x, y, value);
+    DWIN_Draw_Value(true, 1, true, 0, font, color, bColor, iNum, fNum, x, y, value);
   }
   inline void Draw_Signed_Float(uint8_t size, uint16_t color, uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value) {
-    Draw_Signed_Float(true, true, 0, size, color, bColor, iNum, fNum, x, y, value);
+    DWIN_Draw_Value(true, 1, true, 0, size, color, bColor, iNum, fNum, x, y, value);
   }
 
   // Draw a char at cursor position
-  void Draw_Char(const char c);
+  void Draw_Char(uint16_t color, const char c);
+  inline void Draw_Char(const char c) { Draw_Char(textcolor, c); }
 
   // Draw a string at cursor position
   //  color: Character color
   //  bColor: Background color
   //  y: Upper coordinate of the string
   //  *string: The string
-  void Draw_CenteredString(bool bShow, uint8_t size, uint16_t color, uint16_t bColor, uint16_t y, const char * const string);
+  void Draw_CenteredString(bool bShow, uint8_t size, uint16_t color, uint16_t bColor, uint16_t x1, uint16_t x2, uint16_t y, const char * const string);
+  inline void Draw_CenteredString(bool bShow, uint8_t size, uint16_t color, uint16_t bColor, uint16_t y, const char * const string) {
+    Draw_CenteredString(bShow, size, color, bColor, 0, DWIN_WIDTH, y, string);
+  }
   inline void Draw_CenteredString(bool bShow, uint8_t size, uint16_t color, uint16_t bColor, uint16_t y, FSTR_P string) {
     Draw_CenteredString(bShow, size, color, bColor, y, FTOP(string));
   }
   //  color2 : End color
   uint16_t ColorInt(int16_t val, int16_t minv, int16_t maxv, uint16_t color1, uint16_t color2);
 
+  // ------------------------- Buttons ------------------------------//
+
+  void Draw_Button(uint16_t color, uint16_t bcolor, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, const char * const caption);
+  inline void Draw_Button(uint16_t color, uint16_t bcolor, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, FSTR_P caption) {
+    Draw_Button(color, bcolor, x1, y1, x2, y2, FTOP(caption));
+  }
+  inline void Draw_Button(FSTR_P caption, uint16_t x, uint16_t y) {
+    Draw_Button(textcolor, buttoncolor, x, y, x + 99, y + 37, caption);
+  }
+  void Draw_Button(uint8_t id, uint16_t x, uint16_t y);
+
   // -------------------------- Extra -------------------------------//
 
   // Draw a circle filled with color

Marlin/src/lcd/e3v2/proui/endstop_diag.cpp

  */
 
 /**
- * DWIN End Stops diagnostic page
+ * DWIN End Stops diagnostic page for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 1.0.2
- * Date: 2021/11/06
- *
- * Based on the original code provided by Creality under GPL
+ * Version: 1.2.2
+ * Date: 2022/02/24
  */
 
-#include "../../../inc/MarlinConfigPre.h"
 #include "dwin_defines.h"
 
 #if BOTH(DWIN_LCD_PROUI, HAS_ESDIAG)
   Title.ShowCaption(F("End-stops Diagnostic"));
   DWINUI::ClearMenuArea();
   Draw_Popup_Bkgd();
-  DWINUI::Draw_Icon(ICON_Continue_E, 86, 250);
+  DWINUI::Draw_Button(BTN_Continue, 86, 250);
   DWINUI::cursor.y = 80;
   #define ES_LABEL(S) draw_es_label(F(STR_##S))
   #if HAS_X_MIN

Marlin/src/lcd/e3v2/proui/endstop_diag.h

 #pragma once
 
 /**
- * DWIN End Stops diagnostic page
+ * DWIN End Stops diagnostic page for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 1.0
- * Date: 2021/11/06
- *
- * Based on the original code provided by Creality under GPL
+ * Version: 1.2.3
+ * Date: 2022/02/24
  */
 
 class ESDiagClass {

Marlin/src/lcd/e3v2/proui/lockscreen.cpp

  */
 
 /**
- * Lock screen implementation for DWIN UI Enhanced implementation
+ * Lock screen implementation for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
  * Version: 2.1
  * Date: 2021/11/09
- *
- * Based on the original code provided by Creality under GPL
  */
 
 #include "../../../inc/MarlinConfigPre.h"

Marlin/src/lcd/e3v2/proui/lockscreen.h

 #pragma once
 
 /**
- * Lock screen implementation for DWIN UI Enhanced implementation
+ * Lock screen implementation for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
  * Version: 2.1
  * Date: 2021/11/09
- *
- * Based on the original code provided by Creality under GPL
  */
 
 #include "../common/encoder.h"

Marlin/src/lcd/e3v2/proui/menus.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2022 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program 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.
+ *
+ * This program 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/>.
+ *
+ */
+
+/**
+ * Menu functions for ProUI
+ * Author: Miguel A. Risco-Castillo
+ * Version: 1.2.1
+ * Date: 2022/02/25
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../../../inc/MarlinConfigPre.h"
+
+#if ENABLED(DWIN_LCD_PROUI)
+
+#include "../common/encoder.h"
+#include "dwin_lcd.h"
+#include "dwinui.h"
+#include "dwin.h"
+#include "menus.h"
+
+MenuData_t MenuData;
+
+// Menuitem Drawing functions =================================================
+
+void Draw_Title(TitleClass* title) {
+  DWIN_Draw_Rectangle(1, HMI_data.TitleBg_color, 0, 0, DWIN_WIDTH - 1, TITLE_HEIGHT - 1);
+  if (title->frameid)
+    DWIN_Frame_AreaCopy(title->frameid, title->frame.left, title->frame.top, title->frame.right, title->frame.bottom, 14, (TITLE_HEIGHT - (title->frame.bottom - title->frame.top)) / 2 - 1);
+  else
+    DWIN_Draw_String(false, DWIN_FONT_HEAD, HMI_data.TitleTxt_color, HMI_data.TitleBg_color, 14, (TITLE_HEIGHT - DWINUI::fontHeight(DWIN_FONT_HEAD)) / 2 - 1, title->caption);
+}
+
+void Draw_Menu(MenuClass* menu) {
+  DWINUI::SetColors(HMI_data.Text_Color, HMI_data.Background_Color, HMI_data.StatusBg_Color);
+  DWIN_Draw_Rectangle(1, DWINUI::backcolor, 0, TITLE_HEIGHT, DWIN_WIDTH - 1, STATUS_Y - 1);
+}
+
+void Draw_Menu_Cursor(const int8_t line) {
+  DWIN_Draw_Rectangle(1, HMI_data.Cursor_color, 0, MBASE(line) - 18, 14, MBASE(line + 1) - 20);
+}
+
+void Erase_Menu_Cursor(const int8_t line) {
+  DWIN_Draw_Rectangle(1, HMI_data.Background_Color, 0, MBASE(line) - 18, 14, MBASE(line + 1) - 20);
+}
+
+void Draw_Menu_Line(const uint8_t line, const uint8_t icon /*=0*/, const char * const label /*=nullptr*/, bool more /*=false*/) {
+  if (icon)  DWINUI::Draw_Icon(icon, ICOX, MBASE(line) - 3);
+  if (label) DWINUI::Draw_String(LBLX, MBASE(line) - 1, (char*)label);
+  if (more)  DWINUI::Draw_Icon(ICON_More, VALX + 16, MBASE(line) - 3);
+  DWIN_Draw_HLine(HMI_data.SplitLine_Color, 16, MYPOS(line + 1), 240);
+}
+
+void Draw_Chkb_Line(const uint8_t line, const bool checked) {
+  DWINUI::Draw_Checkbox(HMI_data.Text_Color, HMI_data.Background_Color, VALX + 16, MBASE(line) - 1, checked);
+}
+
+void Draw_Menu_IntValue(uint16_t bcolor, const uint8_t line, uint8_t iNum, const int32_t value /*=0*/) {
+  DWINUI::Draw_Signed_Int(HMI_data.Text_Color, bcolor, iNum , VALX, MBASE(line) - 1, value);
+}
+
+void onDrawMenuItem(MenuItemClass* menuitem, int8_t line) {
+  if (menuitem->icon) DWINUI::Draw_Icon(menuitem->icon, ICOX, MBASE(line) - 3);
+  if (menuitem->frameid)
+    DWIN_Frame_AreaCopy(menuitem->frameid, menuitem->frame.left, menuitem->frame.top, menuitem->frame.right, menuitem->frame.bottom, LBLX, MBASE(line));
+  else if (menuitem->caption)
+    DWINUI::Draw_String(LBLX, MBASE(line) - 1, menuitem->caption);
+  DWIN_Draw_HLine(HMI_data.SplitLine_Color, 16, MYPOS(line + 1), 240);
+}
+
+void onDrawSubMenu(MenuItemClass* menuitem, int8_t line) {
+  onDrawMenuItem(menuitem, line);
+  DWINUI::Draw_Icon(ICON_More, VALX + 16, MBASE(line) - 3);
+}
+
+void onDrawIntMenu(MenuItemClass* menuitem, int8_t line, int32_t value) {
+  onDrawMenuItem(menuitem, line);
+  Draw_Menu_IntValue(HMI_data.Background_Color, line, 4, value);
+}
+
+void onDrawPIntMenu(MenuItemClass* menuitem, int8_t line) {
+  const int16_t value = *(int16_t*)static_cast<MenuItemPtrClass*>(menuitem)->value;
+  onDrawIntMenu(menuitem, line, value);
+}
+
+void onDrawPInt8Menu(MenuItemClass* menuitem, int8_t line) {
+  const uint8_t value = *(uint8_t*)static_cast<MenuItemPtrClass*>(menuitem)->value;
+  onDrawIntMenu(menuitem, line, value);
+}
+
+void onDrawPInt32Menu(MenuItemClass* menuitem, int8_t line) {
+  const uint32_t value = *(uint32_t*)static_cast<MenuItemPtrClass*>(menuitem)->value;
+  onDrawIntMenu(menuitem, line, value);
+}
+
+void onDrawFloatMenu(MenuItemClass* menuitem, int8_t line, uint8_t dp, const float value) {
+  onDrawMenuItem(menuitem, line);
+  DWINUI::Draw_Signed_Float(HMI_data.Text_Color, HMI_data.Background_Color, 3, dp, VALX - dp * DWINUI::fontWidth(DWIN_FONT_MENU), MBASE(line), value);
+}
+
+void onDrawPFloatMenu(MenuItemClass* menuitem, int8_t line) {
+  const float value = *(float*)static_cast<MenuItemPtrClass*>(menuitem)->value;
+  const int8_t dp = UNITFDIGITS;
+  onDrawFloatMenu(menuitem, line, dp, value);
+}
+
+void onDrawPFloat2Menu(MenuItemClass* menuitem, int8_t line) {
+  const float value = *(float*)static_cast<MenuItemPtrClass*>(menuitem)->value;
+  onDrawFloatMenu(menuitem, line, 2, value);
+}
+
+void onDrawChkbMenu(MenuItemClass* menuitem, int8_t line, bool checked) {
+  onDrawMenuItem(menuitem, line);
+  Draw_Chkb_Line(line, checked);
+}
+
+//-----------------------------------------------------------------------------
+// On click functions
+//-----------------------------------------------------------------------------
+
+// Generic onclick event without draw
+//  process: process id HMI destiny
+//  lo: low limit
+//  hi: high limit
+//  dp: decimal places, 0 for integers
+//  val: value / scaled value
+//  LiveUpdate: live update function when the encoder changes
+//  Apply: update function when the encoder is pressed
+void SetOnClick(uint8_t process, const int32_t lo, const int32_t hi, uint8_t dp, const int32_t val, void (*Apply)() /*= nullptr*/, void (*LiveUpdate)() /*= nullptr*/) {
+  checkkey = process;
+  MenuData.MinValue = lo;
+  MenuData.MaxValue = hi;
+  MenuData.dp = dp;
+  MenuData.Apply = Apply;
+  MenuData.LiveUpdate = LiveUpdate;
+  MenuData.Value = val;
+  EncoderRate.enabled = true;
+}
+
+// Generic onclick event for integer values
+//  process: process id HMI destiny
+//  lo: scaled low limit
+//  hi: scaled high limit
+//  val: value
+//  LiveUpdate: live update function when the encoder changes
+//  Apply: update function when the encoder is pressed
+void SetValueOnClick(uint8_t process, const int32_t lo, const int32_t hi, const int32_t val, void (*Apply)() /*= nullptr*/, void (*LiveUpdate)() /*= nullptr*/) {
+  SetOnClick(process, lo, hi, 0, val, Apply, LiveUpdate);
+  Draw_Menu_IntValue(HMI_data.Selected_Color, CurrentMenu->line(), 4, MenuData.Value);
+}
+
+// Generic onclick event for float values
+//  process: process id HMI destiny
+//  lo: scaled low limit
+//  hi: scaled high limit
+//  val: value
+//  LiveUpdate: live update function when the encoder changes
+//  Apply: update function when the encoder is pressed
+void SetValueOnClick(uint8_t process, const float lo, const float hi, uint8_t dp, const float val, void (*Apply)() /*= nullptr*/, void (*LiveUpdate)() /*= nullptr*/) {
+  const int32_t value =  round(val * POW(10, dp));
+  SetOnClick(process, lo * POW(10, dp), hi * POW(10, dp), dp, value, Apply, LiveUpdate);
+  DWINUI::Draw_Signed_Float(HMI_data.Text_Color, HMI_data.Selected_Color, 3, dp, VALX - dp * DWINUI::fontWidth(DWIN_FONT_MENU), MBASE(CurrentMenu->line()), val);
+}
+
+// Generic onclick event for integer values
+//  lo: scaled low limit
+//  hi: scaled high limit
+//  val: value
+//  LiveUpdate: live update function when the encoder changes
+//  Apply: update function when the encoder is pressed
+void SetIntOnClick(const int32_t lo, const int32_t hi, const int32_t val, void (*Apply)() /*= nullptr*/, void (*LiveUpdate)() /*= nullptr*/) {
+  SetValueOnClick(SetInt, lo, hi, val, Apply, LiveUpdate);
+}
+
+// Generic onclick event for set pointer to 16 bit uinteger values
+//  lo: low limit
+//  hi: high limit
+//  LiveUpdate: live update function when the encoder changes
+//  Apply: update function when the encoder is pressed
+void SetPIntOnClick(const int32_t lo, const int32_t hi, void (*Apply)() /*= nullptr*/, void (*LiveUpdate)() /*= nullptr*/) {
+  MenuData.P_Int = (int16_t*)static_cast<MenuItemPtrClass*>(CurrentMenu->SelectedItem())->value;
+  const int32_t value = *MenuData.P_Int;
+  SetValueOnClick(SetPInt, lo, hi, value, Apply, LiveUpdate);
+}
+
+// Generic onclick event for float values
+//  process: process id HMI destiny
+//  lo: low limit
+//  hi: high limit
+//  dp: decimal places
+//  val: value
+void SetFloatOnClick(const float lo, const float hi, uint8_t dp, const float val, void (*Apply)() /*= nullptr*/, void (*LiveUpdate)() /*= nullptr*/) {
+  SetValueOnClick(SetFloat, lo, hi, dp, val, Apply, LiveUpdate);
+}
+
+// Generic onclick event for set pointer to float values
+//  lo: low limit
+//  hi: high limit
+//  LiveUpdate: live update function when the encoder changes
+//  Apply: update function when the encoder is pressed
+void SetPFloatOnClick(const float lo, const float hi, uint8_t dp, void (*Apply)() /*= nullptr*/, void (*LiveUpdate)() /*= nullptr*/) {
+  MenuData.P_Float = (float*)static_cast<MenuItemPtrClass*>(CurrentMenu->SelectedItem())->value;
+  SetValueOnClick(SetPFloat, lo, hi, dp, *MenuData.P_Float, Apply, LiveUpdate);
+}
+
+// HMI Control functions ======================================================
+
+// Generic menu control using the encoder
+void HMI_Menu() {
+  EncoderState encoder_diffState = get_encoder_state();
+  if (encoder_diffState == ENCODER_DIFF_NO) return;
+  if (CurrentMenu) {
+    if (encoder_diffState == ENCODER_DIFF_ENTER)
+      CurrentMenu->onClick();
+    else
+      CurrentMenu->onScroll(encoder_diffState == ENCODER_DIFF_CW);
+  }
+}
+
+// Get an integer value using the encoder without draw anything
+//  lo: low limit
+//  hi: high limit
+// Return value:
+//  0 : no change
+//  1 : live change
+//  2 : apply change
+int8_t HMI_GetIntNoDraw(const int32_t lo, const int32_t hi) {
+  EncoderState encoder_diffState = Encoder_ReceiveAnalyze();
+  if (encoder_diffState != ENCODER_DIFF_NO) {
+    if (Apply_Encoder(encoder_diffState, MenuData.Value)) {
+      EncoderRate.enabled = false;
+      checkkey = Menu;
+      return 2;
+    }
+    LIMIT(MenuData.Value, lo, hi);
+    return 1;
+  }
+  return 0;
+}
+
+// Get an integer value using the encoder
+//  lo: low limit
+//  hi: high limit
+// Return value:
+//  0 : no change
+//  1 : live change
+//  2 : apply change
+int8_t HMI_GetInt(const int32_t lo, const int32_t hi) {
+  EncoderState encoder_diffState = Encoder_ReceiveAnalyze();
+  if (encoder_diffState != ENCODER_DIFF_NO) {
+    if (Apply_Encoder(encoder_diffState, MenuData.Value)) {
+      EncoderRate.enabled = false;
+      DWINUI::Draw_Signed_Int(HMI_data.Text_Color, HMI_data.Background_Color, 4 , VALX, MBASE(CurrentMenu->line()) - 1, MenuData.Value);
+      checkkey = Menu;
+      return 2;
+    }
+    LIMIT(MenuData.Value, lo, hi);
+    DWINUI::Draw_Signed_Int(HMI_data.Text_Color, HMI_data.Selected_Color, 4 , VALX, MBASE(CurrentMenu->line()) - 1, MenuData.Value);
+    return 1;
+  }
+  return 0;
+}
+
+// Set an integer using the encoder
+void HMI_SetInt() {
+  int8_t val = HMI_GetInt(MenuData.MinValue, MenuData.MaxValue);
+  switch (val) {
+    case 0: return; break;
+    case 1: if (MenuData.LiveUpdate) MenuData.LiveUpdate(); break;
+    case 2: if (MenuData.Apply) MenuData.Apply(); break;
+  }
+}
+
+// Set an integer without drawing
+void HMI_SetIntNoDraw() {
+  int8_t val = HMI_GetIntNoDraw(MenuData.MinValue, MenuData.MaxValue);
+  switch (val) {
+    case 0: return; break;
+    case 1: if (MenuData.LiveUpdate) MenuData.LiveUpdate(); break;
+    case 2: if (MenuData.Apply) MenuData.Apply(); break;
+  }
+}
+
+// Set an integer pointer variable using the encoder
+void HMI_SetPInt() {
+  int8_t val = HMI_GetInt(MenuData.MinValue, MenuData.MaxValue);
+  switch (val) {
+    case 0: return;
+    case 1: if (MenuData.LiveUpdate) MenuData.LiveUpdate(); break;
+    case 2: *MenuData.P_Int = MenuData.Value; if (MenuData.Apply) MenuData.Apply(); break;
+  }
+}
+
+// Get a scaled float value using the encoder
+//  dp: decimal places
+//  lo: scaled low limit
+//  hi: scaled high limit
+// Return value:
+//  0 : no change
+//  1 : live change
+//  2 : apply change
+int8_t HMI_GetFloat(uint8_t dp, int32_t lo, int32_t hi) {
+  EncoderState encoder_diffState = Encoder_ReceiveAnalyze();
+  if (encoder_diffState != ENCODER_DIFF_NO) {
+    if (Apply_Encoder(encoder_diffState, MenuData.Value)) {
+      EncoderRate.enabled = false;
+      DWINUI::Draw_Signed_Float(HMI_data.Text_Color, HMI_data.Background_Color, 3, dp, VALX - dp * DWINUI::fontWidth(DWIN_FONT_MENU), MBASE(CurrentMenu->line()), MenuData.Value / POW(10, dp));
+      checkkey = Menu;
+      return 2;
+    }
+    LIMIT(MenuData.Value, lo, hi);
+    DWINUI::Draw_Signed_Float(HMI_data.Text_Color, HMI_data.Selected_Color, 3, dp, VALX - dp * DWINUI::fontWidth(DWIN_FONT_MENU), MBASE(CurrentMenu->line()), MenuData.Value / POW(10, dp));
+    return 1;
+  }
+  return 0;
+}
+
+// Set a scaled float using the encoder
+void HMI_SetFloat() {
+  const int8_t val = HMI_GetFloat(MenuData.dp, MenuData.MinValue, MenuData.MaxValue);
+  switch (val) {
+    case 0: return;
+    case 1: if (MenuData.LiveUpdate) MenuData.LiveUpdate(); break;
+    case 2: if (MenuData.Apply) MenuData.Apply(); break;
+  }
+}
+
+// Set a scaled float pointer variable using the encoder
+void HMI_SetPFloat() {
+  const int8_t val = HMI_GetFloat(MenuData.dp, MenuData.MinValue, MenuData.MaxValue);
+  switch (val) {
+    case 0: return;
+    case 1: if (MenuData.LiveUpdate) MenuData.LiveUpdate(); break;
+    case 2: *MenuData.P_Float = MenuData.Value / POW(10, MenuData.dp); if (MenuData.Apply) MenuData.Apply(); break;
+  }
+}
+
+#endif // DWIN_LCD_PROUI

Marlin/src/lcd/e3v2/proui/menus.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2022 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program 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.
+ *
+ * This program 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/>.
+ *
+ */
+
+/**
+ * Menu functions for ProUI
+ * Author: Miguel A. Risco-Castillo
+ * Version: 1.2.1
+ * Date: 2022/02/25
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include "dwinui.h"
+
+typedef struct {
+  int32_t MaxValue     = 0;        // Auxiliar max integer/scaled float value
+  int32_t MinValue     = 0;        // Auxiliar min integer/scaled float value
+  int8_t dp            = 0;        // Auxiliar decimal places
+  int32_t Value        = 0;        // Auxiliar integer / scaled float value
+  int16_t *P_Int       = nullptr;  // Auxiliar pointer to 16 bit integer variable
+  float *P_Float       = nullptr;  // Auxiliar pointer to float variable
+  void (*Apply)()      = nullptr;  // Auxiliar apply function
+  void (*LiveUpdate)() = nullptr;  // Auxiliar live update function
+} MenuData_t;
+
+extern MenuData_t MenuData;
+
+// Menuitem Drawing functions =================================================
+void Draw_Title(TitleClass* title);
+void Draw_Menu(MenuClass* menu);
+void Draw_Menu_Cursor(const int8_t line);
+void Erase_Menu_Cursor(const int8_t line);
+void Draw_Menu_Line(const uint8_t line, const uint8_t icon=0, const char * const label=nullptr, bool more=false);
+void Draw_Chkb_Line(const uint8_t line, const bool checked);
+void Draw_Menu_IntValue(uint16_t bcolor, const uint8_t line, uint8_t iNum, const int32_t value=0);
+void onDrawMenuItem(MenuItemClass* menuitem, int8_t line);
+void onDrawSubMenu(MenuItemClass* menuitem, int8_t line);
+void onDrawIntMenu(MenuItemClass* menuitem, int8_t line, int32_t value);
+void onDrawPIntMenu(MenuItemClass* menuitem, int8_t line);
+void onDrawPInt8Menu(MenuItemClass* menuitem, int8_t line);
+void onDrawPInt32Menu(MenuItemClass* menuitem, int8_t line);
+void onDrawFloatMenu(MenuItemClass* menuitem, int8_t line, uint8_t dp, const float value);
+void onDrawPFloatMenu(MenuItemClass* menuitem, int8_t line);
+void onDrawPFloat2Menu(MenuItemClass* menuitem, int8_t line);
+void onDrawChkbMenu(MenuItemClass* menuitem, int8_t line, bool checked);
+
+// On click functions =========================================================
+void SetOnClick(uint8_t process, const int32_t lo, const int32_t hi, uint8_t dp, const int32_t val, void (*Apply)() = nullptr, void (*LiveUpdate)() = nullptr);
+void SetValueOnClick(uint8_t process, const int32_t lo, const int32_t hi, const int32_t val, void (*Apply)() = nullptr, void (*LiveUpdate)() = nullptr);
+void SetValueOnClick(uint8_t process, const float lo, const float hi, uint8_t dp, const float val, void (*Apply)() = nullptr, void (*LiveUpdate)() = nullptr);
+void SetIntOnClick(const int32_t lo, const int32_t hi, const int32_t val, void (*Apply)() = nullptr, void (*LiveUpdate)() = nullptr);
+void SetPIntOnClick(const int32_t lo, const int32_t hi, void (*Apply)() = nullptr, void (*LiveUpdate)() = nullptr);
+void SetFloatOnClick(const float lo, const float hi, uint8_t dp, const float val, void (*Apply)() = nullptr, void (*LiveUpdate)() = nullptr);
+void SetPFloatOnClick(const float lo, const float hi, uint8_t dp, void (*Apply)() = nullptr, void (*LiveUpdate)() = nullptr);
+
+// HMI user control functions =================================================
+void HMI_Menu();
+void HMI_SetInt();
+void HMI_SetPInt();
+void HMI_SetIntNoDraw();
+void HMI_SetFloat();
+void HMI_SetPFloat();

Marlin/src/lcd/e3v2/proui/meshviewer.cpp

  */
 
 /**
- * DWIN Mesh Viewer
+ * Mesh Viewer for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 3.9.1
- * Date: 2021/11/09
- *
- * Based on the original code provided by Creality under GPL
+ * version: 3.12.1
+ * Date: 2022/02/24
  */
 
 #include "../../../inc/MarlinConfigPre.h"
 #include "dwin_lcd.h"
 #include "dwinui.h"
 #include "dwin.h"
+#include "dwin_popup.h"
 #include "../../../feature/bedlevel/bedlevel.h"
 
 MeshViewerClass MeshViewer;
 
-void MeshViewerClass::Draw() {
+void MeshViewerClass::DrawMesh(bed_mesh_t zval, const uint8_t sizex, const uint8_t sizey) {
   const int8_t mx = 25, my = 25;  // Margins
-  const int16_t stx = (DWIN_WIDTH - 2 * mx) / (GRID_MAX_POINTS_X - 1),  // Steps
-                sty = (DWIN_WIDTH - 2 * my) / (GRID_MAX_POINTS_Y - 1);
+  const int16_t stx = (DWIN_WIDTH - 2 * mx) / (sizex - 1),  // Steps
+                sty = (DWIN_WIDTH - 2 * my) / (sizey - 1);
   const int8_t rmax = _MIN(mx - 2, stx / 2);
   const int8_t rmin = 7;
-  int16_t zmesh[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y], maxz =-32000, minz = 32000;
+  int16_t zmesh[sizex][sizey];
   #define px(xp) (mx + (xp) * stx)
   #define py(yp) (30 + DWIN_WIDTH - my - (yp) * sty)
   #define rm(z) ((z - minz) * (rmax - rmin) / _MAX(1, (maxz - minz)) + rmin)
-  #define DrawMeshValue(xp, yp, zv) DWINUI::Draw_Signed_Float(font6x12, 1, 2, px(xp) - 12, py(yp) - 6, zv)
+  #define DrawMeshValue(xp, yp, zv) DWINUI::Draw_Signed_Float(font6x12, 1, 2, px(xp) - 18, py(yp) - 6, zv)
   #define DrawMeshHLine(yp) DWIN_Draw_HLine(HMI_data.SplitLine_Color, px(0), py(yp), DWIN_WIDTH - 2 * mx)
-  #define DrawMeshVLine(xp) DWIN_Draw_VLine(HMI_data.SplitLine_Color, px(xp), py(GRID_MAX_POINTS_Y - 1), DWIN_WIDTH - 2 * my)
-  GRID_LOOP(x, y) {
-    const float v = isnan(Z_VALUES(x,y)) ? 0 : round(Z_VALUES(x,y) * 100);
+  #define DrawMeshVLine(xp) DWIN_Draw_VLine(HMI_data.SplitLine_Color, px(xp), py(sizey - 1), DWIN_WIDTH - 2 * my)
+  int16_t maxz =-32000; int16_t minz = 32000; avg = 0;
+  LOOP_L_N(y, sizey) LOOP_L_N(x, sizex) {
+    const float v = isnan(zval[x][y]) ? 0 : round(zval[x][y] * 100);
     zmesh[x][y] = v;
+    avg += v;
     NOLESS(maxz, v);
     NOMORE(minz, v);
   }
-  Title.ShowCaption(F("Mesh Viewer"));
+  max = (float)maxz / 100;
+  min = (float)minz / 100;
+  avg = avg / (100 * sizex * sizey);
   DWINUI::ClearMenuArea();
-  DWINUI::Draw_Icon(ICON_Continue_E, 86, 305);
-  DWIN_Draw_Rectangle(0, HMI_data.SplitLine_Color, px(0), py(0), px(GRID_MAX_POINTS_X - 1), py(GRID_MAX_POINTS_Y - 1));
-  LOOP_S_L_N(x, 1, GRID_MAX_POINTS_X - 1) DrawMeshVLine(x);
-  LOOP_S_L_N(y, 1, GRID_MAX_POINTS_Y - 1) DrawMeshHLine(y);
-  LOOP_L_N(y, GRID_MAX_POINTS_Y) {
+  DWIN_Draw_Rectangle(0, HMI_data.SplitLine_Color, px(0), py(0), px(sizex - 1), py(sizey - 1));
+  LOOP_S_L_N(x, 1, sizex - 1) DrawMeshVLine(x);
+  LOOP_S_L_N(y, 1, sizey - 1) DrawMeshHLine(y);
+  LOOP_L_N(y, sizey) {
     watchdog_refresh();
-    LOOP_L_N(x, GRID_MAX_POINTS_X) {
+    LOOP_L_N(x, sizex) {
       uint16_t color = DWINUI::RainbowInt(zmesh[x][y], _MIN(-5, minz), _MAX(5, maxz));
       uint8_t radius = rm(zmesh[x][y]);
       DWINUI::Draw_FillCircle(color, px(x), py(y), radius);
-      if (GRID_MAX_POINTS_X < 9)
-        DWINUI::Draw_Signed_Float(font6x12, 1, 2, px(x) - 12, py(y) - 6, Z_VALUES(x,y));
+      if (sizex < 9)
+        DWINUI::Draw_Signed_Float(font6x12, 1, 2, px(x) - 18, py(y) - 6, zval[x][y]);
       else {
         char str_1[9];
         str_1[0] = 0;
         switch (zmesh[x][y]) {
           case -999 ... -100:
-            DWINUI::Draw_Signed_Float(font6x12, 1, 1, px(x) - 12, py(y) - 6, Z_VALUES(x,y));
+            DWINUI::Draw_Signed_Float(font6x12, 1, 1, px(x) - 18, py(y) - 6, zval[x][y]);
             break;
           case -99 ... -1:
             sprintf_P(str_1, PSTR("-.%02i"), -zmesh[x][y]);
             sprintf_P(str_1, PSTR(".%02i"), zmesh[x][y]);
             break;
           case 100 ... 999:
-            DWINUI::Draw_Signed_Float(font6x12, 1, 1, px(x) - 12, py(y) - 6, Z_VALUES(x,y));
+            DWINUI::Draw_Signed_Float(font6x12, 1, 1, px(x) - 18, py(y) - 6, zval[x][y]);
             break;
         }
         if (str_1[0])
       }
     }
   }
+}
+
+void MeshViewerClass::Draw(bool withsave /*= false*/) {
+  Title.ShowCaption(F("Mesh Viewer"));
+  DrawMesh(Z_VALUES_ARR, GRID_MAX_POINTS_X, GRID_MAX_POINTS_Y);
+  if (withsave) {
+    DWINUI::Draw_Button(BTN_Save, 26, 305);
+    DWINUI::Draw_Button(BTN_Continue, 146, 305);
+    Draw_Select_Highlight(HMI_flag.select_flag, 305);
+  } else DWINUI::Draw_Button(BTN_Continue, 86, 305);
   char str_1[6], str_2[6] = "";
   ui.status_printf(0, F("Mesh minZ: %s, maxZ: %s"),
-    dtostrf((float)minz / 100, 1, 2, str_1),
-    dtostrf((float)maxz / 100, 1, 2, str_2)
+    dtostrf(min, 1, 2, str_1),
+    dtostrf(max, 1, 2, str_2)
   );
 }
 
+void Draw_MeshViewer() { MeshViewer.Draw(true); }
+void onClick_MeshViewer() { if (HMI_flag.select_flag) WriteEeprom(); HMI_ReturnScreen(); }
+void Goto_MeshViewer() { if (leveling_is_valid()) Goto_Popup(Draw_MeshViewer, onClick_MeshViewer);  else HMI_ReturnScreen(); }
+
 #endif // DWIN_LCD_PROUI && HAS_MESH

Marlin/src/lcd/e3v2/proui/meshviewer.h

  */
 #pragma once
 
+#include "../../../core/types.h"
+#include "../../../feature/bedlevel/bedlevel.h"
+
 /**
- * DWIN Mesh Viewer
+ * Mesh Viewer for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 3.9.1
- * Date: 2021/11/09
- *
- * Based on the original code provided by Creality under GPL
+ * version: 3.12.1
+ * Date: 2022/02/24
  */
 
 class MeshViewerClass {
 public:
-  void Draw();
+  float avg, max, min;
+  void Draw(bool withsave = false);
+  void DrawMesh(bed_mesh_t zval, const uint8_t sizex, const uint8_t sizey);
 };
 
 extern MeshViewerClass MeshViewer;
+
+void Goto_MeshViewer();

Marlin/src/lcd/e3v2/proui/printstats.cpp

  */
 
 /**
- * DWIN Print Stats page
+ * Print Stats page for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 1.1
- * Date: 2022/01/09
- *
- * Based on the original code provided by Creality under GPL
+ * Version: 1.3.0
+ * Date: 2022/02/24
  */
 
 #include "../../../inc/MarlinConfigPre.h"
 #include "printstats.h"
 
 #include "../../../core/types.h"
+#include "../../../MarlinCore.h"
 #include "../../marlinui.h"
 #include "../../../module/printcounter.h"
 #include "dwin_lcd.h"
   Title.ShowCaption(GET_TEXT_F(MSG_INFO_STATS_MENU));
   DWINUI::ClearMenuArea();
   Draw_Popup_Bkgd();
-  DWINUI::Draw_Icon(ICON_Continue_E, 86, 250);
+  DWINUI::Draw_Button(BTN_Continue, 86, 250);
   printStatistics ps = print_job_timer.getStats();
 
   sprintf_P(buf, PSTR(S_FMT ": %i"), GET_TEXT(MSG_INFO_PRINT_COUNT), ps.totalPrints);
   HMI_AudioFeedback();
 }
 
+void Goto_PrintStats() {
+  PrintStats.Draw();
+  HMI_SaveProcessID(WaitResponse);
+}
+
 #endif // DWIN_LCD_PROUI && PRINTCOUNTER

Marlin/src/lcd/e3v2/proui/printstats.h

 #pragma once
 
 /**
- * DWIN Print Stats page
+ * Print Stats page for PRO UI
  * Author: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 1.1
- * Date: 2022/01/09
- *
- * Based on the original code provided by Creality under GPL
+ * Version: 1.3.0
+ * Date: 2022/02/24
  */
 
 class PrintStatsClass {
 public:
-  void Draw();
+  static void Draw();
   static void Reset();
 };
 
 extern PrintStatsClass PrintStats;
+
+void Goto_PrintStats();

Marlin/src/lcd/language/language_en.h

   LSTR MSG_BED_LEVELING                   = _UxGT("Bed Leveling");
   LSTR MSG_LEVEL_BED                      = _UxGT("Level Bed");
   LSTR MSG_BED_TRAMMING                   = _UxGT("Bed Tramming");
+  LSTR MSG_BED_TRAMMING_MANUAL            = _UxGT("Manual Tramming");
   LSTR MSG_BED_TRAMMING_RAISE             = _UxGT("Adjust bed until the probe triggers.");
   LSTR MSG_BED_TRAMMING_IN_RANGE          = _UxGT("Corners within tolerance. Bed trammed.");
   LSTR MSG_BED_TRAMMING_GOOD_POINTS       = _UxGT("Good Points: ");
   LSTR MSG_ADVANCE_K_E                    = _UxGT("Advance K *");
   LSTR MSG_CONTRAST                       = _UxGT("LCD Contrast");
   LSTR MSG_BRIGHTNESS                     = _UxGT("LCD Brightness");
-  LSTR MSG_LCD_BKL_TIMEOUT                = _UxGT("LCD Sleep (s)");
+  LSTR MSG_BRIGHTNESS_OFF                 = _UxGT("Turn Off LCD");
   LSTR MSG_STORE_EEPROM                   = _UxGT("Store Settings");
   LSTR MSG_LOAD_EEPROM                    = _UxGT("Load Settings");
   LSTR MSG_RESTORE_DEFAULTS               = _UxGT("Restore Defaults");
   LSTR MSG_BUTTON_RESET                   = _UxGT("Reset");
   LSTR MSG_BUTTON_IGNORE                  = _UxGT("Ignore");
   LSTR MSG_BUTTON_CANCEL                  = _UxGT("Cancel");
+  LSTR MSG_BUTTON_CONFIRM                 = _UxGT("Confirm");
+  LSTR MSG_BUTTON_CONTINUE                = _UxGT("Continue");
   LSTR MSG_BUTTON_DONE                    = _UxGT("Done");
   LSTR MSG_BUTTON_BACK                    = _UxGT("Back");
   LSTR MSG_BUTTON_PROCEED                 = _UxGT("Proceed");
   LSTR MSG_BUTTON_PAUSE                   = _UxGT("Pause");
   LSTR MSG_BUTTON_RESUME                  = _UxGT("Resume");
   LSTR MSG_BUTTON_ADVANCED                = _UxGT("Advanced");
+  LSTR MSG_BUTTON_SAVE                    = _UxGT("Save");
   LSTR MSG_PAUSING                        = _UxGT("Pausing...");
   LSTR MSG_PAUSE_PRINT                    = _UxGT("Pause Print");
   LSTR MSG_ADVANCED_PAUSE                 = _UxGT("Advanced Pause");

Marlin/src/lcd/marlinui.cpp

 #if ENABLED(DWIN_CREALITY_LCD)
   #include "e3v2/creality/dwin.h"
 #elif ENABLED(DWIN_LCD_PROUI)
-  #include "fontutils.h"
   #include "e3v2/proui/dwin.h"
 #elif ENABLED(DWIN_CREALITY_LCD_JYERSUI)
   #include "e3v2/jyersui/dwin.h"
       else if (print_job_timer.needsService(3)) msg = FPSTR(service3);
     #endif
 
-    else if (!no_welcome)
-      msg = GET_TEXT_F(WELCOME_MSG);
+    else if (!no_welcome) msg = GET_TEXT_F(WELCOME_MSG);
+
+    else if (ENABLED(DWIN_LCD_PROUI))
+        msg = F("");
     else
       return;
 

Marlin/src/lcd/marlinui.h

   static void set_status(FSTR_P const fstr, const int8_t level=0);
   static void status_printf(const uint8_t level, FSTR_P const fmt, ...);
 
-  #if EITHER(HAS_DISPLAY, DWIN_LCD_PROUI)
-    static void kill_screen(FSTR_P const lcd_error, FSTR_P const lcd_component);
-    #if DISABLED(LIGHTWEIGHT_UI)
-      static void draw_status_message(const bool blink);
-    #endif
-  #else
-    static void kill_screen(FSTR_P const, FSTR_P const) {}
-  #endif
-
   #if HAS_DISPLAY
 
     static void update();
     #endif
 
     static void draw_kill_screen();
+    static void kill_screen(FSTR_P const lcd_error, FSTR_P const lcd_component);
+    #if DISABLED(LIGHTWEIGHT_UI)
+      static void draw_status_message(const bool blink);
+    #endif
 
   #else // No LCD
 
     static void update() {}
     static void return_to_status() {}
+    static void kill_screen(FSTR_P const, FSTR_P const) {}
 
   #endif
 

Marlin/src/module/settings.cpp

     //
     #if ENABLED(DWIN_LCD_PROUI)
     {
+      _FIELD_TEST(dwin_data);
       char dwin_data[eeprom_data_size] = { 0 };
       DWIN_StoreSettings(dwin_data);
-      _FIELD_TEST(dwin_data);
       EEPROM_WRITE(dwin_data);
     }
-    #elif ENABLED(DWIN_CREALITY_LCD_JYERSUI)
+    #endif
+
+    #if ENABLED(DWIN_CREALITY_LCD_JYERSUI)
     {
+      _FIELD_TEST(dwin_settings);
       char dwin_settings[CrealityDWIN.eeprom_data_size] = { 0 };
       CrealityDWIN.Save_Settings(dwin_settings);
-      _FIELD_TEST(dwin_settings);
       EEPROM_WRITE(dwin_settings);
     }
     #endif

Marlin/src/module/stepper.cpp

 
 bool Stepper::disable_axis(const AxisEnum axis) {
   mark_axis_disabled(axis);
+
+  TERN_(DWIN_LCD_PROUI, set_axis_untrusted(axis)); // MRISCOC workaround: https://github.com/MarlinFirmware/Marlin/issues/23095
+
   // If all the axes that share the enabled bit are disabled
   const bool can_disable = can_axis_disable(axis);
   if (can_disable) {

Marlin/src/module/temperature.cpp

       hal.idletask();
 
       // Run UI update
-      TERN(HAS_DWIN_E3V2_BASIC, DWIN_Update(), ui.update());
+      TERN(DWIN_CREALITY_LCD, DWIN_Update(), ui.update());
     }
     wait_for_heatup = false;
 

Marlin/src/pins/stm32f1/pins_BTT_SKR_MINI_E3_common.h

       #define TFTGLCD_CS                    PA9
 
     #endif
-  
+
   #elif ENABLED(FYSETC_MINI_12864_2_1)
 
     #error "CAUTION! FYSETC_MINI_12864_2_1 / MKS_MINI_12864_V3 / BTT_MINI_12864_V1 requires wiring modifications. See 'pins_BTT_SKR_MINI_E3_common.h' for details. Comment out this line to continue."

Marlin/src/pins/stm32f1/pins_CREALITY_V24S1_301.h

 #include "env_validate.h"
 
 #if HAS_MULTI_HOTEND || E_STEPPERS > 1
-  #error "Creality V4 only supports one hotend / E-stepper. Comment out this line to continue."
+  #error "Creality V24S1 only supports one hotend / E-stepper. Comment out this line to continue."
+#endif
+
+#if BOTH(BLTOUCH, Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN)
+  #error "Disable Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN when using BLTOUCH with Creality V24S1-301."
 #endif
 
 #define BOARD_INFO_NAME      "Creality V24S1-301"
 //
 // Limit Switches
 //
-#define Z_STOP_PIN                          PC14
+#define Z_STOP_PIN                          PA15
 
 #ifndef Z_MIN_PROBE_PIN
   #define Z_MIN_PROBE_PIN                   PC14  // BLTouch IN
 #define HEATER_BED_PIN                      PA7   // HOT BED
 #define FAN1_PIN                            PC0   // extruder fan
 
+//
+// SD Card
+//
+#define ONBOARD_SPI_DEVICE                  1
+#define ONBOARD_SD_CS_PIN                   PA4  // SDSS
+
+//
+// M3/M4/M5 - Spindle/Laser Control
+//
+#if HAS_CUTTER
+  //#define HEATER_0_PIN                    -1
+  //#define HEATER_BED_PIN                  -1
+  #define FAN_PIN                           -1
+  #define SPINDLE_LASER_ENA_PIN             PA0  // FET 1
+  #define SPINDLE_LASER_PWM_PIN             PA0  // Bed FET
+  #define SPINDLE_DIR_PIN                   PA0  // FET 4
+#endif
+
 #include "pins_CREALITY_V4.h"

Marlin/src/sd/cardreader.cpp

 }
 
 //
-// Return 'true' if the item is something Marlin can read
+// Return 'true' if the item is a folder, G-code file or Binary file
 //
 bool CardReader::is_visible_entity(const dir_t &p OPTARG(CUSTOM_FIRMWARE_UPLOAD, bool onlyBin/*=false*/)) {
   //uint8_t pn0 = p.name[0];
   ) return false;
 
   flag.filenameIsDir = DIR_IS_SUBDIR(&p);               // We know it's a File or Folder
+  setBinFlag(p.name[8] == 'B' &&                        // List .bin files (a firmware file for flashing)
+             p.name[9] == 'I' &&
+             p.name[10]== 'N');
 
   return (
     flag.filenameIsDir                                  // All Directories are ok
+    || fileIsBinary()                                   // BIN files are accepted
     || (!onlyBin && p.name[8] == 'G'
                  && p.name[9] != '~')                   // Non-backup *.G* files are accepted
-    || ( onlyBin && p.name[8]  == 'B'
-                 && p.name[9]  == 'I'
-                 && p.name[10] == 'N')                  // BIN files are accepted
   );
 }
 
       strcpy(filename, sortshort[nr]);
       strcpy(longFilename, sortnames[nr]);
       flag.filenameIsDir = IS_DIR(nr);
+      setBinFlag(strcmp_P(strrchr(filename, '.'), PSTR(".BIN")) == 0);
       return;
     }
   #endif
         strcpy(filename, sortshort[nr]);
         strcpy(longFilename, sortnames[nr]);
         flag.filenameIsDir = IS_DIR(nr);
+        setBinFlag(strcmp_P(strrchr(filename, '.'), PSTR(".BIN")) == 0);
         return;
       }
   #endif

Marlin/src/sd/cardreader.h

        filenameIsDir:1,
        workDirIsRoot:1,
        abort_sd_printing:1
+       #if DO_LIST_BIN_FILES
+         , filenameIsBin:1
+       #endif
        #if ENABLED(BINARY_FILE_TRANSFER)
          , binary_mode:1
        #endif
     static void removeJobRecoveryFile();
   #endif
 
+  // Binary flag for the current file
+  static bool fileIsBinary() { return TERN0(DO_LIST_BIN_FILES, flag.filenameIsBin); }
+  static void setBinFlag(const bool bin) { TERN(DO_LIST_BIN_FILES, flag.filenameIsBin = bin, UNUSED(bin)); }
+
   // Current Working Dir - Set by cd, cdup, cdroot, and diveToFile(true, ...)
   static char* getWorkDirName()  { workDir.getDosName(filename); return filename; }
   static SdFile& getWorkDir()    { return workDir.isOpen() ? workDir : root; }

buildroot/tests/STM32F103RE_creality

 
 use_example_configs "Creality/Ender-3 V2/CrealityV422/CrealityUI"
 opt_disable DWIN_CREALITY_LCD
-opt_enable DWIN_LCD_PROUI BLTOUCH AUTO_BED_LEVELING_UBL Z_SAFE_HOMING INDIVIDUAL_AXIS_HOMING_SUBMENU LCD_SET_PROGRESS_MANUALLY STATUS_MESSAGE_SCROLLING BAUD_RATE_GCODE
-exec_test $1 $2 "Ender 3 v2 with Pro UI" "$3"
+opt_enable BLTOUCH AUTO_BED_LEVELING_UBL Z_SAFE_HOMING INDIVIDUAL_AXIS_HOMING_SUBMENU LCD_SET_PROGRESS_MANUALLY STATUS_MESSAGE_SCROLLING BAUD_RATE_GCODE \
+           DWIN_LCD_PROUI SOUND_MENU_ITEM PRINTCOUNTER
+exec_test $1 $2 "Ender 3 v2 with ProUI" "$3"
 
 use_example_configs "Creality/Ender-3 V2/CrealityV422/CrealityUI"
 opt_disable DWIN_CREALITY_LCD