Merge pull request #4011 from thinkyhead/rc_manual_move_cond

Wrap all items depending on ULTIPANEL
9 years ago · d50ba08246
parent ddbb05fd8d ae9b09fe94
commit d50ba08246
2 changed files with 1495 additions and 1481 deletions
--- a/Marlin/ultralcd.cpp
+++ b/Marlin/ultralcd.cpp
@ -29,33 +29,6 @@
 #include "stepper.h"
 #include "configuration_store.h"

-/**
- * REVERSE_MENU_DIRECTION
- *
- * To reverse the menu direction we need a general way to reverse
- * the direction of the encoder everywhere. So encoderDirection is
- * added to allow the encoder to go the other way.
- *
- * This behavior is limited to scrolling Menus and SD card listings,
- * and is disabled in other contexts.
- */
-#if ENABLED(REVERSE_MENU_DIRECTION)
-  int8_t encoderDirection = 1;
-  #define ENCODER_DIRECTION_NORMAL() (encoderDirection = 1)
-  #define ENCODER_DIRECTION_MENUS() (encoderDirection = -1)
-#else
-  #define ENCODER_DIRECTION_NORMAL() ;
-  #define ENCODER_DIRECTION_MENUS() ;
-#endif
-
-int8_t encoderDiff; // updated from interrupt context and added to encoderPosition every LCD update
-
-int8_t manual_move_axis = (int8_t)NO_AXIS;
-millis_t manual_move_start_time = 0;
-
-bool encoderRateMultiplierEnabled;
-int32_t lastEncoderMovementMillis;
-
 int plaPreheatHotendTemp;
 int plaPreheatHPBTemp;
 int plaPreheatFanSpeed;
@ -68,9 +41,6 @@ int absPreheatFanSpeed;
  millis_t previous_lcd_status_ms = 0;
 #endif

-// Function pointer to menu functions.
-typedef void (*menuFunc_t)();
-
 uint8_t lcd_status_message_level;
 char lcd_status_message[3 * (LCD_WIDTH) + 1] = WELCOME_MSG; // worst case is kana with up to 3*LCD_WIDTH+1

@ -83,8 +53,50 @@ char lcd_status_message[3 * (LCD_WIDTH) + 1] = WELCOME_MSG; // worst case is kan
 // The main status screen
 static void lcd_status_screen();

+millis_t next_lcd_update_ms;
+
+enum LCDViewAction {
+  LCDVIEW_NONE,
+  LCDVIEW_REDRAW_NOW,
+  LCDVIEW_CALL_REDRAW_NEXT,
+  LCDVIEW_CLEAR_CALL_REDRAW,
+  LCDVIEW_CALL_NO_REDRAW
+};
+
+uint8_t lcdDrawUpdate = LCDVIEW_CLEAR_CALL_REDRAW; // Set when the LCD needs to draw, decrements after every draw. Set to 2 in LCD routines so the LCD gets at least 1 full redraw (first redraw is partial)
+
 #if ENABLED(ULTIPANEL)

+  // place-holders for Ki and Kd edits
+  float raw_Ki, raw_Kd;
+
+  /**
+   * REVERSE_MENU_DIRECTION
+   *
+   * To reverse the menu direction we need a general way to reverse
+   * the direction of the encoder everywhere. So encoderDirection is
+   * added to allow the encoder to go the other way.
+   *
+   * This behavior is limited to scrolling Menus and SD card listings,
+   * and is disabled in other contexts.
+   */
+  #if ENABLED(REVERSE_MENU_DIRECTION)
+    int8_t encoderDirection = 1;
+    #define ENCODER_DIRECTION_NORMAL() (encoderDirection = 1)
+    #define ENCODER_DIRECTION_MENUS() (encoderDirection = -1)
+  #else
+    #define ENCODER_DIRECTION_NORMAL() ;
+    #define ENCODER_DIRECTION_MENUS() ;
+  #endif
+
+  int8_t encoderDiff; // updated from interrupt context and added to encoderPosition every LCD update
+
+  int8_t manual_move_axis = (int8_t)NO_AXIS;
+  millis_t manual_move_start_time = 0;
+
+  bool encoderRateMultiplierEnabled;
+  int32_t lastEncoderMovementMillis;
+
  #if HAS_POWER_SWITCH
    extern bool powersupply;
  #endif
@ -116,11 +128,14 @@ static void lcd_status_screen();
    #include "mesh_bed_leveling.h"
  #endif

-  /* Different types of actions that can be used in menu items. */
+  // Function pointer to menu functions.
+  typedef void (*screenFunc_t)();
+
+  // Different types of actions that can be used in menu items.
  static void menu_action_back();
-  static void menu_action_submenu(menuFunc_t data);
+  static void menu_action_submenu(screenFunc_t data);
  static void menu_action_gcode(const char* pgcode);
-  static void menu_action_function(menuFunc_t data);
+  static void menu_action_function(screenFunc_t data);
  static void menu_action_setting_edit_bool(const char* pstr, bool* ptr);
  static void menu_action_setting_edit_int3(const char* pstr, int* ptr, int minValue, int maxValue);
  static void menu_action_setting_edit_float3(const char* pstr, float* ptr, float minValue, float maxValue);
@ -130,15 +145,15 @@ static void lcd_status_screen();
  static void menu_action_setting_edit_float51(const char* pstr, float* ptr, float minValue, float maxValue);
  static void menu_action_setting_edit_float52(const char* pstr, float* ptr, float minValue, float maxValue);
  static void menu_action_setting_edit_long5(const char* pstr, unsigned long* ptr, unsigned long minValue, unsigned long maxValue);
-  static void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, menuFunc_t callbackFunc);
-  static void menu_action_setting_edit_callback_int3(const char* pstr, int* ptr, int minValue, int maxValue, menuFunc_t callbackFunc);
-  static void menu_action_setting_edit_callback_float3(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
-  static void menu_action_setting_edit_callback_float32(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
-  static void menu_action_setting_edit_callback_float43(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
-  static void menu_action_setting_edit_callback_float5(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
-  static void menu_action_setting_edit_callback_float51(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
-  static void menu_action_setting_edit_callback_float52(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
-  static void menu_action_setting_edit_callback_long5(const char* pstr, unsigned long* ptr, unsigned long minValue, unsigned long maxValue, menuFunc_t callbackFunc);
+  static void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, screenFunc_t callbackFunc);
+  static void menu_action_setting_edit_callback_int3(const char* pstr, int* ptr, int minValue, int maxValue, screenFunc_t callbackFunc);
+  static void menu_action_setting_edit_callback_float3(const char* pstr, float* ptr, float minValue, float maxValue, screenFunc_t callbackFunc);
+  static void menu_action_setting_edit_callback_float32(const char* pstr, float* ptr, float minValue, float maxValue, screenFunc_t callbackFunc);
+  static void menu_action_setting_edit_callback_float43(const char* pstr, float* ptr, float minValue, float maxValue, screenFunc_t callbackFunc);
+  static void menu_action_setting_edit_callback_float5(const char* pstr, float* ptr, float minValue, float maxValue, screenFunc_t callbackFunc);
+  static void menu_action_setting_edit_callback_float51(const char* pstr, float* ptr, float minValue, float maxValue, screenFunc_t callbackFunc);
+  static void menu_action_setting_edit_callback_float52(const char* pstr, float* ptr, float minValue, float maxValue, screenFunc_t callbackFunc);
+  static void menu_action_setting_edit_callback_long5(const char* pstr, unsigned long* ptr, unsigned long minValue, unsigned long maxValue, screenFunc_t callbackFunc);

  #if ENABLED(SDSUPPORT)
    static void lcd_sdcard_menu();
@ -270,91 +285,80 @@ static void lcd_status_screen();
    uint8_t lcd_sd_status;
  #endif

-#endif // ULTIPANEL
-
-typedef struct {
-  menuFunc_t menu_function;
-  #if ENABLED(ULTIPANEL)
+  typedef struct {
+    screenFunc_t menu_function;
    uint32_t encoder_position;
-  #endif
-} menuPosition;
+  } menuPosition;

-menuFunc_t currentMenu = lcd_status_screen; // pointer to the currently active menu handler
+  screenFunc_t currentScreen = lcd_status_screen; // pointer to the currently active menu handler

-menuPosition menu_history[10];
-uint8_t menu_history_depth = 0;
+  menuPosition screen_history[10];
+  uint8_t screen_history_depth = 0;

-millis_t next_lcd_update_ms;
-bool ignore_click = false;
-bool wait_for_unclick;
-bool defer_return_to_status = false;
+  bool ignore_click = false;
+  bool wait_for_unclick;
+  bool defer_return_to_status = false;

-enum LCDViewAction {
-  LCDVIEW_NONE,
-  LCDVIEW_REDRAW_NOW,
-  LCDVIEW_CALL_REDRAW_NEXT,
-  LCDVIEW_CLEAR_CALL_REDRAW,
-  LCDVIEW_CALL_NO_REDRAW
-};
-
-uint8_t lcdDrawUpdate = LCDVIEW_CLEAR_CALL_REDRAW; // Set when the LCD needs to draw, decrements after every draw. Set to 2 in LCD routines so the LCD gets at least 1 full redraw (first redraw is partial)
-
-// Variables used when editing values.
-const char* editLabel;
-void* editValue;
-int32_t minEditValue, maxEditValue;
-menuFunc_t callbackFunc;              // call this after editing
-
-// place-holders for Ki and Kd edits
-float raw_Ki, raw_Kd;
+  // Variables used when editing values.
+  const char* editLabel;
+  void* editValue;
+  int32_t minEditValue, maxEditValue;
+  screenFunc_t callbackFunc;              // call this after editing

-/**
+  /**
   * General function to go directly to a menu
   * Remembers the previous position
   */
-static void lcd_goto_menu(menuFunc_t menu, const bool feedback = false, const uint32_t encoder = 0) {
-  if (currentMenu != menu) {
-    currentMenu = menu;
+  static void lcd_goto_screen(screenFunc_t screen, const bool feedback = false, const uint32_t encoder = 0) {
+    if (currentScreen != screen) {
+      currentScreen = screen;
      lcdDrawUpdate = LCDVIEW_CLEAR_CALL_REDRAW;
      #if ENABLED(NEWPANEL)
        encoderPosition = encoder;
        if (feedback) lcd_quick_feedback();
      #endif
-    if (menu == lcd_status_screen) {
+      if (screen == lcd_status_screen) {
        defer_return_to_status = false;
-      menu_history_depth = 0;
+        screen_history_depth = 0;
      }
      #if ENABLED(LCD_PROGRESS_BAR)
        // For LCD_PROGRESS_BAR re-initialize custom characters
-      lcd_set_custom_characters(menu == lcd_status_screen);
+        lcd_set_custom_characters(screen == lcd_status_screen);
      #endif
    }
-}
+  }

-static void lcd_return_to_status() { lcd_goto_menu(lcd_status_screen); }
+  static void lcd_return_to_status() { lcd_goto_screen(lcd_status_screen); }

-inline void lcd_save_previous_menu() {
-  if (menu_history_depth < COUNT(menu_history)) {
-    menu_history[menu_history_depth].menu_function = currentMenu;
+  inline void lcd_save_previous_menu() {
+    if (screen_history_depth < COUNT(screen_history)) {
+      screen_history[screen_history_depth].menu_function = currentScreen;
      #if ENABLED(ULTIPANEL)
-      menu_history[menu_history_depth].encoder_position = encoderPosition;
+        screen_history[screen_history_depth].encoder_position = encoderPosition;
      #endif
-    ++menu_history_depth;
+      ++screen_history_depth;
+    }
  }
-}

-static void lcd_goto_previous_menu(bool feedback=false) {
-  if (menu_history_depth > 0) {
-    --menu_history_depth;
-    lcd_goto_menu(menu_history[menu_history_depth].menu_function, feedback
+  static void lcd_goto_previous_menu(bool feedback=false) {
+    if (screen_history_depth > 0) {
+      --screen_history_depth;
+      lcd_goto_screen(screen_history[screen_history_depth].menu_function, feedback
        #if ENABLED(ULTIPANEL)
-        , menu_history[menu_history_depth].encoder_position
+          , screen_history[screen_history_depth].encoder_position
        #endif
      );
    }
    else
      lcd_return_to_status();
-}
+  }
+
+  void lcd_ignore_click(bool b) {
+    ignore_click = b;
+    wait_for_unclick = false;
+  }
+
+#endif // ULTIPANEL

 /**
 *
@ -364,8 +368,11 @@ static void lcd_goto_previous_menu(bool feedback=false) {
 */

 static void lcd_status_screen() {
+
+  #if ENABLED(ULTIPANEL)
    ENCODER_DIRECTION_NORMAL();
    encoderRateMultiplierEnabled = false;
+  #endif

  #if ENABLED(LCD_PROGRESS_BAR)
    millis_t ms = millis();
@ -421,10 +428,10 @@ static void lcd_status_screen() {
    }

    if (current_click) {
-      lcd_goto_menu(lcd_main_menu, true);
+      lcd_goto_screen(lcd_main_menu, true);
      lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
-        #if ENABLED(LCD_PROGRESS_BAR)
-          currentMenu == lcd_status_screen
+        #if ENABLED(LCD_PROGRESS_BAR) && ENABLED(ULTIPANEL)
+          currentScreen == lcd_status_screen
        #endif
      );
      #if ENABLED(FILAMENT_LCD_DISPLAY)
@ -462,16 +469,16 @@ static void lcd_status_screen() {

 #if ENABLED(ULTIPANEL)

-inline void line_to_current(AxisEnum axis) {
+  inline void line_to_current(AxisEnum axis) {
    #if ENABLED(DELTA)
      calculate_delta(current_position);
      planner.buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], current_position[E_AXIS], manual_feedrate[axis]/60, active_extruder);
-  #else
+    #else // !DELTA
      planner.buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[axis]/60, active_extruder);
-  #endif
-}
+    #endif // !DELTA
+  }

-#if ENABLED(SDSUPPORT)
+  #if ENABLED(SDSUPPORT)

    static void lcd_sdcard_pause() {
      card.pauseSDPrint();
@ -487,7 +494,7 @@ inline void line_to_current(AxisEnum axis) {
      stepper.quick_stop();
      #if DISABLED(DELTA) && DISABLED(SCARA)
        set_current_position_from_planner();
-    #endif
+      #endif // !DELTA && !SCARA
      clear_command_queue();
      card.sdprinting = false;
      card.closefile();
@ -497,15 +504,15 @@ inline void line_to_current(AxisEnum axis) {
      lcd_setstatus(MSG_PRINT_ABORTED, true);
    }

-#endif //SDSUPPORT
+  #endif //SDSUPPORT

-/**
+  /**
   *
   * "Main" menu
   *
   */

-static void lcd_main_menu() {
+  static void lcd_main_menu() {
    START_MENU();
    MENU_ITEM(back, MSG_WATCH);
    if (planner.movesplanned() || IS_SD_PRINTING) {
@ -544,24 +551,24 @@ static void lcd_main_menu() {
    #endif //SDSUPPORT

    END_MENU();
-}
+  }

-/**
+  /**
   *
   * "Tune" submenu items
   *
   */

-/**
+  /**
   * Set the home offset based on the current_position
   */
-void lcd_set_home_offsets() {
+  void lcd_set_home_offsets() {
    // M428 Command
    enqueue_and_echo_commands_P(PSTR("M428"));
    lcd_return_to_status();
-}
+  }

-#if ENABLED(BABYSTEPPING)
+  #if ENABLED(BABYSTEPPING)

    int babysteps_done = 0;

@ -581,18 +588,18 @@ void lcd_set_home_offsets() {
    #if ENABLED(BABYSTEP_XY)
      static void _lcd_babystep_x() { _lcd_babystep(X_AXIS, PSTR(MSG_BABYSTEPPING_X)); }
      static void _lcd_babystep_y() { _lcd_babystep(Y_AXIS, PSTR(MSG_BABYSTEPPING_Y)); }
-    static void lcd_babystep_x() { babysteps_done = 0; lcd_goto_menu(_lcd_babystep_x); }
-    static void lcd_babystep_y() { babysteps_done = 0; lcd_goto_menu(_lcd_babystep_y); }
+      static void lcd_babystep_x() { babysteps_done = 0; lcd_goto_screen(_lcd_babystep_x); }
+      static void lcd_babystep_y() { babysteps_done = 0; lcd_goto_screen(_lcd_babystep_y); }
    #endif
    static void _lcd_babystep_z() { _lcd_babystep(Z_AXIS, PSTR(MSG_BABYSTEPPING_Z)); }
-  static void lcd_babystep_z() { babysteps_done = 0; lcd_goto_menu(_lcd_babystep_z); }
+    static void lcd_babystep_z() { babysteps_done = 0; lcd_goto_screen(_lcd_babystep_z); }

-#endif //BABYSTEPPING
+  #endif //BABYSTEPPING

-/**
+  /**
   * Watch temperature callbacks
   */
-#if ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0
+  #if ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0
    #if TEMP_SENSOR_0 != 0
      void watch_temp_callback_E0() { thermalManager.start_watching_heater(0); }
    #endif
@ -605,7 +612,7 @@ void lcd_set_home_offsets() {
    #if HOTENDS > 3 && TEMP_SENSOR_3 != 0
      void watch_temp_callback_E3() { thermalManager.start_watching_heater(3); }
    #endif // HOTENDS > 3
-#else
+  #else
    #if TEMP_SENSOR_0 != 0
      void watch_temp_callback_E0() {}
    #endif
@ -618,24 +625,24 @@ void lcd_set_home_offsets() {
    #if HOTENDS > 3 && TEMP_SENSOR_3 != 0
      void watch_temp_callback_E3() {}
    #endif // HOTENDS > 3
-#endif
+  #endif

-#if ENABLED(THERMAL_PROTECTION_BED) && WATCH_BED_TEMP_PERIOD > 0
+  #if ENABLED(THERMAL_PROTECTION_BED) && WATCH_BED_TEMP_PERIOD > 0
    #if TEMP_SENSOR_BED != 0
      void watch_temp_callback_bed() { thermalManager.start_watching_bed(); }
    #endif
-#else
+  #else
    #if TEMP_SENSOR_BED != 0
      void watch_temp_callback_bed() {}
    #endif
-#endif
+  #endif

-/**
+  /**
   *
   * "Tune" submenu
   *
   */
-static void lcd_tune_menu() {
+  static void lcd_tune_menu() {
    START_MENU();

    //
@ -749,14 +756,14 @@ static void lcd_tune_menu() {
    #endif

    END_MENU();
-}
+  }

-/**
+  /**
   *
   * "Prepare" submenu items
   *
   */
-void _lcd_preheat(int endnum, const float temph, const float tempb, const int fan) {
+  void _lcd_preheat(int endnum, const float temph, const float tempb, const int fan) {
    if (temph > 0) thermalManager.setTargetHotend(temph, endnum);
    #if TEMP_SENSOR_BED != 0
      thermalManager.setTargetBed(tempb);
@ -773,14 +780,14 @@ void _lcd_preheat(int endnum, const float temph, const float tempb, const int fa
      UNUSED(fan);
    #endif
    lcd_return_to_status();
-}
+  }

-#if TEMP_SENSOR_0 != 0
+  #if TEMP_SENSOR_0 != 0
    void lcd_preheat_pla0() { _lcd_preheat(0, plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed); }
    void lcd_preheat_abs0() { _lcd_preheat(0, absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed); }
-#endif
+  #endif

-#if HOTENDS > 1
+  #if HOTENDS > 1
    void lcd_preheat_pla1() { _lcd_preheat(1, plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed); }
    void lcd_preheat_abs1() { _lcd_preheat(1, absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed); }
    #if HOTENDS > 2
@ -817,14 +824,14 @@ void _lcd_preheat(int endnum, const float temph, const float tempb, const int fa
      lcd_preheat_abs0();
    }

-#endif // HOTENDS > 1
+  #endif // HOTENDS > 1

-#if TEMP_SENSOR_BED != 0
+  #if TEMP_SENSOR_BED != 0
    void lcd_preheat_pla_bedonly() { _lcd_preheat(0, 0, plaPreheatHPBTemp, plaPreheatFanSpeed); }
    void lcd_preheat_abs_bedonly() { _lcd_preheat(0, 0, absPreheatHPBTemp, absPreheatFanSpeed); }
-#endif
+  #endif

-#if TEMP_SENSOR_0 != 0 && (TEMP_SENSOR_1 != 0 || TEMP_SENSOR_2 != 0 || TEMP_SENSOR_3 != 0 || TEMP_SENSOR_BED != 0)
+  #if TEMP_SENSOR_0 != 0 && (TEMP_SENSOR_1 != 0 || TEMP_SENSOR_2 != 0 || TEMP_SENSOR_3 != 0 || TEMP_SENSOR_BED != 0)

    static void lcd_preheat_pla_menu() {
      START_MENU();
@ -870,17 +877,17 @@ void _lcd_preheat(int endnum, const float temph, const float tempb, const int fa
      END_MENU();
    }

-#endif // TEMP_SENSOR_0 && (TEMP_SENSOR_1 || TEMP_SENSOR_2 || TEMP_SENSOR_3 || TEMP_SENSOR_BED)
+  #endif // TEMP_SENSOR_0 && (TEMP_SENSOR_1 || TEMP_SENSOR_2 || TEMP_SENSOR_3 || TEMP_SENSOR_BED)

-void lcd_cooldown() {
+  void lcd_cooldown() {
    #if FAN_COUNT > 0
      for (uint8_t i = 0; i < FAN_COUNT; i++) fanSpeeds[i] = 0;
    #endif
    thermalManager.disable_all_heaters();
    lcd_return_to_status();
-}
+  }

-#if ENABLED(SDSUPPORT) && ENABLED(MENU_ADDAUTOSTART)
+  #if ENABLED(SDSUPPORT) && ENABLED(MENU_ADDAUTOSTART)

    static void lcd_autostart_sd() {
      card.autostart_index = 0;
@ -888,9 +895,9 @@ void lcd_cooldown() {
      card.checkautostart(true);
    }

-#endif
+  #endif

-#if ENABLED(MANUAL_BED_LEVELING)
+  #if ENABLED(MANUAL_BED_LEVELING)

    /**
     *
@ -963,7 +970,7 @@ void lcd_cooldown() {
          debounce_click = true; // ignore multiple "clicks" in a row
          mbl.set_zigzag_z(_lcd_level_bed_position++, current_position[Z_AXIS]);
          if (_lcd_level_bed_position == (MESH_NUM_X_POINTS) * (MESH_NUM_Y_POINTS)) {
-          lcd_goto_menu(_lcd_level_bed_done, true);
+            lcd_goto_screen(_lcd_level_bed_done, true);

            current_position[Z_AXIS] = MESH_HOME_SEARCH_Z
              #if MIN_Z_HEIGHT_FOR_HOMING > 0
@ -983,7 +990,7 @@ void lcd_cooldown() {
            #endif
          }
          else {
-          lcd_goto_menu(_lcd_level_goto_next_point, true);
+            lcd_goto_screen(_lcd_level_goto_next_point, true);
          }
        }
      }
@ -1024,7 +1031,7 @@ void lcd_cooldown() {
     */
    static void _lcd_level_goto_next_point() {
      // Set the menu to display ahead of blocking call
-    lcd_goto_menu(_lcd_level_bed_moving);
+      lcd_goto_screen(_lcd_level_bed_moving);

      // _mbl_goto_xy runs the menu loop until the move is done
      int8_t px, py;
@ -1032,7 +1039,7 @@ void lcd_cooldown() {
      _mbl_goto_xy(mbl.get_probe_x(px), mbl.get_probe_y(py));

      // After the blocking function returns, change menus
-    lcd_goto_menu(_lcd_level_bed_get_z);
+      lcd_goto_screen(_lcd_level_bed_get_z);
    }

    /**
@ -1045,7 +1052,7 @@ void lcd_cooldown() {
        _lcd_level_bed_position = 0;
        current_position[Z_AXIS] = MESH_HOME_SEARCH_Z;
        planner.set_position_mm(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
-      lcd_goto_menu(_lcd_level_goto_next_point, true);
+        lcd_goto_screen(_lcd_level_goto_next_point, true);
      }
    }

@ -1062,7 +1069,7 @@ void lcd_cooldown() {
        #endif
      ;
      if (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS])
-      lcd_goto_menu(_lcd_level_bed_homing_done);
+        lcd_goto_screen(_lcd_level_bed_homing_done);
    }

    /**
@ -1073,7 +1080,7 @@ void lcd_cooldown() {
      axis_homed[X_AXIS] = axis_homed[Y_AXIS] = axis_homed[Z_AXIS] = false;
      mbl.reset();
      enqueue_and_echo_commands_P(PSTR("G28"));
-    lcd_goto_menu(_lcd_level_bed_homing);
+      lcd_goto_screen(_lcd_level_bed_homing);
    }

    /**
@ -1086,15 +1093,15 @@ void lcd_cooldown() {
      END_MENU();
    }

-#endif  // MANUAL_BED_LEVELING
+  #endif  // MANUAL_BED_LEVELING

-/**
+  /**
   *
   * "Prepare" submenu
   *
   */

-static void lcd_prepare_menu() {
+  static void lcd_prepare_menu() {
    START_MENU();

    //
@ -1176,9 +1183,9 @@ static void lcd_prepare_menu() {
    #endif

    END_MENU();
-}
+  }

-#if ENABLED(DELTA_CALIBRATION_MENU)
+  #if ENABLED(DELTA_CALIBRATION_MENU)

    static void lcd_delta_calibrate_menu() {
      START_MENU();
@ -1191,13 +1198,13 @@ static void lcd_prepare_menu() {
      END_MENU();
    }

-#endif // DELTA_CALIBRATION_MENU
+  #endif // DELTA_CALIBRATION_MENU

-/**
+  /**
   * If the most recent manual move hasn't been fed to the planner yet,
   * and the planner can accept one, send immediately
   */
-inline void manage_manual_move() {
+  inline void manage_manual_move() {
    if (manual_move_axis != (int8_t)NO_AXIS && millis() >= manual_move_start_time && !planner.is_full()) {
      #if ENABLED(DELTA)
        calculate_delta(current_position);
@ -1207,26 +1214,26 @@ inline void manage_manual_move() {
      #endif
      manual_move_axis = (int8_t)NO_AXIS;
    }
-}
+  }

-/**
+  /**
   * Set a flag that lcd_update() should start a move
   * to "current_position" after a short delay.
   */
-inline void manual_move_to_current(AxisEnum axis) {
+  inline void manual_move_to_current(AxisEnum axis) {
    manual_move_start_time = millis() + 500UL; // 1/2 second delay
    manual_move_axis = (int8_t)axis;
-}
+  }

-/**
+  /**
   *
   * "Prepare" > "Move Axis" submenu
   *
   */

-float move_menu_scale;
+  float move_menu_scale;

-static void _lcd_move(const char* name, AxisEnum axis, float min, float max) {
+  static void _lcd_move(const char* name, AxisEnum axis, float min, float max) {
    ENCODER_DIRECTION_NORMAL();
    if (encoderPosition) {
      refresh_cmd_timeout();
@ -1239,22 +1246,22 @@ static void _lcd_move(const char* name, AxisEnum axis, float min, float max) {
    }
    if (lcdDrawUpdate) lcd_implementation_drawedit(name, ftostr41sign(current_position[axis]));
    if (LCD_CLICKED) lcd_goto_previous_menu(true);
-}
-#if ENABLED(DELTA)
+  }
+  #if ENABLED(DELTA)
    static float delta_clip_radius_2 =  (DELTA_PRINTABLE_RADIUS) * (DELTA_PRINTABLE_RADIUS);
    static int delta_clip( float a ) { return sqrt(delta_clip_radius_2 - a*a); }
    static void lcd_move_x() { int clip = delta_clip(current_position[Y_AXIS]); _lcd_move(PSTR(MSG_MOVE_X), X_AXIS, max(sw_endstop_min[X_AXIS], -clip), min(sw_endstop_max[X_AXIS], clip)); }
    static void lcd_move_y() { int clip = delta_clip(current_position[X_AXIS]); _lcd_move(PSTR(MSG_MOVE_Y), Y_AXIS, max(sw_endstop_min[Y_AXIS], -clip), min(sw_endstop_max[Y_AXIS], clip)); }
-#else
+  #else
    static void lcd_move_x() { _lcd_move(PSTR(MSG_MOVE_X), X_AXIS, sw_endstop_min[X_AXIS], sw_endstop_max[X_AXIS]); }
    static void lcd_move_y() { _lcd_move(PSTR(MSG_MOVE_Y), Y_AXIS, sw_endstop_min[Y_AXIS], sw_endstop_max[Y_AXIS]); }
-#endif
-static void lcd_move_z() { _lcd_move(PSTR(MSG_MOVE_Z), Z_AXIS, sw_endstop_min[Z_AXIS], sw_endstop_max[Z_AXIS]); }
-static void lcd_move_e(
+  #endif
+  static void lcd_move_z() { _lcd_move(PSTR(MSG_MOVE_Z), Z_AXIS, sw_endstop_min[Z_AXIS], sw_endstop_max[Z_AXIS]); }
+  static void lcd_move_e(
    #if EXTRUDERS > 1
      uint8_t e
    #endif
-) {
+  ) {
    ENCODER_DIRECTION_NORMAL();
    #if EXTRUDERS > 1
      unsigned short original_active_extruder = active_extruder;
@ -1288,9 +1295,9 @@ static void lcd_move_e(
    #if EXTRUDERS > 1
      active_extruder = original_active_extruder;
    #endif
-}
+  }

-#if EXTRUDERS > 1
+  #if EXTRUDERS > 1
    static void lcd_move_e0() { lcd_move_e(0); }
    static void lcd_move_e1() { lcd_move_e(1); }
    #if EXTRUDERS > 2
@ -1299,21 +1306,21 @@ static void lcd_move_e(
        static void lcd_move_e3() { lcd_move_e(3); }
      #endif
    #endif
-#endif // EXTRUDERS > 1
+  #endif // EXTRUDERS > 1

-/**
+  /**
   *
   * "Prepare" > "Move Xmm" > "Move XYZ" submenu
   *
   */

-#if ENABLED(DELTA) || ENABLED(SCARA)
+  #if ENABLED(DELTA) || ENABLED(SCARA)
    #define _MOVE_XYZ_ALLOWED (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS])
-#else
+  #else
    #define _MOVE_XYZ_ALLOWED true
-#endif
+  #endif

-static void _lcd_move_menu_axis() {
+  static void _lcd_move_menu_axis() {
    START_MENU();
    MENU_ITEM(back, MSG_MOVE_AXIS);

@ -1337,28 +1344,28 @@ static void _lcd_move_menu_axis() {
      #endif // EXTRUDERS > 1
    }
    END_MENU();
-}
+  }

-static void lcd_move_menu_10mm() {
+  static void lcd_move_menu_10mm() {
    move_menu_scale = 10.0;
    _lcd_move_menu_axis();
-}
-static void lcd_move_menu_1mm() {
+  }
+  static void lcd_move_menu_1mm() {
    move_menu_scale = 1.0;
    _lcd_move_menu_axis();
-}
-static void lcd_move_menu_01mm() {
+  }
+  static void lcd_move_menu_01mm() {
    move_menu_scale = 0.1;
    _lcd_move_menu_axis();
-}
+  }

-/**
+  /**
   *
   * "Prepare" > "Move Axis" submenu
   *
   */

-static void lcd_move_menu() {
+  static void lcd_move_menu() {
    START_MENU();
    MENU_ITEM(back, MSG_PREPARE);

@ -1369,15 +1376,15 @@ static void lcd_move_menu() {
    MENU_ITEM(submenu, MSG_MOVE_01MM, lcd_move_menu_01mm);
    //TODO:X,Y,Z,E
    END_MENU();
-}
+  }

-/**
+  /**
   *
   * "Control" submenu
   *
   */

-static void lcd_control_menu() {
+  static void lcd_control_menu() {
    START_MENU();
    MENU_ITEM(back, MSG_MAIN);
    MENU_ITEM(submenu, MSG_TEMPERATURE, lcd_control_temperature_menu);
@ -1397,15 +1404,15 @@ static void lcd_control_menu() {
    #endif
    MENU_ITEM(function, MSG_RESTORE_FAILSAFE, Config_ResetDefault);
    END_MENU();
-}
+  }

-/**
+  /**
   *
   * "Temperature" submenu
   *
   */

-#if ENABLED(PID_AUTOTUNE_MENU)
+  #if ENABLED(PID_AUTOTUNE_MENU)

    #if ENABLED(PIDTEMP)
      int autotune_temp[HOTENDS] = ARRAY_BY_HOTENDS1(150);
@ -1430,9 +1437,9 @@ static void lcd_control_menu() {
      enqueue_and_echo_command(cmd);
    }

-#endif //PID_AUTOTUNE_MENU
+  #endif //PID_AUTOTUNE_MENU

-#if ENABLED(PIDTEMP)
+  #if ENABLED(PIDTEMP)

    // Helpers for editing PID Ki & Kd values
    // grab the PID value out of the temp variable; scale it; then update the PID driver
@ -1475,14 +1482,14 @@ static void lcd_control_menu() {
      #endif //HOTENDS > 1
    #endif //PID_PARAMS_PER_HOTEND

-#endif //PIDTEMP
+  #endif //PIDTEMP

-/**
+  /**
   *
   * "Control" > "Temperature" submenu
   *
   */
-static void lcd_control_temperature_menu() {
+  static void lcd_control_temperature_menu() {
    START_MENU();

    //
@ -1611,14 +1618,14 @@ static void lcd_control_temperature_menu() {
    //
    MENU_ITEM(submenu, MSG_PREHEAT_ABS_SETTINGS, lcd_control_temperature_preheat_abs_settings_menu);
    END_MENU();
-}
+  }

-/**
+  /**
   *
   * "Temperature" > "Preheat PLA conf" submenu
   *
   */
-static void lcd_control_temperature_preheat_pla_settings_menu() {
+  static void lcd_control_temperature_preheat_pla_settings_menu() {
    START_MENU();
    MENU_ITEM(back, MSG_TEMPERATURE);
    MENU_ITEM_EDIT(int3, MSG_FAN_SPEED, &plaPreheatFanSpeed, 0, 255);
@ -1632,14 +1639,14 @@ static void lcd_control_temperature_preheat_pla_settings_menu() {
      MENU_ITEM(function, MSG_STORE_EPROM, Config_StoreSettings);
    #endif
    END_MENU();
-}
+  }

-/**
+  /**
   *
   * "Temperature" > "Preheat ABS conf" submenu
   *
   */
-static void lcd_control_temperature_preheat_abs_settings_menu() {
+  static void lcd_control_temperature_preheat_abs_settings_menu() {
    START_MENU();
    MENU_ITEM(back, MSG_TEMPERATURE);
    MENU_ITEM_EDIT(int3, MSG_FAN_SPEED, &absPreheatFanSpeed, 0, 255);
@ -1653,16 +1660,16 @@ static void lcd_control_temperature_preheat_abs_settings_menu() {
      MENU_ITEM(function, MSG_STORE_EPROM, Config_StoreSettings);
    #endif
    END_MENU();
-}
+  }

-static void _reset_acceleration_rates() { planner.reset_acceleration_rates(); }
+  static void _reset_acceleration_rates() { planner.reset_acceleration_rates(); }

-/**
+  /**
   *
   * "Control" > "Motion" submenu
   *
   */
-static void lcd_control_motion_menu() {
+  static void lcd_control_motion_menu() {
    START_MENU();
    MENU_ITEM(back, MSG_CONTROL);
    #if ENABLED(AUTO_BED_LEVELING_FEATURE)
@ -1708,14 +1715,14 @@ static void lcd_control_motion_menu() {
      MENU_ITEM_EDIT(float74, MSG_YSCALE, &axis_scaling[Y_AXIS], 0.5, 2);
    #endif
    END_MENU();
-}
+  }

-/**
+  /**
   *
   * "Control" > "Filament" submenu
   *
   */
-static void lcd_control_volumetric_menu() {
+  static void lcd_control_volumetric_menu() {
    START_MENU();
    MENU_ITEM(back, MSG_CONTROL);

@ -1737,14 +1744,14 @@ static void lcd_control_volumetric_menu() {
    }

    END_MENU();
-}
+  }

-/**
+  /**
   *
   * "Control" > "Contrast" submenu
   *
   */
-#if HAS_LCD_CONTRAST
+  #if HAS_LCD_CONTRAST
    static void lcd_set_contrast() {
      ENCODER_DIRECTION_NORMAL();
      if (encoderPosition) {
@ -1763,14 +1770,14 @@ static void lcd_control_volumetric_menu() {
      }
      if (LCD_CLICKED) lcd_goto_previous_menu(true);
    }
-#endif // HAS_LCD_CONTRAST
+  #endif // HAS_LCD_CONTRAST

-/**
+  /**
   *
   * "Control" > "Retract" submenu
   *
   */
-#if ENABLED(FWRETRACT)
+  #if ENABLED(FWRETRACT)
    static void lcd_control_retract_menu() {
      START_MENU();
      MENU_ITEM(back, MSG_CONTROL);
@ -1788,9 +1795,9 @@ static void lcd_control_volumetric_menu() {
      MENU_ITEM_EDIT(float3, MSG_CONTROL_RETRACT_RECOVERF, &retract_recover_feedrate, 1, 999);
      END_MENU();
    }
-#endif // FWRETRACT
+  #endif // FWRETRACT

-#if ENABLED(SDSUPPORT)
+  #if ENABLED(SDSUPPORT)

    #if !PIN_EXISTS(SD_DETECT)
      static void lcd_sd_refresh() {
@ -1846,9 +1853,9 @@ static void lcd_control_volumetric_menu() {
      END_MENU();
    }

-#endif //SDSUPPORT
+  #endif //SDSUPPORT

-/**
+  /**
   *
   * Functions for editing single values
   *
@ -1861,7 +1868,7 @@ static void lcd_control_volumetric_menu() {
   *   void menu_edit_callback_int3(); // edit int (interactively) with callback on completion
   *   static void _menu_action_setting_edit_int3(const char* pstr, int* ptr, int minValue, int maxValue);
   *   static void menu_action_setting_edit_int3(const char* pstr, int* ptr, int minValue, int maxValue);
- *   static void menu_action_setting_edit_callback_int3(const char* pstr, int* ptr, int minValue, int maxValue, menuFunc_t callback); // edit int with callback
+   *   static void menu_action_setting_edit_callback_int3(const char* pstr, int* ptr, int minValue, int maxValue, screenFunc_t callback); // edit int with callback
   *
   * You can then use one of the menu macros to present the edit interface:
   *   MENU_ITEM_EDIT(int3, MSG_SPEED, &feedrate_multiplier, 10, 999)
@ -1874,7 +1881,7 @@ static void lcd_control_volumetric_menu() {
   *
   *       menu_action_setting_edit_int3(PSTR(MSG_SPEED), &feedrate_multiplier, 10, 999)
   */
-#define menu_edit_type(_type, _name, _strFunc, scale) \
+  #define menu_edit_type(_type, _name, _strFunc, scale) \
    bool _menu_edit_ ## _name () { \
      ENCODER_DIRECTION_NORMAL(); \
      bool isClicked = LCD_CLICKED; \
@ -1903,28 +1910,28 @@ static void lcd_control_volumetric_menu() {
    } \
    static void menu_action_setting_edit_ ## _name (const char* pstr, _type* ptr, _type minValue, _type maxValue) { \
      _menu_action_setting_edit_ ## _name(pstr, ptr, minValue, maxValue); \
-    currentMenu = menu_edit_ ## _name; \
+      currentScreen = menu_edit_ ## _name; \
    }\
-  static void menu_action_setting_edit_callback_ ## _name (const char* pstr, _type* ptr, _type minValue, _type maxValue, menuFunc_t callback) { \
+    static void menu_action_setting_edit_callback_ ## _name (const char* pstr, _type* ptr, _type minValue, _type maxValue, screenFunc_t callback) { \
      _menu_action_setting_edit_ ## _name(pstr, ptr, minValue, maxValue); \
-    currentMenu = menu_edit_callback_ ## _name; \
+      currentScreen = menu_edit_callback_ ## _name; \
      callbackFunc = callback; \
    }
-menu_edit_type(int, int3, itostr3, 1);
-menu_edit_type(float, float3, ftostr3, 1);
-menu_edit_type(float, float32, ftostr32, 100);
-menu_edit_type(float, float43, ftostr43sign, 1000);
-menu_edit_type(float, float5, ftostr5rj, 0.01);
-menu_edit_type(float, float51, ftostr51sign, 10);
-menu_edit_type(float, float52, ftostr52sign, 100);
-menu_edit_type(unsigned long, long5, ftostr5rj, 0.01);
+  menu_edit_type(int, int3, itostr3, 1);
+  menu_edit_type(float, float3, ftostr3, 1);
+  menu_edit_type(float, float32, ftostr32, 100);
+  menu_edit_type(float, float43, ftostr43sign, 1000);
+  menu_edit_type(float, float5, ftostr5rj, 0.01);
+  menu_edit_type(float, float51, ftostr51sign, 10);
+  menu_edit_type(float, float52, ftostr52sign, 100);
+  menu_edit_type(unsigned long, long5, ftostr5rj, 0.01);

-/**
+  /**
   *
   * Handlers for RepRap World Keypad input
   *
   */
-#if ENABLED(REPRAPWORLD_KEYPAD)
+  #if ENABLED(REPRAPWORLD_KEYPAD)
    static void reprapworld_keypad_move_z_up() {
      encoderPosition = 1;
      move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
@ -1958,22 +1965,22 @@ menu_edit_type(unsigned long, long5, ftostr5rj, 0.01);
    static void reprapworld_keypad_move_home() {
      enqueue_and_echo_commands_P(PSTR("G28")); // move all axes home
    }
-#endif // REPRAPWORLD_KEYPAD
+  #endif // REPRAPWORLD_KEYPAD


-/**
+  /**
   *
   * Audio feedback for controller clicks
   *
   */

-#if ENABLED(LCD_USE_I2C_BUZZER)
+  #if ENABLED(LCD_USE_I2C_BUZZER)
    void lcd_buzz(long duration, uint16_t freq) { // called from buzz() in Marlin_main.cpp where lcd is unknown
      lcd.buzz(duration, freq);
    }
-#endif
+  #endif

-void lcd_quick_feedback() {
+  void lcd_quick_feedback() {
    lcdDrawUpdate = LCDVIEW_CLEAR_CALL_REDRAW;
    next_button_update_ms = millis() + 500;

@ -1984,19 +1991,19 @@ void lcd_quick_feedback() {
    #else
      delay(LCD_FEEDBACK_FREQUENCY_DURATION_MS);
    #endif
-}
+  }

-/**
+  /**
   *
   * Menu actions
   *
   */
-static void menu_action_back() { lcd_goto_previous_menu(); }
-static void menu_action_submenu(menuFunc_t func) { lcd_save_previous_menu(); lcd_goto_menu(func); }
-static void menu_action_gcode(const char* pgcode) { enqueue_and_echo_commands_P(pgcode); }
-static void menu_action_function(menuFunc_t func) { (*func)(); }
+  static void menu_action_back() { lcd_goto_previous_menu(); }
+  static void menu_action_submenu(screenFunc_t func) { lcd_save_previous_menu(); lcd_goto_screen(func); }
+  static void menu_action_gcode(const char* pgcode) { enqueue_and_echo_commands_P(pgcode); }
+  static void menu_action_function(screenFunc_t func) { (*func)(); }

-#if ENABLED(SDSUPPORT)
+  #if ENABLED(SDSUPPORT)

    static void menu_action_sdfile(const char* filename, char* longFilename) {
      UNUSED(longFilename);
@ -2010,13 +2017,13 @@ static void menu_action_function(menuFunc_t func) { (*func)(); }
      encoderPosition = 0;
    }

-#endif //SDSUPPORT
+  #endif //SDSUPPORT

-static void menu_action_setting_edit_bool(const char* pstr, bool* ptr) {UNUSED(pstr); *ptr = !(*ptr); }
-static void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, menuFunc_t callback) {
+  static void menu_action_setting_edit_bool(const char* pstr, bool* ptr) {UNUSED(pstr); *ptr = !(*ptr); }
+  static void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, screenFunc_t callback) {
    menu_action_setting_edit_bool(pstr, ptr);
    (*callback)();
-}
+  }

 #endif //ULTIPANEL

@ -2158,13 +2165,12 @@ bool lcd_blink() {
 * No worries. This function is only called from the main thread.
 */
 void lcd_update() {
+
  #if ENABLED(ULTIPANEL)
    static millis_t return_to_status_ms = 0;
-
    manage_manual_move();
  #endif

-
  lcd_buttons_update();

  #if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_DETECT)
@ -2173,8 +2179,8 @@ void lcd_update() {
    if (sd_status != lcd_sd_status && lcd_detected()) {
      lcdDrawUpdate = LCDVIEW_CLEAR_CALL_REDRAW;
      lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
-        #if ENABLED(LCD_PROGRESS_BAR)
-          currentMenu == lcd_status_screen
+        #if ENABLED(LCD_PROGRESS_BAR) && ENABLED(ULTIPANEL)
+          currentScreen == lcd_status_screen
        #endif
      );

@ -2272,7 +2278,11 @@ void lcd_update() {
    // We arrive here every ~100ms when idling often enough.
    // Instead of tracking the changes simply redraw the Info Screen ~1 time a second.
    static int8_t lcd_status_update_delay = 1; // first update one loop delayed
-    if (currentMenu == lcd_status_screen && !lcd_status_update_delay--) {
+    if (
+      #if ENABLED(ULTIPANEL)
+        currentScreen == lcd_status_screen &&
+      #endif
+        !lcd_status_update_delay--) {
      lcd_status_update_delay = 9;
      lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
    }
@ -2301,17 +2311,25 @@ void lcd_update() {
          u8g.setColorIndex(dot_color); // Set color for the alive dot
          u8g.drawPixel(127, 63); // draw alive dot
          u8g.setColorIndex(1); // black on white
-          (*currentMenu)();
+          #if ENABLED(ULTIPANEL)
+            (*currentScreen)();
+          #else
+            lcd_status_screen();
+          #endif
        } while (u8g.nextPage());
      #else
-        (*currentMenu)();
+        #if ENABLED(ULTIPANEL)
+          (*currentScreen)();
+        #else
+          lcd_status_screen();
+        #endif
      #endif
    }

    #if ENABLED(ULTIPANEL)

      // Return to Status Screen after a timeout
-      if (currentMenu == lcd_status_screen || defer_return_to_status)
+      if (currentScreen == lcd_status_screen || defer_return_to_status)
        return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS;
      else if (ELAPSED(ms, return_to_status_ms))
        lcd_return_to_status();
@ -2334,11 +2352,6 @@ void lcd_update() {
  }
 }

-void lcd_ignore_click(bool b) {
-  ignore_click = b;
-  wait_for_unclick = false;
-}
-
 void lcd_finishstatus(bool persist=false) {
  #if !(ENABLED(LCD_PROGRESS_BAR) && (PROGRESS_MSG_EXPIRE > 0))
    UNUSED(persist);
--- a/Marlin/ultralcd.h
+++ b/Marlin/ultralcd.h
@ -61,8 +61,11 @@
  #define LCD_TIMEOUT_TO_STATUS 15000

  #if ENABLED(ULTIPANEL)
-    void lcd_buttons_update();
    extern volatile uint8_t buttons;  //the last checked buttons in a bit array.
+    void lcd_buttons_update();
+    void lcd_quick_feedback(); // Audible feedback for a button click - could also be visual
+    bool lcd_clicked();
+    void lcd_ignore_click(bool b=true);
  #else
    FORCE_INLINE void lcd_buttons_update() {}
  #endif
@ -79,12 +82,10 @@
  #if ENABLED(FILAMENT_LCD_DISPLAY)
    extern millis_t previous_lcd_status_ms;
  #endif
-  void lcd_quick_feedback(); // Audible feedback for a button click - could also be visual
-  bool lcd_clicked();
-  void lcd_ignore_click(bool b=true);
+
  bool lcd_blink();

-  #if ENABLED(ULTIPANEL) && ENABLED(REPRAPWORLD_KEYPAD)
+  #if ENABLED(REPRAPWORLD_KEYPAD)

    #define REPRAPWORLD_BTN_OFFSET 0 // bit offset into buttons for shift register values

@ -114,7 +115,7 @@
    #define REPRAPWORLD_KEYPAD_MOVE_Y_UP    (buttons_reprapworld_keypad & EN_REPRAPWORLD_KEYPAD_UP)
    #define REPRAPWORLD_KEYPAD_MOVE_X_LEFT  (buttons_reprapworld_keypad & EN_REPRAPWORLD_KEYPAD_LEFT)

-  #endif //ULTIPANEL && REPRAPWORLD_KEYPAD
+  #endif // REPRAPWORLD_KEYPAD

  #if ENABLED(NEWPANEL)