🎨 More lowercase (ProUI)

Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp

@@ -753,7 +753,7 @@ void unified_bed_leveling::shift_mesh_height() {
 
     TERN_(HAS_MARLINUI_MENU, ui.capture());
     TERN_(EXTENSIBLE_UI, ExtUI::onLevelingStart());
-    TERN_(DWIN_LCD_PROUI, DWIN_LevelingStart());
+    TERN_(DWIN_LCD_PROUI, dwinLevelingStart());
 
     save_ubl_active_state_and_disable();  // No bed level correction so only raw data is obtained
     grid_count_t count = GRID_MAX_POINTS;
@@ -814,7 +814,7 @@ void unified_bed_leveling::shift_mesh_height() {
     );
 
     TERN_(EXTENSIBLE_UI, ExtUI::onLevelingDone());
-    TERN_(DWIN_LCD_PROUI, DWIN_LevelingDone());
+    TERN_(DWIN_LCD_PROUI, dwinLevelingDone());
   }
 
 #endif // HAS_BED_PROBE

Marlin/src/feature/runout.cpp

@@ -88,7 +88,7 @@ void event_filament_runout(const uint8_t extruder) {
   #endif
 
   TERN_(EXTENSIBLE_UI, ExtUI::onFilamentRunout(ExtUI::getTool(extruder)));
-  TERN_(DWIN_LCD_PROUI, DWIN_FilamentRunout(extruder));
+  TERN_(DWIN_LCD_PROUI, dwinFilamentRunout(extruder));
 
   #if ANY(HOST_PROMPT_SUPPORT, HOST_ACTION_COMMANDS, MULTI_FILAMENT_SENSOR)
     const char tool = '0' + TERN0(MULTI_FILAMENT_SENSOR, extruder);

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

@@ -426,7 +426,7 @@ G29_TYPE GcodeSuite::G29() {
       if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("> 3-point Leveling");
       points[0].z = points[1].z = points[2].z = 0;  // Probe at 3 arbitrary points
     #elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
-      TERN_(DWIN_LCD_PROUI, DWIN_LevelingStart());
+      TERN_(DWIN_LCD_PROUI, dwinLevelingStart());
     #endif
 
     TERN_(EXTENSIBLE_UI, ExtUI::onLevelingStart());
@@ -437,7 +437,7 @@ G29_TYPE GcodeSuite::G29() {
       #if ENABLED(PREHEAT_BEFORE_LEVELING)
         if (!abl.dryrun) probe.preheat_for_probing(LEVELING_NOZZLE_TEMP,
           #if ALL(DWIN_LCD_PROUI, HAS_HEATED_BED)
-            HMI_data.BedLevT
+            hmiData.BedLevT
           #else
             LEVELING_BED_TEMP
           #endif

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

@@ -143,7 +143,7 @@ void GcodeSuite::G29() {
         queue.inject(F("G29S2"));
 
         TERN_(EXTENSIBLE_UI, ExtUI::onLevelingStart());
-        TERN_(DWIN_LCD_PROUI, DWIN_LevelingStart());
+        TERN_(DWIN_LCD_PROUI, dwinLevelingStart());
 
         return;
       }
@@ -169,7 +169,7 @@ void GcodeSuite::G29() {
         // Save Z for the previous mesh position
         bedlevel.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));
+        TERN_(DWIN_LCD_PROUI, dwinMeshUpdate(_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.
@@ -236,7 +236,7 @@ void GcodeSuite::G29() {
       if (parser.seenval('Z')) {
         bedlevel.z_values[ix][iy] = parser.value_linear_units();
         TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(ix, iy, bedlevel.z_values[ix][iy]));
-        TERN_(DWIN_LCD_PROUI, DWIN_MeshUpdate(ix, iy, bedlevel.z_values[ix][iy]));
+        TERN_(DWIN_LCD_PROUI, dwinMeshUpdate(ix, iy, bedlevel.z_values[ix][iy]));
       }
       else
         return echo_not_entered('Z');

Marlin/src/gcode/bedlevel/ubl/M421.cpp

@@ -69,7 +69,7 @@ void GcodeSuite::M421() {
     float &zval = bedlevel.z_values[ij.x][ij.y];                               // Altering this Mesh Point
     zval = hasN ? NAN : parser.value_linear_units() + (hasQ ? zval : 0);  // N=NAN, Z=NEWVAL, or Q=ADDVAL
     TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(ij.x, ij.y, zval));          // Ping ExtUI in case it's showing the mesh
-    TERN_(DWIN_LCD_PROUI, DWIN_MeshUpdate(ij.x, ij.y, zval));
+    TERN_(DWIN_LCD_PROUI, dwinMeshUpdate(ij.x, ij.y, zval));
   }
 }
 

Marlin/src/gcode/config/M302.cpp

@@ -51,7 +51,7 @@ void GcodeSuite::M302() {
   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);
+    TERN_(DWIN_LCD_PROUI, hmiData.ExtMinT = thermalManager.extrude_min_temp);
   }
 
   if (parser.seen('P'))

Marlin/src/gcode/control/M997.cpp

@@ -33,7 +33,7 @@
  */
 void GcodeSuite::M997() {
 
-  TERN_(DWIN_LCD_PROUI, DWIN_RebootScreen());
+  TERN_(DWIN_LCD_PROUI, dwinRebootScreen());
 
   flashFirmware(parser.intval('S'));
 

Marlin/src/gcode/lcd/M0_M1.cpp

@@ -73,9 +73,9 @@ void GcodeSuite::M0_M1() {
       ExtUI::onUserConfirmRequired(GET_TEXT_F(MSG_USERWAIT));
   #elif ENABLED(DWIN_LCD_PROUI)
     if (parser.string_arg)
-      DWIN_Popup_Confirm(ICON_BLTouch, parser.string_arg, GET_TEXT_F(MSG_USERWAIT));
+      dwinPopupConfirm(ICON_BLTouch, parser.string_arg, GET_TEXT_F(MSG_USERWAIT));
     else
-      DWIN_Popup_Confirm(ICON_BLTouch, GET_TEXT_F(MSG_STOPPED), GET_TEXT_F(MSG_USERWAIT));
+      dwinPopupConfirm(ICON_BLTouch, GET_TEXT_F(MSG_STOPPED), GET_TEXT_F(MSG_USERWAIT));
   #else
 
     if (parser.string_arg) {

Marlin/src/gcode/lcd/M73.cpp

@@ -51,7 +51,7 @@ void GcodeSuite::M73() {
 
   #if ENABLED(DWIN_LCD_PROUI)
 
-    DWIN_M73();
+    dwinM73();
 
   #else
 

Marlin/src/gcode/sd/M1001.cpp

@@ -49,8 +49,6 @@
 
 #if ENABLED(EXTENSIBLE_UI)
   #include "../../lcd/extui/ui_api.h"
-#elif ENABLED(DWIN_LCD_PROUI)
-  #include "../../lcd/e3v2/proui/dwin.h"
 #endif
 
 #if ENABLED(HOST_ACTION_COMMANDS)

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

@@ -39,7 +39,7 @@
 void GcodeSuite::M75() {
   startOrResumeJob();
   #if ENABLED(DWIN_LCD_PROUI)
-    if (!IS_SD_PRINTING()) DWIN_Print_Header(parser.string_arg && parser.string_arg[0] ? parser.string_arg : GET_TEXT(MSG_HOST_START_PRINT));
+    if (!IS_SD_PRINTING()) dwinPrintHeader(parser.string_arg && parser.string_arg[0] ? parser.string_arg : GET_TEXT(MSG_HOST_START_PRINT));
   #endif
 }
 

Marlin/src/gcode/temp/M303.cpp

@@ -31,7 +31,7 @@
 
 #if ENABLED(EXTENSIBLE_UI)
   #include "../../lcd/extui/ui_api.h"
-#elif ENABLED(DWIN_LCD_PROUI)
+#elif ENABLED(PROUI_PID_TUNE)
   #include "../../lcd/e3v2/proui/dwin.h"
 #endif
 
@@ -69,7 +69,7 @@ void GcodeSuite::M303() {
       SERIAL_ECHOPGM(STR_PID_AUTOTUNE);
       SERIAL_ECHOLNPGM(STR_PID_BAD_HEATER_ID);
       TERN_(EXTENSIBLE_UI, ExtUI::onPidTuning(ExtUI::result_t::PID_BAD_HEATER_ID));
-      TERN_(DWIN_PID_TUNE, DWIN_PidTuning(PID_BAD_HEATER_ID));
+      TERN_(PROUI_PID_TUNE, dwinPidTuning(PID_BAD_HEATER_ID));
       return;
   }
 
@@ -79,7 +79,7 @@ void GcodeSuite::M303() {
   const celsius_t temp = seenS ? parser.value_celsius() : default_temp;
   const bool u = parser.boolval('U');
 
-  TERN_(DWIN_PID_TUNE, DWIN_StartM303(seenC, c, seenS, hid, temp));
+  TERN_(PROUI_PID_TUNE, dwinStartM303(seenC, c, seenS, hid, temp));
 
   IF_DISABLED(BUSY_WHILE_HEATING, KEEPALIVE_STATE(NOT_BUSY));
 

Marlin/src/inc/Conditionals_post.h

@@ -2386,10 +2386,10 @@
 
 #if ENABLED(DWIN_LCD_PROUI)
   #if ANY(PIDTEMP, PIDTEMPBED)
-    #define DWIN_PID_TUNE 1
+    #define PROUI_PID_TUNE 1
   #endif
-  #if ANY(DWIN_PID_TUNE, MPC_AUTOTUNE) && DISABLED(DISABLE_TUNING_GRAPH)
-    #define SHOW_TUNING_GRAPH 1
+  #if ANY(PROUI_PID_TUNE, MPC_AUTOTUNE) && DISABLED(DISABLE_TUNING_GRAPH)
+    #define PROUI_TUNING_GRAPH 1
   #endif
 #endif
 

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

@@ -63,29 +63,29 @@
 #include "dwin_popup.h"
 #include "bedlevel_tools.h"
 
-BedLevelToolsClass bedLevelTools;
+BedLevelTools bedLevelTools;
 
 #if ENABLED(USE_UBL_VIEWER)
-  bool BedLevelToolsClass::viewer_asymmetric_range = false;
-  bool BedLevelToolsClass::viewer_print_value = false;
+  bool BedLevelTools::viewer_asymmetric_range = false;
+  bool BedLevelTools::viewer_print_value = false;
 #endif
-bool BedLevelToolsClass::goto_mesh_value = false;
-uint8_t BedLevelToolsClass::mesh_x = 0;
-uint8_t BedLevelToolsClass::mesh_y = 0;
-uint8_t BedLevelToolsClass::tilt_grid = 1;
+bool BedLevelTools::goto_mesh_value = false;
+uint8_t BedLevelTools::mesh_x = 0;
+uint8_t BedLevelTools::mesh_y = 0;
+uint8_t BedLevelTools::tilt_grid = 1;
 
 bool drawing_mesh = false;
 char cmd[MAX_CMD_SIZE+16], str_1[16], str_2[16], str_3[16];
 
 #if ENABLED(AUTO_BED_LEVELING_UBL)
 
-  void BedLevelToolsClass::manual_value_update(const uint8_t mesh_x, const uint8_t mesh_y, bool undefined/*=false*/) {
+  void BedLevelTools::manual_value_update(const uint8_t mesh_x, const uint8_t mesh_y, bool undefined/*=false*/) {
     sprintf_P(cmd, PSTR("M421 I%i J%i Z%s %s"), mesh_x, mesh_y, dtostrf(current_position.z, 1, 3, str_1), undefined ? "N" : "");
     gcode.process_subcommands_now(cmd);
     planner.synchronize();
   }
 
-  bool BedLevelToolsClass::create_plane_from_mesh() {
+  bool BedLevelTools::create_plane_from_mesh() {
     struct linear_fit_data lsf_results;
     incremental_LSF_reset(&lsf_results);
     GRID_LOOP(x, y) {
@@ -125,15 +125,15 @@ char cmd[MAX_CMD_SIZE+16], str_1[16], str_2[16], str_3[16];
 
 #else
 
-  void BedLevelToolsClass::manual_value_update(const uint8_t mesh_x, const uint8_t mesh_y) {
+  void BedLevelTools::manual_value_update(const uint8_t mesh_x, const uint8_t mesh_y) {
     sprintf_P(cmd, PSTR("G29 I%i J%i Z%s"), mesh_x, mesh_y, dtostrf(current_position.z, 1, 3, str_1));
     gcode.process_subcommands_now(cmd);
     planner.synchronize();
   }
 
 #endif
 
-void BedLevelToolsClass::manual_move(const uint8_t mesh_x, const uint8_t mesh_y, bool zmove/*=false*/) {
+void BedLevelTools::manual_move(const uint8_t mesh_x, const uint8_t mesh_y, bool zmove/*=false*/) {
   gcode.process_subcommands_now(F("G28O"));
   if (zmove) {
     planner.synchronize();
@@ -142,8 +142,8 @@ void BedLevelToolsClass::manual_move(const uint8_t mesh_x, const uint8_t mesh_y,
     planner.synchronize();
   }
   else {
-    DWIN_Show_Popup(ICON_BLTouch, F("Moving to Point"), F("Please wait until done."));
-    HMI_SaveProcessID(NothingToDo);
+    dwinShowPopup(ICON_BLTouch, F("Moving to Point"), F("Please wait until done."));
+    hmiSaveProcessID(ID_NothingToDo);
     sprintf_P(cmd, PSTR("G0 F300 Z%s"), dtostrf(Z_CLEARANCE_BETWEEN_PROBES, 1, 3, str_1));
     gcode.process_subcommands_now(cmd);
     sprintf_P(cmd, PSTR("G42 F4000 I%i J%i"), mesh_x, mesh_y);
@@ -152,24 +152,24 @@ void BedLevelToolsClass::manual_move(const uint8_t mesh_x, const uint8_t mesh_y,
     current_position.z = goto_mesh_value ? bedlevel.z_values[mesh_x][mesh_y] : Z_CLEARANCE_BETWEEN_PROBES;
     planner.buffer_line(current_position, homing_feedrate(Z_AXIS), active_extruder);
     planner.synchronize();
-    HMI_ReturnScreen();
+    hmiReturnScreen();
   }
 }
 
 // Move / Probe methods. As examples, not yet used.
-void BedLevelToolsClass::MoveToXYZ() {
+void BedLevelTools::MoveToXYZ() {
   bedLevelTools.goto_mesh_value = true;
   bedLevelTools.manual_move(bedLevelTools.mesh_x, bedLevelTools.mesh_y, false);
 }
-void BedLevelToolsClass::MoveToXY() {
+void BedLevelTools::MoveToXY() {
   bedLevelTools.goto_mesh_value = false;
   bedLevelTools.manual_move(bedLevelTools.mesh_x, bedLevelTools.mesh_y, false);
 }
-void BedLevelToolsClass::MoveToZ() {
+void BedLevelTools::MoveToZ() {
   bedLevelTools.goto_mesh_value = true;
   bedLevelTools.manual_move(bedLevelTools.mesh_x, bedLevelTools.mesh_y, true);
 }
-void BedLevelToolsClass::ProbeXY() {
+void BedLevelTools::ProbeXY() {
   const uint16_t Clear = Z_CLEARANCE_DEPLOY_PROBE;
   sprintf_P(cmd, PSTR("G28O\nG0Z%i\nG30X%sY%s"),
     Clear,
@@ -180,7 +180,7 @@ void BedLevelToolsClass::ProbeXY() {
 }
 
 // Accessors
-float BedLevelToolsClass::get_max_value() {
+float BedLevelTools::get_max_value() {
   float max = __FLT_MAX__ * -1;
   GRID_LOOP(x, y) {
     if (!isnan(bedlevel.z_values[x][y]) && bedlevel.z_values[x][y] > max)
@@ -189,7 +189,7 @@ float BedLevelToolsClass::get_max_value() {
   return max;
 }
 
-float BedLevelToolsClass::get_min_value() {
+float BedLevelTools::get_min_value() {
   float min = __FLT_MAX__;
   GRID_LOOP(x, y) {
     if (!isnan(bedlevel.z_values[x][y]) && bedlevel.z_values[x][y] < min)
@@ -199,7 +199,7 @@ float BedLevelToolsClass::get_min_value() {
 }
 
 // Return 'true' if mesh is good and within LCD limits
-bool BedLevelToolsClass::meshvalidate() {
+bool BedLevelTools::meshvalidate() {
   GRID_LOOP(x, y) {
     const float v = bedlevel.z_values[x][y];
     if (isnan(v) || !WITHIN(v, UBL_Z_OFFSET_MIN, UBL_Z_OFFSET_MAX)) return false;
@@ -209,21 +209,21 @@ bool BedLevelToolsClass::meshvalidate() {
 
 #if ENABLED(USE_UBL_VIEWER)
 
-  void BedLevelToolsClass::Draw_Bed_Mesh(int16_t selected /*= -1*/, uint8_t gridline_width /*= 1*/, uint16_t padding_x /*= 8*/, uint16_t padding_y_top /*= 40 + 53 - 7*/) {
+  void BedLevelTools::drawBedMesh(int16_t selected /*= -1*/, uint8_t gridline_width /*= 1*/, uint16_t padding_x /*= 8*/, uint16_t padding_y_top /*= 40 + 53 - 7*/) {
     drawing_mesh = true;
     const uint16_t total_width_px = DWIN_WIDTH - padding_x - padding_x;
     const uint16_t cell_width_px  = total_width_px / (GRID_MAX_POINTS_X);
     const uint16_t cell_height_px = total_width_px / (GRID_MAX_POINTS_Y);
     const float v_max = abs(get_max_value()), v_min = abs(get_min_value()), range = _MAX(v_min, v_max);
 
     // Clear background from previous selection and select new square
-    DWIN_Draw_Rectangle(1, Color_Bg_Black, _MAX(0, padding_x - gridline_width), _MAX(0, padding_y_top - gridline_width), padding_x + total_width_px, padding_y_top + total_width_px);
+    dwinDrawRectangle(1, Color_Bg_Black, _MAX(0, padding_x - gridline_width), _MAX(0, padding_y_top - gridline_width), padding_x + total_width_px, padding_y_top + total_width_px);
     if (selected >= 0) {
       const auto selected_y = selected / (GRID_MAX_POINTS_X);
       const auto selected_x = selected - (GRID_MAX_POINTS_X) * selected_y;
       const auto start_y_px = padding_y_top + selected_y * cell_height_px;
       const auto start_x_px = padding_x + selected_x * cell_width_px;
-      DWIN_Draw_Rectangle(1, Color_White, _MAX(0, start_x_px - gridline_width), _MAX(0, start_y_px - gridline_width), start_x_px + cell_width_px, start_y_px + cell_height_px);
+      dwinDrawRectangle(1, Color_White, _MAX(0, start_x_px - gridline_width), _MAX(0, start_y_px - gridline_width), start_x_px + cell_width_px, start_y_px + cell_height_px);
     }
 
     // Draw value square grid
@@ -233,7 +233,7 @@ bool BedLevelToolsClass::meshvalidate() {
       const auto end_x_px   = start_x_px + cell_width_px - 1 - gridline_width;
       const auto start_y_px = padding_y_top + ((GRID_MAX_POINTS_Y) - y - 1) * cell_height_px;
       const auto end_y_px   = start_y_px + cell_height_px - 1 - gridline_width;
-      DWIN_Draw_Rectangle(1,                                                                                 // RGB565 colors: http://www.barth-dev.de/online/rgb565-color-picker/
+      dwinDrawRectangle(1,                                                                                 // RGB565 colors: http://www.barth-dev.de/online/rgb565-color-picker/
         isnan(bedlevel.z_values[x][y]) ? Color_Grey : (                                                           // gray if undefined
           (bedlevel.z_values[x][y] < 0 ?
             (uint16_t)round(0x1F * -bedlevel.z_values[x][y] / (!viewer_asymmetric_range ? range : v_min)) << 11 : // red if mesh point value is negative
@@ -249,7 +249,7 @@ bool BedLevelToolsClass::meshvalidate() {
       if (viewer_print_value) {
         int8_t offset_x, offset_y = cell_height_px / 2 - 6;
         if (isnan(bedlevel.z_values[x][y])) {  // undefined
-          DWIN_Draw_String(false, font6x12, Color_White, Color_Bg_Blue, start_x_px + cell_width_px / 2 - 5, start_y_px + offset_y, F("X"));
+          dwinDrawString(false, font6x12, Color_White, Color_Bg_Blue, start_x_px + cell_width_px / 2 - 5, start_y_px + offset_y, F("X"));
         }
         else {                          // has value
           if (GRID_MAX_POINTS_X < 10)
@@ -258,16 +258,16 @@ bool BedLevelToolsClass::meshvalidate() {
             sprintf_P(buf, PSTR("%02i"), (uint16_t)(abs(bedlevel.z_values[x][y] - (int16_t)bedlevel.z_values[x][y]) * 100));
           offset_x = cell_width_px / 2 - 3 * (strlen(buf)) - 2;
           if (!(GRID_MAX_POINTS_X < 10))
-            DWIN_Draw_String(false, font6x12, Color_White, Color_Bg_Blue, start_x_px - 2 + offset_x, start_y_px + offset_y /*+ square / 2 - 6*/, F("."));
-          DWIN_Draw_String(false, font6x12, Color_White, Color_Bg_Blue, start_x_px + 1 + offset_x, start_y_px + offset_y /*+ square / 2 - 6*/, buf);
+            dwinDrawString(false, font6x12, Color_White, Color_Bg_Blue, start_x_px - 2 + offset_x, start_y_px + offset_y /*+ square / 2 - 6*/, F("."));
+          dwinDrawString(false, font6x12, Color_White, Color_Bg_Blue, start_x_px + 1 + offset_x, start_y_px + offset_y /*+ square / 2 - 6*/, buf);
         }
         safe_delay(10);
         LCD_SERIAL.flushTX();
       }
     }
   }
 
-  void BedLevelToolsClass::Set_Mesh_Viewer_Status() { // TODO: draw gradient with values as a legend instead
+  void BedLevelTools::setMeshViewerStatus() { // TODO: draw gradient with values as a legend instead
     float v_max = abs(get_max_value()), v_min = abs(get_min_value()), range = _MAX(v_min, v_max);
     if (v_min > 3e+10F) v_min = 0.0000001;
     if (v_max > 3e+10F) v_max = 0.0000001;

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

@@ -52,7 +52,7 @@
 #define UBL_Z_OFFSET_MIN -3.0
 #define UBL_Z_OFFSET_MAX  3.0
 
-class BedLevelToolsClass {
+class BedLevelTools {
 public:
   #if ENABLED(USE_UBL_VIEWER)
     static bool viewer_asymmetric_range;
@@ -78,9 +78,9 @@ class BedLevelToolsClass {
   static float get_min_value();
   static bool meshvalidate();
   #if ENABLED(USE_UBL_VIEWER)
-    static void Draw_Bed_Mesh(int16_t selected = -1, uint8_t gridline_width = 1, uint16_t padding_x = 8, uint16_t padding_y_top = 40 + 53 - 7);
-    static void Set_Mesh_Viewer_Status();
+    static void drawBedMesh(int16_t selected = -1, uint8_t gridline_width = 1, uint16_t padding_x = 8, uint16_t padding_y_top = 40 + 53 - 7);
+    static void setMeshViewerStatus();
   #endif
 };
 
-extern BedLevelToolsClass bedLevelTools;
+extern BedLevelTools bedLevelTools;