Followup to Menu Refactor (#12275)

Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_shared_hw_spi.cpp

 
 #include "../../inc/MarlinConfigPre.h"
 
-#if ENABLED(DOGLCD)
+#if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 
   return 1;
 }
 
-#endif  // DOGLCD
+#endif // HAS_GRAPHICAL_LCD
 
-#endif  //__SAM3X8E__
+#endif //__SAM3X8E__

Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_st7920_sw_spi.cpp

 
 #include "../../inc/MarlinConfigPre.h"
 
-#if ENABLED(DOGLCD)
+#if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 #include <Arduino.h>
   return 1;
 }
 
-#endif // DOGLCD
+#endif // HAS_GRAPHICAL_LCD
 
 #endif // ARDUINO_ARCH_SAM

Marlin/src/HAL/HAL_LPC1768/spi_pins.h

 
 #include "src/core/macros.h"
 
-#if ENABLED(SDSUPPORT) && ENABLED(DOGLCD) && (LCD_PINS_D4 == SCK_PIN || LCD_PINS_ENABLE == MOSI_PIN || DOGLCD_SCK == SCK_PIN || DOGLCD_MOSI == MOSI_PIN)
+#if ENABLED(SDSUPPORT) && HAS_GRAPHICAL_LCD && (LCD_PINS_D4 == SCK_PIN || LCD_PINS_ENABLE == MOSI_PIN || DOGLCD_SCK == SCK_PIN || DOGLCD_MOSI == MOSI_PIN)
   #define LPC_SOFTWARE_SPI  // If the SD card and LCD adapter share the same SPI pins, then software SPI is currently
                             // needed due to the speed and mode requred for communicating with each device being different.
                             // This requirement can be removed if the SPI access to these devices is updated to use

Marlin/src/HAL/HAL_LPC1768/u8g/u8g_com_HAL_LPC1768_hw_spi.cpp

 
 #include "../../../inc/MarlinConfigPre.h"
 
-#if ENABLED(DOGLCD)
+#if HAS_GRAPHICAL_LCD
 
 //#include <inttypes.h>
 #include <U8glib.h>
   return 1;
 }
 
-#endif // DOGLCD
+#endif // HAS_GRAPHICAL_LCD
 
 #endif // TARGET_LPC1768

Marlin/src/HAL/HAL_LPC1768/u8g/u8g_com_HAL_LPC1768_ssd_hw_i2c.cpp

 
 #include "../../../inc/MarlinConfigPre.h"
 
-#if ENABLED(DOGLCD)
+#if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 
   return 1;
 }
 
-#endif // DOGLCD
+#endif // HAS_GRAPHICAL_LCD
 
 #endif // TARGET_LPC1768

Marlin/src/HAL/HAL_LPC1768/u8g/u8g_com_HAL_LPC1768_ssd_sw_i2c.cpp under construction

 
 #include "../../inc/MarlinConfigPre.h"
 
-#if ENABLED(DOGLCD)
+#if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 
   return 1;
 }
 
-#endif // DOGLCD
+#endif // HAS_GRAPHICAL_LCD
 
 #endif // TARGET_LPC1768

Marlin/src/HAL/HAL_LPC1768/u8g/u8g_com_HAL_LPC1768_st7920_hw_spi.cpp

 
 #include "../../../inc/MarlinConfigPre.h"
 
-#if ENABLED(DOGLCD)
+#if HAS_GRAPHICAL_LCD
 
 //#include <inttypes.h>
 #include <U8glib.h>
   return 1;
 }
 
-#endif // DOGLCD
+#endif // HAS_GRAPHICAL_LCD
 
 #endif // TARGET_LPC1768

Marlin/src/HAL/HAL_LPC1768/u8g/u8g_com_HAL_LPC1768_st7920_sw_spi.cpp

 
 #include "../../../inc/MarlinConfigPre.h"
 
-#if ENABLED(DOGLCD)
+#if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 #include "SoftwareSPI.h"
   return 1;
 }
 
-#endif // DOGLCD
+#endif // HAS_GRAPHICAL_LCD
 
 #endif // TARGET_LPC1768

Marlin/src/HAL/HAL_LPC1768/u8g/u8g_com_HAL_LPC1768_sw_spi.cpp

 
 #include "../../../inc/MarlinConfigPre.h"
 
-#if ENABLED(DOGLCD)
+#if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 #include "SoftwareSPI.h"
   return 1;
 }
 
-#endif // DOGLCD
+#endif // HAS_GRAPHICAL_LCD
 
 #endif // TARGET_LPC1768

Marlin/src/HAL/HAL_STM32F7/HAL.cpp

  *
  */
 
-
 #ifdef STM32F7
 
 // --------------------------------------------------------------------------

Marlin/src/Marlin.cpp

       #if ENABLED(DISABLE_INACTIVE_E)
         disable_e_steppers();
       #endif
-      #if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(ULTIPANEL)  // Only needed with an LCD
+      #if HAS_LCD_MENU && ENABLED(AUTO_BED_LEVELING_UBL)
         if (ubl.lcd_map_control) ubl.lcd_map_control = defer_return_to_status = false;
       #endif
     }

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

   constexpr float unified_bed_leveling::_mesh_index_to_xpos[16],
                   unified_bed_leveling::_mesh_index_to_ypos[16];
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     bool unified_bed_leveling::lcd_map_control = false;
   #endif
 

Marlin/src/feature/bedlevel/ubl/ubl.h

                               MESH_MIN_Y + 14 * (MESH_Y_DIST), MESH_MIN_Y + 15 * (MESH_Y_DIST)
                             };
 
-    #if ENABLED(ULTIPANEL)
+    #if HAS_LCD_MENU
       static bool lcd_map_control;
     #endif
 

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

 
     LEAVE:
 
-    #if ENABLED(ULTIPANEL)
+    #if HAS_LCD_MENU
       lcd_reset_alert_level();
       lcd_quick_feedback(true);
       lcd_reset_status();

Marlin/src/feature/pause.cpp

   #include "../feature/runout.h"
 #endif
 
-#if ENABLED(ULTIPANEL)
+#if HAS_LCD_MENU
   #include "../lcd/ultralcd.h"
 #endif
 
     }
   #endif
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_WAIT_FOR_NOZZLES_TO_HEAT, mode);
   #else
     UNUSED(mode);
   #endif
 
   if (!ensure_safe_temperature(mode)) {
-    #if ENABLED(ULTIPANEL)
+    #if HAS_LCD_MENU
       if (show_lcd) // Show status screen
         lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_STATUS);
     #endif
   }
 
   if (pause_for_user) {
-    #if ENABLED(ULTIPANEL)
+    #if HAS_LCD_MENU
       if (show_lcd) // Show "insert filament"
         lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_INSERT, mode);
     #endif
     KEEPALIVE_STATE(IN_HANDLER);
   }
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     if (show_lcd) // Show "wait for load" message
       lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_LOAD, mode);
   #endif
 
   #if ENABLED(ADVANCED_PAUSE_CONTINUOUS_PURGE)
 
-    #if ENABLED(ULTIPANEL)
+    #if HAS_LCD_MENU
       if (show_lcd)
         lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_CONTINUOUS_PURGE);
     #endif
     do {
       if (purge_length > 0) {
         // "Wait for filament purge"
-        #if ENABLED(ULTIPANEL)
+        #if HAS_LCD_MENU
           if (show_lcd)
             lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_PURGE, mode);
         #endif
       }
 
       // Show "Purge More" / "Resume" menu and wait for reply
-      #if ENABLED(ULTIPANEL)
+      #if HAS_LCD_MENU
         if (show_lcd) {
           KEEPALIVE_STATE(PAUSED_FOR_USER);
           wait_for_user = false;
 
       // Keep looping if "Purge More" was selected
     } while (
-      #if ENABLED(ULTIPANEL)
+      #if HAS_LCD_MENU
         show_lcd && advanced_pause_menu_response == ADVANCED_PAUSE_RESPONSE_EXTRUDE_MORE
       #else
         0
                      const AdvancedPauseMode mode/*=ADVANCED_PAUSE_MODE_PAUSE_PRINT*/
 ) {
   if (!ensure_safe_temperature(mode)) {
-    #if ENABLED(ULTIPANEL)
+    #if HAS_LCD_MENU
       if (show_lcd) // Show status screen
         lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_STATUS);
     #endif
     SERIAL_ECHOLNPGM("//action:" ACTION_ON_PAUSE);
   #endif
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     if (show_lcd) // Show initial message
       lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_INIT);
   #endif
     SERIAL_ERROR_START();
     SERIAL_ERRORLNPGM(MSG_ERR_HOTEND_TOO_COLD);
 
-    #if ENABLED(ULTIPANEL)
+    #if HAS_LCD_MENU
       if (show_lcd) { // Show status screen
         lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_STATUS);
         LCD_MESSAGEPGM(MSG_M600_TOO_COLD);
 void wait_for_filament_reload(const int8_t max_beep_count/*=0*/ DXC_ARGS) {
   bool nozzle_timed_out = false;
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_INSERT);
   #endif
   SERIAL_ECHO_START();
         nozzle_timed_out |= thermalManager.is_heater_idle(e);
 
     if (nozzle_timed_out) {
-      #if ENABLED(ULTIPANEL)
+      #if HAS_LCD_MENU
         lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_CLICK_TO_HEAT_NOZZLE);
       #endif
       SERIAL_ECHO_START();
-      #if ENABLED(ULTIPANEL) && ENABLED(EMERGENCY_PARSER)
+      #if HAS_LCD_MENU && ENABLED(EMERGENCY_PARSER)
         SERIAL_ECHOLNPGM(MSG_FILAMENT_CHANGE_HEAT);
       #elif ENABLED(EMERGENCY_PARSER)
         SERIAL_ECHOLNPGM(MSG_FILAMENT_CHANGE_HEAT_M108);
       // Wait for the heaters to reach the target temperatures
       ensure_safe_temperature();
 
-      #if ENABLED(ULTIPANEL)
+      #if HAS_LCD_MENU
         lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_INSERT);
       #endif
       SERIAL_ECHO_START();
-      #if ENABLED(ULTIPANEL) && ENABLED(EMERGENCY_PARSER)
+      #if HAS_LCD_MENU && ENABLED(EMERGENCY_PARSER)
         SERIAL_ECHOLNPGM(MSG_FILAMENT_CHANGE_INSERT);
       #elif ENABLED(EMERGENCY_PARSER)
         SERIAL_ECHOLNPGM(MSG_FILAMENT_CHANGE_INSERT_M108);
   if (nozzle_timed_out || thermalManager.hotEnoughToExtrude(active_extruder)) // Load the new filament
     load_filament(slow_load_length, fast_load_length, purge_length, max_beep_count, true, nozzle_timed_out, ADVANCED_PAUSE_MODE_PAUSE_PRINT DXC_PASS);
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_RESUME); // "Wait for print to resume"
   #endif
 
     runout.reset();
   #endif
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     // Show status screen
     lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_STATUS);
   #endif

Marlin/src/gcode/bedlevel/G26.cpp

 
 int8_t g26_prime_flag;
 
-#if ENABLED(ULTIPANEL)
+#if HAS_LCD_MENU
 
   /**
    * If the LCD is clicked, cancel, wait for release, return true
   bool user_canceled() {
     if (!is_lcd_clicked()) return false; // Return if the button isn't pressed
     lcd_setstatusPGM(PSTR("Mesh Validation Stopped."), 99);
-    #if ENABLED(ULTIPANEL)
+    #if HAS_LCD_MENU
       lcd_quick_feedback(true);
     #endif
     wait_for_release();
   for (uint8_t i = 0; i < GRID_MAX_POINTS_X; i++) {
     for (uint8_t j = 0; j < GRID_MAX_POINTS_Y; j++) {
 
-      #if ENABLED(ULTIPANEL)
+      #if HAS_LCD_MENU
         if (user_canceled()) return true;     // Check if the user wants to stop the Mesh Validation
       #endif
 
       if (g26_bed_temp > 25) {
         lcd_setstatusPGM(PSTR("G26 Heating Bed."), 99);
         lcd_quick_feedback(true);
-        #if ENABLED(ULTIPANEL)
+        #if HAS_LCD_MENU
           lcd_external_control = true;
         #endif
     #endif
         thermalManager.setTargetBed(g26_bed_temp);
         while (ABS(thermalManager.degBed() - g26_bed_temp) > 3) {
 
-          #if ENABLED(ULTIPANEL)
+          #if HAS_LCD_MENU
             if (is_lcd_clicked()) return exit_from_g26();
           #endif
 
   thermalManager.setTargetHotend(g26_hotend_temp, 0);
   while (ABS(thermalManager.degHotend(0) - g26_hotend_temp) > 3) {
 
-    #if ENABLED(ULTIPANEL)
+    #if HAS_LCD_MENU
       if (is_lcd_clicked()) return exit_from_g26();
     #endif
 
  */
 inline bool prime_nozzle() {
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     #if ENABLED(PREVENT_LENGTHY_EXTRUDE)
       float Total_Prime = 0.0;
     #endif
 
   if (parser.seen('P')) {
     if (!parser.has_value()) {
-      #if ENABLED(ULTIPANEL)
+      #if HAS_LCD_MENU
         g26_prime_flag = -1;
       #else
         SERIAL_PROTOCOLLNPGM("?Prime length must be specified when not using an LCD.");
   }
 
   int16_t g26_repeats;
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     g26_repeats = parser.intval('R', GRID_MAX_POINTS + 1);
   #else
     if (!parser.seen('R')) {
   move_to(destination, 0.0);
   move_to(destination, g26_ooze_amount);
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     lcd_external_control = true;
   #endif
 
         plan_arc(endpoint, arc_offset, false);  // Draw a counter-clockwise arc
         feedrate_mm_s = save_feedrate;
         set_destination_from_current();
-        #if ENABLED(ULTIPANEL)
+        #if HAS_LCD_MENU
           if (user_canceled()) goto LEAVE; // Check if the user wants to stop the Mesh Validation
         #endif
 
 
         for (int8_t ind = start_ind; ind <= end_ind; ind++) {
 
-          #if ENABLED(ULTIPANEL)
+          #if HAS_LCD_MENU
             if (user_canceled()) goto LEAVE;          // Check if the user wants to stop the Mesh Validation
           #endif
 
   move_to(destination, 0); // Move back to the starting position
   //debug_current_and_destination(PSTR("done doing X/Y move."));
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     lcd_external_control = false;     // Give back control of the LCD Panel!
   #endif
 

Marlin/src/gcode/calibrate/G33.cpp

   #endif
 }
 
-#if HAS_BED_PROBE && ENABLED(ULTIPANEL)
+#if HAS_BED_PROBE && HAS_LCD_MENU
   static float probe_z_shift(const float center) {
     STOW_PROBE();
     endstops.enable_z_probe(false);
 
       switch (probe_points) {
         case -1:
-          #if HAS_BED_PROBE && ENABLED(ULTIPANEL)
+          #if HAS_BED_PROBE && HAS_LCD_MENU
             zprobe_zoffset += probe_z_shift(z_at_pt[CEN]);
           #endif
 

Marlin/src/gcode/control/M17_M18_M84.cpp

       #endif
     }
 
-    #if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(ULTIPANEL)  // Only needed with an LCD
+    #if HAS_LCD_MENU && ENABLED(AUTO_BED_LEVELING_UBL)
       if (ubl.lcd_map_control) ubl.lcd_map_control = defer_return_to_status = false;
     #endif
   }

Marlin/src/gcode/control/M80_M81.cpp

 
 #include "../../inc/MarlinConfig.h"
 
-#if ENABLED(ULTIPANEL)
+#if HAS_LCD_MENU
   #include "../../lcd/ultralcd.h"
 #endif
 
       restore_stepper_drivers();
     #endif
 
-    #if ENABLED(ULTIPANEL)
+    #if HAS_LCD_MENU
       lcd_reset_status();
     #endif
   }
     PSU_OFF();
   #endif
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     LCD_MESSAGEPGM(MACHINE_NAME " " MSG_OFF ".");
   #endif
 }

Marlin/src/gcode/feature/pause/M600.cpp

   #include "../../../module/tool_change.h"
 #endif
 
-#if ENABLED(ULTIPANEL)
+#if HAS_LCD_MENU
   #include "../../../lcd/ultralcd.h"
 #endif
 
   #endif
 
   // Show initial "wait for start" message
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_INIT, ADVANCED_PAUSE_MODE_PAUSE_PRINT, target_extruder);
   #endif
 

Marlin/src/gcode/feature/pause/M701_M702.cpp

   #include "../../../module/tool_change.h"
 #endif
 
-#if ENABLED(ULTIPANEL)
+#if HAS_LCD_MENU
   #include "../../../lcd/ultralcd.h"
 #endif
 
   if (parser.seenval('Z')) park_point.z = parser.linearval('Z');
 
   // Show initial "wait for load" message
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_LOAD, ADVANCED_PAUSE_MODE_LOAD_FILAMENT, target_extruder);
   #endif
 
   #endif
 
   // Show status screen
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_STATUS);
   #endif
 }
   if (parser.seenval('Z')) park_point.z = parser.linearval('Z');
 
   // Show initial "wait for unload" message
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_UNLOAD, ADVANCED_PAUSE_MODE_UNLOAD_FILAMENT, target_extruder);
   #endif
 
   #endif
 
   // Show status screen
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_STATUS);
   #endif
 }

Marlin/src/gcode/gcode.cpp

       case 120: M120(); break;                                    // M120: Enable endstops
       case 121: M121(); break;                                    // M121: Disable endstops
 
-      #if ENABLED(ULTIPANEL)
+      #if HAS_LCD_MENU
         case 145: M145(); break;                                  // M145: Set material heatup parameters
       #endif
 

Marlin/src/gcode/gcode.h

     static void M190();
   #endif
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     static void M145();
   #endif
 

Marlin/src/gcode/lcd/M0_M1.cpp

 #include "../gcode.h"
 #include "../../module/stepper.h"
 
-#if ENABLED(ULTIPANEL)
+#if HAS_LCD_MENU
   #include "../../lcd/ultralcd.h"
 #endif
 
 
   planner.synchronize();
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
 
     if (has_message)
       lcd_setstatus(args, true);
     printerEventLEDs.onResumeAfterWait();
   #endif
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     lcd_reset_status();
   #endif
 

Marlin/src/gcode/lcd/M145.cpp

 
 #include "../../inc/MarlinConfig.h"
 
-#if ENABLED(ULTIPANEL)
+#if HAS_LCD_MENU
 
 #include "../gcode.h"
 #include "../../lcd/ultralcd.h"
   }
 }
 
-#endif // ULTIPANEL
+#endif // HAS_LCD_MENU

Marlin/src/gcode/parser.h

 
     static inline void set_input_temp_units(TempUnit units) { input_temp_units = units; }
 
-    #if ENABLED(ULTIPANEL) && DISABLED(DISABLE_M503)
+    #if HAS_LCD_MENU && DISABLED(DISABLE_M503)
 
       FORCE_INLINE static char temp_units_code() {
         return input_temp_units == TEMPUNIT_K ? 'K' : input_temp_units == TEMPUNIT_F ? 'F' : 'C';
         }
       }
 
-    #endif // ULTIPANEL && !DISABLE_M503
+    #endif // HAS_LCD_MENU && !DISABLE_M503
 
     static inline float value_celsius() {
       const float f = value_float();

Marlin/src/gcode/queue.cpp

           // Process critical commands early
           if (strcmp(command, "M108") == 0) {
             wait_for_heatup = false;
-            #if ENABLED(ULTIPANEL)
+            #if HAS_LCD_MENU
               wait_for_user = false;
             #endif
           }

Marlin/src/gcode/queue.h

  */
 bool enqueue_and_echo_command(const char* cmd);
 
-#define HAS_LCD_QUEUE_NOW (ENABLED(MALYAN_LCD) || (ENABLED(ULTIPANEL) && (ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(PID_AUTOTUNE_MENU) || ENABLED(ADVANCED_PAUSE_FEATURE))))
+#define HAS_LCD_QUEUE_NOW (ENABLED(MALYAN_LCD) || (HAS_LCD_MENU && (ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(PID_AUTOTUNE_MENU) || ENABLED(ADVANCED_PAUSE_FEATURE))))
 #define HAS_QUEUE_NOW (ENABLED(SDSUPPORT) || HAS_LCD_QUEUE_NOW)
 
 #if HAS_QUEUE_NOW

Marlin/src/inc/Conditionals_post.h

 /**
  * Override here because this is set in Configuration_adv.h
  */
-#if ENABLED(ULTIPANEL) && DISABLED(ELB_FULL_GRAPHIC_CONTROLLER)
+#if HAS_LCD_MENU && DISABLED(ELB_FULL_GRAPHIC_CONTROLLER)
   #undef SD_DETECT_INVERTED
 #endif
 

Marlin/src/inc/SanityCheck.h

     #error "You probably want to use Max Endstops for DELTA!"
   #elif ENABLED(ENABLE_LEVELING_FADE_HEIGHT) && DISABLED(AUTO_BED_LEVELING_BILINEAR) && !UBL_SEGMENTED
     #error "ENABLE_LEVELING_FADE_HEIGHT on DELTA requires AUTO_BED_LEVELING_BILINEAR or AUTO_BED_LEVELING_UBL."
-  #elif ENABLED(DELTA_AUTO_CALIBRATION) && !(HAS_BED_PROBE || ENABLED(ULTIPANEL))
+  #elif ENABLED(DELTA_AUTO_CALIBRATION) && !(HAS_BED_PROBE || HAS_LCD_MENU)
     #error "DELTA_AUTO_CALIBRATION requires a probe or LCD Controller."
   #elif ABL_GRID
     #if (GRID_MAX_POINTS_X & 1) == 0 || (GRID_MAX_POINTS_Y & 1) == 0

Marlin/src/lcd/HD44780/lcdprint_hd44780.cpp

 
 #include "../../inc/MarlinConfigPre.h"
 
-#if ENABLED(ULTRA_LCD) && DISABLED(DOGLCD)
+#if HAS_CHARACTER_LCD
 
 #include "../ultralcd.h"
 #include "../../Marlin.h"
 
+#include "ultralcd_common_HD44780.h"
+
 #include <string.h>
-#include "../fontutils.h"
-#include "../lcdprint.h"
 
-#include "ultralcd_common_HD44780.h"
 #ifndef LCD_CLASS
   #include <LiquidCrystal.h>
   #define LCD_CLASS LiquidCrystal
   return lcd_put_u8str_max_cb(utf8_str_P, read_byte_rom, max_length);
 }
 
-#endif // ULTRA_LCD && !DOGLCD
+#endif // HAS_CHARACTER_LCD

Marlin/src/lcd/HD44780/ultralcd_common_HD44780.h

   #include "../../libs/duration_t.h"
 #endif
 
-#if ENABLED(AUTO_BED_LEVELING_UBL)
-  #include "../../feature/bedlevel/ubl/ubl.h"
-
-  #if ENABLED(ULTIPANEL)
-    #define ULTRA_X_PIXELS_PER_CHAR    5
-    #define ULTRA_Y_PIXELS_PER_CHAR    8
-    #define ULTRA_COLUMNS_FOR_MESH_MAP 7
-    #define ULTRA_ROWS_FOR_MESH_MAP    4
-
-    #define N_USER_CHARS    8
-
-    #define TOP_LEFT      _BV(0)
-    #define TOP_RIGHT     _BV(1)
-    #define LOWER_LEFT    _BV(2)
-    #define LOWER_RIGHT   _BV(3)
-  #endif
-#endif
-
 ////////////////////////////////////
 // Setup button and encode mappings for each panel (into 'buttons' variable
 //
 // macro name. The mapping is independent of whether the button is directly connected or
 // via a shift/i2c register.
 
-#if ENABLED(ULTIPANEL)
+#if HAS_LCD_MENU
 
   extern volatile uint8_t buttons;
 
     #define LCD_CLICKED (buttons & (B_MI|B_ST))
   #endif
 
-#endif // ULTIPANEL
+  #if ENABLED(AUTO_BED_LEVELING_UBL)
+    #define ULTRA_X_PIXELS_PER_CHAR    5
+    #define ULTRA_Y_PIXELS_PER_CHAR    8
+    #define ULTRA_COLUMNS_FOR_MESH_MAP 7
+    #define ULTRA_ROWS_FOR_MESH_MAP    4
+
+    #define N_USER_CHARS    8
+
+    #define TOP_LEFT      _BV(0)
+    #define TOP_RIGHT     _BV(1)
+    #define LOWER_LEFT    _BV(2)
+    #define LOWER_RIGHT   _BV(3)
+  #endif
+
+#endif // HAS_LCD_MENU
 
 ////////////////////////////////////
 // Create LCD class instance and chipset-specific information
 
 #elif ENABLED(LCD_I2C_TYPE_MCP23017)
   // For the LED indicators (which may be mapped to different events in lcd_implementation_update_indicators())
+  #define LCD_HAS_STATUS_INDICATORS
   #define LED_A 0x04 //100
   #define LED_B 0x02 //010
   #define LED_C 0x01 //001
 
-  #define LCD_HAS_STATUS_INDICATORS
-
   #include <Wire.h>
   #include <LiquidTWI2.h>
   #define LCD_CLASS LiquidTWI2
   #include <LiquidCrystal_I2C.h>
   #define LCD_CLASS LiquidCrystal_I2C
 
-// 2 wire Non-latching LCD SR from:
-// https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/schematics#!shiftregister-connection
 #elif ENABLED(SR_LCD_2W_NL)
+  // 2 wire Non-latching LCD SR from:
+  // https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/schematics#!shiftregister-connection
   extern "C" void __cxa_pure_virtual() { while (1); }
   #include <LCD.h>
   #include <LiquidCrystal_SR.h>
   // Standard directly connected LCD implementations
   #include <LiquidCrystal.h>
   #define LCD_CLASS LiquidCrystal
-
 #endif
 
 #include "../fontutils.h"
 #include "../lcdprint.h"
-
-#if ENABLED(LCD_PROGRESS_BAR)
-  #define LCD_STR_PROGRESS  "\x03\x04\x05"
-#endif

Marlin/src/lcd/HD44780/ultralcd_impl_HD44780.cpp

 
 #include "../../inc/MarlinConfigPre.h"
 
-#if ENABLED(ULTRA_LCD) && DISABLED(DOGLCD)
+#if HAS_CHARACTER_LCD
 
 /**
  * ultralcd_impl_HD44780.cpp
 #include "../../module/planner.h"
 #include "../../module/motion.h"
 
+#if ENABLED(AUTO_BED_LEVELING_UBL)
+  #include "../../feature/bedlevel/ubl/ubl.h"
+#endif
+
 ////////////////////////////////////
 // Create LCD class instance and chipset-specific information
 #if ENABLED(LCD_I2C_TYPE_PCF8575)
   LCD_CLASS lcd(LCD_PINS_RS, LCD_PINS_ENABLE, LCD_PINS_D4, LCD_PINS_D5, LCD_PINS_D6, LCD_PINS_D7); //RS,Enable,D4,D5,D6,D7
 #endif
 
-#include "../fontutils.h"
-#include "../lcdprint.h"
-
-#if ENABLED(LCD_PROGRESS_BAR)
-  static millis_t progress_bar_ms = 0;     // Start millis of the current progress bar cycle
-  #if PROGRESS_MSG_EXPIRE > 0
-    static millis_t expire_status_ms = 0;  // millis at which to expire the status message
-  #endif
-#endif
-
 #if ENABLED(LCD_HAS_STATUS_INDICATORS)
   static void lcd_implementation_update_indicators();
 #endif
   lcd.createChar(c, temp);
 }
 
+#if ENABLED(LCD_PROGRESS_BAR)
+  #define LCD_STR_PROGRESS  "\x03\x04\x05"
+#endif
+
 void lcd_set_custom_characters(
   #if ENABLED(LCD_PROGRESS_BAR) || ENABLED(SHOW_BOOTSCREEN)
-    const uint8_t screen_charset=CHARSET_INFO
+    const HD44780CharSet screen_charset/*=CHARSET_INFO*/
   #endif
 ) {
   // CHARSET_BOOT
 
 }
 
-void lcd_implementation_init(
-  #if ENABLED(LCD_PROGRESS_BAR)
-    const uint8_t screen_charset=CHARSET_INFO
-  #endif
-) {
+void lcd_implementation_init() {
 
   #if ENABLED(LCD_I2C_TYPE_PCF8575)
     lcd.begin(LCD_WIDTH, LCD_HEIGHT);
     lcd.begin(LCD_WIDTH, LCD_HEIGHT);
   #endif
 
-  lcd_set_custom_characters(
-    #if ENABLED(LCD_PROGRESS_BAR)
-      screen_charset
-    #endif
-  );
+  LCD_SET_CHARSET(currentScreen == lcd_status_screen ? CHARSET_INFO : CHARSET_MENU);
 
   lcd.clear();
 }
   }
 
   void lcd_bootscreen() {
-    lcd_set_custom_characters(CHARSET_BOOT);
+    LCD_SET_CHARSET(CHARSET_BOOT);
     lcd.clear();
 
     #define LCD_EXTRA_SPACE (LCD_WIDTH-8)
 
     lcd.clear();
     safe_delay(100);
-    lcd_set_custom_characters();
+    LCD_SET_CHARSET(CHARSET_INFO);
     lcd.clear();
   }
 
 
 #endif
 
-#if ENABLED(ULTIPANEL)
+#if HAS_LCD_MENU
 
   #if ENABLED(ADVANCED_PAUSE_FEATURE)
 
 
   #endif // AUTO_BED_LEVELING_UBL
 
-#endif // ULTIPANEL
+#endif // HAS_LCD_MENU
 
-#endif // ULTRA_LCD && !DOGLCD
+#endif // HAS_CHARACTER_LCD

Marlin/src/lcd/dogm/lcdprint_u8g.cpp

 
 #include "../../inc/MarlinConfigPre.h"
 
-#if ENABLED(DOGLCD)
+#if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 extern U8GLIB *pu8g;
   return ret;
 }
 
-#endif // DOGLCD
+#endif // HAS_GRAPHICAL_LCD

Marlin/src/lcd/dogm/u8g_dev_ssd1306_sh1106_128x64_I2C.cpp

 
 #include "../../inc/MarlinConfigPre.h"
 
-#if ENABLED(DOGLCD)
+#if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 #include "HAL_LCD_com_defines.h"
   return 1;
 }
 
-#endif // DOGLCD
+#endif // HAS_GRAPHICAL_LCD

Marlin/src/lcd/dogm/u8g_dev_st7565_64128n_HAL.cpp

 
 #include "../../inc/MarlinConfig.h"
 
-#if ENABLED(DOGLCD)
+#if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 
 U8G_PB_DEV(u8g_dev_st7565_64128n_HAL_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_64128n_HAL_fn, U8G_COM_HAL_HW_SPI_FN);
 u8g_dev_t u8g_dev_st7565_64128n_HAL_2x_hw_spi = { u8g_dev_st7565_64128n_HAL_2x_fn, &u8g_dev_st7565_64128n_HAL_2x_pb, U8G_COM_HAL_HW_SPI_FN };
 
-#endif // DOGLCD
+#endif // HAS_GRAPHICAL_LCD

Marlin/src/lcd/dogm/u8g_dev_st7920_128x64_HAL.cpp

 
 #include "../../inc/MarlinConfigPre.h"
 
-#if ENABLED(DOGLCD)
+#if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 
   u8g_dev_t u8g_dev_st7920_128x64_rrd_sw_spi = { u8g_dev_st7920_128x64_HAL_4x_fn, &u8g_dev_st7920_128x64_HAL_4x_pb, U8G_COM_ST7920_HAL_SW_SPI };
 #endif
 
-#endif // DOGLCD
+#endif // HAS_GRAPHICAL_LCD

Marlin/src/lcd/dogm/u8g_dev_uc1701_mini12864_HAL.cpp

 
 #include "../../inc/MarlinConfigPre.h"
 
-#if ENABLED(DOGLCD)
+#if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 
       u8g_InitCom(u8g, dev, U8G_SPI_CLK_CYCLE_300NS);
       u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_init_seq);
       break;
-    case U8G_DEV_MSG_STOP:
-      break;
-    case U8G_DEV_MSG_PAGE_NEXT:
-      {
-        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
-        u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start);
-        u8g_WriteByte(u8g, dev, 0x0B0 | pb->p.page); /* select current page */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
-          return 0;
-        u8g_SetChipSelect(u8g, dev, 0);
-      }
-      break;
+
+    case U8G_DEV_MSG_STOP: break;
+
+    case U8G_DEV_MSG_PAGE_NEXT: {
+      u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start);
+      u8g_WriteByte(u8g, dev, 0x0B0 | pb->p.page); /* select current page */
+      u8g_SetAddress(u8g, dev, 1);           /* data mode */
+      if (!u8g_pb_WriteBuffer(pb, u8g, dev)) return 0;
+      u8g_SetChipSelect(u8g, dev, 0);
+    } break;
+
     case U8G_DEV_MSG_CONTRAST:
       u8g_SetChipSelect(u8g, dev, 1);
       u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
       u8g_InitCom(u8g, dev, U8G_SPI_CLK_CYCLE_300NS);
       u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_init_seq);
       break;
-    case U8G_DEV_MSG_STOP:
-      break;
-    case U8G_DEV_MSG_PAGE_NEXT:
-      {
-        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
-
-        u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start);
-        u8g_WriteByte(u8g, dev, 0x0B0 | (2*pb->p.page)); /* select current page */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-  u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)pb->buf);
-        u8g_SetChipSelect(u8g, dev, 0);
-
-        u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start);
-        u8g_WriteByte(u8g, dev, 0x0B0 | (2*pb->p.page+1)); /* select current page */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-  u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width);
-        u8g_SetChipSelect(u8g, dev, 0);
-      }
-      break;
+
+    case U8G_DEV_MSG_STOP: break;
+
+    case U8G_DEV_MSG_PAGE_NEXT: {
+      u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start);
+      u8g_WriteByte(u8g, dev, 0x0B0 | (2*pb->p.page)); /* select current page */
+      u8g_SetAddress(u8g, dev, 1);           /* data mode */
+      u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)pb->buf);
+      u8g_SetChipSelect(u8g, dev, 0);
+
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start);
+      u8g_WriteByte(u8g, dev, 0x0B0 | (2*pb->p.page+1)); /* select current page */
+      u8g_SetAddress(u8g, dev, 1);           /* data mode */
+      u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width);
+      u8g_SetChipSelect(u8g, dev, 0);
+    } break;
+
     case U8G_DEV_MSG_CONTRAST:
       u8g_SetChipSelect(u8g, dev, 1);
       u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
 u8g_dev_t u8g_dev_uc1701_mini12864_HAL_2x_sw_spi = { u8g_dev_uc1701_mini12864_HAL_2x_fn, &u8g_dev_uc1701_mini12864_HAL_2x_pb, U8G_COM_HAL_SW_SPI_FN };
 u8g_dev_t u8g_dev_uc1701_mini12864_HAL_2x_hw_spi = { u8g_dev_uc1701_mini12864_HAL_2x_fn, &u8g_dev_uc1701_mini12864_HAL_2x_pb, U8G_COM_HAL_HW_SPI_FN };
 
-#endif // DOGLCD
+#endif // HAS_GRAPHICAL_LCD

Marlin/src/lcd/dogm/u8g_fontutf8.cpp

 
 #include "../../inc/MarlinConfigPre.h"
 
-#if ENABLED(DOGLCD)
+#if HAS_GRAPHICAL_LCD
 
 #include <string.h>
 #include "../fontutils.h"
   return data.adv;
 }
 
-#endif // DOGLCD
+#endif // HAS_GRAPHICAL_LCD

Marlin/src/lcd/dogm/ultralcd_impl_DOGM.cpp

 
 void lcd_implementation_clear() { } // Automatically cleared by Picture Loop
 
-#if ENABLED(ULTIPANEL)
+#if HAS_LCD_MENU
 
   uint8_t row_y1, row_y2;
 
 
   #endif // BABYSTEP_ZPROBE_GFX_OVERLAY || MESH_EDIT_GFX_OVERLAY
 
-#endif // ULTIPANEL
+#endif // HAS_LCD_MENU
 
 #endif // HAS_GRAPHICAL_LCD

Marlin/src/lcd/menu/menu.cpp

 
 #include "../../inc/MarlinConfigPre.h"
 
-#if ENABLED(ULTIPANEL)
+#if HAS_LCD_MENU
 
 #include "menu.h"
 #include "../ultralcd.h"
 //////// Menu Navigation & History /////////
 ////////////////////////////////////////////
 
-void lcd_status_screen();
-
 void lcd_return_to_status() { lcd_goto_screen(lcd_status_screen); }
 
 void lcd_save_previous_screen() {
 
 bool printer_busy() { return planner.movesplanned() || IS_SD_PRINTING(); }
 
-#if HAS_CHARACTER_LCD && (ENABLED(LCD_PROGRESS_BAR) || ENABLED(LCD_PROGRESS_BAR_TEST) || ENABLED(AUTO_BED_LEVELING_UBL))
-  void lcd_set_custom_characters(
-    #if ENABLED(LCD_PROGRESS_BAR) || ENABLED(SHOW_BOOTSCREEN)
-      const uint8_t screen_charset=CHARSET_INFO
-    #endif
-  );
-#endif
-
 /**
  * General function to go directly to a screen
  */
       #endif
       screen_history_depth = 0;
     }
+
     lcd_implementation_clear();
+
     // Re-initialize custom characters that may be re-used
-    #if HAS_CHARACTER_LCD && ENABLED(AUTO_BED_LEVELING_UBL)
-      if (!ubl.lcd_map_control) {
-        lcd_set_custom_characters(
-          #if ENABLED(LCD_PROGRESS_BAR)
-            screen == lcd_status_screen ? CHARSET_INFO : CHARSET_MENU
-          #endif
-        );
-      }
-    #elif ENABLED(LCD_PROGRESS_BAR)
-      lcd_set_custom_characters(screen == lcd_status_screen ? CHARSET_INFO : CHARSET_MENU);
+    #if HAS_CHARACTER_LCD
+      #if ENABLED(AUTO_BED_LEVELING_UBL)
+        if (!ubl.lcd_map_control)
+      #endif
+          LCD_SET_CHARSET(screen == lcd_status_screen ? CHARSET_INFO : CHARSET_MENU);
     #endif
+
     lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NEXT;
     screen_changed = true;
     #if HAS_GRAPHICAL_LCD
   void _lcd_toggle_bed_leveling() { set_bed_leveling_enabled(!planner.leveling_active); }
 #endif
 
-#endif // ULTIPANEL
+#endif // HAS_LCD_MENU

Marlin/src/lcd/menu/menu_configuration.cpp

     static int8_t bar_percent = 0;
     if (use_click()) {
       lcd_goto_previous_menu();
-      lcd_set_custom_characters(CHARSET_MENU);
+      LCD_SET_CHARSET(CHARSET_MENU);
       return;
     }
     bar_percent += (int8_t)encoderPosition;
 
   void _progress_bar_test() {
     lcd_goto_screen(progress_bar_test);
-    lcd_set_custom_characters();
+    LCD_SET_CHARSET(CHARSET_INFO);
   }
 
 #endif // LCD_PROGRESS_BAR_TEST

Marlin/src/lcd/ultralcd.cpp

 
 #if ENABLED(POWER_LOSS_RECOVERY)
   #include "../feature/power_loss_recovery.h"
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     void menu_job_recovery();
   #endif
 #endif
   millis_t previous_lcd_status_ms = 0;
 #endif
 
-#if ENABLED(SDSUPPORT) && ENABLED(ULTIPANEL) && ENABLED(SCROLL_LONG_FILENAMES)
+#if HAS_LCD_MENU && ENABLED(SDSUPPORT) && ENABLED(SCROLL_LONG_FILENAMES)
   uint8_t filename_scroll_pos, filename_scroll_max;
 #endif
 
   int8_t encoderDirection = 1;
 #endif
 
-void lcd_status_screen();
-
 #if HAS_LCD_MENU
   #include "menu/menu.h"
 
 
   lcd_buttons_update();
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     encoderDiff = 0;
   #endif
 }
  * This is very display-dependent, so the lcd implementation draws this.
  */
 
+#if ENABLED(LCD_PROGRESS_BAR)
+  millis_t progress_bar_ms = 0;     // Start millis of the current progress bar cycle
+  #if PROGRESS_MSG_EXPIRE > 0
+    static millis_t expire_status_ms = 0;
+    void dontExpireStatus() { expire_status_ms = 0; }
+  #endif
+#endif
+
 #if LCD_INFO_SCREEN_STYLE == 0
   void lcd_impl_status_screen_0();
 #elif LCD_INFO_SCREEN_STYLE == 1
 
 void lcd_status_screen() {
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     ENCODER_DIRECTION_NORMAL();
     ENCODER_RATE_MULTIPLY(false);
   #endif
 
-  #if ENABLED(LCD_SET_PROGRESS_MANUALLY) && ENABLED(SDSUPPORT) && (ENABLED(LCD_PROGRESS_BAR) || ENABLED(DOGLCD))
+  #if ENABLED(LCD_SET_PROGRESS_MANUALLY) && ENABLED(SDSUPPORT) && (ENABLED(LCD_PROGRESS_BAR) || HAS_GRAPHICAL_LCD)
     // Progress bar % comes from SD when actively printing
     if (IS_SD_PRINTING())
       progress_bar_percent = card.percentDone();
 
   #endif // LCD_PROGRESS_BAR
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
 
     if (use_click()) {
       #if ENABLED(FILAMENT_LCD_DISPLAY) && ENABLED(SDSUPPORT)
         previous_lcd_status_ms = millis();  // get status message to show up for a while
       #endif
-      lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
-        #if ENABLED(LCD_PROGRESS_BAR)
-          CHARSET_MENU
-        #endif
-      );
       lcd_goto_screen(menu_main);
+      lcd_implementation_init(); // May revive the LCD if static electricity killed it
       return;
     }
 
 
     feedrate_percentage = constrain(feedrate_percentage, 10, 999);
 
-  #endif // ULTIPANEL
+  #endif // HAS_LCD_MENU
 
   #if LCD_INFO_SCREEN_STYLE == 0
     lcd_impl_status_screen_0();
 
 void lcd_quick_feedback(const bool clear_buttons) {
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     lcd_refresh();
     if (clear_buttons) buttons = 0;
     next_button_update_ms = millis() + 500;
   // Buzz and wait. The delay is needed for buttons to settle!
   lcd_buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ);
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     #if ENABLED(LCD_USE_I2C_BUZZER)
       delay(10);
     #elif PIN_EXISTS(BEEPER)
   #endif
 }
 
-#if ENABLED(ULTIPANEL)
+#if HAS_LCD_MENU
 
   extern bool no_reentry; // Flag to prevent recursion into menu handlers
 
     }
   }
 
-#endif // ULTIPANEL
+#endif // HAS_LCD_MENU
 
 /**
  * Update the LCD, read encoder buttons, etc.
   static uint16_t max_display_update_time = 0;
   static millis_t next_lcd_update_ms;
 
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     static millis_t return_to_status_ms = 0;
 
     // Handle any queued Move Axis motion
       }
     #endif
 
-  #endif // ULTIPANEL
+  #endif // HAS_LCD_MENU
 
   #if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_DETECT)
 
       }
 
       lcd_refresh();
-      lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
-        #if ENABLED(LCD_PROGRESS_BAR)
-          currentScreen == lcd_status_screen ? CHARSET_INFO : CHARSET_MENU
-        #endif
-      );
+      lcd_implementation_init(); // May revive the LCD if static electricity killed it
     }
 
   #endif // SDSUPPORT && SD_DETECT_PIN
 
   const millis_t ms = millis();
   if (ELAPSED(ms, next_lcd_update_ms)
-    #if ENABLED(DOGLCD)
+    #if HAS_GRAPHICAL_LCD
       || drawing_screen
     #endif
   ) {
       lcd_implementation_update_indicators();
     #endif
 
-    #if ENABLED(ULTIPANEL)
+    #if HAS_LCD_MENU
 
       #if ENABLED(LCD_HAS_SLOW_BUTTONS)
         slow_buttons = lcd_implementation_read_slow_buttons(); // buttons which take too long to read in interrupt context
         lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
       }
 
-    #endif // ULTIPANEL
+    #endif // HAS_LCD_MENU
 
     // This runs every ~100ms when idling often enough.
     // Instead of tracking changes just redraw the Status Screen once per second.
     if (
-      #if ENABLED(ULTIPANEL)
+      #if HAS_LCD_MENU
         currentScreen == lcd_status_screen &&
       #endif
       !lcd_status_update_delay--
     ) {
       lcd_status_update_delay = 9
-        #if ENABLED(DOGLCD)
+        #if HAS_GRAPHICAL_LCD
           + 3
         #endif
       ;
       lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
     }
 
-    #if ENABLED(ULTIPANEL) && ENABLED(SCROLL_LONG_FILENAMES)
+    #if HAS_LCD_MENU && ENABLED(SCROLL_LONG_FILENAMES)
       // If scrolling of long file names is enabled and we are in the sd card menu,
       // cause a refresh to occur until all the text has scrolled into view.
       if (currentScreen == menu_sdcard && filename_scroll_pos < filename_scroll_max && !lcd_status_update_delay--) {
     // then we want to use 1/2 of the time only.
     uint16_t bbr2 = planner.block_buffer_runtime() >> 1;
 
-    #if ENABLED(DOGLCD)
+    #if HAS_GRAPHICAL_LCD
       const bool &is_drawing = drawing_screen;
     #else
       constexpr bool is_drawing = false;
         buttons_reprapworld_keypad = 0;
       #endif
 
-      #if ENABLED(ULTIPANEL)
+      #if HAS_LCD_MENU
         #define CURRENTSCREEN() (*currentScreen)()
       #else
         #define CURRENTSCREEN() lcd_status_screen()
       #endif
 
-      #if ENABLED(DOGLCD)
+      #if HAS_GRAPHICAL_LCD
         #if ENABLED(LIGHTWEIGHT_UI)
-          #if ENABLED(ULTIPANEL)
+          #if HAS_LCD_MENU
             const bool in_status = currentScreen == lcd_status_screen;
           #else
             constexpr bool in_status = true;
         CURRENTSCREEN();
       #endif
 
-      #if ENABLED(ULTIPANEL)
+      #if HAS_LCD_MENU
         lcd_clicked = false;
       #endif
 
       NOLESS(max_display_update_time, millis() - ms);
     }
 
-    #if ENABLED(ULTIPANEL)
+    #if HAS_LCD_MENU
 
       // Return to Status Screen after a timeout
       if (currentScreen == lcd_status_screen || defer_return_to_status)
       else if (ELAPSED(ms, return_to_status_ms))
         lcd_return_to_status();
 
-    #endif // ULTIPANEL
+    #endif // HAS_LCD_MENU
 
     // Change state of drawing flag between screen updates
     if (!is_drawing) switch (lcdDrawUpdate) {
       expire_status_ms = persist ? 0 : progress_bar_ms + PROGRESS_MSG_EXPIRE;
     #endif
   #endif
+
   lcd_refresh();
 
   #if ENABLED(FILAMENT_LCD_DISPLAY) && ENABLED(SDSUPPORT)
   #endif
 }
 
-#if ENABLED(LCD_PROGRESS_BAR) && PROGRESS_MSG_EXPIRE > 0
-  void dontExpireStatus() { expire_status_ms = 0; }
-#endif
-
 bool lcd_hasstatus() { return (lcd_status_message[0] != '\0'); }
 
 void lcd_setstatus(const char * const message, const bool persist) {
 
 void lcd_setalertstatusPGM(PGM_P const message) {
   lcd_setstatusPGM(message, 1);
-  #if ENABLED(ULTIPANEL)
+  #if HAS_LCD_MENU
     lcd_return_to_status();
   #endif
 }
   }
 #endif
 
-#if ENABLED(ULTIPANEL)
+#if HAS_LCD_MENU
 
   /**
    * Setup Rotary Encoder Bit Values (for two pin encoders to indicate movement)
     }
   }
 
-#endif // ULTIPANEL
+#endif // HAS_LCD_MENU
 
 #endif // ULTRA_LCD

Marlin/src/lcd/ultralcd.h

 
   #elif ENABLED(U8GLIB_SSD1306)
     // Generic support for SSD1306 OLED I2C LCDs
-    //#define U8G_CLASS U8GLIB_SSD1306_128X64_2X_I2C_2_WIRE 
+    //#define U8G_CLASS U8GLIB_SSD1306_128X64_2X_I2C_2_WIRE
     //#define U8G_PARAM (U8G_I2C_OPT_NONE | U8G_I2C_OPT_FAST)           // 4 stripes
     #define U8G_CLASS U8GLIB_SSD1306_128X64_2X
     #define U8G_PARAM (U8G_I2C_OPT_NONE | U8G_I2C_OPT_FAST)             // 4 stripes
     //#define U8G_PARAM DOGLCD_SCK, DOGLCD_MOSI, DOGLCD_CS, DOGLCD_A0   // 4 stripes
   #elif ENABLED(U8GLIB_SH1106)
     // Generic support for SH1106 OLED I2C LCDs
-    //#define U8G_CLASS U8GLIB_SH1106_128X64_2X_I2C_2_WIRE 
+    //#define U8G_CLASS U8GLIB_SH1106_128X64_2X_I2C_2_WIRE
     //#define U8G_PARAM (U8G_I2C_OPT_NONE | U8G_I2C_OPT_FAST)           // 4 stripes
     #define U8G_CLASS U8GLIB_SH1106_128X64_2X
     #define U8G_PARAM (U8G_I2C_OPT_NONE | U8G_I2C_OPT_FAST)             // 4 stripes
     #include "../module/motion.h" // for active_extruder
   #endif
 
+  void lcd_status_screen();
   void lcd_return_to_status();
   bool lcd_hasstatus();
   void lcd_setstatus(const char* message, const bool persist=false);
 
   void lcd_quick_feedback(const bool clear_buttons); // Audible feedback for a button click - could also be visual
 
-  #if ENABLED(LCD_PROGRESS_BAR) && PROGRESS_MSG_EXPIRE > 0
-    void dontExpireStatus();
+  #if ENABLED(LCD_PROGRESS_BAR)
+    extern millis_t progress_bar_ms;  // Start time for the current progress bar cycle
+    #if PROGRESS_MSG_EXPIRE > 0
+      void dontExpireStatus();
+    #endif
   #endif
 
   #if ENABLED(LCD_SET_PROGRESS_MANUALLY)
     void set_lcd_contrast(const int16_t value);
   #endif
 
-  #if ENABLED(DOGLCD)
+  #if HAS_GRAPHICAL_LCD
     #define SETCURSOR(col, row) lcd_moveto(col * (DOG_CHAR_WIDTH), (row + 1) * (DOG_CHAR_HEIGHT))
     #define SETCURSOR_RJ(len, row) lcd_moveto(LCD_PIXEL_WIDTH - len * (DOG_CHAR_WIDTH), (row + 1) * (DOG_CHAR_HEIGHT))
   #else
       extern uint8_t filename_scroll_pos, filename_scroll_max;
     #endif
 
-  #endif // ULTIPANEL
+  #endif // HAS_LCD_MENU
 
   #if ENABLED(FILAMENT_LCD_DISPLAY) && ENABLED(SDSUPPORT)
     extern millis_t previous_lcd_status_ms;
   void lcd_reselect_last_file();
 #endif
 
-// LCD implementations
-void lcd_implementation_clear();
-void lcd_implementation_init();
-
 #if HAS_GRAPHICAL_LCD
   extern bool drawing_screen, first_page;
 #elif HAS_SPI_LCD
   constexpr bool first_page = true;
 #endif
 
+// LCD implementations
+void lcd_implementation_clear();
+void lcd_implementation_init();
+
 #if HAS_CHARACTER_LCD
 
-  enum HD44780CharSet : uint8_t {
-    CHARSET_MENU,
-    CHARSET_INFO,
-    CHARSET_BOOT
-  };
+  enum HD44780CharSet : uint8_t { CHARSET_MENU, CHARSET_INFO, CHARSET_BOOT };
+
+  void lcd_set_custom_characters(
+    #if ENABLED(LCD_PROGRESS_BAR) || ENABLED(SHOW_BOOTSCREEN)
+      const HD44780CharSet screen_charset=CHARSET_INFO
+    #endif
+  );
+  #if ENABLED(LCD_PROGRESS_BAR)
+    #define LCD_SET_CHARSET(C) lcd_set_custom_characters(C)
+  #else
+    #define LCD_SET_CHARSET(C) lcd_set_custom_characters()
+  #endif
 
 #endif

Marlin/src/module/tool_change.cpp

   #include "../feature/fanmux.h"
 #endif
 
-#if ENABLED(ULTIPANEL)
+#if HAS_LCD_MENU
   #include "../lcd/ultralcd.h"
 #endif
 
                 no_move = true;
           #endif
 
-          #if ENABLED(ULTIPANEL)
+          #if HAS_LCD_MENU
             lcd_return_to_status();
           #endif