Aliases for common menu item types

Marlin/src/lcd/menu/menu.cpp

@@ -134,7 +134,7 @@ void MenuItem_gcode::action(PGM_P const, PGM_P const pgcode) { queue.inject_P(pg
  *   void MenuItem_int3::action_edit(PGM_P const pstr, int16_t * const ptr, const int16_t minValue, const int16_t maxValue, const screenFunc_t callback = null, const bool live = false);
  *
  * You can then use one of the menu macros to present the edit interface:
- *   MENU_ITEM_EDIT(int3, MSG_SPEED, &feedrate_percentage, 10, 999)
+ *   EDIT_ITEM(int3, MSG_SPEED, &feedrate_percentage, 10, 999)
  *
  * This expands into a more primitive menu item:
  *   MENU_ITEM_VARIANT(int3, _edit, MSG_SPEED, PSTR(MSG_SPEED), &feedrate_percentage, 10, 999)

Marlin/src/lcd/menu/menu.h

@@ -293,17 +293,17 @@ class MenuItem_bool {
  *   MenuItem_<type>::action[_variant](arg3...)
  *
  * Examples:
- *   MENU_ITEM(back, MSG_WATCH, 0 [dummy parameter] )
- *   or
- *   MENU_BACK(MSG_WATCH)
+ *   BACK_ITEM(MSG_WATCH)
+ *   MENU_ITEM(back, MSG_WATCH)
  *     draw_menu_item_back(sel, row, PSTR(MSG_WATCH))
  *     MenuItem_back::action()
  *
+ *   ACTION_ITEM(MSG_PAUSE_PRINT, lcd_sdcard_pause)
  *   MENU_ITEM(function, MSG_PAUSE_PRINT, lcd_sdcard_pause)
  *     draw_menu_item_function(sel, row, PSTR(MSG_PAUSE_PRINT), lcd_sdcard_pause)
  *     MenuItem_function::action(lcd_sdcard_pause)
  *
- *   MENU_ITEM_EDIT(int3, MSG_SPEED, &feedrate_percentage, 10, 999)
+ *   EDIT_ITEM(int3, MSG_SPEED, &feedrate_percentage, 10, 999)
  *     draw_menu_item_edit_int3(sel, row, PSTR(MSG_SPEED), &feedrate_percentage, 10, 999)
  *     MenuItem_int3::action_edit(PSTR(MSG_SPEED), &feedrate_percentage, 10, 999)
  *
@@ -346,14 +346,16 @@ class MenuItem_bool {
 
 #define STATIC_ITEM(LABEL, V...) STATIC_ITEM_P(PSTR(LABEL), ##V)
 
-#define MENU_BACK(LABEL) MENU_ITEM(back, LABEL)
-#define MENU_ITEM_DUMMY() do { _thisItemNr++; }while(0)
-#define MENU_ITEM_P(TYPE, PLABEL, V...)                       _MENU_ITEM_VARIANT_P(TYPE,      , false, PLABEL,      ##V)
-#define MENU_ITEM(TYPE, LABEL, V...)                          _MENU_ITEM_VARIANT_P(TYPE,      , false, PSTR(LABEL), ##V)
-#define MENU_ITEM_EDIT(TYPE, LABEL, V...)                     _MENU_ITEM_VARIANT_P(TYPE, _edit, false, PSTR(LABEL), ##V)
-#define MENU_ITEM_EDIT_CALLBACK(TYPE, LABEL, V...)            _MENU_ITEM_VARIANT_P(TYPE, _edit, false, PSTR(LABEL), ##V)
-#define MENU_MULTIPLIER_ITEM_EDIT(TYPE, LABEL, V...)          _MENU_ITEM_VARIANT_P(TYPE, _edit,  true, PSTR(LABEL), ##V)
-#define MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(TYPE, LABEL, V...) _MENU_ITEM_VARIANT_P(TYPE, _edit,  true, PSTR(LABEL), ##V)
+#define MENU_ITEM_P(TYPE, PLABEL, V...)   _MENU_ITEM_VARIANT_P(TYPE,      , false, PLABEL,      ##V)
+#define MENU_ITEM(TYPE, LABEL, V...)      _MENU_ITEM_VARIANT_P(TYPE,      , false, PSTR(LABEL), ##V)
+#define EDIT_ITEM(TYPE, LABEL, V...)      _MENU_ITEM_VARIANT_P(TYPE, _edit, false, PSTR(LABEL), ##V)
+#define EDIT_ITEM_FAST(TYPE, LABEL, V...) _MENU_ITEM_VARIANT_P(TYPE, _edit,  true, PSTR(LABEL), ##V)
+
+#define SKIP_ITEM()                 (_thisItemNr++)
+#define BACK_ITEM(LABEL)            MENU_ITEM(back,LABEL)
+#define SUBMENU(LABEL, DEST)        MENU_ITEM(submenu, LABEL, DEST)
+#define GCODES_ITEM(LABEL, GCODES)  MENU_ITEM(gcode, LABEL, GCODES)
+#define ACTION_ITEM(LABEL, ACTION)  MENU_ITEM(function, LABEL, ACTION)
 
 ////////////////////////////////////////////
 /////////////// Menu Screens ///////////////

Marlin/src/lcd/menu/menu_advanced.cpp

@@ -62,13 +62,13 @@ void menu_backlash();
   void menu_dac() {
     dac_driver_getValues();
     START_MENU();
-    MENU_BACK(MSG_ADVANCED_SETTINGS);
-    #define EDIT_DAC_PERCENT(N) MENU_ITEM_EDIT_CALLBACK(uint8, MSG_##N " " MSG_DAC_PERCENT, &driverPercent[_AXIS(N)], 0, 100, dac_driver_commit)
+    BACK_ITEM(MSG_ADVANCED_SETTINGS);
+    #define EDIT_DAC_PERCENT(N) EDIT_ITEM(uint8, MSG_##N " " MSG_DAC_PERCENT, &driverPercent[_AXIS(N)], 0, 100, dac_driver_commit)
     EDIT_DAC_PERCENT(X);
     EDIT_DAC_PERCENT(Y);
     EDIT_DAC_PERCENT(Z);
     EDIT_DAC_PERCENT(E);
-    MENU_ITEM(function, MSG_DAC_EEPROM_WRITE, dac_commit_eeprom);
+    ACTION_ITEM(MSG_DAC_EEPROM_WRITE, dac_commit_eeprom);
     END_MENU();
   }
 
@@ -80,8 +80,8 @@ void menu_backlash();
 
   void menu_pwm() {
     START_MENU();
-    MENU_BACK(MSG_ADVANCED_SETTINGS);
-    #define EDIT_CURRENT_PWM(LABEL,I) MENU_ITEM_EDIT_CALLBACK(long5, LABEL, &stepper.motor_current_setting[I], 100, 2000, stepper.refresh_motor_power)
+    BACK_ITEM(MSG_ADVANCED_SETTINGS);
+    #define EDIT_CURRENT_PWM(LABEL,I) EDIT_ITEM(long5, LABEL, &stepper.motor_current_setting[I], 100, 2000, stepper.refresh_motor_power)
     #if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
       EDIT_CURRENT_PWM(MSG_X MSG_Y, 0);
     #endif
@@ -116,13 +116,13 @@ void menu_backlash();
   //
   void menu_advanced_filament() {
     START_MENU();
-    MENU_BACK(MSG_ADVANCED_SETTINGS);
+    BACK_ITEM(MSG_ADVANCED_SETTINGS);
 
     #if ENABLED(LIN_ADVANCE)
       #if EXTRUDERS == 1
-        MENU_ITEM_EDIT(float52, MSG_ADVANCE_K, &planner.extruder_advance_K[0], 0, 999);
+        EDIT_ITEM(float52, MSG_ADVANCE_K, &planner.extruder_advance_K[0], 0, 999);
       #elif EXTRUDERS > 1
-        #define EDIT_ADVANCE_K(N) MENU_ITEM_EDIT(float52, MSG_ADVANCE_K MSG_E##N, &planner.extruder_advance_K[N-1], 0, 999)
+        #define EDIT_ADVANCE_K(N) EDIT_ITEM(float52, MSG_ADVANCE_K MSG_E##N, &planner.extruder_advance_K[N-1], 0, 999)
         EDIT_ADVANCE_K(1);
         EDIT_ADVANCE_K(2);
         #if EXTRUDERS > 2
@@ -141,14 +141,14 @@ void menu_backlash();
     #endif
 
     #if DISABLED(NO_VOLUMETRICS)
-      MENU_ITEM_EDIT_CALLBACK(bool, MSG_VOLUMETRIC_ENABLED, &parser.volumetric_enabled, planner.calculate_volumetric_multipliers);
+      EDIT_ITEM(bool, MSG_VOLUMETRIC_ENABLED, &parser.volumetric_enabled, planner.calculate_volumetric_multipliers);
 
       if (parser.volumetric_enabled) {
         #if EXTRUDERS == 1
-          MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM, &planner.filament_size[0], 1.5f, 3.25f, planner.calculate_volumetric_multipliers);
+          EDIT_ITEM_FAST(float43, MSG_FILAMENT_DIAM, &planner.filament_size[0], 1.5f, 3.25f, planner.calculate_volumetric_multipliers);
         #else // EXTRUDERS > 1
-          #define EDIT_FIL_DIAM(N) MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM MSG_DIAM_E##N, &planner.filament_size[N-1], 1.5f, 3.25f, planner.calculate_volumetric_multipliers)
-          MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM, &planner.filament_size[active_extruder], 1.5f, 3.25f, planner.calculate_volumetric_multipliers);
+          #define EDIT_FIL_DIAM(N) EDIT_ITEM_FAST(float43, MSG_FILAMENT_DIAM MSG_DIAM_E##N, &planner.filament_size[N-1], 1.5f, 3.25f, planner.calculate_volumetric_multipliers)
+          EDIT_ITEM_FAST(float43, MSG_FILAMENT_DIAM, &planner.filament_size[active_extruder], 1.5f, 3.25f, planner.calculate_volumetric_multipliers);
           EDIT_FIL_DIAM(1);
           EDIT_FIL_DIAM(2);
           #if EXTRUDERS > 2
@@ -177,10 +177,10 @@ void menu_backlash();
       ;
 
       #if EXTRUDERS == 1
-        MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_FILAMENT_UNLOAD, &fc_settings[0].unload_length, 0, extrude_maxlength);
+        EDIT_ITEM_FAST(float3, MSG_FILAMENT_UNLOAD, &fc_settings[0].unload_length, 0, extrude_maxlength);
       #elif EXTRUDERS > 1
-        #define EDIT_FIL_UNLOAD(N) MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_FILAMENT_UNLOAD MSG_DIAM_E##N, &fc_settings[N-1].unload_length, 0, extrude_maxlength)
-        MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_FILAMENT_UNLOAD, &fc_settings[active_extruder].unload_length, 0, extrude_maxlength);
+        #define EDIT_FIL_UNLOAD(N) EDIT_ITEM_FAST(float3, MSG_FILAMENT_UNLOAD MSG_DIAM_E##N, &fc_settings[N-1].unload_length, 0, extrude_maxlength)
+        EDIT_ITEM_FAST(float3, MSG_FILAMENT_UNLOAD, &fc_settings[active_extruder].unload_length, 0, extrude_maxlength);
         EDIT_FIL_UNLOAD(1);
         EDIT_FIL_UNLOAD(2);
         #if EXTRUDERS > 2
@@ -198,10 +198,10 @@ void menu_backlash();
       #endif // EXTRUDERS > 1
 
       #if EXTRUDERS == 1
-        MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_FILAMENT_LOAD, &fc_settings[0].load_length, 0, extrude_maxlength);
+        EDIT_ITEM_FAST(float3, MSG_FILAMENT_LOAD, &fc_settings[0].load_length, 0, extrude_maxlength);
       #elif EXTRUDERS > 1
-        #define EDIT_FIL_LOAD(N) MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_FILAMENT_LOAD MSG_DIAM_E##N, &fc_settings[N-1].load_length, 0, extrude_maxlength)
-        MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_FILAMENT_LOAD, &fc_settings[active_extruder].load_length, 0, extrude_maxlength);
+        #define EDIT_FIL_LOAD(N) EDIT_ITEM_FAST(float3, MSG_FILAMENT_LOAD MSG_DIAM_E##N, &fc_settings[N-1].load_length, 0, extrude_maxlength)
+        EDIT_ITEM_FAST(float3, MSG_FILAMENT_LOAD, &fc_settings[active_extruder].load_length, 0, extrude_maxlength);
         EDIT_FIL_LOAD(1);
         EDIT_FIL_LOAD(2);
         #if EXTRUDERS > 2
@@ -220,7 +220,7 @@ void menu_backlash();
     #endif
 
     #if ENABLED(FILAMENT_RUNOUT_SENSOR) && FILAMENT_RUNOUT_DISTANCE_MM
-      MENU_ITEM_EDIT_CALLBACK(float3, MSG_RUNOUT_DISTANCE_MM, &lcd_runout_distance_mm, 1, 30, []{
+      EDIT_ITEM(float3, MSG_RUNOUT_DISTANCE_MM, &lcd_runout_distance_mm, 1, 30, []{
         runout.set_runout_distance(lcd_runout_distance_mm);
       });
     #endif
@@ -328,15 +328,15 @@ void menu_backlash();
 
   void menu_advanced_temperature() {
     START_MENU();
-    MENU_BACK(MSG_ADVANCED_SETTINGS);
+    BACK_ITEM(MSG_ADVANCED_SETTINGS);
     //
     // Autotemp, Min, Max, Fact
     //
     #if ENABLED(AUTOTEMP) && HAS_TEMP_HOTEND
-      MENU_ITEM_EDIT(bool, MSG_AUTOTEMP, &planner.autotemp_enabled);
-      MENU_ITEM_EDIT(float3, MSG_MIN, &planner.autotemp_min, 0, float(HEATER_0_MAXTEMP) - 15);
-      MENU_ITEM_EDIT(float3, MSG_MAX, &planner.autotemp_max, 0, float(HEATER_0_MAXTEMP) - 15);
-      MENU_ITEM_EDIT(float52, MSG_FACTOR, &planner.autotemp_factor, 0, 10);
+      EDIT_ITEM(bool, MSG_AUTOTEMP, &planner.autotemp_enabled);
+      EDIT_ITEM(float3, MSG_MIN, &planner.autotemp_min, 0, float(HEATER_0_MAXTEMP) - 15);
+      EDIT_ITEM(float3, MSG_MAX, &planner.autotemp_max, 0, float(HEATER_0_MAXTEMP) - 15);
+      EDIT_ITEM(float52, MSG_FACTOR, &planner.autotemp_factor, 0, 10);
     #endif
 
     //
@@ -352,14 +352,14 @@ void menu_backlash();
       #define _PID_BASE_MENU_ITEMS(ELABEL, eindex) \
         raw_Ki = unscalePID_i(PID_PARAM(Ki, eindex)); \
         raw_Kd = unscalePID_d(PID_PARAM(Kd, eindex)); \
-        MENU_ITEM_EDIT(float52sign, MSG_PID_P ELABEL, &PID_PARAM(Kp, eindex), 1, 9990); \
-        MENU_ITEM_EDIT_CALLBACK(float52sign, MSG_PID_I ELABEL, &raw_Ki, 0.01f, 9990, copy_and_scalePID_i_E ## eindex); \
-        MENU_ITEM_EDIT_CALLBACK(float52sign, MSG_PID_D ELABEL, &raw_Kd, 1, 9990, copy_and_scalePID_d_E ## eindex)
+        EDIT_ITEM(float52sign, MSG_PID_P ELABEL, &PID_PARAM(Kp, eindex), 1, 9990); \
+        EDIT_ITEM(float52sign, MSG_PID_I ELABEL, &raw_Ki, 0.01f, 9990, copy_and_scalePID_i_E ## eindex); \
+        EDIT_ITEM(float52sign, MSG_PID_D ELABEL, &raw_Kd, 1, 9990, copy_and_scalePID_d_E ## eindex)
 
       #if ENABLED(PID_EXTRUSION_SCALING)
         #define _PID_EDIT_MENU_ITEMS(ELABEL, eindex) \
           _PID_BASE_MENU_ITEMS(ELABEL, eindex); \
-          MENU_ITEM_EDIT(float3, MSG_PID_C ELABEL, &PID_PARAM(Kc, eindex), 1, 9990)
+          EDIT_ITEM(float3, MSG_PID_C ELABEL, &PID_PARAM(Kc, eindex), 1, 9990)
       #else
         #define _PID_EDIT_MENU_ITEMS(ELABEL, eindex) _PID_BASE_MENU_ITEMS(ELABEL, eindex)
       #endif
@@ -373,7 +373,7 @@ void menu_backlash();
     #if ENABLED(PID_AUTOTUNE_MENU)
       #define PID_EDIT_MENU_ITEMS(ELABEL, eindex) \
         _PID_EDIT_MENU_ITEMS(ELABEL, eindex); \
-        MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_PID_AUTOTUNE ELABEL, &autotune_temp[eindex], 150, heater_maxtemp[eindex] - 15, lcd_autotune_callback_E ## eindex)
+        EDIT_ITEM_FAST(int3, MSG_PID_AUTOTUNE ELABEL, &autotune_temp[eindex], 150, heater_maxtemp[eindex] - 15, lcd_autotune_callback_E ## eindex)
     #else
       #define PID_EDIT_MENU_ITEMS(ELABEL, eindex) _PID_EDIT_MENU_ITEMS(ELABEL, eindex)
     #endif
@@ -450,7 +450,7 @@ void menu_backlash();
   // M203 / M205 Velocity options
   void menu_advanced_velocity() {
     START_MENU();
-    MENU_BACK(MSG_ADVANCED_SETTINGS);
+    BACK_ITEM(MSG_ADVANCED_SETTINGS);
 
     // M203 Max Feedrate
     constexpr xyze_feedrate_t max_fr_edit =
@@ -467,14 +467,14 @@ void menu_backlash();
     #else
       const xyze_feedrate_t &max_fr_edit_scaled = max_fr_edit;
     #endif
-    #define EDIT_VMAX(N) MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_VMAX MSG_##N, &planner.settings.max_feedrate_mm_s[_AXIS(N)], 1, max_fr_edit_scaled[_AXIS(N)])
+    #define EDIT_VMAX(N) EDIT_ITEM_FAST(float3, MSG_VMAX MSG_##N, &planner.settings.max_feedrate_mm_s[_AXIS(N)], 1, max_fr_edit_scaled[_AXIS(N)])
     EDIT_VMAX(A);
     EDIT_VMAX(B);
     EDIT_VMAX(C);
 
     #if ENABLED(DISTINCT_E_FACTORS)
-      #define EDIT_VMAX_E(N) MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_VMAX MSG_E##N, &planner.settings.max_feedrate_mm_s[E_AXIS_N(N-1)], 1, max_fr_edit_scaled.e)
-      MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_VMAX MSG_E, &planner.settings.max_feedrate_mm_s[E_AXIS_N(active_extruder)], 1, max_fr_edit_scaled.e);
+      #define EDIT_VMAX_E(N) EDIT_ITEM_FAST(float3, MSG_VMAX MSG_E##N, &planner.settings.max_feedrate_mm_s[E_AXIS_N(N-1)], 1, max_fr_edit_scaled.e)
+      EDIT_ITEM_FAST(float3, MSG_VMAX MSG_E, &planner.settings.max_feedrate_mm_s[E_AXIS_N(active_extruder)], 1, max_fr_edit_scaled.e);
       EDIT_VMAX_E(1);
       EDIT_VMAX_E(2);
       #if E_STEPPERS > 2
@@ -490,14 +490,14 @@ void menu_backlash();
         #endif // E_STEPPERS > 3
       #endif // E_STEPPERS > 2
     #elif E_STEPPERS
-      MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_VMAX MSG_E, &planner.settings.max_feedrate_mm_s[E_AXIS], 1, max_fr_edit_scaled.e);
+      EDIT_ITEM_FAST(float3, MSG_VMAX MSG_E, &planner.settings.max_feedrate_mm_s[E_AXIS], 1, max_fr_edit_scaled.e);
     #endif
 
     // M205 S Min Feedrate
-    MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_VMIN, &planner.settings.min_feedrate_mm_s, 0, 999);
+    EDIT_ITEM_FAST(float3, MSG_VMIN, &planner.settings.min_feedrate_mm_s, 0, 999);
 
     // M205 T Min Travel Feedrate
-    MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_VTRAV_MIN, &planner.settings.min_travel_feedrate_mm_s, 0, 999);
+    EDIT_ITEM_FAST(float3, MSG_VTRAV_MIN, &planner.settings.min_travel_feedrate_mm_s, 0, 999);
 
     END_MENU();
   }
@@ -505,17 +505,17 @@ void menu_backlash();
   // M201 / M204 Accelerations
   void menu_advanced_acceleration() {
     START_MENU();
-    MENU_BACK(MSG_ADVANCED_SETTINGS);
+    BACK_ITEM(MSG_ADVANCED_SETTINGS);
 
     static float max_accel = _MAX(planner.settings.max_acceleration_mm_per_s2[A_AXIS], planner.settings.max_acceleration_mm_per_s2[B_AXIS], planner.settings.max_acceleration_mm_per_s2[C_AXIS]);
     // M204 P Acceleration
-    MENU_MULTIPLIER_ITEM_EDIT(float5_25, MSG_ACC, &planner.settings.acceleration, 25, max_accel);
+    EDIT_ITEM_FAST(float5_25, MSG_ACC, &planner.settings.acceleration, 25, max_accel);
 
     // M204 R Retract Acceleration
-    MENU_MULTIPLIER_ITEM_EDIT(float5, MSG_A_RETRACT, &planner.settings.retract_acceleration, 100, max_accel);
+    EDIT_ITEM_FAST(float5, MSG_A_RETRACT, &planner.settings.retract_acceleration, 100, max_accel);
 
     // M204 T Travel Acceleration
-    MENU_MULTIPLIER_ITEM_EDIT(float5_25, MSG_A_TRAVEL, &planner.settings.travel_acceleration, 25, max_accel);
+    EDIT_ITEM_FAST(float5_25, MSG_A_TRAVEL, &planner.settings.travel_acceleration, 25, max_accel);
 
     // M201 settings
     constexpr xyze_ulong_t max_accel_edit =
@@ -533,15 +533,15 @@ void menu_backlash();
       const xyze_ulong_t &max_accel_edit_scaled = max_accel_edit;
     #endif
 
-    #define EDIT_AMAX(Q,L) MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(long5_25, MSG_AMAX MSG_##Q, &planner.settings.max_acceleration_mm_per_s2[_AXIS(Q)], L, max_accel_edit_scaled[_AXIS(Q)], _reset_acceleration_rates)
+    #define EDIT_AMAX(Q,L) EDIT_ITEM_FAST(long5_25, MSG_AMAX MSG_##Q, &planner.settings.max_acceleration_mm_per_s2[_AXIS(Q)], L, max_accel_edit_scaled[_AXIS(Q)], _reset_acceleration_rates)
 
     EDIT_AMAX(A,100);
     EDIT_AMAX(B,100);
     EDIT_AMAX(C, 10);
 
     #if ENABLED(DISTINCT_E_FACTORS)
-      #define EDIT_AMAX_E(N,E) MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(long5_25, MSG_AMAX MSG_E##N, &planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(E)], 100, max_accel_edit_scaled.e, _reset_e##E##_acceleration_rate)
-      MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(long5_25, MSG_AMAX MSG_E, &planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(active_extruder)], 100, max_accel_edit_scaled.e, _reset_acceleration_rates);
+      #define EDIT_AMAX_E(N,E) EDIT_ITEM_FAST(long5_25, MSG_AMAX MSG_E##N, &planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(E)], 100, max_accel_edit_scaled.e, _reset_e##E##_acceleration_rate)
+      EDIT_ITEM_FAST(long5_25, MSG_AMAX MSG_E, &planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(active_extruder)], 100, max_accel_edit_scaled.e, _reset_acceleration_rates);
       EDIT_AMAX_E(1,0);
       EDIT_AMAX_E(2,1);
       #if E_STEPPERS > 2
@@ -557,7 +557,7 @@ void menu_backlash();
         #endif // E_STEPPERS > 3
       #endif // E_STEPPERS > 2
     #elif E_STEPPERS
-      MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(long5_25, MSG_AMAX MSG_E, &planner.settings.max_acceleration_mm_per_s2[E_AXIS], 100, max_accel_edit_scaled.e, _reset_acceleration_rates);
+      EDIT_ITEM_FAST(long5_25, MSG_AMAX MSG_E, &planner.settings.max_acceleration_mm_per_s2[E_AXIS], 100, max_accel_edit_scaled.e, _reset_acceleration_rates);
     #endif
 
     END_MENU();
@@ -566,13 +566,13 @@ void menu_backlash();
   // M205 Jerk
   void menu_advanced_jerk() {
     START_MENU();
-    MENU_BACK(MSG_ADVANCED_SETTINGS);
+    BACK_ITEM(MSG_ADVANCED_SETTINGS);
 
     #if ENABLED(JUNCTION_DEVIATION)
       #if ENABLED(LIN_ADVANCE)
-        MENU_ITEM_EDIT_CALLBACK(float43, MSG_JUNCTION_DEVIATION, &planner.junction_deviation_mm, 0.01f, 0.3f, planner.recalculate_max_e_jerk);
+        EDIT_ITEM(float43, MSG_JUNCTION_DEVIATION, &planner.junction_deviation_mm, 0.01f, 0.3f, planner.recalculate_max_e_jerk);
       #else
-        MENU_ITEM_EDIT(float43, MSG_JUNCTION_DEVIATION, &planner.junction_deviation_mm, 0.01f, 0.3f);
+        EDIT_ITEM(float43, MSG_JUNCTION_DEVIATION, &planner.junction_deviation_mm, 0.01f, 0.3f);
       #endif
     #endif
     #if HAS_CLASSIC_JERK
@@ -585,16 +585,16 @@ void menu_backlash();
           { 990, 990, 990, 990 }
         #endif
       ;
-      #define EDIT_JERK(N) MENU_MULTIPLIER_ITEM_EDIT(float3, MSG_V##N##_JERK, &planner.max_jerk[_AXIS(N)], 1, max_jerk_edit[_AXIS(N)])
+      #define EDIT_JERK(N) EDIT_ITEM_FAST(float3, MSG_V##N##_JERK, &planner.max_jerk[_AXIS(N)], 1, max_jerk_edit[_AXIS(N)])
       EDIT_JERK(A);
       EDIT_JERK(B);
       #if ENABLED(DELTA)
         EDIT_JERK(C);
       #else
-        MENU_MULTIPLIER_ITEM_EDIT(float52sign, MSG_VC_JERK, &planner.max_jerk.c, 0.1f, max_jerk_edit.c);
+        EDIT_ITEM_FAST(float52sign, MSG_VC_JERK, &planner.max_jerk.c, 0.1f, max_jerk_edit.c);
       #endif
       #if !BOTH(JUNCTION_DEVIATION, LIN_ADVANCE)
-        MENU_MULTIPLIER_ITEM_EDIT(float52sign, MSG_VE_JERK, &planner.max_jerk.e, 0.1f, max_jerk_edit.e);
+        EDIT_ITEM_FAST(float52sign, MSG_VE_JERK, &planner.max_jerk.e, 0.1f, max_jerk_edit.e);
       #endif
     #endif
 
@@ -604,16 +604,16 @@ void menu_backlash();
   // M92 Steps-per-mm
   void menu_advanced_steps_per_mm() {
     START_MENU();
-    MENU_BACK(MSG_ADVANCED_SETTINGS);
+    BACK_ITEM(MSG_ADVANCED_SETTINGS);
 
-    #define EDIT_QSTEPS(Q) MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float51, MSG_##Q##STEPS, &planner.settings.axis_steps_per_mm[_AXIS(Q)], 5, 9999, _planner_refresh_positioning)
+    #define EDIT_QSTEPS(Q) EDIT_ITEM_FAST(float51, MSG_##Q##STEPS, &planner.settings.axis_steps_per_mm[_AXIS(Q)], 5, 9999, _planner_refresh_positioning)
     EDIT_QSTEPS(A);
     EDIT_QSTEPS(B);
     EDIT_QSTEPS(C);
 
     #if ENABLED(DISTINCT_E_FACTORS)
-      #define EDIT_ESTEPS(N,E) MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float51, MSG_E##N##STEPS, &planner.settings.axis_steps_per_mm[E_AXIS_N(E)], 5, 9999, _planner_refresh_e##E##_positioning)
-      MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float51, MSG_ESTEPS, &planner.settings.axis_steps_per_mm[E_AXIS_N(active_extruder)], 5, 9999, _planner_refresh_positioning);
+      #define EDIT_ESTEPS(N,E) EDIT_ITEM_FAST(float51, MSG_E##N##STEPS, &planner.settings.axis_steps_per_mm[E_AXIS_N(E)], 5, 9999, _planner_refresh_e##E##_positioning)
+      EDIT_ITEM_FAST(float51, MSG_ESTEPS, &planner.settings.axis_steps_per_mm[E_AXIS_N(active_extruder)], 5, 9999, _planner_refresh_positioning);
       EDIT_ESTEPS(1,0);
       EDIT_ESTEPS(2,1);
       #if E_STEPPERS > 2
@@ -629,7 +629,7 @@ void menu_backlash();
         #endif // E_STEPPERS > 3
       #endif // E_STEPPERS > 2
     #elif E_STEPPERS
-      MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float51, MSG_ESTEPS, &planner.settings.axis_steps_per_mm[E_AXIS], 5, 9999, _planner_refresh_positioning);
+      EDIT_ITEM_FAST(float51, MSG_ESTEPS, &planner.settings.axis_steps_per_mm[E_AXIS], 5, 9999, _planner_refresh_positioning);
     #endif
 
     END_MENU();
@@ -663,7 +663,7 @@ void menu_advanced_settings() {
     lcd_runout_distance_mm = runout.runout_distance();
   #endif
   START_MENU();
-  MENU_BACK(MSG_CONFIGURATION);
+  BACK_ITEM(MSG_CONFIGURATION);
 
   #if DISABLED(SLIM_LCD_MENUS)
 
@@ -671,50 +671,50 @@ void menu_advanced_settings() {
       //
       // Set Home Offsets
       //
-      MENU_ITEM(function, MSG_SET_HOME_OFFSETS, _lcd_set_home_offsets);
+      ACTION_ITEM(MSG_SET_HOME_OFFSETS, _lcd_set_home_offsets);
     #endif
 
     // M203 / M205 - Feedrate items
-    MENU_ITEM(submenu, MSG_VELOCITY, menu_advanced_velocity);
+    SUBMENU(MSG_VELOCITY, menu_advanced_velocity);
 
     // M201 - Acceleration items
-    MENU_ITEM(submenu, MSG_ACCELERATION, menu_advanced_acceleration);
+    SUBMENU(MSG_ACCELERATION, menu_advanced_acceleration);
 
     // M205 - Max Jerk
-    MENU_ITEM(submenu, MSG_JERK, menu_advanced_jerk);
+    SUBMENU(MSG_JERK, menu_advanced_jerk);
 
     if (!printer_busy()) {
       // M92 - Steps Per mm
-      MENU_ITEM(submenu, MSG_STEPS_PER_MM, menu_advanced_steps_per_mm);
+      SUBMENU(MSG_STEPS_PER_MM, menu_advanced_steps_per_mm);
     }
   #endif // !SLIM_LCD_MENUS
 
   #if ENABLED(BACKLASH_GCODE)
-    MENU_ITEM(submenu, MSG_BACKLASH, menu_backlash);
+    SUBMENU(MSG_BACKLASH, menu_backlash);
   #endif
 
   #if ENABLED(DAC_STEPPER_CURRENT)
-    MENU_ITEM(submenu, MSG_DRIVE_STRENGTH, menu_dac);
+    SUBMENU(MSG_DRIVE_STRENGTH, menu_dac);
   #endif
   #if HAS_MOTOR_CURRENT_PWM
-    MENU_ITEM(submenu, MSG_DRIVE_STRENGTH, menu_pwm);
+    SUBMENU(MSG_DRIVE_STRENGTH, menu_pwm);
   #endif
 
   #if HAS_TRINAMIC
-    MENU_ITEM(submenu, MSG_TMC_DRIVERS, menu_tmc);
+    SUBMENU(MSG_TMC_DRIVERS, menu_tmc);
   #endif
 
   #if SHOW_MENU_ADVANCED_TEMPERATURE
-    MENU_ITEM(submenu, MSG_TEMPERATURE, menu_advanced_temperature);
+    SUBMENU(MSG_TEMPERATURE, menu_advanced_temperature);
   #endif
 
   #if DISABLED(NO_VOLUMETRICS) || ENABLED(ADVANCED_PAUSE_FEATURE)
-    MENU_ITEM(submenu, MSG_FILAMENT, menu_advanced_filament);
+    SUBMENU(MSG_FILAMENT, menu_advanced_filament);
   #elif ENABLED(LIN_ADVANCE)
     #if EXTRUDERS == 1
-      MENU_ITEM_EDIT(float52, MSG_ADVANCE_K, &planner.extruder_advance_K[0], 0, 999);
+      EDIT_ITEM(float52, MSG_ADVANCE_K, &planner.extruder_advance_K[0], 0, 999);
     #elif EXTRUDERS > 1
-      #define EDIT_ADVANCE_K(N) MENU_ITEM_EDIT(float52, MSG_ADVANCE_K MSG_E##N, &planner.extruder_advance_K[N-1], 0, 999)
+      #define EDIT_ADVANCE_K(N) EDIT_ITEM(float52, MSG_ADVANCE_K MSG_E##N, &planner.extruder_advance_K[N-1], 0, 999)
       EDIT_ADVANCE_K(1);
       EDIT_ADVANCE_K(2);
       #if EXTRUDERS > 2
@@ -734,12 +734,12 @@ void menu_advanced_settings() {
 
   // M540 S - Abort on endstop hit when SD printing
   #if ENABLED(SD_ABORT_ON_ENDSTOP_HIT)
-    MENU_ITEM_EDIT(bool, MSG_ENDSTOP_ABORT, &planner.abort_on_endstop_hit);
+    EDIT_ITEM(bool, MSG_ENDSTOP_ABORT, &planner.abort_on_endstop_hit);
   #endif
 
   #if ENABLED(SD_FIRMWARE_UPDATE)
     bool sd_update_state = settings.sd_update_status();
-    MENU_ITEM_EDIT_CALLBACK(bool, MSG_MEDIA_UPDATE, &sd_update_state, []{
+    EDIT_ITEM(bool, MSG_MEDIA_UPDATE, &sd_update_state, []{
       //
       // Toggle the SD Firmware Update state in EEPROM
       //
@@ -754,7 +754,7 @@ void menu_advanced_settings() {
   #endif
 
   #if ENABLED(EEPROM_SETTINGS) && DISABLED(SLIM_LCD_MENUS)
-    MENU_ITEM(submenu, MSG_INIT_EEPROM, lcd_init_eeprom_confirm);
+    SUBMENU(MSG_INIT_EEPROM, lcd_init_eeprom_confirm);
   #endif
 
   END_MENU();

Marlin/src/lcd/menu/menu_backlash.cpp

@@ -34,17 +34,17 @@
 
 void menu_backlash() {
   START_MENU();
-  MENU_BACK(MSG_MAIN);
+  BACK_ITEM(MSG_MAIN);
 
-  MENU_MULTIPLIER_ITEM_EDIT(percent, MSG_BACKLASH_CORRECTION, &backlash.correction, all_off, all_on);
+  EDIT_ITEM_FAST(percent, MSG_BACKLASH_CORRECTION, &backlash.correction, all_off, all_on);
 
-  #define EDIT_BACKLASH_DISTANCE(N) MENU_MULTIPLIER_ITEM_EDIT(float43, MSG_##N, &backlash.distance_mm[_AXIS(N)], 0.0f, 9.9f);
+  #define EDIT_BACKLASH_DISTANCE(N) EDIT_ITEM_FAST(float43, MSG_##N, &backlash.distance_mm[_AXIS(N)], 0.0f, 9.9f);
   EDIT_BACKLASH_DISTANCE(A);
   EDIT_BACKLASH_DISTANCE(B);
   EDIT_BACKLASH_DISTANCE(C);
 
   #ifdef BACKLASH_SMOOTHING_MM
-    MENU_MULTIPLIER_ITEM_EDIT(float43, MSG_BACKLASH_SMOOTHING, &backlash.smoothing_mm, 0.0f, 9.9f);
+    EDIT_ITEM_FAST(float43, MSG_BACKLASH_SMOOTHING, &backlash.smoothing_mm, 0.0f, 9.9f);
   #endif
 
   END_MENU();

Marlin/src/lcd/menu/menu_bed_leveling.cpp

@@ -210,10 +210,10 @@
   void menu_edit_mesh() {
     static uint8_t xind, yind; // =0
     START_MENU();
-    MENU_BACK(MSG_BED_LEVELING);
-    MENU_ITEM_EDIT(uint8, MSG_MESH_X, &xind, 0, GRID_MAX_POINTS_X - 1);
-    MENU_ITEM_EDIT(uint8, MSG_MESH_Y, &yind, 0, GRID_MAX_POINTS_Y - 1);
-    MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_MESH_EDIT_Z, &Z_VALUES(xind, yind), -(LCD_PROBE_Z_RANGE) * 0.5, (LCD_PROBE_Z_RANGE) * 0.5, refresh_planner);
+    BACK_ITEM(MSG_BED_LEVELING);
+    EDIT_ITEM(uint8, MSG_MESH_X, &xind, 0, GRID_MAX_POINTS_X - 1);
+    EDIT_ITEM(uint8, MSG_MESH_Y, &yind, 0, GRID_MAX_POINTS_Y - 1);
+    EDIT_ITEM_FAST(float43, MSG_MESH_EDIT_Z, &Z_VALUES(xind, yind), -(LCD_PROBE_Z_RANGE) * 0.5, (LCD_PROBE_Z_RANGE) * 0.5, refresh_planner);
     END_MENU();
   }
 
@@ -235,60 +235,60 @@
  */
 void menu_bed_leveling() {
   START_MENU();
-  MENU_BACK(MSG_MOTION);
+  BACK_ITEM(MSG_MOTION);
 
   const bool is_homed = all_axes_known();
 
   // Auto Home if not using manual probing
   #if NONE(PROBE_MANUALLY, MESH_BED_LEVELING)
-    if (!is_homed) MENU_ITEM(gcode, MSG_AUTO_HOME, PSTR("G28"));
+    if (!is_homed) GCODES_ITEM(MSG_AUTO_HOME, PSTR("G28"));
   #endif
 
   // Level Bed
   #if EITHER(PROBE_MANUALLY, MESH_BED_LEVELING)
     // Manual leveling uses a guided procedure
-    MENU_ITEM(submenu, MSG_LEVEL_BED, _lcd_level_bed_continue);
+    SUBMENU(MSG_LEVEL_BED, _lcd_level_bed_continue);
   #else
     // Automatic leveling can just run the G-code
-    MENU_ITEM(gcode, MSG_LEVEL_BED, is_homed ? PSTR("G29") : PSTR("G28\nG29"));
+    GCODES_ITEM(MSG_LEVEL_BED, is_homed ? PSTR("G29") : PSTR("G28\nG29"));
   #endif
 
   #if ENABLED(MESH_EDIT_MENU)
     if (leveling_is_valid())
-      MENU_ITEM(submenu, MSG_EDIT_MESH, menu_edit_mesh);
+      SUBMENU(MSG_EDIT_MESH, menu_edit_mesh);
   #endif
 
   // Homed and leveling is valid? Then leveling can be toggled.
   if (is_homed && leveling_is_valid()) {
     bool new_level_state = planner.leveling_active;
-    MENU_ITEM_EDIT_CALLBACK(bool, MSG_BED_LEVELING, &new_level_state, _lcd_toggle_bed_leveling);
+    EDIT_ITEM(bool, MSG_BED_LEVELING, &new_level_state, _lcd_toggle_bed_leveling);
   }
 
   // Z Fade Height
   #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
-    MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float3, MSG_Z_FADE_HEIGHT, &lcd_z_fade_height, 0, 100, _lcd_set_z_fade_height);
+    EDIT_ITEM_FAST(float3, MSG_Z_FADE_HEIGHT, &lcd_z_fade_height, 0, 100, _lcd_set_z_fade_height);
   #endif
 
   //
   // Mesh Bed Leveling Z-Offset
   //
   #if ENABLED(MESH_BED_LEVELING)
-    MENU_ITEM_EDIT(float43, MSG_BED_Z, &mbl.z_offset, -1, 1);
+    EDIT_ITEM(float43, MSG_BED_Z, &mbl.z_offset, -1, 1);
   #endif
 
   #if ENABLED(BABYSTEP_ZPROBE_OFFSET)
-    MENU_ITEM(submenu, MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
+    SUBMENU(MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
   #elif HAS_BED_PROBE
-    MENU_ITEM_EDIT(float52, MSG_ZPROBE_ZOFFSET, &probe_offset.z, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX);
+    EDIT_ITEM(float52, MSG_ZPROBE_ZOFFSET, &probe_offset.z, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX);
   #endif
 
   #if ENABLED(LEVEL_BED_CORNERS)
-    MENU_ITEM(submenu, MSG_LEVEL_CORNERS, _lcd_level_bed_corners);
+    SUBMENU(MSG_LEVEL_CORNERS, _lcd_level_bed_corners);
   #endif
 
   #if ENABLED(EEPROM_SETTINGS)
-    MENU_ITEM(function, MSG_LOAD_EEPROM, lcd_load_settings);
-    MENU_ITEM(function, MSG_STORE_EEPROM, lcd_store_settings);
+    ACTION_ITEM(MSG_LOAD_EEPROM, lcd_load_settings);
+    ACTION_ITEM(MSG_STORE_EEPROM, lcd_store_settings);
   #endif
   END_MENU();
 }

Marlin/src/lcd/menu/menu_configuration.cpp

@@ -92,10 +92,10 @@ static void lcd_factory_settings() {
   void menu_debug() {
     START_MENU();
 
-    MENU_BACK(MSG_CONFIGURATION);
+    BACK_ITEM(MSG_CONFIGURATION);
 
     #if ENABLED(LCD_PROGRESS_BAR_TEST)
-      MENU_ITEM(submenu, MSG_PROGRESS_BAR_TEST, _progress_bar_test);
+      SUBMENU(MSG_PROGRESS_BAR_TEST, _progress_bar_test);
     #endif
 
     END_MENU();
@@ -109,7 +109,7 @@ static void lcd_factory_settings() {
 
   void menu_tool_change() {
     START_MENU();
-    MENU_BACK(MSG_CONFIGURATION);
+    BACK_ITEM(MSG_CONFIGURATION);
     #if ENABLED(TOOLCHANGE_FILAMENT_SWAP)
       static constexpr float max_extrude =
         #if ENABLED(PREVENT_LENGTHY_EXTRUDE)
@@ -118,12 +118,12 @@ static void lcd_factory_settings() {
           500
         #endif
       ;
-      MENU_ITEM_EDIT(float3, MSG_FILAMENT_SWAP_LENGTH, &toolchange_settings.swap_length, 0, max_extrude);
-      MENU_ITEM_EDIT(float3, MSG_FILAMENT_PURGE_LENGTH, &toolchange_settings.extra_prime, 0, max_extrude);
-      MENU_MULTIPLIER_ITEM_EDIT(int4, MSG_SINGLENOZZLE_RETRACT_SPD, &toolchange_settings.retract_speed, 10, 5400);
-      MENU_MULTIPLIER_ITEM_EDIT(int4, MSG_SINGLENOZZLE_PRIME_SPD, &toolchange_settings.prime_speed, 10, 5400);
+      EDIT_ITEM(float3, MSG_FILAMENT_SWAP_LENGTH, &toolchange_settings.swap_length, 0, max_extrude);
+      EDIT_ITEM(float3, MSG_FILAMENT_PURGE_LENGTH, &toolchange_settings.extra_prime, 0, max_extrude);
+      EDIT_ITEM_FAST(int4, MSG_SINGLENOZZLE_RETRACT_SPD, &toolchange_settings.retract_speed, 10, 5400);
+      EDIT_ITEM_FAST(int4, MSG_SINGLENOZZLE_PRIME_SPD, &toolchange_settings.prime_speed, 10, 5400);
     #endif
-    MENU_ITEM_EDIT(float3, MSG_TOOL_CHANGE_ZLIFT, &toolchange_settings.z_raise, 0, 10);
+    EDIT_ITEM(float3, MSG_TOOL_CHANGE_ZLIFT, &toolchange_settings.z_raise, 0, 10);
     END_MENU();
   }
 
@@ -143,16 +143,16 @@ static void lcd_factory_settings() {
     };
 
     START_MENU();
-    MENU_BACK(MSG_CONFIGURATION);
+    BACK_ITEM(MSG_CONFIGURATION);
     #if ENABLED(DUAL_X_CARRIAGE)
-      MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float51, MSG_X_OFFSET, &hotend_offset[1].x, float(X2_HOME_POS - 25), float(X2_HOME_POS + 25), _recalc_offsets);
+      EDIT_ITEM_FAST(float51, MSG_X_OFFSET, &hotend_offset[1].x, float(X2_HOME_POS - 25), float(X2_HOME_POS + 25), _recalc_offsets);
     #else
-      MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float52sign, MSG_X_OFFSET, &hotend_offset[1].x, -99.0, 99.0, _recalc_offsets);
+      EDIT_ITEM_FAST(float52sign, MSG_X_OFFSET, &hotend_offset[1].x, -99.0, 99.0, _recalc_offsets);
     #endif
-    MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float52sign, MSG_Y_OFFSET, &hotend_offset[1].y, -99.0, 99.0, _recalc_offsets);
-    MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float52sign, MSG_Z_OFFSET, &hotend_offset[1].z, Z_PROBE_LOW_POINT, 10.0, _recalc_offsets);
+    EDIT_ITEM_FAST(float52sign, MSG_Y_OFFSET, &hotend_offset[1].y, -99.0, 99.0, _recalc_offsets);
+    EDIT_ITEM_FAST(float52sign, MSG_Z_OFFSET, &hotend_offset[1].z, Z_PROBE_LOW_POINT, 10.0, _recalc_offsets);
     #if ENABLED(EEPROM_SETTINGS)
-      MENU_ITEM(function, MSG_STORE_EEPROM, lcd_store_settings);
+      ACTION_ITEM(MSG_STORE_EEPROM, lcd_store_settings);
     #endif
     END_MENU();
   }
@@ -162,19 +162,21 @@ static void lcd_factory_settings() {
 
   void menu_idex() {
     START_MENU();
-    MENU_BACK(MSG_CONFIGURATION);
+    BACK_ITEM(MSG_CONFIGURATION);
 
-    MENU_ITEM(gcode, MSG_IDEX_MODE_AUTOPARK,  PSTR("M605 S1\nG28 X\nG1 X100"));
+    GCODES_ITEM(MSG_IDEX_MODE_AUTOPARK,  PSTR("M605 S1\nG28 X\nG1 X100"));
     const bool need_g28 = !(TEST(axis_known_position, Y_AXIS) && TEST(axis_known_position, Z_AXIS));
-    MENU_ITEM(gcode, MSG_IDEX_MODE_DUPLICATE, need_g28
+
+    GCODES_ITEM(MSG_IDEX_MODE_DUPLICATE, need_g28
       ? PSTR("M605 S1\nT0\nG28\nM605 S2 X200\nG28 X\nG1 X100")                // If Y or Z is not homed, do a full G28 first
       : PSTR("M605 S1\nT0\nM605 S2 X200\nG28 X\nG1 X100")
     );
-    MENU_ITEM(gcode, MSG_IDEX_MODE_MIRRORED_COPY, need_g28
+
+    GCODES_ITEM(MSG_IDEX_MODE_MIRRORED_COPY, need_g28
       ? PSTR("M605 S1\nT0\nG28\nM605 S2 X200\nG28 X\nG1 X100\nM605 S3 X200")  // If Y or Z is not homed, do a full G28 first
       : PSTR("M605 S1\nT0\nM605 S2 X200\nG28 X\nG1 X100\nM605 S3 X200")
     );
-    MENU_ITEM(gcode, MSG_IDEX_MODE_FULL_CTRL, PSTR("M605 S0\nG28 X"));
+    GCODES_ITEM(MSG_IDEX_MODE_FULL_CTRL, PSTR("M605 S0\nG28 X"));
     END_MENU();
   }
 
@@ -202,27 +204,27 @@ static void lcd_factory_settings() {
 
   void menu_bltouch() {
     START_MENU();
-    MENU_BACK(MSG_CONFIGURATION);
-    MENU_ITEM(function, MSG_BLTOUCH_RESET, bltouch._reset);
-    MENU_ITEM(function, MSG_BLTOUCH_SELFTEST, bltouch._selftest);
-    MENU_ITEM(function, MSG_BLTOUCH_DEPLOY, bltouch._deploy);
-    MENU_ITEM(function, MSG_BLTOUCH_STOW, bltouch._stow);
-    MENU_ITEM(function, MSG_BLTOUCH_SW_MODE, bltouch._set_SW_mode);
+    BACK_ITEM(MSG_CONFIGURATION);
+    ACTION_ITEM(MSG_BLTOUCH_RESET, bltouch._reset);
+    ACTION_ITEM(MSG_BLTOUCH_SELFTEST, bltouch._selftest);
+    ACTION_ITEM(MSG_BLTOUCH_DEPLOY, bltouch._deploy);
+    ACTION_ITEM(MSG_BLTOUCH_STOW, bltouch._stow);
+    ACTION_ITEM(MSG_BLTOUCH_SW_MODE, bltouch._set_SW_mode);
     #if ENABLED(BLTOUCH_LCD_VOLTAGE_MENU)
-      MENU_ITEM(submenu, MSG_BLTOUCH_5V_MODE, []{
+      SUBMENU(MSG_BLTOUCH_5V_MODE, []{
         do_select_screen(PSTR(MSG_BLTOUCH_5V_MODE), PSTR(MSG_BUTTON_CANCEL), bltouch._set_5V_mode, ui.goto_previous_screen, PSTR(MSG_BLTOUCH_MODE_CHANGE));
       });
-      MENU_ITEM(submenu, MSG_BLTOUCH_OD_MODE, []{
+      SUBMENU(MSG_BLTOUCH_OD_MODE, []{
         do_select_screen(PSTR(MSG_BLTOUCH_OD_MODE), PSTR(MSG_BUTTON_CANCEL), bltouch._set_OD_mode, ui.goto_previous_screen, PSTR(MSG_BLTOUCH_MODE_CHANGE));
       });
-      MENU_ITEM(function, MSG_BLTOUCH_MODE_STORE, bltouch._mode_store);
-      MENU_ITEM(submenu, MSG_BLTOUCH_MODE_STORE_5V, []{
+      ACTION_ITEM(MSG_BLTOUCH_MODE_STORE, bltouch._mode_store);
+      SUBMENU(MSG_BLTOUCH_MODE_STORE_5V, []{
         do_select_screen(PSTR(MSG_BLTOUCH_MODE_STORE_5V), PSTR(MSG_BUTTON_CANCEL), bltouch.mode_conv_5V, ui.goto_previous_screen, PSTR(MSG_BLTOUCH_MODE_CHANGE));
       });
-      MENU_ITEM(submenu, MSG_BLTOUCH_MODE_STORE_OD, []{
+      SUBMENU(MSG_BLTOUCH_MODE_STORE_OD, []{
         do_select_screen(PSTR(MSG_BLTOUCH_MODE_STORE_OD), PSTR(MSG_BUTTON_CANCEL), bltouch.mode_conv_OD, ui.goto_previous_screen, PSTR(MSG_BLTOUCH_MODE_CHANGE));
       });
-      MENU_ITEM(function, MSG_BLTOUCH_MODE_ECHO, bltouch_report);
+      ACTION_ITEM(MSG_BLTOUCH_MODE_ECHO, bltouch_report);
     #endif
     END_MENU();
   }
@@ -233,11 +235,11 @@ static void lcd_factory_settings() {
   void menu_touchmi() {
     START_MENU();
     ui.defer_status_screen();
-    MENU_BACK(MSG_CONFIGURATION);
-    MENU_ITEM(gcode, MSG_TOUCHMI_INIT, PSTR("M851 Z0\nG28\nG1 F200 Z0"));
-    MENU_ITEM(submenu, MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
-    MENU_ITEM(gcode, MSG_TOUCHMI_SAVE, PSTR("M500\nG1 F200 Z10"));
-    MENU_ITEM(gcode, MSG_TOUCHMI_ZTEST, PSTR("G28\nG1 F200 Z0"));
+    BACK_ITEM(MSG_CONFIGURATION);
+    GCODES_ITEM(MSG_TOUCHMI_INIT, PSTR("M851 Z0\nG28\nG1 F200 Z0"));
+    SUBMENU(MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
+    GCODES_ITEM(MSG_TOUCHMI_SAVE, PSTR("M500\nG1 F200 Z10"));
+    GCODES_ITEM(MSG_TOUCHMI_ZTEST, PSTR("G28\nG1 F200 Z0"));
     END_MENU();
   }
 #endif
@@ -250,9 +252,9 @@ static void lcd_factory_settings() {
 
     void menu_case_light() {
       START_MENU();
-      MENU_BACK(MSG_CONFIGURATION);
-      MENU_ITEM_EDIT_CALLBACK(uint8, MSG_CASE_LIGHT_BRIGHTNESS, &case_light_brightness, 0, 255, update_case_light, true);
-      MENU_ITEM_EDIT_CALLBACK(bool, MSG_CASE_LIGHT, (bool*)&case_light_on, update_case_light);
+      BACK_ITEM(MSG_CONFIGURATION);
+      EDIT_ITEM(uint8, MSG_CASE_LIGHT_BRIGHTNESS, &case_light_brightness, 0, 255, update_case_light, true);
+      EDIT_ITEM(bool, MSG_CASE_LIGHT, (bool*)&case_light_on, update_case_light);
       END_MENU();
     }
 
@@ -266,23 +268,23 @@ static void lcd_factory_settings() {
 
   void menu_config_retract() {
     START_MENU();
-    MENU_BACK(MSG_CONFIGURATION);
+    BACK_ITEM(MSG_CONFIGURATION);
     #if ENABLED(FWRETRACT_AUTORETRACT)
-      MENU_ITEM_EDIT_CALLBACK(bool, MSG_AUTORETRACT, &fwretract.autoretract_enabled, fwretract.refresh_autoretract);
+      EDIT_ITEM(bool, MSG_AUTORETRACT, &fwretract.autoretract_enabled, fwretract.refresh_autoretract);
     #endif
-    MENU_ITEM_EDIT(float52sign, MSG_CONTROL_RETRACT, &fwretract.settings.retract_length, 0, 100);
+    EDIT_ITEM(float52sign, MSG_CONTROL_RETRACT, &fwretract.settings.retract_length, 0, 100);
     #if EXTRUDERS > 1
-      MENU_ITEM_EDIT(float52sign, MSG_CONTROL_RETRACT_SWAP, &fwretract.settings.swap_retract_length, 0, 100);
+      EDIT_ITEM(float52sign, MSG_CONTROL_RETRACT_SWAP, &fwretract.settings.swap_retract_length, 0, 100);
     #endif
-    MENU_ITEM_EDIT(float3, MSG_CONTROL_RETRACTF, &fwretract.settings.retract_feedrate_mm_s, 1, 999);
-    MENU_ITEM_EDIT(float52sign, MSG_CONTROL_RETRACT_ZHOP, &fwretract.settings.retract_zraise, 0, 999);
-    MENU_ITEM_EDIT(float52sign, MSG_CONTROL_RETRACT_RECOVER, &fwretract.settings.retract_recover_extra, -100, 100);
+    EDIT_ITEM(float3, MSG_CONTROL_RETRACTF, &fwretract.settings.retract_feedrate_mm_s, 1, 999);
+    EDIT_ITEM(float52sign, MSG_CONTROL_RETRACT_ZHOP, &fwretract.settings.retract_zraise, 0, 999);
+    EDIT_ITEM(float52sign, MSG_CONTROL_RETRACT_RECOVER, &fwretract.settings.retract_recover_extra, -100, 100);
     #if EXTRUDERS > 1
-      MENU_ITEM_EDIT(float52sign, MSG_CONTROL_RETRACT_RECOVER_SWAP, &fwretract.settings.swap_retract_recover_extra, -100, 100);
+      EDIT_ITEM(float52sign, MSG_CONTROL_RETRACT_RECOVER_SWAP, &fwretract.settings.swap_retract_recover_extra, -100, 100);
     #endif
-    MENU_ITEM_EDIT(float3, MSG_CONTROL_RETRACT_RECOVERF, &fwretract.settings.retract_recover_feedrate_mm_s, 1, 999);
+    EDIT_ITEM(float3, MSG_CONTROL_RETRACT_RECOVERF, &fwretract.settings.retract_recover_feedrate_mm_s, 1, 999);
     #if EXTRUDERS > 1
-      MENU_ITEM_EDIT(float3, MSG_CONTROL_RETRACT_RECOVER_SWAPF, &fwretract.settings.swap_retract_recover_feedrate_mm_s, 1, 999);
+      EDIT_ITEM(float3, MSG_CONTROL_RETRACT_RECOVER_SWAPF, &fwretract.settings.swap_retract_recover_feedrate_mm_s, 1, 999);
     #endif
     END_MENU();
   }
@@ -312,16 +314,16 @@ static void lcd_factory_settings() {
       #define MAXTEMP_ALL HEATER_0_MAXTEMP
     #endif
     START_MENU();
-    MENU_BACK(MSG_CONFIGURATION);
-    MENU_ITEM_EDIT(percent, MSG_FAN_SPEED, &ui.preheat_fan_speed[material], 0, 255);
+    BACK_ITEM(MSG_CONFIGURATION);
+    EDIT_ITEM(percent, MSG_FAN_SPEED, &ui.preheat_fan_speed[material], 0, 255);
     #if HAS_TEMP_HOTEND
-      MENU_ITEM_EDIT(int3, MSG_NOZZLE, &ui.preheat_hotend_temp[material], MINTEMP_ALL, MAXTEMP_ALL - 15);
+      EDIT_ITEM(int3, MSG_NOZZLE, &ui.preheat_hotend_temp[material], MINTEMP_ALL, MAXTEMP_ALL - 15);
     #endif
     #if HAS_HEATED_BED
-      MENU_ITEM_EDIT(int3, MSG_BED, &ui.preheat_bed_temp[material], BED_MINTEMP, BED_MAXTEMP - 10);
+      EDIT_ITEM(int3, MSG_BED, &ui.preheat_bed_temp[material], BED_MINTEMP, BED_MAXTEMP - 10);
     #endif
     #if ENABLED(EEPROM_SETTINGS)
-      MENU_ITEM(function, MSG_STORE_EEPROM, lcd_store_settings);
+      ACTION_ITEM(MSG_STORE_EEPROM, lcd_store_settings);
     #endif
     END_MENU();
   }
@@ -333,21 +335,21 @@ static void lcd_factory_settings() {
 
 void menu_configuration() {
   START_MENU();
-  MENU_BACK(MSG_MAIN);
+  BACK_ITEM(MSG_MAIN);
 
   //
   // Debug Menu when certain options are enabled
   //
   #if HAS_DEBUG_MENU
-    MENU_ITEM(submenu, MSG_DEBUG_MENU, menu_debug);
+    SUBMENU(MSG_DEBUG_MENU, menu_debug);
   #endif
 
-  MENU_ITEM(submenu, MSG_ADVANCED_SETTINGS, menu_advanced_settings);
+  SUBMENU(MSG_ADVANCED_SETTINGS, menu_advanced_settings);
 
   #if ENABLED(BABYSTEP_ZPROBE_OFFSET)
-    MENU_ITEM(submenu, MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
+    SUBMENU(MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
   #elif HAS_BED_PROBE
-    MENU_ITEM_EDIT(float52, MSG_ZPROBE_ZOFFSET, &probe_offset.z, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX);
+    EDIT_ITEM(float52, MSG_ZPROBE_ZOFFSET, &probe_offset.z, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX);
   #endif
 
   const bool busy = printer_busy();
@@ -356,23 +358,23 @@ void menu_configuration() {
     // Delta Calibration
     //
     #if EITHER(DELTA_CALIBRATION_MENU, DELTA_AUTO_CALIBRATION)
-      MENU_ITEM(submenu, MSG_DELTA_CALIBRATE, menu_delta_calibrate);
+      SUBMENU(MSG_DELTA_CALIBRATE, menu_delta_calibrate);
     #endif
 
     #if HAS_HOTEND_OFFSET
-      MENU_ITEM(submenu, MSG_OFFSETS_MENU, menu_tool_offsets);
+      SUBMENU(MSG_OFFSETS_MENU, menu_tool_offsets);
     #endif
 
     #if ENABLED(DUAL_X_CARRIAGE)
-      MENU_ITEM(submenu, MSG_IDEX_MENU, menu_idex);
+      SUBMENU(MSG_IDEX_MENU, menu_idex);
     #endif
 
     #if ENABLED(BLTOUCH)
-      MENU_ITEM(submenu, MSG_BLTOUCH, menu_bltouch);
+      SUBMENU(MSG_BLTOUCH, menu_bltouch);
     #endif
 
     #if ENABLED(TOUCH_MI_PROBE)
-      MENU_ITEM(submenu, MSG_TOUCHMI_PROBE, menu_touchmi);
+      SUBMENU(MSG_TOUCHMI_PROBE, menu_touchmi);
     #endif
   }
 
@@ -380,7 +382,7 @@ void menu_configuration() {
   // Set single nozzle filament retract and prime length
   //
   #if EXTRUDERS > 1
-    MENU_ITEM(submenu, MSG_TOOL_CHANGE, menu_tool_change);
+    SUBMENU(MSG_TOOL_CHANGE, menu_tool_change);
   #endif
 
   //
@@ -389,41 +391,41 @@ void menu_configuration() {
   #if ENABLED(CASE_LIGHT_MENU)
     #if DISABLED(CASE_LIGHT_NO_BRIGHTNESS)
       if (PWM_PIN(CASE_LIGHT_PIN))
-        MENU_ITEM(submenu, MSG_CASE_LIGHT, menu_case_light);
+        SUBMENU(MSG_CASE_LIGHT, menu_case_light);
       else
     #endif
-        MENU_ITEM_EDIT_CALLBACK(bool, MSG_CASE_LIGHT, (bool*)&case_light_on, update_case_light);
+        EDIT_ITEM(bool, MSG_CASE_LIGHT, (bool*)&case_light_on, update_case_light);
   #endif
 
   #if HAS_LCD_CONTRAST
-    MENU_ITEM_EDIT_CALLBACK(int3, MSG_CONTRAST, &ui.contrast, LCD_CONTRAST_MIN, LCD_CONTRAST_MAX, ui.refresh_contrast, true);
+    EDIT_ITEM(int3, MSG_CONTRAST, &ui.contrast, LCD_CONTRAST_MIN, LCD_CONTRAST_MAX, ui.refresh_contrast, true);
   #endif
   #if ENABLED(FWRETRACT)
-    MENU_ITEM(submenu, MSG_RETRACT, menu_config_retract);
+    SUBMENU(MSG_RETRACT, menu_config_retract);
   #endif
 
   #if HAS_FILAMENT_SENSOR
-    MENU_ITEM_EDIT_CALLBACK(bool, MSG_RUNOUT_SENSOR, &runout.enabled, runout.reset);
+    EDIT_ITEM(bool, MSG_RUNOUT_SENSOR, &runout.enabled, runout.reset);
   #endif
 
   #if ENABLED(POWER_LOSS_RECOVERY)
-    MENU_ITEM_EDIT_CALLBACK(bool, MSG_OUTAGE_RECOVERY, &recovery.enabled, recovery.changed);
+    EDIT_ITEM(bool, MSG_OUTAGE_RECOVERY, &recovery.enabled, recovery.changed);
   #endif
 
   #if DISABLED(SLIM_LCD_MENUS)
     // Preheat configurations
-    MENU_ITEM(submenu, MSG_PREHEAT_1_SETTINGS, menu_preheat_material1_settings);
-    MENU_ITEM(submenu, MSG_PREHEAT_2_SETTINGS, menu_preheat_material2_settings);
+    SUBMENU(MSG_PREHEAT_1_SETTINGS, menu_preheat_material1_settings);
+    SUBMENU(MSG_PREHEAT_2_SETTINGS, menu_preheat_material2_settings);
   #endif
 
   #if ENABLED(EEPROM_SETTINGS)
-    MENU_ITEM(function, MSG_STORE_EEPROM, lcd_store_settings);
+    ACTION_ITEM(MSG_STORE_EEPROM, lcd_store_settings);
     if (!busy)
-      MENU_ITEM(function, MSG_LOAD_EEPROM, lcd_load_settings);
+      ACTION_ITEM(MSG_LOAD_EEPROM, lcd_load_settings);
   #endif
 
   if (!busy)
-    MENU_ITEM(function, MSG_RESTORE_FAILSAFE, lcd_factory_settings);
+    ACTION_ITEM(MSG_RESTORE_FAILSAFE, lcd_factory_settings);
 
   END_MENU();
 }

Marlin/src/lcd/menu/menu_custom.cpp

@@ -65,21 +65,21 @@ void _lcd_user_gcode(PGM_P const cmd) {
 
 void menu_user() {
   START_MENU();
-  MENU_BACK(MSG_MAIN);
+  BACK_ITEM(MSG_MAIN);
   #if defined(USER_DESC_1) && defined(USER_GCODE_1)
-    MENU_ITEM(function, USER_DESC_1, lcd_user_gcode_1);
+    ACTION_ITEM(USER_DESC_1, lcd_user_gcode_1);
   #endif
   #if defined(USER_DESC_2) && defined(USER_GCODE_2)
-    MENU_ITEM(function, USER_DESC_2, lcd_user_gcode_2);
+    ACTION_ITEM(USER_DESC_2, lcd_user_gcode_2);
   #endif
   #if defined(USER_DESC_3) && defined(USER_GCODE_3)
-    MENU_ITEM(function, USER_DESC_3, lcd_user_gcode_3);
+    ACTION_ITEM(USER_DESC_3, lcd_user_gcode_3);
   #endif
   #if defined(USER_DESC_4) && defined(USER_GCODE_4)
-    MENU_ITEM(function, USER_DESC_4, lcd_user_gcode_4);
+    ACTION_ITEM(USER_DESC_4, lcd_user_gcode_4);
   #endif
   #if defined(USER_DESC_5) && defined(USER_GCODE_5)
-    MENU_ITEM(function, USER_DESC_5, lcd_user_gcode_5);
+    ACTION_ITEM(USER_DESC_5, lcd_user_gcode_5);
   #endif
   END_MENU();
 }

Marlin/src/lcd/menu/menu_delta_calibrate.cpp

@@ -103,42 +103,42 @@ void _recalc_delta_settings() {
 
 void lcd_delta_settings() {
   START_MENU();
-  MENU_BACK(MSG_DELTA_CALIBRATE);
-  MENU_ITEM_EDIT_CALLBACK(float52sign, MSG_DELTA_HEIGHT, &delta_height, delta_height - 10, delta_height + 10, _recalc_delta_settings);
-  #define EDIT_ENDSTOP_ADJ(LABEL,N) MENU_ITEM_EDIT_CALLBACK(float43, LABEL, &delta_endstop_adj.N, -5, 5, _recalc_delta_settings)
+  BACK_ITEM(MSG_DELTA_CALIBRATE);
+  EDIT_ITEM(float52sign, MSG_DELTA_HEIGHT, &delta_height, delta_height - 10, delta_height + 10, _recalc_delta_settings);
+  #define EDIT_ENDSTOP_ADJ(LABEL,N) EDIT_ITEM(float43, LABEL, &delta_endstop_adj.N, -5, 5, _recalc_delta_settings)
   EDIT_ENDSTOP_ADJ("Ex",a);
   EDIT_ENDSTOP_ADJ("Ey",b);
   EDIT_ENDSTOP_ADJ("Ez",c);
-  MENU_ITEM_EDIT_CALLBACK(float52sign, MSG_DELTA_RADIUS, &delta_radius, delta_radius - 5, delta_radius + 5, _recalc_delta_settings);
-  #define EDIT_ANGLE_TRIM(LABEL,N) MENU_ITEM_EDIT_CALLBACK(float43, LABEL, &delta_tower_angle_trim.N, -5, 5, _recalc_delta_settings)
+  EDIT_ITEM(float52sign, MSG_DELTA_RADIUS, &delta_radius, delta_radius - 5, delta_radius + 5, _recalc_delta_settings);
+  #define EDIT_ANGLE_TRIM(LABEL,N) EDIT_ITEM(float43, LABEL, &delta_tower_angle_trim.N, -5, 5, _recalc_delta_settings)
   EDIT_ANGLE_TRIM("Tx",a);
   EDIT_ANGLE_TRIM("Ty",b);
   EDIT_ANGLE_TRIM("Tz",c);
-  MENU_ITEM_EDIT_CALLBACK(float52sign, MSG_DELTA_DIAG_ROD, &delta_diagonal_rod, delta_diagonal_rod - 5, delta_diagonal_rod + 5, _recalc_delta_settings);
+  EDIT_ITEM(float52sign, MSG_DELTA_DIAG_ROD, &delta_diagonal_rod, delta_diagonal_rod - 5, delta_diagonal_rod + 5, _recalc_delta_settings);
   END_MENU();
 }
 
 void menu_delta_calibrate() {
   START_MENU();
-  MENU_BACK(MSG_MAIN);
+  BACK_ITEM(MSG_MAIN);
 
   #if ENABLED(DELTA_AUTO_CALIBRATION)
-    MENU_ITEM(gcode, MSG_DELTA_AUTO_CALIBRATE, PSTR("G33"));
+    GCODES_ITEM(MSG_DELTA_AUTO_CALIBRATE, PSTR("G33"));
     #if ENABLED(EEPROM_SETTINGS)
-      MENU_ITEM(function, MSG_STORE_EEPROM, lcd_store_settings);
-      MENU_ITEM(function, MSG_LOAD_EEPROM, lcd_load_settings);
+      ACTION_ITEM(MSG_STORE_EEPROM, lcd_store_settings);
+      ACTION_ITEM(MSG_LOAD_EEPROM, lcd_load_settings);
     #endif
   #endif
 
-  MENU_ITEM(submenu, MSG_DELTA_SETTINGS, lcd_delta_settings);
+  SUBMENU(MSG_DELTA_SETTINGS, lcd_delta_settings);
 
   #if ENABLED(DELTA_CALIBRATION_MENU)
-    MENU_ITEM(submenu, MSG_AUTO_HOME, _lcd_delta_calibrate_home);
+    SUBMENU(MSG_AUTO_HOME, _lcd_delta_calibrate_home);
     if (all_axes_homed()) {
-      MENU_ITEM(submenu, MSG_DELTA_CALIBRATE_X, _goto_tower_x);
-      MENU_ITEM(submenu, MSG_DELTA_CALIBRATE_Y, _goto_tower_y);
-      MENU_ITEM(submenu, MSG_DELTA_CALIBRATE_Z, _goto_tower_z);
-      MENU_ITEM(submenu, MSG_DELTA_CALIBRATE_CENTER, _goto_center);
+      SUBMENU(MSG_DELTA_CALIBRATE_X, _goto_tower_x);
+      SUBMENU(MSG_DELTA_CALIBRATE_Y, _goto_tower_y);
+      SUBMENU(MSG_DELTA_CALIBRATE_Z, _goto_tower_z);
+      SUBMENU(MSG_DELTA_CALIBRATE_CENTER, _goto_center);
     }
   #endif
 

Marlin/src/lcd/menu/menu_filament.cpp

@@ -80,9 +80,9 @@ void _menu_temp_filament_op(const PauseMode mode, const int8_t extruder) {
   _change_filament_temp_extruder = extruder;
   START_MENU();
   if (LCD_HEIGHT >= 4) STATIC_ITEM_P(change_filament_header(mode), SS_CENTER|SS_INVERT);
-  MENU_BACK(MSG_BACK);
-  MENU_ITEM(function, MSG_PREHEAT_1, _lcd_change_filament_temp_1_func);
-  MENU_ITEM(function, MSG_PREHEAT_2, _lcd_change_filament_temp_2_func);
+  BACK_ITEM(MSG_BACK);
+  ACTION_ITEM(MSG_PREHEAT_1, _lcd_change_filament_temp_1_func);
+  ACTION_ITEM(MSG_PREHEAT_2, _lcd_change_filament_temp_2_func);
   uint16_t max_temp;
   switch (extruder) {
     default: max_temp = HEATER_0_MAXTEMP;
@@ -102,7 +102,7 @@ void _menu_temp_filament_op(const PauseMode mode, const int8_t extruder) {
       #endif
     #endif
   }
-  MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_PREHEAT_CUSTOM, &thermalManager.temp_hotend[_change_filament_temp_extruder].target, EXTRUDE_MINTEMP, max_temp - 15, _lcd_change_filament_temp_custom_cb);
+  EDIT_ITEM_FAST(int3, MSG_PREHEAT_CUSTOM, &thermalManager.temp_hotend[_change_filament_temp_extruder].target, EXTRUDE_MINTEMP, max_temp - 15, _lcd_change_filament_temp_custom_cb);
   END_MENU();
 }
 #if E_STEPPERS
@@ -142,7 +142,7 @@ void _menu_temp_filament_op(const PauseMode mode, const int8_t extruder) {
 #if E_STEPPERS > 1 || ENABLED(FILAMENT_LOAD_UNLOAD_GCODES)
   void menu_change_filament() {
     START_MENU();
-    MENU_BACK(MSG_MAIN);
+    BACK_ITEM(MSG_MAIN);
 
     // Change filament
     #if E_STEPPERS == 1
@@ -245,9 +245,9 @@ void _menu_temp_filament_op(const PauseMode mode, const int8_t extruder) {
         // Unload filament
         #if E_STEPPERS == 1
           if (thermalManager.targetHotEnoughToExtrude(active_extruder))
-            MENU_ITEM(gcode, MSG_FILAMENTUNLOAD, PSTR("M702"));
+            GCODES_ITEM(MSG_FILAMENTUNLOAD, PSTR("M702"));
           else
-            MENU_ITEM(submenu, MSG_FILAMENTUNLOAD, menu_temp_e0_filament_unload);
+            SUBMENU(MSG_FILAMENTUNLOAD, menu_temp_e0_filament_unload);
         #else
           #if ENABLED(FILAMENT_UNLOAD_ALL_EXTRUDERS)
             if (thermalManager.targetHotEnoughToExtrude(0)
@@ -267,38 +267,38 @@ void _menu_temp_filament_op(const PauseMode mode, const int8_t extruder) {
                 #endif // E_STEPPERS > 2
               #endif // E_STEPPERS > 1
             )
-              MENU_ITEM(gcode, MSG_FILAMENTUNLOAD_ALL, PSTR("M702"));
+              GCODES_ITEM(MSG_FILAMENTUNLOAD_ALL, PSTR("M702"));
           else
-            MENU_ITEM(submenu, MSG_FILAMENTUNLOAD_ALL, menu_unload_filament_all_temp);
+            SUBMENU(MSG_FILAMENTUNLOAD_ALL, menu_unload_filament_all_temp);
           #endif
           if (thermalManager.targetHotEnoughToExtrude(0))
-            MENU_ITEM(gcode, MSG_FILAMENTUNLOAD " " MSG_E1, PSTR("M702 T0"));
+            GCODES_ITEM(MSG_FILAMENTUNLOAD " " MSG_E1, PSTR("M702 T0"));
           else
-            MENU_ITEM(submenu, MSG_FILAMENTUNLOAD " " MSG_E1, menu_temp_e0_filament_unload);
+            SUBMENU(MSG_FILAMENTUNLOAD " " MSG_E1, menu_temp_e0_filament_unload);
           if (thermalManager.targetHotEnoughToExtrude(1))
-            MENU_ITEM(gcode, MSG_FILAMENTUNLOAD " " MSG_E2, PSTR("M702 T1"));
+            GCODES_ITEM(MSG_FILAMENTUNLOAD " " MSG_E2, PSTR("M702 T1"));
           else
-            MENU_ITEM(submenu, MSG_FILAMENTUNLOAD " " MSG_E2, menu_temp_e1_filament_unload);
+            SUBMENU(MSG_FILAMENTUNLOAD " " MSG_E2, menu_temp_e1_filament_unload);
           #if E_STEPPERS > 2
             if (thermalManager.targetHotEnoughToExtrude(2))
-              MENU_ITEM(gcode, MSG_FILAMENTUNLOAD " " MSG_E3, PSTR("M702 T2"));
+              GCODES_ITEM(MSG_FILAMENTUNLOAD " " MSG_E3, PSTR("M702 T2"));
             else
-              MENU_ITEM(submenu, MSG_FILAMENTUNLOAD " " MSG_E3, menu_temp_e2_filament_unload);
+              SUBMENU(MSG_FILAMENTUNLOAD " " MSG_E3, menu_temp_e2_filament_unload);
             #if E_STEPPERS > 3
               if (thermalManager.targetHotEnoughToExtrude(3))
-                MENU_ITEM(gcode, MSG_FILAMENTUNLOAD " " MSG_E4, PSTR("M702 T3"));
+                GCODES_ITEM(MSG_FILAMENTUNLOAD " " MSG_E4, PSTR("M702 T3"));
               else
-                MENU_ITEM(submenu, MSG_FILAMENTUNLOAD " " MSG_E4, menu_temp_e3_filament_unload);
+                SUBMENU(MSG_FILAMENTUNLOAD " " MSG_E4, menu_temp_e3_filament_unload);
               #if E_STEPPERS > 4
                 if (thermalManager.targetHotEnoughToExtrude(4))
-                  MENU_ITEM(gcode, MSG_FILAMENTUNLOAD " " MSG_E5, PSTR("M702 T4"));
+                  GCODES_ITEM(MSG_FILAMENTUNLOAD " " MSG_E5, PSTR("M702 T4"));
                 else
-                  MENU_ITEM(submenu, MSG_FILAMENTUNLOAD " " MSG_E5, menu_temp_e4_filament_unload);
+                  SUBMENU(MSG_FILAMENTUNLOAD " " MSG_E5, menu_temp_e4_filament_unload);
                 #if E_STEPPERS > 5
                   if (thermalManager.targetHotEnoughToExtrude(5))
-                    MENU_ITEM(gcode, MSG_FILAMENTUNLOAD " " MSG_E6, PSTR("M702 T5"));
+                    GCODES_ITEM(MSG_FILAMENTUNLOAD " " MSG_E6, PSTR("M702 T5"));
                   else
-                    MENU_ITEM(submenu, MSG_FILAMENTUNLOAD " " MSG_E6, menu_temp_e5_filament_unload);
+                    SUBMENU(MSG_FILAMENTUNLOAD " " MSG_E6, menu_temp_e5_filament_unload);
                 #endif // E_STEPPERS > 5
               #endif // E_STEPPERS > 4
             #endif // E_STEPPERS > 3
@@ -353,13 +353,13 @@ void menu_pause_option() {
   #if LCD_HEIGHT > 2
     STATIC_ITEM(MSG_FILAMENT_CHANGE_OPTION_HEADER);
   #endif
-  MENU_ITEM(function, MSG_FILAMENT_CHANGE_OPTION_PURGE, lcd_pause_extrude_more);
+  ACTION_ITEM(MSG_FILAMENT_CHANGE_OPTION_PURGE, lcd_pause_extrude_more);
   #if HAS_FILAMENT_SENSOR
     if (runout.filament_ran_out)
-      MENU_ITEM_EDIT_CALLBACK(bool, MSG_RUNOUT_SENSOR, &runout.enabled, runout.reset);
+      EDIT_ITEM(bool, MSG_RUNOUT_SENSOR, &runout.enabled, runout.reset);
     else
   #endif
-      MENU_ITEM(function, MSG_FILAMENT_CHANGE_OPTION_RESUME, lcd_pause_resume_print);
+      ACTION_ITEM(MSG_FILAMENT_CHANGE_OPTION_RESUME, lcd_pause_resume_print);
   END_MENU();
 }
 

Marlin/src/lcd/menu/menu_game.cpp

@@ -29,18 +29,18 @@
 
 void menu_game() {
   START_MENU();
-  MENU_BACK(MSG_MAIN);
+  BACK_ITEM(MSG_MAIN);
   #if ENABLED(MARLIN_BRICKOUT)
-    MENU_ITEM(submenu, MSG_BRICKOUT, brickout.enter_game);
+    SUBMENU(MSG_BRICKOUT, brickout.enter_game);
   #endif
   #if ENABLED(MARLIN_INVADERS)
-    MENU_ITEM(submenu, MSG_INVADERS, invaders.enter_game);
+    SUBMENU(MSG_INVADERS, invaders.enter_game);
   #endif
   #if ENABLED(MARLIN_SNAKE)
-    MENU_ITEM(submenu, MSG_SNAKE, snake.enter_game);
+    SUBMENU(MSG_SNAKE, snake.enter_game);
   #endif
   #if ENABLED(MARLIN_MAZE)
-    MENU_ITEM(submenu, MSG_MAZE, maze.enter_game);
+    SUBMENU(MSG_MAZE, maze.enter_game);
   #endif
   END_MENU();
 }

Marlin/src/lcd/menu/menu_info.cpp

@@ -286,9 +286,9 @@ void menu_info_board() {
 //
 void menu_info() {
   START_MENU();
-  MENU_BACK(MSG_MAIN);
+  BACK_ITEM(MSG_MAIN);
   #if ENABLED(LCD_PRINTER_INFO_IS_BOOTSCREEN)
-    MENU_ITEM(submenu, MSG_INFO_PRINTER_MENU, (
+    SUBMENU(MSG_INFO_PRINTER_MENU, (
       #if ENABLED(SHOW_CUSTOM_BOOTSCREEN)
         menu_show_custom_bootscreen
       #else
@@ -296,24 +296,24 @@ void menu_info() {
       #endif
     ));
   #else
-    MENU_ITEM(submenu, MSG_INFO_PRINTER_MENU, menu_info_printer);           // Printer Info >
-    MENU_ITEM(submenu, MSG_INFO_BOARD_MENU, menu_info_board);               // Board Info >
+    SUBMENU(MSG_INFO_PRINTER_MENU, menu_info_printer);           // Printer Info >
+    SUBMENU(MSG_INFO_BOARD_MENU, menu_info_board);               // Board Info >
     #if EXTRUDERS
-      MENU_ITEM(submenu, MSG_INFO_THERMISTOR_MENU, menu_info_thermistors);  // Thermistors >
+      SUBMENU(MSG_INFO_THERMISTOR_MENU, menu_info_thermistors);  // Thermistors >
     #endif
   #endif
 
   #if ENABLED(PRINTCOUNTER)
-    MENU_ITEM(submenu, MSG_INFO_STATS_MENU, menu_info_stats);               // Printer Stats >
+    SUBMENU(MSG_INFO_STATS_MENU, menu_info_stats);               // Printer Stats >
   #endif
 
   #if HAS_GAMES
     #if ENABLED(GAMES_EASTER_EGG)
-      MENU_ITEM_DUMMY();
-      MENU_ITEM_DUMMY();
-      MENU_ITEM_DUMMY();
+      SKIP_ITEM();
+      SKIP_ITEM();
+      SKIP_ITEM();
     #endif
-    MENU_ITEM(submenu, MSG_GAMES, (
+    SUBMENU(MSG_GAMES, (
       #if HAS_GAME_MENU
         menu_game
       #elif ENABLED(MARLIN_BRICKOUT)

Marlin/src/lcd/menu/menu_job_recovery.cpp

@@ -50,8 +50,8 @@ void menu_job_recovery() {
   ui.defer_status_screen();
   START_MENU();
   STATIC_ITEM(MSG_OUTAGE_RECOVERY);
-  MENU_ITEM(function, MSG_RESUME_PRINT, lcd_power_loss_recovery_resume);
-  MENU_ITEM(function, MSG_STOP_PRINT, lcd_power_loss_recovery_cancel);
+  ACTION_ITEM(MSG_RESUME_PRINT, lcd_power_loss_recovery_resume);
+  ACTION_ITEM(MSG_STOP_PRINT, lcd_power_loss_recovery_cancel);
   END_MENU();
 }
 

Marlin/src/lcd/menu/menu_led.cpp

@@ -38,15 +38,15 @@
     #if LCD_HEIGHT > 2
       STATIC_ITEM(MSG_LED_PRESETS, SS_CENTER|SS_INVERT);
     #endif
-    MENU_BACK(MSG_LED_CONTROL);
-    MENU_ITEM(function, MSG_SET_LEDS_WHITE, leds.set_white);
-    MENU_ITEM(function, MSG_SET_LEDS_RED, leds.set_red);
-    MENU_ITEM(function, MSG_SET_LEDS_ORANGE, leds.set_orange);
-    MENU_ITEM(function, MSG_SET_LEDS_YELLOW,leds.set_yellow);
-    MENU_ITEM(function, MSG_SET_LEDS_GREEN, leds.set_green);
-    MENU_ITEM(function, MSG_SET_LEDS_BLUE, leds.set_blue);
-    MENU_ITEM(function, MSG_SET_LEDS_INDIGO, leds.set_indigo);
-    MENU_ITEM(function, MSG_SET_LEDS_VIOLET, leds.set_violet);
+    BACK_ITEM(MSG_LED_CONTROL);
+    ACTION_ITEM(MSG_SET_LEDS_WHITE, leds.set_white);
+    ACTION_ITEM(MSG_SET_LEDS_RED, leds.set_red);
+    ACTION_ITEM(MSG_SET_LEDS_ORANGE, leds.set_orange);
+    ACTION_ITEM(MSG_SET_LEDS_YELLOW,leds.set_yellow);
+    ACTION_ITEM(MSG_SET_LEDS_GREEN, leds.set_green);
+    ACTION_ITEM(MSG_SET_LEDS_BLUE, leds.set_blue);
+    ACTION_ITEM(MSG_SET_LEDS_INDIGO, leds.set_indigo);
+    ACTION_ITEM(MSG_SET_LEDS_VIOLET, leds.set_violet);
     END_MENU();
   }
 
@@ -54,14 +54,14 @@
 
 void menu_led_custom() {
   START_MENU();
-  MENU_BACK(MSG_LED_CONTROL);
-  MENU_ITEM_EDIT_CALLBACK(uint8, MSG_INTENSITY_R, &leds.color.r, 0, 255, leds.update, true);
-  MENU_ITEM_EDIT_CALLBACK(uint8, MSG_INTENSITY_G, &leds.color.g, 0, 255, leds.update, true);
-  MENU_ITEM_EDIT_CALLBACK(uint8, MSG_INTENSITY_B, &leds.color.b, 0, 255, leds.update, true);
+  BACK_ITEM(MSG_LED_CONTROL);
+  EDIT_ITEM(uint8, MSG_INTENSITY_R, &leds.color.r, 0, 255, leds.update, true);
+  EDIT_ITEM(uint8, MSG_INTENSITY_G, &leds.color.g, 0, 255, leds.update, true);
+  EDIT_ITEM(uint8, MSG_INTENSITY_B, &leds.color.b, 0, 255, leds.update, true);
   #if EITHER(RGBW_LED, NEOPIXEL_LED)
-    MENU_ITEM_EDIT_CALLBACK(uint8, MSG_INTENSITY_W, &leds.color.w, 0, 255, leds.update, true);
+    EDIT_ITEM(uint8, MSG_INTENSITY_W, &leds.color.w, 0, 255, leds.update, true);
     #if ENABLED(NEOPIXEL_LED)
-      MENU_ITEM_EDIT_CALLBACK(uint8, MSG_LED_BRIGHTNESS, &leds.color.i, 0, 255, leds.update, true);
+      EDIT_ITEM(uint8, MSG_LED_BRIGHTNESS, &leds.color.i, 0, 255, leds.update, true);
     #endif
   #endif
   END_MENU();
@@ -69,14 +69,14 @@ void menu_led_custom() {
 
 void menu_led() {
   START_MENU();
-  MENU_BACK(MSG_MAIN);
+  BACK_ITEM(MSG_MAIN);
   bool led_on = leds.lights_on;
-  MENU_ITEM_EDIT_CALLBACK(bool, MSG_LEDS, &led_on, leds.toggle);
-  MENU_ITEM(function, MSG_SET_LEDS_DEFAULT, leds.set_default);
+  EDIT_ITEM(bool, MSG_LEDS, &led_on, leds.toggle);
+  ACTION_ITEM(MSG_SET_LEDS_DEFAULT, leds.set_default);
   #if ENABLED(LED_COLOR_PRESETS)
-    MENU_ITEM(submenu, MSG_LED_PRESETS, menu_led_presets);
+    SUBMENU(MSG_LED_PRESETS, menu_led_presets);
   #endif
-  MENU_ITEM(submenu, MSG_CUSTOM_LEDS, menu_led_custom);
+  SUBMENU(MSG_CUSTOM_LEDS, menu_led_custom);
   END_MENU();
 }
 

Marlin/src/lcd/menu/menu_main.cpp

@@ -97,7 +97,7 @@ void menu_configuration();
 
 void menu_main() {
   START_MENU();
-  MENU_BACK(MSG_WATCH);
+  BACK_ITEM(MSG_WATCH);
 
   const bool busy = IS_SD_PRINTING() || print_job_timer.isRunning()
     #if ENABLED(SDSUPPORT)
@@ -108,12 +108,12 @@ void menu_main() {
 
   if (busy) {
     #if MACHINE_CAN_PAUSE
-      MENU_ITEM(function, MSG_PAUSE_PRINT, ui.pause_print);
+      ACTION_ITEM(MSG_PAUSE_PRINT, ui.pause_print);
     #endif
     #if MACHINE_CAN_STOP
-      MENU_ITEM(submenu, MSG_STOP_PRINT, menu_abort_confirm);
+      SUBMENU(MSG_STOP_PRINT, menu_abort_confirm);
     #endif
-    MENU_ITEM(submenu, MSG_TUNE, menu_tune);
+    SUBMENU(MSG_TUNE, menu_tune);
   }
   else {
     #if !HAS_ENCODER_WHEEL && ENABLED(SDSUPPORT)
@@ -121,12 +121,12 @@ void menu_main() {
       // Autostart
       //
       #if ENABLED(MENU_ADDAUTOSTART)
-        if (!busy) MENU_ITEM(function, MSG_AUTOSTART, card.beginautostart);
+        if (!busy) ACTION_ITEM(MSG_AUTOSTART, card.beginautostart);
       #endif
 
       if (card_detected) {
         if (!card_open) {
-          MENU_ITEM(submenu, MSG_MEDIA_MENU, menu_media);
+          SUBMENU(MSG_MEDIA_MENU, menu_media);
           MENU_ITEM(gcode,
             #if PIN_EXISTS(SD_DETECT)
               MSG_CHANGE_MEDIA, PSTR("M21")
@@ -138,10 +138,10 @@ void menu_main() {
       }
       else {
         #if PIN_EXISTS(SD_DETECT)
-          MENU_ITEM(function, MSG_NO_MEDIA, nullptr);
+          ACTION_ITEM(MSG_NO_MEDIA, nullptr);
         #else
-          MENU_ITEM(gcode, MSG_INIT_MEDIA, PSTR("M21"));
-          MENU_ITEM(function, MSG_MEDIA_RELEASED, nullptr);
+          GCODES_ITEM(MSG_INIT_MEDIA, PSTR("M21"));
+          ACTION_ITEM(MSG_MEDIA_RELEASED, nullptr);
         #endif
       }
     #endif // !HAS_ENCODER_WHEEL && SDSUPPORT
@@ -152,49 +152,49 @@ void menu_main() {
           || card.isPaused()
         #endif
       );
-      if (paused) MENU_ITEM(function, MSG_RESUME_PRINT, ui.resume_print);
+      if (paused) ACTION_ITEM(MSG_RESUME_PRINT, ui.resume_print);
     #endif
 
-    MENU_ITEM(submenu, MSG_MOTION, menu_motion);
+    SUBMENU(MSG_MOTION, menu_motion);
   }
 
   #if HAS_CUTTER
-    MENU_ITEM(submenu, MSG_CUTTER(MENU), menu_spindle_laser);
+    SUBMENU(MSG_CUTTER(MENU), menu_spindle_laser);
   #endif
 
-  MENU_ITEM(submenu, MSG_TEMPERATURE, menu_temperature);
+  SUBMENU(MSG_TEMPERATURE, menu_temperature);
 
   #if ENABLED(MIXING_EXTRUDER)
-    MENU_ITEM(submenu, MSG_MIXER, menu_mixer);
+    SUBMENU(MSG_MIXER, menu_mixer);
   #endif
 
   #if ENABLED(MMU2_MENUS)
-    if (!busy) MENU_ITEM(submenu, MSG_MMU2_MENU, menu_mmu2);
+    if (!busy) SUBMENU(MSG_MMU2_MENU, menu_mmu2);
   #endif
 
-  MENU_ITEM(submenu, MSG_CONFIGURATION, menu_configuration);
+  SUBMENU(MSG_CONFIGURATION, menu_configuration);
 
   #if ENABLED(CUSTOM_USER_MENUS)
-    MENU_ITEM(submenu, MSG_USER_MENU, menu_user);
+    SUBMENU(MSG_USER_MENU, menu_user);
   #endif
 
   #if ENABLED(ADVANCED_PAUSE_FEATURE)
     #if E_STEPPERS == 1 && DISABLED(FILAMENT_LOAD_UNLOAD_GCODES)
       if (thermalManager.targetHotEnoughToExtrude(active_extruder))
-        MENU_ITEM(gcode, MSG_FILAMENTCHANGE, PSTR("M600 B0"));
+        GCODES_ITEM(MSG_FILAMENTCHANGE, PSTR("M600 B0"));
       else
-        MENU_ITEM(submenu, MSG_FILAMENTCHANGE, menu_temp_e0_filament_change);
+        SUBMENU(MSG_FILAMENTCHANGE, menu_temp_e0_filament_change);
     #else
-      MENU_ITEM(submenu, MSG_FILAMENTCHANGE, menu_change_filament);
+      SUBMENU(MSG_FILAMENTCHANGE, menu_change_filament);
     #endif
   #endif
 
   #if ENABLED(LCD_INFO_MENU)
-    MENU_ITEM(submenu, MSG_INFO_MENU, menu_info);
+    SUBMENU(MSG_INFO_MENU, menu_info);
   #endif
 
   #if ENABLED(LED_CONTROL_MENU)
-    MENU_ITEM(submenu, MSG_LED_CONTROL, menu_led);
+    SUBMENU(MSG_LED_CONTROL, menu_led);
   #endif
 
   //
@@ -202,9 +202,9 @@ void menu_main() {
   //
   #if HAS_POWER_SWITCH
     if (powersupply_on)
-      MENU_ITEM(gcode, MSG_SWITCH_PS_OFF, PSTR("M81"));
+      GCODES_ITEM(MSG_SWITCH_PS_OFF, PSTR("M81"));
     else
-      MENU_ITEM(gcode, MSG_SWITCH_PS_ON, PSTR("M80"));
+      GCODES_ITEM(MSG_SWITCH_PS_ON, PSTR("M80"));
   #endif
 
   #if HAS_ENCODER_WHEEL && ENABLED(SDSUPPORT)
@@ -212,7 +212,7 @@ void menu_main() {
     // Autostart
     //
     #if ENABLED(MENU_ADDAUTOSTART)
-      if (!busy) MENU_ITEM(function, MSG_AUTOSTART, card.beginautostart);
+      if (!busy) ACTION_ITEM(MSG_AUTOSTART, card.beginautostart);
     #endif
 
     if (card_detected) {
@@ -224,37 +224,37 @@ void menu_main() {
             MSG_RELEASE_MEDIA, PSTR("M22")
           #endif
         );
-        MENU_ITEM(submenu, MSG_MEDIA_MENU, menu_media);
+        SUBMENU(MSG_MEDIA_MENU, menu_media);
       }
     }
     else {
       #if PIN_EXISTS(SD_DETECT)
-        MENU_ITEM(function, MSG_NO_MEDIA, nullptr);
+        ACTION_ITEM(MSG_NO_MEDIA, nullptr);
       #else
-        MENU_ITEM(gcode, MSG_INIT_MEDIA, PSTR("M21"));
-        MENU_ITEM(function, MSG_MEDIA_RELEASED, nullptr);
+        GCODES_ITEM(MSG_INIT_MEDIA, PSTR("M21"));
+        ACTION_ITEM(MSG_MEDIA_RELEASED, nullptr);
       #endif
     }
   #endif // HAS_ENCODER_WHEEL && SDSUPPORT
 
   #if HAS_SERVICE_INTERVALS
     #if SERVICE_INTERVAL_1 > 0
-      MENU_ITEM(submenu, SERVICE_NAME_1, menu_service1);
+      SUBMENU(SERVICE_NAME_1, menu_service1);
     #endif
     #if SERVICE_INTERVAL_2 > 0
-      MENU_ITEM(submenu, SERVICE_NAME_2, menu_service2);
+      SUBMENU(SERVICE_NAME_2, menu_service2);
     #endif
     #if SERVICE_INTERVAL_3 > 0
-      MENU_ITEM(submenu, SERVICE_NAME_3, menu_service3);
+      SUBMENU(SERVICE_NAME_3, menu_service3);
     #endif
   #endif
 
   #if HAS_GAMES && DISABLED(LCD_INFO_MENU)
     #if ENABLED(GAMES_EASTER_EGG)
-      MENU_ITEM_DUMMY();
-      MENU_ITEM_DUMMY();
+      SKIP_ITEM();
+      SKIP_ITEM();
     #endif
-    MENU_ITEM(submenu, MSG_GAMES, (
+    SUBMENU(MSG_GAMES, (
       #if HAS_GAME_MENU
         menu_game
       #elif ENABLED(MARLIN_BRICKOUT)

Marlin/src/lcd/menu/menu_media.cpp

@@ -138,14 +138,14 @@ void menu_media() {
   #endif
 
   START_MENU();
-  MENU_BACK(MSG_MAIN);
+  BACK_ITEM(MSG_MAIN);
   if (card.flag.workDirIsRoot) {
     #if !PIN_EXISTS(SD_DETECT)
-      MENU_ITEM(function, LCD_STR_REFRESH MSG_REFRESH, lcd_sd_refresh);
+      ACTION_ITEM(LCD_STR_REFRESH MSG_REFRESH, lcd_sd_refresh);
     #endif
   }
   else if (card.isMounted())
-    MENU_ITEM(function, LCD_STR_FOLDER "..", lcd_sd_updir);
+    ACTION_ITEM(LCD_STR_FOLDER "..", lcd_sd_updir);
 
   if (ui.should_draw()) for (uint16_t i = 0; i < fileCnt; i++) {
     if (_menuLineNr == _thisItemNr) {
@@ -163,7 +163,7 @@ void menu_media() {
         MENU_ITEM(sdfile, MSG_MEDIA_MENU, card);
     }
     else {
-      MENU_ITEM_DUMMY();
+      SKIP_ITEM();
     }
   }
   END_MENU();

Marlin/src/lcd/menu/menu_mixer.cpp

@@ -90,24 +90,24 @@
 
   void lcd_mixer_edit_gradient_menu() {
     START_MENU();
-    MENU_BACK(MSG_MIXER);
+    BACK_ITEM(MSG_MIXER);
 
-    MENU_ITEM_EDIT_CALLBACK(int8, MSG_START_VTOOL, &mixer.gradient.start_vtool, 0, MIXING_VIRTUAL_TOOLS - 1, mixer.refresh_gradient);
-    MENU_ITEM_EDIT_CALLBACK(int8, MSG_END_VTOOL, &mixer.gradient.end_vtool, 0, MIXING_VIRTUAL_TOOLS - 1, mixer.refresh_gradient);
+    EDIT_ITEM(int8, MSG_START_VTOOL, &mixer.gradient.start_vtool, 0, MIXING_VIRTUAL_TOOLS - 1, mixer.refresh_gradient);
+    EDIT_ITEM(int8, MSG_END_VTOOL, &mixer.gradient.end_vtool, 0, MIXING_VIRTUAL_TOOLS - 1, mixer.refresh_gradient);
 
     #if ENABLED(GRADIENT_VTOOL)
-      MENU_ITEM_EDIT_CALLBACK(int8, MSG_GRADIENT_ALIAS, &mixer.gradient.vtool_index, 0, MIXING_VIRTUAL_TOOLS - 1, mixer.refresh_gradient);
+      EDIT_ITEM(int8, MSG_GRADIENT_ALIAS, &mixer.gradient.vtool_index, 0, MIXING_VIRTUAL_TOOLS - 1, mixer.refresh_gradient);
     #endif
 
     char tmp[18];
 
-    MENU_ITEM(submenu, MSG_START_Z ":", lcd_mixer_gradient_z_start_edit);
+    SUBMENU(MSG_START_Z ":", lcd_mixer_gradient_z_start_edit);
     MENU_ITEM_ADDON_START(9);
       sprintf_P(tmp, PSTR("%4d.%d mm"), int(mixer.gradient.start_z), int(mixer.gradient.start_z * 10) % 10);
       LCDPRINT(tmp);
     MENU_ITEM_ADDON_END();
 
-    MENU_ITEM(submenu, MSG_END_Z ":", lcd_mixer_gradient_z_end_edit);
+    SUBMENU(MSG_END_Z ":", lcd_mixer_gradient_z_end_edit);
     MENU_ITEM_ADDON_START(9);
       sprintf_P(tmp, PSTR("%4d.%d mm"), int(mixer.gradient.end_z), int(mixer.gradient.end_z * 10) % 10);
       LCDPRINT(tmp);
@@ -158,10 +158,10 @@ void lcd_mixer_mix_edit() {
 
   #if CHANNEL_MIX_EDITING
 
-    #define EDIT_COLOR(N) MENU_MULTIPLIER_ITEM_EDIT(float52, MSG_MIX_COMPONENT " " STRINGIFY(N), &mixer.collector[N-1], 0, 10);
+    #define EDIT_COLOR(N) EDIT_ITEM_FAST(float52, MSG_MIX_COMPONENT " " STRINGIFY(N), &mixer.collector[N-1], 0, 10);
 
     START_MENU();
-    MENU_BACK(MSG_MIXER);
+    BACK_ITEM(MSG_MIXER);
     EDIT_COLOR(1);
     EDIT_COLOR(2);
     #if MIXING_STEPPERS > 2
@@ -176,8 +176,8 @@ void lcd_mixer_mix_edit() {
         #endif
       #endif
     #endif
-    MENU_ITEM(function, MSG_CYCLE_MIX, _lcd_mixer_cycle_mix);
-    MENU_ITEM(function, MSG_COMMIT_VTOOL, _lcd_mixer_commit_vtool);
+    ACTION_ITEM(MSG_CYCLE_MIX, _lcd_mixer_cycle_mix);
+    ACTION_ITEM(MSG_COMMIT_VTOOL, _lcd_mixer_commit_vtool);
     END_MENU();
 
   #elif DUAL_MIXING_EXTRUDER
@@ -199,7 +199,7 @@ void lcd_mixer_mix_edit() {
   #else
 
     START_MENU();
-    MENU_BACK(MSG_MIXER);
+    BACK_ITEM(MSG_MIXER);
     END_MENU();
 
   #endif
@@ -263,10 +263,10 @@ void menu_mixer_vtools_reset_confirm() {
 
 void menu_mixer() {
   START_MENU();
-  MENU_BACK(MSG_MAIN);
+  BACK_ITEM(MSG_MAIN);
 
   v_index = mixer.get_current_vtool();
-  MENU_ITEM_EDIT_CALLBACK(uint8, MSG_ACTIVE_VTOOL, &v_index, 0, MIXING_VIRTUAL_TOOLS - 1, _lcd_mixer_select_vtool
+  EDIT_ITEM(uint8, MSG_ACTIVE_VTOOL, &v_index, 0, MIXING_VIRTUAL_TOOLS - 1, _lcd_mixer_select_vtool
     #if DUAL_MIXING_EXTRUDER
       , true
     #endif
@@ -275,29 +275,29 @@ void menu_mixer() {
   #if DUAL_MIXING_EXTRUDER
   {
     char tmp[10];
-    MENU_ITEM(submenu, MSG_MIX, lcd_mixer_mix_edit);
+    SUBMENU(MSG_MIX, lcd_mixer_mix_edit);
     MENU_ITEM_ADDON_START(10);
       mixer.update_mix_from_vtool();
       sprintf_P(tmp, PSTR("%3d;%3d%%"), int(mixer.mix[0]), int(mixer.mix[1]));
       LCDPRINT(tmp);
     MENU_ITEM_ADDON_END();
-    MENU_ITEM(function, MSG_TOGGLE_MIX, _lcd_mixer_toggle_mix);
+    ACTION_ITEM(MSG_TOGGLE_MIX, _lcd_mixer_toggle_mix);
   }
   #else
-    MENU_ITEM(submenu, MSG_MIX, _lcd_goto_mix_edit);
+    SUBMENU(MSG_MIX, _lcd_goto_mix_edit);
   #endif
 
-  MENU_ITEM(submenu, MSG_RESET_VTOOLS, menu_mixer_vtools_reset_confirm);
+  SUBMENU(MSG_RESET_VTOOLS, menu_mixer_vtools_reset_confirm);
 
   #if ENABLED(GRADIENT_MIX)
   {
     char tmp[13];
-    MENU_ITEM(submenu, MSG_GRADIENT, lcd_mixer_edit_gradient_menu);
+    SUBMENU(MSG_GRADIENT, lcd_mixer_edit_gradient_menu);
     MENU_ITEM_ADDON_START(10);
       sprintf_P(tmp, PSTR("T%i->T%i"), mixer.gradient.start_vtool, mixer.gradient.end_vtool);
       LCDPRINT(tmp);
     MENU_ITEM_ADDON_END();
-    MENU_ITEM(function, MSG_REVERSE_GRADIENT, _lcd_mixer_reverse_gradient);
+    ACTION_ITEM(MSG_REVERSE_GRADIENT, _lcd_mixer_reverse_gradient);
   }
   #endif
 

Marlin/src/lcd/menu/menu_mmu2.cpp

@@ -71,24 +71,24 @@ inline void action_mmu2_load_filament_4() { _mmu2_load_filament(4); }
 
 void menu_mmu2_load_filament() {
   START_MENU();
-  MENU_BACK(MSG_MMU2_MENU);
-  MENU_ITEM(function, MSG_MMU2_ALL, action_mmu2_load_all);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT0, action_mmu2_load_filament_0);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT1, action_mmu2_load_filament_1);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT2, action_mmu2_load_filament_2);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT3, action_mmu2_load_filament_3);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT4, action_mmu2_load_filament_4);
+  BACK_ITEM(MSG_MMU2_MENU);
+  ACTION_ITEM(MSG_MMU2_ALL, action_mmu2_load_all);
+  ACTION_ITEM(MSG_MMU2_FILAMENT0, action_mmu2_load_filament_0);
+  ACTION_ITEM(MSG_MMU2_FILAMENT1, action_mmu2_load_filament_1);
+  ACTION_ITEM(MSG_MMU2_FILAMENT2, action_mmu2_load_filament_2);
+  ACTION_ITEM(MSG_MMU2_FILAMENT3, action_mmu2_load_filament_3);
+  ACTION_ITEM(MSG_MMU2_FILAMENT4, action_mmu2_load_filament_4);
   END_MENU();
 }
 
 void menu_mmu2_load_to_nozzle() {
   START_MENU();
-  MENU_BACK(MSG_MMU2_MENU);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT0, action_mmu2_load_filament_to_nozzle_0);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT1, action_mmu2_load_filament_to_nozzle_1);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT2, action_mmu2_load_filament_to_nozzle_2);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT3, action_mmu2_load_filament_to_nozzle_3);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT4, action_mmu2_load_filament_to_nozzle_4);
+  BACK_ITEM(MSG_MMU2_MENU);
+  ACTION_ITEM(MSG_MMU2_FILAMENT0, action_mmu2_load_filament_to_nozzle_0);
+  ACTION_ITEM(MSG_MMU2_FILAMENT1, action_mmu2_load_filament_to_nozzle_1);
+  ACTION_ITEM(MSG_MMU2_FILAMENT2, action_mmu2_load_filament_to_nozzle_2);
+  ACTION_ITEM(MSG_MMU2_FILAMENT3, action_mmu2_load_filament_to_nozzle_3);
+  ACTION_ITEM(MSG_MMU2_FILAMENT4, action_mmu2_load_filament_to_nozzle_4);
   END_MENU();
 }
 
@@ -118,12 +118,12 @@ void action_mmu2_unload_filament() {
 
 void menu_mmu2_eject_filament() {
   START_MENU();
-  MENU_BACK(MSG_MMU2_MENU);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT0, action_mmu2_eject_filament_0);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT1, action_mmu2_eject_filament_1);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT2, action_mmu2_eject_filament_2);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT3, action_mmu2_eject_filament_3);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT4, action_mmu2_eject_filament_4);
+  BACK_ITEM(MSG_MMU2_MENU);
+  ACTION_ITEM(MSG_MMU2_FILAMENT0, action_mmu2_eject_filament_0);
+  ACTION_ITEM(MSG_MMU2_FILAMENT1, action_mmu2_eject_filament_1);
+  ACTION_ITEM(MSG_MMU2_FILAMENT2, action_mmu2_eject_filament_2);
+  ACTION_ITEM(MSG_MMU2_FILAMENT3, action_mmu2_eject_filament_3);
+  ACTION_ITEM(MSG_MMU2_FILAMENT4, action_mmu2_eject_filament_4);
   END_MENU();
 }
 
@@ -138,12 +138,12 @@ void action_mmu2_reset() {
 
 void menu_mmu2() {
   START_MENU();
-  MENU_BACK(MSG_MAIN);
-  MENU_ITEM(submenu, MSG_MMU2_LOAD_FILAMENT, menu_mmu2_load_filament);
-  MENU_ITEM(submenu, MSG_MMU2_LOAD_TO_NOZZLE, menu_mmu2_load_to_nozzle);
-  MENU_ITEM(submenu, MSG_MMU2_EJECT_FILAMENT, menu_mmu2_eject_filament);
-  MENU_ITEM(function, MSG_MMU2_UNLOAD_FILAMENT, action_mmu2_unload_filament);
-  MENU_ITEM(function, MSG_MMU2_RESET, action_mmu2_reset);
+  BACK_ITEM(MSG_MAIN);
+  SUBMENU(MSG_MMU2_LOAD_FILAMENT, menu_mmu2_load_filament);
+  SUBMENU(MSG_MMU2_LOAD_TO_NOZZLE, menu_mmu2_load_to_nozzle);
+  SUBMENU(MSG_MMU2_EJECT_FILAMENT, menu_mmu2_eject_filament);
+  ACTION_ITEM(MSG_MMU2_UNLOAD_FILAMENT, action_mmu2_unload_filament);
+  ACTION_ITEM(MSG_MMU2_RESET, action_mmu2_reset);
   END_MENU();
 }
 
@@ -166,11 +166,11 @@ void menu_mmu2_choose_filament() {
   #if LCD_HEIGHT > 2
     STATIC_ITEM(MSG_MMU2_CHOOSE_FILAMENT_HEADER, SS_CENTER|SS_INVERT);
   #endif
-  MENU_ITEM(function, MSG_MMU2_FILAMENT0, action_mmu2_choose0);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT1, action_mmu2_choose1);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT2, action_mmu2_choose2);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT3, action_mmu2_choose3);
-  MENU_ITEM(function, MSG_MMU2_FILAMENT4, action_mmu2_choose4);
+  ACTION_ITEM(MSG_MMU2_FILAMENT0, action_mmu2_choose0);
+  ACTION_ITEM(MSG_MMU2_FILAMENT1, action_mmu2_choose1);
+  ACTION_ITEM(MSG_MMU2_FILAMENT2, action_mmu2_choose2);
+  ACTION_ITEM(MSG_MMU2_FILAMENT3, action_mmu2_choose3);
+  ACTION_ITEM(MSG_MMU2_FILAMENT4, action_mmu2_choose4);
   END_MENU();
 }
 
@@ -189,10 +189,10 @@ void menu_mmu2_pause() {
   #if LCD_HEIGHT > 2
     STATIC_ITEM(MSG_MMU2_FILAMENT_CHANGE_HEADER, SS_CENTER|SS_INVERT);
   #endif
-  MENU_ITEM(function, MSG_MMU2_RESUME, action_mmu2_M600_resume);
-  MENU_ITEM(function, MSG_MMU2_UNLOAD_FILAMENT, action_mmu2_M600_unload_filament);
-  MENU_ITEM(function, MSG_MMU2_LOAD_FILAMENT, action_mmu2_M600_load_current_filament);
-  MENU_ITEM(function, MSG_MMU2_LOAD_TO_NOZZLE, action_mmu2_M600_load_current_filament_to_nozzle);
+  ACTION_ITEM(MSG_MMU2_RESUME, action_mmu2_M600_resume);
+  ACTION_ITEM(MSG_MMU2_UNLOAD_FILAMENT, action_mmu2_M600_unload_filament);
+  ACTION_ITEM(MSG_MMU2_LOAD_FILAMENT, action_mmu2_M600_load_current_filament);
+  ACTION_ITEM(MSG_MMU2_LOAD_TO_NOZZLE, action_mmu2_M600_load_current_filament_to_nozzle);
   END_MENU();
 }
 

Marlin/src/lcd/menu/menu_motion.cpp

@@ -275,16 +275,16 @@ void _menu_move_distance(const AxisEnum axis, const screenFunc_t func, const int
   }
   #if ENABLED(PREVENT_COLD_EXTRUSION)
     if (axis == E_AXIS && thermalManager.tooColdToExtrude(eindex >= 0 ? eindex : active_extruder))
-      MENU_BACK(MSG_HOTEND_TOO_COLD);
+      BACK_ITEM(MSG_HOTEND_TOO_COLD);
     else
   #endif
   {
-    MENU_BACK(MSG_MOVE_AXIS);
-    MENU_ITEM(submenu, MSG_MOVE_10MM, menu_move_10mm);
-    MENU_ITEM(submenu, MSG_MOVE_1MM, menu_move_1mm);
-    MENU_ITEM(submenu, MSG_MOVE_01MM, menu_move_01mm);
+    BACK_ITEM(MSG_MOVE_AXIS);
+    SUBMENU(MSG_MOVE_10MM, menu_move_10mm);
+    SUBMENU(MSG_MOVE_1MM, menu_move_1mm);
+    SUBMENU(MSG_MOVE_01MM, menu_move_01mm);
     if (axis == Z_AXIS && (SHORT_MANUAL_Z_MOVE) > 0.0f && (SHORT_MANUAL_Z_MOVE) < 0.1f) {
-      MENU_ITEM(submenu, "", []{ _goto_manual_move(float(SHORT_MANUAL_Z_MOVE)); });
+      SUBMENU("", []{ _goto_manual_move(float(SHORT_MANUAL_Z_MOVE)); });
       MENU_ITEM_ADDON_START(1);
         char tmp[20], numstr[10];
         // Determine digits needed right of decimal
@@ -330,10 +330,10 @@ void lcd_move_get_z_amount() { _menu_move_distance(Z_AXIS, lcd_move_z); }
 
 void menu_move() {
   START_MENU();
-  MENU_BACK(MSG_MOTION);
+  BACK_ITEM(MSG_MOTION);
 
   #if HAS_SOFTWARE_ENDSTOPS && ENABLED(SOFT_ENDSTOPS_MENU_ITEM)
-    MENU_ITEM_EDIT(bool, MSG_LCD_SOFT_ENDSTOPS, &soft_endstops_enabled);
+    EDIT_ITEM(bool, MSG_LCD_SOFT_ENDSTOPS, &soft_endstops_enabled);
   #endif
 
   if (
@@ -350,57 +350,57 @@ void menu_move() {
         true
       #endif
     ) {
-      MENU_ITEM(submenu, MSG_MOVE_X, lcd_move_get_x_amount);
-      MENU_ITEM(submenu, MSG_MOVE_Y, lcd_move_get_y_amount);
+      SUBMENU(MSG_MOVE_X, lcd_move_get_x_amount);
+      SUBMENU(MSG_MOVE_Y, lcd_move_get_y_amount);
     }
     #if ENABLED(DELTA)
       else
-        MENU_ITEM(function, MSG_FREE_XY, lcd_lower_z_to_clip_height);
+        ACTION_ITEM(MSG_FREE_XY, lcd_lower_z_to_clip_height);
     #endif
 
-    MENU_ITEM(submenu, MSG_MOVE_Z, lcd_move_get_z_amount);
+    SUBMENU(MSG_MOVE_Z, lcd_move_get_z_amount);
   }
   else
-    MENU_ITEM(gcode, MSG_AUTO_HOME, PSTR("G28"));
+    GCODES_ITEM(MSG_AUTO_HOME, PSTR("G28"));
 
   #if ANY(SWITCHING_EXTRUDER, SWITCHING_NOZZLE, MAGNETIC_SWITCHING_TOOLHEAD)
 
     #if EXTRUDERS == 6
       switch (active_extruder) {
-        case 0: MENU_ITEM(gcode, MSG_SELECT " " MSG_E2, PSTR("T1")); break;
-        case 1: MENU_ITEM(gcode, MSG_SELECT " " MSG_E1, PSTR("T0")); break;
-        case 2: MENU_ITEM(gcode, MSG_SELECT " " MSG_E4, PSTR("T3")); break;
-        case 3: MENU_ITEM(gcode, MSG_SELECT " " MSG_E3, PSTR("T2")); break;
-        case 4: MENU_ITEM(gcode, MSG_SELECT " " MSG_E6, PSTR("T5")); break;
-        case 5: MENU_ITEM(gcode, MSG_SELECT " " MSG_E5, PSTR("T4")); break;
+        case 0: GCODES_ITEM(MSG_SELECT " " MSG_E2, PSTR("T1")); break;
+        case 1: GCODES_ITEM(MSG_SELECT " " MSG_E1, PSTR("T0")); break;
+        case 2: GCODES_ITEM(MSG_SELECT " " MSG_E4, PSTR("T3")); break;
+        case 3: GCODES_ITEM(MSG_SELECT " " MSG_E3, PSTR("T2")); break;
+        case 4: GCODES_ITEM(MSG_SELECT " " MSG_E6, PSTR("T5")); break;
+        case 5: GCODES_ITEM(MSG_SELECT " " MSG_E5, PSTR("T4")); break;
       }
     #elif EXTRUDERS == 5 || EXTRUDERS == 4
       switch (active_extruder) {
-        case 0: MENU_ITEM(gcode, MSG_SELECT " " MSG_E2, PSTR("T1")); break;
-        case 1: MENU_ITEM(gcode, MSG_SELECT " " MSG_E1, PSTR("T0")); break;
-        case 2: MENU_ITEM(gcode, MSG_SELECT " " MSG_E4, PSTR("T3")); break;
-        case 3: MENU_ITEM(gcode, MSG_SELECT " " MSG_E3, PSTR("T2")); break;
+        case 0: GCODES_ITEM(MSG_SELECT " " MSG_E2, PSTR("T1")); break;
+        case 1: GCODES_ITEM(MSG_SELECT " " MSG_E1, PSTR("T0")); break;
+        case 2: GCODES_ITEM(MSG_SELECT " " MSG_E4, PSTR("T3")); break;
+        case 3: GCODES_ITEM(MSG_SELECT " " MSG_E3, PSTR("T2")); break;
       }
     #elif EXTRUDERS == 3
       if (active_extruder < 2) {
         if (active_extruder)
-          MENU_ITEM(gcode, MSG_SELECT " " MSG_E1, PSTR("T0"));
+          GCODES_ITEM(MSG_SELECT " " MSG_E1, PSTR("T0"));
         else
-          MENU_ITEM(gcode, MSG_SELECT " " MSG_E2, PSTR("T1"));
+          GCODES_ITEM(MSG_SELECT " " MSG_E2, PSTR("T1"));
       }
     #else
       if (active_extruder)
-        MENU_ITEM(gcode, MSG_SELECT " " MSG_E1, PSTR("T0"));
+        GCODES_ITEM(MSG_SELECT " " MSG_E1, PSTR("T0"));
       else
-        MENU_ITEM(gcode, MSG_SELECT " " MSG_E2, PSTR("T1"));
+        GCODES_ITEM(MSG_SELECT " " MSG_E2, PSTR("T1"));
     #endif
 
   #elif ENABLED(DUAL_X_CARRIAGE)
 
     if (active_extruder)
-      MENU_ITEM(gcode, MSG_SELECT " " MSG_E1, PSTR("T0"));
+      GCODES_ITEM(MSG_SELECT " " MSG_E1, PSTR("T0"));
     else
-      MENU_ITEM(gcode, MSG_SELECT " " MSG_E2, PSTR("T1"));
+      GCODES_ITEM(MSG_SELECT " " MSG_E2, PSTR("T1"));
 
   #endif
 
@@ -409,29 +409,29 @@ void menu_move() {
     #if EITHER(SWITCHING_EXTRUDER, SWITCHING_NOZZLE)
 
       // Only the current...
-      MENU_ITEM(submenu, MSG_MOVE_E, lcd_move_get_e_amount);
+      SUBMENU(MSG_MOVE_E, lcd_move_get_e_amount);
       // ...and the non-switching
       #if E_MANUAL == 5
-        MENU_ITEM(submenu, MSG_MOVE_E MSG_MOVE_E5, lcd_move_get_e4_amount);
+        SUBMENU(MSG_MOVE_E MSG_MOVE_E5, lcd_move_get_e4_amount);
       #elif E_MANUAL == 3
-        MENU_ITEM(submenu, MSG_MOVE_E MSG_MOVE_E3, lcd_move_get_e2_amount);
+        SUBMENU(MSG_MOVE_E MSG_MOVE_E3, lcd_move_get_e2_amount);
       #endif
 
     #else
 
       // Independent extruders with one E-stepper per hotend
-      MENU_ITEM(submenu, MSG_MOVE_E, lcd_move_get_e_amount);
+      SUBMENU(MSG_MOVE_E, lcd_move_get_e_amount);
       #if E_MANUAL > 1
-        MENU_ITEM(submenu, MSG_MOVE_E MSG_MOVE_E1, lcd_move_get_e0_amount);
-        MENU_ITEM(submenu, MSG_MOVE_E MSG_MOVE_E2, lcd_move_get_e1_amount);
+        SUBMENU(MSG_MOVE_E MSG_MOVE_E1, lcd_move_get_e0_amount);
+        SUBMENU(MSG_MOVE_E MSG_MOVE_E2, lcd_move_get_e1_amount);
         #if E_MANUAL > 2
-          MENU_ITEM(submenu, MSG_MOVE_E MSG_MOVE_E3, lcd_move_get_e2_amount);
+          SUBMENU(MSG_MOVE_E MSG_MOVE_E3, lcd_move_get_e2_amount);
           #if E_MANUAL > 3
-            MENU_ITEM(submenu, MSG_MOVE_E MSG_MOVE_E4, lcd_move_get_e3_amount);
+            SUBMENU(MSG_MOVE_E MSG_MOVE_E4, lcd_move_get_e3_amount);
             #if E_MANUAL > 4
-              MENU_ITEM(submenu, MSG_MOVE_E MSG_MOVE_E5, lcd_move_get_e4_amount);
+              SUBMENU(MSG_MOVE_E MSG_MOVE_E5, lcd_move_get_e4_amount);
               #if E_MANUAL > 5
-                MENU_ITEM(submenu, MSG_MOVE_E MSG_MOVE_E6, lcd_move_get_e5_amount);
+                SUBMENU(MSG_MOVE_E MSG_MOVE_E6, lcd_move_get_e5_amount);
               #endif // E_MANUAL > 5
             #endif // E_MANUAL > 4
           #endif // E_MANUAL > 3
@@ -457,7 +457,7 @@ void menu_motion() {
   //
   // ^ Main
   //
-  MENU_BACK(MSG_MAIN);
+  BACK_ITEM(MSG_MAIN);
 
   //
   // Move Axis
@@ -465,23 +465,23 @@ void menu_motion() {
   #if ENABLED(DELTA)
     if (all_axes_homed())
   #endif
-      MENU_ITEM(submenu, MSG_MOVE_AXIS, menu_move);
+      SUBMENU(MSG_MOVE_AXIS, menu_move);
 
   //
   // Auto Home
   //
-  MENU_ITEM(gcode, MSG_AUTO_HOME, PSTR("G28"));
+  GCODES_ITEM(MSG_AUTO_HOME, PSTR("G28"));
   #if ENABLED(INDIVIDUAL_AXIS_HOMING_MENU)
-    MENU_ITEM(gcode, MSG_AUTO_HOME_X, PSTR("G28 X"));
-    MENU_ITEM(gcode, MSG_AUTO_HOME_Y, PSTR("G28 Y"));
-    MENU_ITEM(gcode, MSG_AUTO_HOME_Z, PSTR("G28 Z"));
+    GCODES_ITEM(MSG_AUTO_HOME_X, PSTR("G28 X"));
+    GCODES_ITEM(MSG_AUTO_HOME_Y, PSTR("G28 Y"));
+    GCODES_ITEM(MSG_AUTO_HOME_Z, PSTR("G28 Z"));
   #endif
 
   //
   // Auto Z-Align
   //
   #if ENABLED(Z_STEPPER_AUTO_ALIGN)
-    MENU_ITEM(gcode, MSG_AUTO_Z_ALIGN, PSTR("G34"));
+    GCODES_ITEM(MSG_AUTO_Z_ALIGN, PSTR("G34"));
   #endif
 
   //
@@ -489,39 +489,39 @@ void menu_motion() {
   //
   #if ENABLED(AUTO_BED_LEVELING_UBL)
 
-    MENU_ITEM(submenu, MSG_UBL_LEVEL_BED, _lcd_ubl_level_bed);
+    SUBMENU(MSG_UBL_LEVEL_BED, _lcd_ubl_level_bed);
 
   #elif ENABLED(LCD_BED_LEVELING)
 
-    if (!g29_in_progress) MENU_ITEM(submenu, MSG_BED_LEVELING, menu_bed_leveling);
+    if (!g29_in_progress) SUBMENU(MSG_BED_LEVELING, menu_bed_leveling);
 
   #elif HAS_LEVELING && DISABLED(SLIM_LCD_MENUS)
 
     #if DISABLED(PROBE_MANUALLY)
-      MENU_ITEM(gcode, MSG_LEVEL_BED, PSTR("G28\nG29"));
+      GCODES_ITEM(MSG_LEVEL_BED, PSTR("G28\nG29"));
     #endif
     if (all_axes_homed() && leveling_is_valid()) {
       bool new_level_state = planner.leveling_active;
-      MENU_ITEM_EDIT_CALLBACK(bool, MSG_BED_LEVELING, &new_level_state, _lcd_toggle_bed_leveling);
+      EDIT_ITEM(bool, MSG_BED_LEVELING, &new_level_state, _lcd_toggle_bed_leveling);
     }
     #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
-      MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float3, MSG_Z_FADE_HEIGHT, &lcd_z_fade_height, 0, 100, _lcd_set_z_fade_height);
+      EDIT_ITEM_FAST(float3, MSG_Z_FADE_HEIGHT, &lcd_z_fade_height, 0, 100, _lcd_set_z_fade_height);
     #endif
 
   #endif
 
   #if ENABLED(LEVEL_BED_CORNERS) && DISABLED(LCD_BED_LEVELING)
-    MENU_ITEM(function, MSG_LEVEL_CORNERS, _lcd_level_bed_corners);
+    ACTION_ITEM(MSG_LEVEL_CORNERS, _lcd_level_bed_corners);
   #endif
 
   #if ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)
-    MENU_ITEM(gcode, MSG_M48_TEST, PSTR("G28\nM48 P10"));
+    GCODES_ITEM(MSG_M48_TEST, PSTR("G28\nM48 P10"));
   #endif
 
   //
   // Disable Steppers
   //
-  MENU_ITEM(gcode, MSG_DISABLE_STEPPERS, PSTR("M84"));
+  GCODES_ITEM(MSG_DISABLE_STEPPERS, PSTR("M84"));
 
   END_MENU();
 }

Marlin/src/lcd/menu/menu_spindle_laser.cpp

@@ -35,17 +35,17 @@
   void menu_spindle_laser() {
 
     START_MENU();
-    MENU_BACK(MSG_MAIN);
+    BACK_ITEM(MSG_MAIN);
     if (cutter.enabled()) {
       #if ENABLED(SPINDLE_LASER_PWM)
-        MENU_ITEM_EDIT_CALLBACK(CUTTER_MENU_TYPE, MSG_CUTTER(POWER), &cutter.power, SPEED_POWER_MIN, SPEED_POWER_MAX, cutter.update_output);
+        EDIT_ITEM(CUTTER_MENU_TYPE, MSG_CUTTER(POWER), &cutter.power, SPEED_POWER_MIN, SPEED_POWER_MAX, cutter.update_output);
       #endif
-      MENU_ITEM(function, MSG_CUTTER(OFF), cutter.disable);
+      ACTION_ITEM(MSG_CUTTER(OFF), cutter.disable);
     }
     else {
-      MENU_ITEM(function, MSG_CUTTER(ON), cutter.enable_forward);
+      ACTION_ITEM(MSG_CUTTER(ON), cutter.enable_forward);
       #if ENABLED(SPINDLE_CHANGE_DIR)
-        MENU_ITEM(function, MSG_SPINDLE_REVERSE, cutter.enable_reverse);
+        ACTION_ITEM(MSG_SPINDLE_REVERSE, cutter.enable_reverse);
       #endif
     }
     END_MENU();

Marlin/src/lcd/menu/menu_temperature.cpp

@@ -183,120 +183,120 @@ void _lcd_preheat(const int16_t endnum, const int16_t temph, const int16_t tempb
 
   void menu_preheat_m1() {
     START_MENU();
-    MENU_BACK(MSG_TEMPERATURE);
+    BACK_ITEM(MSG_TEMPERATURE);
     #if HOTENDS == 1
       #if HAS_HEATED_BED
-        MENU_ITEM(function, MSG_PREHEAT_1, lcd_preheat_m1_e0);
-        MENU_ITEM(function, MSG_PREHEAT_1_END, lcd_preheat_m1_e0_only);
+        ACTION_ITEM(MSG_PREHEAT_1, lcd_preheat_m1_e0);
+        ACTION_ITEM(MSG_PREHEAT_1_END, lcd_preheat_m1_e0_only);
       #else
-        MENU_ITEM(function, MSG_PREHEAT_1, lcd_preheat_m1_e0_only);
+        ACTION_ITEM(MSG_PREHEAT_1, lcd_preheat_m1_e0_only);
       #endif
     #elif HOTENDS > 1
       #if HAS_HEATED_BED
-        MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H1, lcd_preheat_m1_e0);
-        MENU_ITEM(function, MSG_PREHEAT_1_END " " MSG_E1, lcd_preheat_m1_e0_only);
-        MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H2, lcd_preheat_m1_e1);
-        MENU_ITEM(function, MSG_PREHEAT_1_END " " MSG_E2, lcd_preheat_m1_e1_only);
+        ACTION_ITEM(MSG_PREHEAT_1_N MSG_H1, lcd_preheat_m1_e0);
+        ACTION_ITEM(MSG_PREHEAT_1_END " " MSG_E1, lcd_preheat_m1_e0_only);
+        ACTION_ITEM(MSG_PREHEAT_1_N MSG_H2, lcd_preheat_m1_e1);
+        ACTION_ITEM(MSG_PREHEAT_1_END " " MSG_E2, lcd_preheat_m1_e1_only);
       #else
-        MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H1, lcd_preheat_m1_e0_only);
-        MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H2, lcd_preheat_m1_e1_only);
+        ACTION_ITEM(MSG_PREHEAT_1_N MSG_H1, lcd_preheat_m1_e0_only);
+        ACTION_ITEM(MSG_PREHEAT_1_N MSG_H2, lcd_preheat_m1_e1_only);
       #endif
       #if HOTENDS > 2
         #if HAS_HEATED_BED
-          MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H3, lcd_preheat_m1_e2);
-          MENU_ITEM(function, MSG_PREHEAT_1_END " " MSG_E3, lcd_preheat_m1_e2_only);
+          ACTION_ITEM(MSG_PREHEAT_1_N MSG_H3, lcd_preheat_m1_e2);
+          ACTION_ITEM(MSG_PREHEAT_1_END " " MSG_E3, lcd_preheat_m1_e2_only);
         #else
-          MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H3, lcd_preheat_m1_e2_only);
+          ACTION_ITEM(MSG_PREHEAT_1_N MSG_H3, lcd_preheat_m1_e2_only);
         #endif
         #if HOTENDS > 3
           #if HAS_HEATED_BED
-            MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H4, lcd_preheat_m1_e3);
-            MENU_ITEM(function, MSG_PREHEAT_1_END " " MSG_E4, lcd_preheat_m1_e3_only);
+            ACTION_ITEM(MSG_PREHEAT_1_N MSG_H4, lcd_preheat_m1_e3);
+            ACTION_ITEM(MSG_PREHEAT_1_END " " MSG_E4, lcd_preheat_m1_e3_only);
           #else
-            MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H4, lcd_preheat_m1_e3_only);
+            ACTION_ITEM(MSG_PREHEAT_1_N MSG_H4, lcd_preheat_m1_e3_only);
           #endif
           #if HOTENDS > 4
             #if HAS_HEATED_BED
-              MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H5, lcd_preheat_m1_e4);
-              MENU_ITEM(function, MSG_PREHEAT_1_END " " MSG_E5, lcd_preheat_m1_e4_only);
+              ACTION_ITEM(MSG_PREHEAT_1_N MSG_H5, lcd_preheat_m1_e4);
+              ACTION_ITEM(MSG_PREHEAT_1_END " " MSG_E5, lcd_preheat_m1_e4_only);
             #else
-              MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H5, lcd_preheat_m1_e4_only);
+              ACTION_ITEM(MSG_PREHEAT_1_N MSG_H5, lcd_preheat_m1_e4_only);
             #endif
             #if HOTENDS > 5
               #if HAS_HEATED_BED
-                MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H6, lcd_preheat_m1_e5);
-                MENU_ITEM(function, MSG_PREHEAT_1_END " " MSG_E6, lcd_preheat_m1_e5_only);
+                ACTION_ITEM(MSG_PREHEAT_1_N MSG_H6, lcd_preheat_m1_e5);
+                ACTION_ITEM(MSG_PREHEAT_1_END " " MSG_E6, lcd_preheat_m1_e5_only);
               #else
-                MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H6, lcd_preheat_m1_e5_only);
+                ACTION_ITEM(MSG_PREHEAT_1_N MSG_H6, lcd_preheat_m1_e5_only);
               #endif
             #endif // HOTENDS > 5
           #endif // HOTENDS > 4
         #endif // HOTENDS > 3
       #endif // HOTENDS > 2
-      MENU_ITEM(function, MSG_PREHEAT_1_ALL, lcd_preheat_m1_all);
+      ACTION_ITEM(MSG_PREHEAT_1_ALL, lcd_preheat_m1_all);
     #endif // HOTENDS > 1
     #if HAS_HEATED_BED
-      MENU_ITEM(function, MSG_PREHEAT_1_BEDONLY, lcd_preheat_m1_bedonly);
+      ACTION_ITEM(MSG_PREHEAT_1_BEDONLY, lcd_preheat_m1_bedonly);
     #endif
     END_MENU();
   }
 
   void menu_preheat_m2() {
     START_MENU();
-    MENU_BACK(MSG_TEMPERATURE);
+    BACK_ITEM(MSG_TEMPERATURE);
     #if HOTENDS == 1
       #if HAS_HEATED_BED
-        MENU_ITEM(function, MSG_PREHEAT_2, lcd_preheat_m2_e0);
-        MENU_ITEM(function, MSG_PREHEAT_2_END, lcd_preheat_m2_e0_only);
+        ACTION_ITEM(MSG_PREHEAT_2, lcd_preheat_m2_e0);
+        ACTION_ITEM(MSG_PREHEAT_2_END, lcd_preheat_m2_e0_only);
       #else
-        MENU_ITEM(function, MSG_PREHEAT_2, lcd_preheat_m2_e0_only);
+        ACTION_ITEM(MSG_PREHEAT_2, lcd_preheat_m2_e0_only);
       #endif
     #elif HOTENDS > 1
       #if HAS_HEATED_BED
-        MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H1, lcd_preheat_m2_e0);
-        MENU_ITEM(function, MSG_PREHEAT_2_END " " MSG_E1, lcd_preheat_m2_e0_only);
-        MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H2, lcd_preheat_m2_e1);
-        MENU_ITEM(function, MSG_PREHEAT_2_END " " MSG_E2, lcd_preheat_m2_e1_only);
+        ACTION_ITEM(MSG_PREHEAT_2_N MSG_H1, lcd_preheat_m2_e0);
+        ACTION_ITEM(MSG_PREHEAT_2_END " " MSG_E1, lcd_preheat_m2_e0_only);
+        ACTION_ITEM(MSG_PREHEAT_2_N MSG_H2, lcd_preheat_m2_e1);
+        ACTION_ITEM(MSG_PREHEAT_2_END " " MSG_E2, lcd_preheat_m2_e1_only);
       #else
-        MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H1, lcd_preheat_m2_e0_only);
-        MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H2, lcd_preheat_m2_e1_only);
+        ACTION_ITEM(MSG_PREHEAT_2_N MSG_H1, lcd_preheat_m2_e0_only);
+        ACTION_ITEM(MSG_PREHEAT_2_N MSG_H2, lcd_preheat_m2_e1_only);
       #endif
       #if HOTENDS > 2
         #if HAS_HEATED_BED
-          MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H3, lcd_preheat_m2_e2);
-          MENU_ITEM(function, MSG_PREHEAT_2_END " " MSG_E3, lcd_preheat_m2_e2_only);
+          ACTION_ITEM(MSG_PREHEAT_2_N MSG_H3, lcd_preheat_m2_e2);
+          ACTION_ITEM(MSG_PREHEAT_2_END " " MSG_E3, lcd_preheat_m2_e2_only);
         #else
-          MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H3, lcd_preheat_m2_e2_only);
+          ACTION_ITEM(MSG_PREHEAT_2_N MSG_H3, lcd_preheat_m2_e2_only);
         #endif
         #if HOTENDS > 3
           #if HAS_HEATED_BED
-            MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H4, lcd_preheat_m2_e3);
-            MENU_ITEM(function, MSG_PREHEAT_2_END " " MSG_E4, lcd_preheat_m2_e3_only);
+            ACTION_ITEM(MSG_PREHEAT_2_N MSG_H4, lcd_preheat_m2_e3);
+            ACTION_ITEM(MSG_PREHEAT_2_END " " MSG_E4, lcd_preheat_m2_e3_only);
           #else
-            MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H4, lcd_preheat_m2_e3_only);
+            ACTION_ITEM(MSG_PREHEAT_2_N MSG_H4, lcd_preheat_m2_e3_only);
           #endif
           #if HOTENDS > 4
             #if HAS_HEATED_BED
-              MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H5, lcd_preheat_m2_e4);
-              MENU_ITEM(function, MSG_PREHEAT_2_END " " MSG_E5, lcd_preheat_m2_e4_only);
+              ACTION_ITEM(MSG_PREHEAT_2_N MSG_H5, lcd_preheat_m2_e4);
+              ACTION_ITEM(MSG_PREHEAT_2_END " " MSG_E5, lcd_preheat_m2_e4_only);
             #else
-              MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H5, lcd_preheat_m2_e4_only);
+              ACTION_ITEM(MSG_PREHEAT_2_N MSG_H5, lcd_preheat_m2_e4_only);
             #endif
             #if HOTENDS > 5
               #if HAS_HEATED_BED
-                MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H6, lcd_preheat_m2_e5);
-                MENU_ITEM(function, MSG_PREHEAT_2_END " " MSG_E6, lcd_preheat_m2_e5_only);
+                ACTION_ITEM(MSG_PREHEAT_2_N MSG_H6, lcd_preheat_m2_e5);
+                ACTION_ITEM(MSG_PREHEAT_2_END " " MSG_E6, lcd_preheat_m2_e5_only);
               #else
-                MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H6, lcd_preheat_m2_e5_only);
+                ACTION_ITEM(MSG_PREHEAT_2_N MSG_H6, lcd_preheat_m2_e5_only);
               #endif
             #endif // HOTENDS > 5
           #endif // HOTENDS > 4
         #endif // HOTENDS > 3
       #endif // HOTENDS > 2
-      MENU_ITEM(function, MSG_PREHEAT_2_ALL, lcd_preheat_m2_all);
+      ACTION_ITEM(MSG_PREHEAT_2_ALL, lcd_preheat_m2_all);
     #endif // HOTENDS > 1
     #if HAS_HEATED_BED
-      MENU_ITEM(function, MSG_PREHEAT_2_BEDONLY, lcd_preheat_m2_bedonly);
+      ACTION_ITEM(MSG_PREHEAT_2_BEDONLY, lcd_preheat_m2_bedonly);
     #endif
     END_MENU();
   }
@@ -311,16 +311,16 @@ void _lcd_preheat(const int16_t endnum, const int16_t temph, const int16_t tempb
 
 void menu_temperature() {
   START_MENU();
-  MENU_BACK(MSG_MAIN);
+  BACK_ITEM(MSG_MAIN);
 
   //
   // Nozzle:
   // Nozzle [1-5]:
   //
   #if HOTENDS == 1
-    MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE, &thermalManager.temp_hotend[0].target, 0, HEATER_0_MAXTEMP - 15, thermalManager.start_watching_E0);
+    EDIT_ITEM_FAST(int3, MSG_NOZZLE, &thermalManager.temp_hotend[0].target, 0, HEATER_0_MAXTEMP - 15, thermalManager.start_watching_E0);
   #elif HOTENDS > 1
-    #define EDIT_TARGET(N) MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE MSG_LCD_N##N, &thermalManager.temp_hotend[N].target, 0, HEATER_##N##_MAXTEMP - 15, thermalManager.start_watching_E##N)
+    #define EDIT_TARGET(N) EDIT_ITEM_FAST(int3, MSG_NOZZLE MSG_LCD_N##N, &thermalManager.temp_hotend[N].target, 0, HEATER_##N##_MAXTEMP - 15, thermalManager.start_watching_E##N)
     EDIT_TARGET(0);
     EDIT_TARGET(1);
     #if HOTENDS > 2
@@ -338,21 +338,21 @@ void menu_temperature() {
   #endif // HOTENDS > 1
 
   #if ENABLED(SINGLENOZZLE)
-    MENU_MULTIPLIER_ITEM_EDIT(uint16_3, MSG_NOZZLE_STANDBY, &singlenozzle_temp[active_extruder ? 0 : 1], 0, HEATER_0_MAXTEMP - 15);
+    EDIT_ITEM_FAST(uint16_3, MSG_NOZZLE_STANDBY, &singlenozzle_temp[active_extruder ? 0 : 1], 0, HEATER_0_MAXTEMP - 15);
   #endif
 
   //
   // Bed:
   //
   #if HAS_HEATED_BED
-    MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_BED, &thermalManager.temp_bed.target, 0, BED_MAXTEMP - 10, thermalManager.start_watching_bed);
+    EDIT_ITEM_FAST(int3, MSG_BED, &thermalManager.temp_bed.target, 0, BED_MAXTEMP - 10, thermalManager.start_watching_bed);
   #endif
 
   //
   // Chamber:
   //
   #if HAS_HEATED_CHAMBER
-    MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_CHAMBER, &thermalManager.temp_chamber.target, 0, CHAMBER_MAXTEMP - 5, thermalManager.start_watching_chamber);
+    EDIT_ITEM_FAST(int3, MSG_CHAMBER, &thermalManager.temp_chamber.target, 0, CHAMBER_MAXTEMP - 5, thermalManager.start_watching_chamber);
   #endif
 
   //
@@ -360,21 +360,21 @@ void menu_temperature() {
   //
   #if FAN_COUNT > 0
     #if HAS_FAN0
-      MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(percent, MSG_FAN_SPEED FAN_SPEED_1_SUFFIX, &thermalManager.lcd_tmpfan_speed[0], 0, 255, thermalManager.lcd_setFanSpeed0);
+      EDIT_ITEM_FAST(percent, MSG_FAN_SPEED FAN_SPEED_1_SUFFIX, &thermalManager.lcd_tmpfan_speed[0], 0, 255, thermalManager.lcd_setFanSpeed0);
       #if ENABLED(EXTRA_FAN_SPEED)
-        MENU_MULTIPLIER_ITEM_EDIT(percent, MSG_EXTRA_FAN_SPEED FAN_SPEED_1_SUFFIX, &thermalManager.new_fan_speed[0], 3, 255);
+        EDIT_ITEM_FAST(percent, MSG_EXTRA_FAN_SPEED FAN_SPEED_1_SUFFIX, &thermalManager.new_fan_speed[0], 3, 255);
       #endif
     #endif
     #if HAS_FAN1 || (ENABLED(SINGLENOZZLE) && EXTRUDERS > 1)
-      MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(percent, MSG_FAN_SPEED " 2", &thermalManager.lcd_tmpfan_speed[1], 0, 255, thermalManager.lcd_setFanSpeed1);
+      EDIT_ITEM_FAST(percent, MSG_FAN_SPEED " 2", &thermalManager.lcd_tmpfan_speed[1], 0, 255, thermalManager.lcd_setFanSpeed1);
       #if ENABLED(EXTRA_FAN_SPEED)
-        MENU_MULTIPLIER_ITEM_EDIT(percent, MSG_EXTRA_FAN_SPEED " 2", &thermalManager.new_fan_speed[1], 3, 255);
+        EDIT_ITEM_FAST(percent, MSG_EXTRA_FAN_SPEED " 2", &thermalManager.new_fan_speed[1], 3, 255);
       #endif
     #endif
     #if HAS_FAN2 || (ENABLED(SINGLENOZZLE) && EXTRUDERS > 2)
-      MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(percent, MSG_FAN_SPEED " 3", &thermalManager.lcd_tmpfan_speed[2], 0, 255, thermalManager.lcd_setFanSpeed2);
+      EDIT_ITEM_FAST(percent, MSG_FAN_SPEED " 3", &thermalManager.lcd_tmpfan_speed[2], 0, 255, thermalManager.lcd_setFanSpeed2);
       #if ENABLED(EXTRA_FAN_SPEED)
-        MENU_MULTIPLIER_ITEM_EDIT(percent, MSG_EXTRA_FAN_SPEED " 3", &thermalManager.new_fan_speed[2], 3, 255);
+        EDIT_ITEM_FAST(percent, MSG_EXTRA_FAN_SPEED " 3", &thermalManager.new_fan_speed[2], 3, 255);
       #endif
     #endif
   #endif // FAN_COUNT > 0
@@ -385,11 +385,11 @@ void menu_temperature() {
     // Preheat for Material 1 and 2
     //
     #if TEMP_SENSOR_1 != 0 || TEMP_SENSOR_2 != 0 || TEMP_SENSOR_3 != 0 || TEMP_SENSOR_4 != 0 || TEMP_SENSOR_5 != 0 || HAS_HEATED_BED
-      MENU_ITEM(submenu, MSG_PREHEAT_1, menu_preheat_m1);
-      MENU_ITEM(submenu, MSG_PREHEAT_2, menu_preheat_m2);
+      SUBMENU(MSG_PREHEAT_1, menu_preheat_m1);
+      SUBMENU(MSG_PREHEAT_2, menu_preheat_m2);
     #else
-      MENU_ITEM(function, MSG_PREHEAT_1, lcd_preheat_m1_e0_only);
-      MENU_ITEM(function, MSG_PREHEAT_2, lcd_preheat_m2_e0_only);
+      ACTION_ITEM(MSG_PREHEAT_1, lcd_preheat_m1_e0_only);
+      ACTION_ITEM(MSG_PREHEAT_2, lcd_preheat_m2_e0_only);
     #endif
 
     //
@@ -400,7 +400,7 @@ void menu_temperature() {
     #if HAS_TEMP_BED
       if (thermalManager.temp_bed.target) has_heat = true;
     #endif
-    if (has_heat) MENU_ITEM(function, MSG_COOLDOWN, lcd_cooldown);
+    if (has_heat) ACTION_ITEM(MSG_COOLDOWN, lcd_cooldown);
 
   #endif // HAS_TEMP_HOTEND
 

Marlin/src/lcd/menu/menu_tmc.cpp

@@ -32,7 +32,7 @@
 #include "../../module/stepper/indirection.h"
 #include "../../feature/tmc_util.h"
 
-#define TMC_EDIT_STORED_I_RMS(ST,MSG) MENU_ITEM_EDIT_CALLBACK(uint16_4, MSG, &stepper##ST.val_mA, 100, 3000, refresh_stepper_current_##ST)
+#define TMC_EDIT_STORED_I_RMS(ST,MSG) EDIT_ITEM(uint16_4, MSG, &stepper##ST.val_mA, 100, 3000, refresh_stepper_current_##ST)
 
 #if AXIS_IS_TMC(X)
   void refresh_stepper_current_X()  { stepperX.refresh_stepper_current();  }
@@ -76,7 +76,7 @@
 
 void menu_tmc_current() {
   START_MENU();
-  MENU_BACK(MSG_TMC_DRIVERS);
+  BACK_ITEM(MSG_TMC_DRIVERS);
   #if AXIS_IS_TMC(X)
     TMC_EDIT_STORED_I_RMS(X, MSG_X);
   #endif
@@ -121,7 +121,7 @@ void menu_tmc_current() {
 
 #if ENABLED(HYBRID_THRESHOLD)
 
-  #define TMC_EDIT_STORED_HYBRID_THRS(ST, MSG) MENU_ITEM_EDIT_CALLBACK(uint8, MSG, &stepper##ST.stored.hybrid_thrs, 0, 255, refresh_hybrid_thrs_##ST);
+  #define TMC_EDIT_STORED_HYBRID_THRS(ST, MSG) EDIT_ITEM(uint8, MSG, &stepper##ST.stored.hybrid_thrs, 0, 255, refresh_hybrid_thrs_##ST);
 
   #if AXIS_HAS_STEALTHCHOP(X)
     void refresh_hybrid_thrs_X()  {  stepperX.refresh_hybrid_thrs(); }
@@ -165,7 +165,7 @@ void menu_tmc_current() {
 
   void menu_tmc_hybrid_thrs() {
     START_MENU();
-    MENU_BACK(MSG_TMC_DRIVERS);
+    BACK_ITEM(MSG_TMC_DRIVERS);
     #if AXIS_HAS_STEALTHCHOP(X)
       TMC_EDIT_STORED_HYBRID_THRS(X, MSG_X);
     #endif
@@ -212,7 +212,7 @@ void menu_tmc_current() {
 
 #if ENABLED(SENSORLESS_HOMING)
 
-  #define TMC_EDIT_STORED_SGT(ST) MENU_ITEM_EDIT_CALLBACK(int4, MSG_##ST, &stepper##ST.stored.homing_thrs, stepper##ST.sgt_min, stepper##ST.sgt_max, refresh_homing_thrs_##ST);
+  #define TMC_EDIT_STORED_SGT(ST) EDIT_ITEM(int4, MSG_##ST, &stepper##ST.stored.homing_thrs, stepper##ST.sgt_min, stepper##ST.sgt_max, refresh_homing_thrs_##ST);
 
   #if X_SENSORLESS
     void refresh_homing_thrs_X()  { stepperX.refresh_homing_thrs();  }
@@ -229,7 +229,7 @@ void menu_tmc_current() {
 
   void menu_tmc_homing_thrs() {
     START_MENU();
-    MENU_BACK(MSG_TMC_DRIVERS);
+    BACK_ITEM(MSG_TMC_DRIVERS);
     #if X_SENSORLESS
       TMC_EDIT_STORED_SGT(X);
     #endif
@@ -249,7 +249,7 @@ void menu_tmc_current() {
 
 #if HAS_STEALTHCHOP
 
-  #define TMC_EDIT_STEP_MODE(ST, MSG) MENU_ITEM_EDIT_CALLBACK(bool, MSG, &stepper##ST.stored.stealthChop_enabled, refresh_stepping_mode_##ST)
+  #define TMC_EDIT_STEP_MODE(ST, MSG) EDIT_ITEM(bool, MSG, &stepper##ST.stored.stealthChop_enabled, refresh_stepping_mode_##ST)
 
   #if AXIS_HAS_STEALTHCHOP(X)
     void refresh_stepping_mode_X()  { stepperX.refresh_stepping_mode();  }
@@ -294,7 +294,7 @@ void menu_tmc_current() {
   void menu_tmc_step_mode() {
     START_MENU();
     STATIC_ITEM(MSG_TMC_STEALTH_ENABLED);
-    MENU_BACK(MSG_TMC_DRIVERS);
+    BACK_ITEM(MSG_TMC_DRIVERS);
     #if AXIS_HAS_STEALTHCHOP(X)
       TMC_EDIT_STEP_MODE(X, MSG_X);
     #endif
@@ -341,16 +341,16 @@ void menu_tmc_current() {
 
 void menu_tmc() {
   START_MENU();
-  MENU_BACK(MSG_CONTROL);
-  MENU_ITEM(submenu, MSG_TMC_CURRENT, menu_tmc_current);
+  BACK_ITEM(MSG_CONTROL);
+  SUBMENU(MSG_TMC_CURRENT, menu_tmc_current);
   #if ENABLED(HYBRID_THRESHOLD)
-    MENU_ITEM(submenu, MSG_TMC_HYBRID_THRS, menu_tmc_hybrid_thrs);
+    SUBMENU(MSG_TMC_HYBRID_THRS, menu_tmc_hybrid_thrs);
   #endif
   #if ENABLED(SENSORLESS_HOMING)
-    MENU_ITEM(submenu, MSG_TMC_HOMING_THRS, menu_tmc_homing_thrs);
+    SUBMENU(MSG_TMC_HOMING_THRS, menu_tmc_homing_thrs);
   #endif
   #if HAS_STEALTHCHOP
-    MENU_ITEM(submenu, MSG_TMC_STEPPING_MODE, menu_tmc_step_mode);
+    SUBMENU(MSG_TMC_STEPPING_MODE, menu_tmc_step_mode);
   #endif
   END_MENU();
 }

Marlin/src/lcd/menu/menu_tune.cpp

@@ -124,18 +124,18 @@
 
 void menu_tune() {
   START_MENU();
-  MENU_BACK(MSG_MAIN);
+  BACK_ITEM(MSG_MAIN);
 
   //
   // Speed:
   //
-  MENU_ITEM_EDIT(int3, MSG_SPEED, &feedrate_percentage, 10, 999);
+  EDIT_ITEM(int3, MSG_SPEED, &feedrate_percentage, 10, 999);
 
   //
   // Manual bed leveling, Bed Z:
   //
   #if BOTH(MESH_BED_LEVELING, LCD_BED_LEVELING)
-    MENU_ITEM_EDIT(float43, MSG_BED_Z, &mbl.z_offset, -1, 1);
+    EDIT_ITEM(float43, MSG_BED_Z, &mbl.z_offset, -1, 1);
   #endif
 
   //
@@ -143,9 +143,9 @@ void menu_tune() {
   // Nozzle [1-4]:
   //
   #if HOTENDS == 1
-    MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE, &thermalManager.temp_hotend[0].target, 0, HEATER_0_MAXTEMP - 15, thermalManager.start_watching_E0);
+    EDIT_ITEM_FAST(int3, MSG_NOZZLE, &thermalManager.temp_hotend[0].target, 0, HEATER_0_MAXTEMP - 15, thermalManager.start_watching_E0);
   #elif HOTENDS > 1
-    #define EDIT_NOZZLE(N) MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE MSG_LCD_N##N, &thermalManager.temp_hotend[N].target, 0, HEATER_##N##_MAXTEMP - 15, thermalManager.start_watching_E##N)
+    #define EDIT_NOZZLE(N) EDIT_ITEM_FAST(int3, MSG_NOZZLE MSG_LCD_N##N, &thermalManager.temp_hotend[N].target, 0, HEATER_##N##_MAXTEMP - 15, thermalManager.start_watching_E##N)
     EDIT_NOZZLE(0);
     EDIT_NOZZLE(1);
     #if HOTENDS > 2
@@ -163,14 +163,14 @@ void menu_tune() {
   #endif // HOTENDS > 1
 
   #if ENABLED(SINGLENOZZLE)
-    MENU_MULTIPLIER_ITEM_EDIT(uint16_3, MSG_NOZZLE_STANDBY, &singlenozzle_temp[active_extruder ? 0 : 1], 0, HEATER_0_MAXTEMP - 15);
+    EDIT_ITEM_FAST(uint16_3, MSG_NOZZLE_STANDBY, &singlenozzle_temp[active_extruder ? 0 : 1], 0, HEATER_0_MAXTEMP - 15);
   #endif
 
   //
   // Bed:
   //
   #if HAS_HEATED_BED
-    MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_BED, &thermalManager.temp_bed.target, 0, BED_MAXTEMP - 10, thermalManager.start_watching_bed);
+    EDIT_ITEM_FAST(int3, MSG_BED, &thermalManager.temp_bed.target, 0, BED_MAXTEMP - 10, thermalManager.start_watching_bed);
   #endif
 
   //
@@ -178,21 +178,21 @@ void menu_tune() {
   //
   #if FAN_COUNT > 0
     #if HAS_FAN0
-      MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(uint8, MSG_FAN_SPEED FAN_SPEED_1_SUFFIX, &thermalManager.lcd_tmpfan_speed[0], 0, 255, thermalManager.lcd_setFanSpeed0);
+      EDIT_ITEM_FAST(uint8, MSG_FAN_SPEED FAN_SPEED_1_SUFFIX, &thermalManager.lcd_tmpfan_speed[0], 0, 255, thermalManager.lcd_setFanSpeed0);
       #if ENABLED(EXTRA_FAN_SPEED)
-        MENU_MULTIPLIER_ITEM_EDIT(uint8, MSG_EXTRA_FAN_SPEED FAN_SPEED_1_SUFFIX, &thermalManager.new_fan_speed[0], 3, 255);
+        EDIT_ITEM_FAST(uint8, MSG_EXTRA_FAN_SPEED FAN_SPEED_1_SUFFIX, &thermalManager.new_fan_speed[0], 3, 255);
       #endif
     #endif
     #if HAS_FAN1 || (ENABLED(SINGLENOZZLE) && EXTRUDERS > 1)
-      MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(uint8, MSG_FAN_SPEED " 2", &thermalManager.lcd_tmpfan_speed[1], 0, 255, thermalManager.lcd_setFanSpeed1);
+      EDIT_ITEM_FAST(uint8, MSG_FAN_SPEED " 2", &thermalManager.lcd_tmpfan_speed[1], 0, 255, thermalManager.lcd_setFanSpeed1);
       #if ENABLED(EXTRA_FAN_SPEED)
-        MENU_MULTIPLIER_ITEM_EDIT(uint8, MSG_EXTRA_FAN_SPEED " 2", &thermalManager.new_fan_speed[1], 3, 255);
+        EDIT_ITEM_FAST(uint8, MSG_EXTRA_FAN_SPEED " 2", &thermalManager.new_fan_speed[1], 3, 255);
       #endif
     #endif
     #if HAS_FAN2 || (ENABLED(SINGLENOZZLE) && EXTRUDERS > 2)
-      MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(uint8, MSG_FAN_SPEED " 3", &thermalManager.lcd_tmpfan_speed[2], 0, 255, thermalManager.lcd_setFanSpeed2);
+      EDIT_ITEM_FAST(uint8, MSG_FAN_SPEED " 3", &thermalManager.lcd_tmpfan_speed[2], 0, 255, thermalManager.lcd_setFanSpeed2);
       #if ENABLED(EXTRA_FAN_SPEED)
-        MENU_MULTIPLIER_ITEM_EDIT(uint8, MSG_EXTRA_FAN_SPEED " 3", &thermalManager.new_fan_speed[2], 3, 255);
+        EDIT_ITEM_FAST(uint8, MSG_EXTRA_FAN_SPEED " 3", &thermalManager.new_fan_speed[2], 3, 255);
       #endif
     #endif
   #endif // FAN_COUNT > 0
@@ -202,10 +202,10 @@ void menu_tune() {
   // Flow [1-5]:
   //
   #if EXTRUDERS == 1
-    MENU_ITEM_EDIT_CALLBACK(int3, MSG_FLOW, &planner.flow_percentage[0], 10, 999, _lcd_refresh_e_factor_0);
+    EDIT_ITEM(int3, MSG_FLOW, &planner.flow_percentage[0], 10, 999, _lcd_refresh_e_factor_0);
   #elif EXTRUDERS
-    MENU_ITEM_EDIT_CALLBACK(int3, MSG_FLOW, &planner.flow_percentage[active_extruder], 10, 999, _lcd_refresh_e_factor);
-    #define EDIT_FLOW(N) MENU_ITEM_EDIT_CALLBACK(int3, MSG_FLOW MSG_LCD_N##N, &planner.flow_percentage[N], 10, 999, _lcd_refresh_e_factor_##N)
+    EDIT_ITEM(int3, MSG_FLOW, &planner.flow_percentage[active_extruder], 10, 999, _lcd_refresh_e_factor);
+    #define EDIT_FLOW(N) EDIT_ITEM(int3, MSG_FLOW MSG_LCD_N##N, &planner.flow_percentage[N], 10, 999, _lcd_refresh_e_factor_##N)
     EDIT_FLOW(0);
     EDIT_FLOW(1);
     #if EXTRUDERS > 2
@@ -229,13 +229,13 @@ void menu_tune() {
   //
   #if ENABLED(BABYSTEPPING)
     #if ENABLED(BABYSTEP_XY)
-      MENU_ITEM(submenu, MSG_BABYSTEP_X, lcd_babystep_x);
-      MENU_ITEM(submenu, MSG_BABYSTEP_Y, lcd_babystep_y);
+      SUBMENU(MSG_BABYSTEP_X, lcd_babystep_x);
+      SUBMENU(MSG_BABYSTEP_Y, lcd_babystep_y);
     #endif
     #if ENABLED(BABYSTEP_ZPROBE_OFFSET)
-      MENU_ITEM(submenu, MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
+      SUBMENU(MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
     #else
-      MENU_ITEM(submenu, MSG_BABYSTEP_Z, lcd_babystep_z);
+      SUBMENU(MSG_BABYSTEP_Z, lcd_babystep_z);
     #endif
   #endif
 

Marlin/src/lcd/menu/menu_ubl.cpp

@@ -127,12 +127,12 @@ void _lcd_ubl_build_custom_mesh() {
  */
 void _lcd_ubl_custom_mesh() {
   START_MENU();
-  MENU_BACK(MSG_UBL_BUILD_MESH_MENU);
-  MENU_ITEM_EDIT(int3, MSG_UBL_HOTEND_TEMP_CUSTOM, &custom_hotend_temp, EXTRUDE_MINTEMP, (HEATER_0_MAXTEMP - 10));
+  BACK_ITEM(MSG_UBL_BUILD_MESH_MENU);
+  EDIT_ITEM(int3, MSG_UBL_HOTEND_TEMP_CUSTOM, &custom_hotend_temp, EXTRUDE_MINTEMP, (HEATER_0_MAXTEMP - 10));
   #if HAS_HEATED_BED
-    MENU_ITEM_EDIT(int3, MSG_UBL_BED_TEMP_CUSTOM, &custom_bed_temp, BED_MINTEMP, (BED_MAXTEMP - 10));
+    EDIT_ITEM(int3, MSG_UBL_BED_TEMP_CUSTOM, &custom_bed_temp, BED_MINTEMP, (BED_MAXTEMP - 10));
   #endif
-  MENU_ITEM(function, MSG_UBL_BUILD_CUSTOM_MESH, _lcd_ubl_build_custom_mesh);
+  ACTION_ITEM(MSG_UBL_BUILD_CUSTOM_MESH, _lcd_ubl_build_custom_mesh);
   END_MENU();
 }
 
@@ -157,9 +157,9 @@ void _lcd_ubl_adjust_height_cmd() {
  */
 void _menu_ubl_height_adjust() {
   START_MENU();
-  MENU_BACK(MSG_EDIT_MESH);
-  MENU_ITEM_EDIT_CALLBACK(int3, MSG_UBL_MESH_HEIGHT_AMOUNT, &ubl_height_amount, -9, 9, _lcd_ubl_adjust_height_cmd);
-  MENU_ITEM(function, MSG_WATCH, ui.return_to_status);
+  BACK_ITEM(MSG_EDIT_MESH);
+  EDIT_ITEM(int3, MSG_UBL_MESH_HEIGHT_AMOUNT, &ubl_height_amount, -9, 9, _lcd_ubl_adjust_height_cmd);
+  ACTION_ITEM(MSG_WATCH, ui.return_to_status);
   END_MENU();
 }
 
@@ -174,11 +174,11 @@ void _menu_ubl_height_adjust() {
  */
 void _lcd_ubl_edit_mesh() {
   START_MENU();
-  MENU_BACK(MSG_UBL_TOOLS);
-  MENU_ITEM(gcode, MSG_UBL_FINE_TUNE_ALL, PSTR("G29 P4 R999 T"));
-  MENU_ITEM(gcode, MSG_UBL_FINE_TUNE_CLOSEST, PSTR("G29 P4 T"));
-  MENU_ITEM(submenu, MSG_UBL_MESH_HEIGHT_ADJUST, _menu_ubl_height_adjust);
-  MENU_ITEM(function, MSG_WATCH, ui.return_to_status);
+  BACK_ITEM(MSG_UBL_TOOLS);
+  GCODES_ITEM(MSG_UBL_FINE_TUNE_ALL, PSTR("G29 P4 R999 T"));
+  GCODES_ITEM(MSG_UBL_FINE_TUNE_CLOSEST, PSTR("G29 P4 T"));
+  SUBMENU(MSG_UBL_MESH_HEIGHT_ADJUST, _menu_ubl_height_adjust);
+  ACTION_ITEM(MSG_WATCH, ui.return_to_status);
   END_MENU();
 }
 
@@ -210,16 +210,16 @@ void _lcd_ubl_validate_custom_mesh() {
  */
 void _lcd_ubl_validate_mesh() {
   START_MENU();
-  MENU_BACK(MSG_UBL_TOOLS);
+  BACK_ITEM(MSG_UBL_TOOLS);
   #if HAS_HEATED_BED
-    MENU_ITEM(gcode, MSG_UBL_VALIDATE_MESH_M1, PSTR("G28\nG26 C B" STRINGIFY(PREHEAT_1_TEMP_BED) " H" STRINGIFY(PREHEAT_1_TEMP_HOTEND) " P"));
-    MENU_ITEM(gcode, MSG_UBL_VALIDATE_MESH_M2, PSTR("G28\nG26 C B" STRINGIFY(PREHEAT_2_TEMP_BED) " H" STRINGIFY(PREHEAT_2_TEMP_HOTEND) " P"));
+    GCODES_ITEM(MSG_UBL_VALIDATE_MESH_M1, PSTR("G28\nG26 C B" STRINGIFY(PREHEAT_1_TEMP_BED) " H" STRINGIFY(PREHEAT_1_TEMP_HOTEND) " P"));
+    GCODES_ITEM(MSG_UBL_VALIDATE_MESH_M2, PSTR("G28\nG26 C B" STRINGIFY(PREHEAT_2_TEMP_BED) " H" STRINGIFY(PREHEAT_2_TEMP_HOTEND) " P"));
   #else
-    MENU_ITEM(gcode, MSG_UBL_VALIDATE_MESH_M1, PSTR("G28\nG26 C B0 H" STRINGIFY(PREHEAT_1_TEMP_HOTEND) " P"));
-    MENU_ITEM(gcode, MSG_UBL_VALIDATE_MESH_M2, PSTR("G28\nG26 C B0 H" STRINGIFY(PREHEAT_2_TEMP_HOTEND) " P"));
+    GCODES_ITEM(MSG_UBL_VALIDATE_MESH_M1, PSTR("G28\nG26 C B0 H" STRINGIFY(PREHEAT_1_TEMP_HOTEND) " P"));
+    GCODES_ITEM(MSG_UBL_VALIDATE_MESH_M2, PSTR("G28\nG26 C B0 H" STRINGIFY(PREHEAT_2_TEMP_HOTEND) " P"));
   #endif
-  MENU_ITEM(function, MSG_UBL_VALIDATE_CUSTOM_MESH, _lcd_ubl_validate_custom_mesh);
-  MENU_ITEM(function, MSG_WATCH, ui.return_to_status);
+  ACTION_ITEM(MSG_UBL_VALIDATE_CUSTOM_MESH, _lcd_ubl_validate_custom_mesh);
+  ACTION_ITEM(MSG_WATCH, ui.return_to_status);
   END_MENU();
 }
 
@@ -241,9 +241,9 @@ void _lcd_ubl_grid_level_cmd() {
  */
 void _lcd_ubl_grid_level() {
   START_MENU();
-  MENU_BACK(MSG_UBL_TOOLS);
-  MENU_ITEM_EDIT(int3, MSG_UBL_SIDE_POINTS, &side_points, 2, 6);
-  MENU_ITEM(function, MSG_UBL_MESH_LEVEL, _lcd_ubl_grid_level_cmd);
+  BACK_ITEM(MSG_UBL_TOOLS);
+  EDIT_ITEM(int3, MSG_UBL_SIDE_POINTS, &side_points, 2, 6);
+  ACTION_ITEM(MSG_UBL_MESH_LEVEL, _lcd_ubl_grid_level_cmd);
   END_MENU();
 }
 
@@ -257,10 +257,10 @@ void _lcd_ubl_grid_level() {
  */
 void _lcd_ubl_mesh_leveling() {
   START_MENU();
-  MENU_BACK(MSG_UBL_TOOLS);
-  MENU_ITEM(gcode, MSG_UBL_3POINT_MESH_LEVELING, PSTR("G29 J0"));
-  MENU_ITEM(submenu, MSG_UBL_GRID_MESH_LEVELING, _lcd_ubl_grid_level);
-  MENU_ITEM(function, MSG_WATCH, ui.return_to_status);
+  BACK_ITEM(MSG_UBL_TOOLS);
+  GCODES_ITEM(MSG_UBL_3POINT_MESH_LEVELING, PSTR("G29 J0"));
+  SUBMENU(MSG_UBL_GRID_MESH_LEVELING, _lcd_ubl_grid_level);
+  ACTION_ITEM(MSG_WATCH, ui.return_to_status);
   END_MENU();
 }
 
@@ -285,11 +285,11 @@ void _lcd_ubl_fillin_amount_cmd() {
  */
 void _menu_ubl_fillin() {
   START_MENU();
-  MENU_BACK(MSG_UBL_BUILD_MESH_MENU);
-  MENU_ITEM_EDIT_CALLBACK(int3, MSG_UBL_FILLIN_AMOUNT, &ubl_fillin_amount, 0, 9, _lcd_ubl_fillin_amount_cmd);
-  MENU_ITEM(gcode, MSG_UBL_SMART_FILLIN, PSTR("G29 P3 T0"));
-  MENU_ITEM(gcode, MSG_UBL_MANUAL_FILLIN, PSTR("G29 P2 B T0"));
-  MENU_ITEM(function, MSG_WATCH, ui.return_to_status);
+  BACK_ITEM(MSG_UBL_BUILD_MESH_MENU);
+  EDIT_ITEM(int3, MSG_UBL_FILLIN_AMOUNT, &ubl_fillin_amount, 0, 9, _lcd_ubl_fillin_amount_cmd);
+  GCODES_ITEM(MSG_UBL_SMART_FILLIN, PSTR("G29 P3 T0"));
+  GCODES_ITEM(MSG_UBL_MANUAL_FILLIN, PSTR("G29 P2 B T0"));
+  ACTION_ITEM(MSG_WATCH, ui.return_to_status);
   END_MENU();
 }
 
@@ -314,9 +314,9 @@ void _lcd_ubl_invalidate() {
  */
 void _lcd_ubl_build_mesh() {
   START_MENU();
-  MENU_BACK(MSG_UBL_TOOLS);
+  BACK_ITEM(MSG_UBL_TOOLS);
   #if HAS_HEATED_BED
-    MENU_ITEM(gcode, MSG_UBL_BUILD_MESH_M1, PSTR(
+    GCODES_ITEM(MSG_UBL_BUILD_MESH_M1, PSTR(
       "G28\n"
       "M190 S" STRINGIFY(PREHEAT_1_TEMP_BED) "\n"
       "M109 S" STRINGIFY(PREHEAT_1_TEMP_HOTEND) "\n"
@@ -324,7 +324,7 @@ void _lcd_ubl_build_mesh() {
       "M104 S0\n"
       "M140 S0"
     ));
-    MENU_ITEM(gcode, MSG_UBL_BUILD_MESH_M2, PSTR(
+    GCODES_ITEM(MSG_UBL_BUILD_MESH_M2, PSTR(
       "G28\n"
       "M190 S" STRINGIFY(PREHEAT_2_TEMP_BED) "\n"
       "M109 S" STRINGIFY(PREHEAT_2_TEMP_HOTEND) "\n"
@@ -333,26 +333,26 @@ void _lcd_ubl_build_mesh() {
       "M140 S0"
     ));
   #else
-    MENU_ITEM(gcode, MSG_UBL_BUILD_MESH_M1, PSTR(
+    GCODES_ITEM(MSG_UBL_BUILD_MESH_M1, PSTR(
       "G28\n"
       "M109 S" STRINGIFY(PREHEAT_1_TEMP_HOTEND) "\n"
       "G29 P1\n"
       "M104 S0"
     ));
-    MENU_ITEM(gcode, MSG_UBL_BUILD_MESH_M2, PSTR(
+    GCODES_ITEM(MSG_UBL_BUILD_MESH_M2, PSTR(
       "G28\n"
       "M109 S" STRINGIFY(PREHEAT_2_TEMP_HOTEND) "\n"
       "G29 P1\n"
       "M104 S0"
     ));
   #endif
-  MENU_ITEM(submenu, MSG_UBL_BUILD_CUSTOM_MESH, _lcd_ubl_custom_mesh);
-  MENU_ITEM(gcode, MSG_UBL_BUILD_COLD_MESH, PSTR("G28\nG29 P1"));
-  MENU_ITEM(submenu, MSG_UBL_FILLIN_MESH, _menu_ubl_fillin);
-  MENU_ITEM(gcode, MSG_UBL_CONTINUE_MESH, PSTR("G29 P1 C"));
-  MENU_ITEM(function, MSG_UBL_INVALIDATE_ALL, _lcd_ubl_invalidate);
-  MENU_ITEM(gcode, MSG_UBL_INVALIDATE_CLOSEST, PSTR("G29 I"));
-  MENU_ITEM(function, MSG_WATCH, ui.return_to_status);
+  SUBMENU(MSG_UBL_BUILD_CUSTOM_MESH, _lcd_ubl_custom_mesh);
+  GCODES_ITEM(MSG_UBL_BUILD_COLD_MESH, PSTR("G28\nG29 P1"));
+  SUBMENU(MSG_UBL_FILLIN_MESH, _menu_ubl_fillin);
+  GCODES_ITEM(MSG_UBL_CONTINUE_MESH, PSTR("G29 P1 C"));
+  ACTION_ITEM(MSG_UBL_INVALIDATE_ALL, _lcd_ubl_invalidate);
+  GCODES_ITEM(MSG_UBL_INVALIDATE_CLOSEST, PSTR("G29 I"));
+  ACTION_ITEM(MSG_WATCH, ui.return_to_status);
   END_MENU();
 }
 
@@ -389,14 +389,14 @@ void _lcd_ubl_save_mesh_cmd() {
 void _lcd_ubl_storage_mesh() {
   int16_t a = settings.calc_num_meshes();
   START_MENU();
-  MENU_BACK(MSG_UBL_LEVEL_BED);
+  BACK_ITEM(MSG_UBL_LEVEL_BED);
   if (!WITHIN(ubl_storage_slot, 0, a - 1)) {
     STATIC_ITEM(MSG_UBL_NO_STORAGE);
   }
   else {
-    MENU_ITEM_EDIT(int3, MSG_UBL_STORAGE_SLOT, &ubl_storage_slot, 0, a - 1);
-    MENU_ITEM(function, MSG_UBL_LOAD_MESH, _lcd_ubl_load_mesh_cmd);
-    MENU_ITEM(function, MSG_UBL_SAVE_MESH, _lcd_ubl_save_mesh_cmd);
+    EDIT_ITEM(int3, MSG_UBL_STORAGE_SLOT, &ubl_storage_slot, 0, a - 1);
+    ACTION_ITEM(MSG_UBL_LOAD_MESH, _lcd_ubl_load_mesh_cmd);
+    ACTION_ITEM(MSG_UBL_SAVE_MESH, _lcd_ubl_save_mesh_cmd);
   }
   END_MENU();
 }
@@ -540,11 +540,11 @@ void _lcd_ubl_output_map_lcd_cmd() {
  */
 void _lcd_ubl_output_map() {
   START_MENU();
-  MENU_BACK(MSG_UBL_LEVEL_BED);
-  MENU_ITEM(gcode, MSG_UBL_OUTPUT_MAP_HOST, PSTR("G29 T0"));
-  MENU_ITEM(gcode, MSG_UBL_OUTPUT_MAP_CSV, PSTR("G29 T1"));
-  MENU_ITEM(gcode, MSG_UBL_OUTPUT_MAP_BACKUP, PSTR("G29 S-1"));
-  MENU_ITEM(function, MSG_UBL_OUTPUT_MAP, _lcd_ubl_output_map_lcd_cmd);
+  BACK_ITEM(MSG_UBL_LEVEL_BED);
+  GCODES_ITEM(MSG_UBL_OUTPUT_MAP_HOST, PSTR("G29 T0"));
+  GCODES_ITEM(MSG_UBL_OUTPUT_MAP_CSV, PSTR("G29 T1"));
+  GCODES_ITEM(MSG_UBL_OUTPUT_MAP_BACKUP, PSTR("G29 S-1"));
+  ACTION_ITEM(MSG_UBL_OUTPUT_MAP, _lcd_ubl_output_map_lcd_cmd);
   END_MENU();
 }
 
@@ -559,12 +559,12 @@ void _lcd_ubl_output_map() {
  */
 void _menu_ubl_tools() {
   START_MENU();
-  MENU_BACK(MSG_UBL_LEVEL_BED);
-  MENU_ITEM(submenu, MSG_UBL_BUILD_MESH_MENU, _lcd_ubl_build_mesh);
-  MENU_ITEM(gcode, MSG_UBL_MANUAL_MESH, PSTR("G29 I999\nG29 P2 B T0"));
-  MENU_ITEM(submenu, MSG_UBL_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
-  MENU_ITEM(submenu, MSG_EDIT_MESH, _lcd_ubl_edit_mesh);
-  MENU_ITEM(submenu, MSG_UBL_MESH_LEVELING, _lcd_ubl_mesh_leveling);
+  BACK_ITEM(MSG_UBL_LEVEL_BED);
+  SUBMENU(MSG_UBL_BUILD_MESH_MENU, _lcd_ubl_build_mesh);
+  GCODES_ITEM(MSG_UBL_MANUAL_MESH, PSTR("G29 I999\nG29 P2 B T0"));
+  SUBMENU(MSG_UBL_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
+  SUBMENU(MSG_EDIT_MESH, _lcd_ubl_edit_mesh);
+  SUBMENU(MSG_UBL_MESH_LEVELING, _lcd_ubl_mesh_leveling);
   END_MENU();
 }
 
@@ -582,14 +582,14 @@ void _menu_ubl_tools() {
  */
 void _lcd_ubl_step_by_step() {
   START_MENU();
-  MENU_BACK(MSG_UBL_LEVEL_BED);
-  MENU_ITEM(gcode, "1 " MSG_UBL_BUILD_COLD_MESH, PSTR("G28\nG29 P1"));
-  MENU_ITEM(gcode, "2 " MSG_UBL_SMART_FILLIN, PSTR("G29 P3 T0"));
-  MENU_ITEM(submenu, "3 " MSG_UBL_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
-  MENU_ITEM(gcode, "4 " MSG_UBL_FINE_TUNE_ALL, PSTR("G29 P4 R999 T"));
-  MENU_ITEM(submenu, "5 " MSG_UBL_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
-  MENU_ITEM(gcode, "6 " MSG_UBL_FINE_TUNE_ALL, PSTR("G29 P4 R999 T"));
-  MENU_ITEM(function, "7 " MSG_UBL_SAVE_MESH, _lcd_ubl_save_mesh_cmd);
+  BACK_ITEM(MSG_UBL_LEVEL_BED);
+  GCODES_ITEM("1 " MSG_UBL_BUILD_COLD_MESH, PSTR("G28\nG29 P1"));
+  GCODES_ITEM("2 " MSG_UBL_SMART_FILLIN, PSTR("G29 P3 T0"));
+  SUBMENU("3 " MSG_UBL_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
+  GCODES_ITEM("4 " MSG_UBL_FINE_TUNE_ALL, PSTR("G29 P4 R999 T"));
+  SUBMENU("5 " MSG_UBL_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
+  GCODES_ITEM("6 " MSG_UBL_FINE_TUNE_ALL, PSTR("G29 P4 R999 T"));
+  ACTION_ITEM("7 " MSG_UBL_SAVE_MESH, _lcd_ubl_save_mesh_cmd);
   END_MENU();
 }
 
@@ -609,19 +609,19 @@ void _lcd_ubl_step_by_step() {
 
 void _lcd_ubl_level_bed() {
   START_MENU();
-  MENU_BACK(MSG_MOTION);
+  BACK_ITEM(MSG_MOTION);
   if (planner.leveling_active)
-    MENU_ITEM(gcode, MSG_UBL_DEACTIVATE_MESH, PSTR("G29 D"));
+    GCODES_ITEM(MSG_UBL_DEACTIVATE_MESH, PSTR("G29 D"));
   else
-    MENU_ITEM(gcode, MSG_UBL_ACTIVATE_MESH, PSTR("G29 A"));
-  MENU_ITEM(submenu, MSG_UBL_STEP_BY_STEP_MENU, _lcd_ubl_step_by_step);
-  MENU_ITEM(function, MSG_UBL_MESH_EDIT, _lcd_ubl_output_map_lcd_cmd);
-  MENU_ITEM(submenu, MSG_UBL_STORAGE_MESH_MENU, _lcd_ubl_storage_mesh);
-  MENU_ITEM(submenu, MSG_UBL_OUTPUT_MAP, _lcd_ubl_output_map);
-  MENU_ITEM(submenu, MSG_UBL_TOOLS, _menu_ubl_tools);
-  MENU_ITEM(gcode, MSG_UBL_INFO_UBL, PSTR("G29 W"));
+    GCODES_ITEM(MSG_UBL_ACTIVATE_MESH, PSTR("G29 A"));
+  SUBMENU(MSG_UBL_STEP_BY_STEP_MENU, _lcd_ubl_step_by_step);
+  ACTION_ITEM(MSG_UBL_MESH_EDIT, _lcd_ubl_output_map_lcd_cmd);
+  SUBMENU(MSG_UBL_STORAGE_MESH_MENU, _lcd_ubl_storage_mesh);
+  SUBMENU(MSG_UBL_OUTPUT_MAP, _lcd_ubl_output_map);
+  SUBMENU(MSG_UBL_TOOLS, _menu_ubl_tools);
+  GCODES_ITEM(MSG_UBL_INFO_UBL, PSTR("G29 W"));
   #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
-    MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float3, MSG_Z_FADE_HEIGHT, &lcd_z_fade_height, 0, 100, _lcd_set_z_fade_height);
+    EDIT_ITEM_FAST(float3, MSG_Z_FADE_HEIGHT, &lcd_z_fade_height, 0, 100, _lcd_set_z_fade_height);
   #endif
   END_MENU();
 }