added parametric wargaming base

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/game/brickout.cpp

@@ -0,0 +1,207 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../../../inc/MarlinConfigPre.h"
+
+#if ENABLED(MARLIN_BRICKOUT)
+
+#include "game.h"
+
+#define BRICK_H      5
+#define BRICK_TOP    MENU_FONT_ASCENT
+
+#define PADDLE_H     2
+#define PADDLE_VEL   3
+#define PADDLE_W    ((LCD_PIXEL_WIDTH) / 8)
+#define PADDLE_Y    (LCD_PIXEL_HEIGHT - 1 - PADDLE_H)
+
+#define BRICK_W     ((LCD_PIXEL_WIDTH) / (BRICK_COLS))
+#define BRICK_BOT   (BRICK_TOP + BRICK_H * BRICK_ROWS - 1)
+
+#define BRICK_COL(X) ((X) / (BRICK_W))
+#define BRICK_ROW(Y) ((Y - (BRICK_TOP)) / (BRICK_H))
+
+brickout_data_t &bdat = marlin_game_data.brickout;
+
+inline void reset_bricks(const uint16_t v) {
+  bdat.brick_count = (BRICK_COLS) * (BRICK_ROWS);
+  LOOP_L_N(i, BRICK_ROWS) bdat.bricks[i] = v;
+}
+
+void reset_ball() {
+  constexpr uint8_t ball_dist = 24;
+  bdat.bally = BTOF(PADDLE_Y - ball_dist);
+  bdat.ballv = FTOP(1.3f);
+  bdat.ballh = -FTOP(1.25f);
+  uint8_t bx = bdat.paddle_x + (PADDLE_W) / 2 + ball_dist;
+  if (bx >= LCD_PIXEL_WIDTH - 10) { bx -= ball_dist * 2; bdat.ballh = -bdat.ballh; }
+  bdat.ballx = BTOF(bx);
+  bdat.hit_dir = -1;
+}
+
+void BrickoutGame::game_screen() {
+  if (game_frame()) {     // Run logic twice for finer resolution
+    // Update Paddle Position
+    bdat.paddle_x = constrain(int8_t(ui.encoderPosition), 0, (LCD_PIXEL_WIDTH - (PADDLE_W)) / (PADDLE_VEL));
+    ui.encoderPosition = bdat.paddle_x;
+    bdat.paddle_x *= (PADDLE_VEL);
+
+    // Run the ball logic
+    if (game_state) do {
+
+      // Provisionally update the ball position
+      const fixed_t newx = bdat.ballx + bdat.ballh, newy = bdat.bally + bdat.ballv;  // current next position
+      if (!WITHIN(newx, 0, BTOF(LCD_PIXEL_WIDTH - 1))) {    // out in x?
+        bdat.ballh = -bdat.ballh; _BUZZ(5, 220);            // bounce x
+      }
+      if (newy < 0) {                                       // out in y?
+        bdat.ballv = -bdat.ballv; _BUZZ(5, 280);            // bounce v
+        bdat.hit_dir = 1;
+      }
+      // Did the ball go below the bottom?
+      else if (newy > BTOF(LCD_PIXEL_HEIGHT)) {
+        _BUZZ(500, 75);
+        if (--bdat.balls_left) reset_ball(); else game_state = 0;
+        break; // done
+      }
+
+      // Is the ball colliding with a brick?
+      if (WITHIN(newy, BTOF(BRICK_TOP), BTOF(BRICK_BOT))) {
+        const int8_t bit = BRICK_COL(FTOB(newx)), row = BRICK_ROW(FTOB(newy));
+        const uint16_t mask = _BV(bit);
+        if (bdat.bricks[row] & mask) {
+          // Yes. Remove it!
+          bdat.bricks[row] &= ~mask;
+          // Score!
+          score += BRICK_ROWS - row;
+          // If bricks are gone, go to reset state
+          if (!--bdat.brick_count) game_state = 2;
+          // Bounce the ball cleverly
+          if ((bdat.ballv < 0) == (bdat.hit_dir < 0)) { bdat.ballv = -bdat.ballv; bdat.ballh += fixed_t(random(-16, 16)); _BUZZ(5, 880); }
+                                       else { bdat.ballh = -bdat.ballh; bdat.ballv += fixed_t(random(-16, 16)); _BUZZ(5, 640); }
+        }
+      }
+      // Is the ball moving down and in paddle range?
+      else if (bdat.ballv > 0 && WITHIN(newy, BTOF(PADDLE_Y), BTOF(PADDLE_Y + PADDLE_H))) {
+        // Ball actually hitting paddle
+        const int8_t diff = FTOB(newx) - bdat.paddle_x;
+        if (WITHIN(diff, 0, PADDLE_W - 1)) {
+
+          // Reverse Y direction
+          bdat.ballv = -bdat.ballv; _BUZZ(3, 880);
+          bdat.hit_dir = -1;
+
+          // Near edges affects X velocity
+          const bool is_left_edge = (diff <= 1);
+          if (is_left_edge || diff >= PADDLE_W-1 - 1) {
+            if ((bdat.ballh > 0) == is_left_edge) bdat.ballh = -bdat.ballh;
+          }
+          else if (diff <= 3) {
+            bdat.ballh += fixed_t(random(-64, 0));
+            NOLESS(bdat.ballh, BTOF(-2));
+            NOMORE(bdat.ballh, BTOF(2));
+          }
+          else if (diff >= PADDLE_W-1 - 3) {
+            bdat.ballh += fixed_t(random( 0, 64));
+            NOLESS(bdat.ballh, BTOF(-2));
+            NOMORE(bdat.ballh, BTOF(2));
+          }
+
+          // Paddle hit after clearing the board? Reset the board.
+          if (game_state == 2) { reset_bricks(0xFFFF); game_state = 1; }
+        }
+      }
+
+      bdat.ballx += bdat.ballh; bdat.bally += bdat.ballv; // update with new velocity
+
+    } while (false);
+  }
+
+  u8g.setColorIndex(1);
+
+  // Draw bricks
+  if (PAGE_CONTAINS(BRICK_TOP, BRICK_BOT)) {
+    LOOP_L_N(y, BRICK_ROWS) {
+      const uint8_t yy = y * BRICK_H + BRICK_TOP;
+      if (PAGE_CONTAINS(yy, yy + BRICK_H - 1)) {
+        LOOP_L_N(x, BRICK_COLS) {
+          if (TEST(bdat.bricks[y], x)) {
+            const uint8_t xx = x * BRICK_W;
+            LOOP_L_N(v, BRICK_H - 1)
+              if (PAGE_CONTAINS(yy + v, yy + v))
+                u8g.drawHLine(xx, yy + v, BRICK_W - 1);
+          }
+        }
+      }
+    }
+  }
+
+  // Draw paddle
+  if (PAGE_CONTAINS(PADDLE_Y-1, PADDLE_Y)) {
+    u8g.drawHLine(bdat.paddle_x, PADDLE_Y, PADDLE_W);
+    #if PADDLE_H > 1
+      u8g.drawHLine(bdat.paddle_x, PADDLE_Y-1, PADDLE_W);
+      #if PADDLE_H > 2
+        u8g.drawHLine(bdat.paddle_x, PADDLE_Y-2, PADDLE_W);
+      #endif
+    #endif
+  }
+
+  // Draw ball while game is running
+  if (game_state) {
+    const uint8_t by = FTOB(bdat.bally);
+    if (PAGE_CONTAINS(by, by+1))
+      u8g.drawFrame(FTOB(bdat.ballx), by, 2, 2);
+  }
+  // Or draw GAME OVER
+  else
+    draw_game_over();
+
+  if (PAGE_UNDER(MENU_FONT_ASCENT)) {
+    // Score Digits
+    //const uint8_t sx = (LCD_PIXEL_WIDTH - (score >= 10 ? score >= 100 ? score >= 1000 ? 4 : 3 : 2 : 1) * MENU_FONT_WIDTH) / 2;
+    constexpr uint8_t sx = 0;
+    lcd_put_int(sx, MENU_FONT_ASCENT - 1, score);
+
+    // Balls Left
+    lcd_moveto(LCD_PIXEL_WIDTH - MENU_FONT_WIDTH * 3, MENU_FONT_ASCENT - 1);
+    PGM_P const ohs = PSTR("ooo\0\0");
+    lcd_put_u8str_P(ohs + 3 - bdat.balls_left);
+  }
+
+  // A click always exits this game
+  if (ui.use_click()) exit_game();
+}
+
+#define SCREEN_M ((LCD_PIXEL_WIDTH) / 2)
+
+void BrickoutGame::enter_game() {
+  init_game(2, game_screen); // 2 = reset bricks on paddle hit
+  constexpr uint8_t paddle_start = SCREEN_M - (PADDLE_W) / 2;
+  bdat.paddle_x = paddle_start;
+  bdat.balls_left = 3;
+  reset_bricks(0x0000);
+  reset_ball();
+  ui.encoderPosition = paddle_start / (PADDLE_VEL);
+}
+
+#endif // MARLIN_BRICKOUT

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/game/brickout.h

@@ -0,0 +1,38 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include "types.h"
+
+#define BRICK_ROWS   4
+#define BRICK_COLS  16
+
+typedef struct {
+  uint8_t balls_left, brick_count;
+  uint16_t bricks[BRICK_ROWS];
+  int8_t paddle_x, hit_dir;
+  fixed_t ballx, bally, ballh, ballv;
+} brickout_data_t;
+
+class BrickoutGame : MarlinGame { public: static void enter_game(), game_screen(); };
+
+extern BrickoutGame brickout;

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/game/game.cpp

@@ -0,0 +1,66 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../../../inc/MarlinConfigPre.h"
+
+#if HAS_GAMES
+
+#include "game.h"
+
+int MarlinGame::score;
+uint8_t MarlinGame::game_state;
+millis_t MarlinGame::next_frame;
+
+MarlinGameData marlin_game_data;
+
+bool MarlinGame::game_frame() {
+  static int8_t slew;
+  if (ui.first_page) slew = 2;
+  ui.refresh(LCDVIEW_CALL_NO_REDRAW); // Refresh as often as possible
+  return (game_state && slew-- > 0);
+}
+
+void MarlinGame::draw_game_over() {
+  constexpr int8_t gowide = (MENU_FONT_WIDTH) * 9,
+                   gohigh = MENU_FONT_ASCENT - 3,
+                       lx = (LCD_PIXEL_WIDTH - gowide) / 2,
+                       ly = (LCD_PIXEL_HEIGHT + gohigh) / 2;
+  if (PAGE_CONTAINS(ly - gohigh - 1, ly + 1)) {
+    u8g.setColorIndex(0);
+    u8g.drawBox(lx - 1, ly - gohigh - 1, gowide + 2, gohigh + 2);
+    u8g.setColorIndex(1);
+    if (ui.get_blink()) lcd_put_u8str_P(lx, ly, PSTR("GAME OVER"));
+  }
+}
+
+void MarlinGame::init_game(const uint8_t init_state, const screenFunc_t screen) {
+  score = 0;
+  game_state = init_state;
+  ui.goto_screen(screen);
+  ui.defer_status_screen();
+}
+
+void MarlinGame::exit_game() {
+  ui.goto_previous_screen_no_defer();
+}
+
+#endif // HAS_GAMES

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/game/game.h

@@ -0,0 +1,70 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include "../../../inc/MarlinConfigPre.h"
+#include "../../dogm/marlinui_DOGM.h"
+#include "../../lcdprint.h"
+#include "../../marlinui.h"
+
+//#define MUTE_GAMES
+
+#if ENABLED(MUTE_GAMES) || !HAS_BUZZER
+  #define _BUZZ(D,F) NOOP
+#else
+  #define _BUZZ(D,F) BUZZ(D,F)
+#endif
+
+#if HAS_GAME_MENU
+  void menu_game();
+#endif
+
+#if ENABLED(MARLIN_BRICKOUT)
+  #include "brickout.h"
+#endif
+#if ENABLED(MARLIN_INVADERS)
+  #include "invaders.h"
+#endif
+#if ENABLED(MARLIN_MAZE)
+  #include "maze.h"
+#endif
+#if ENABLED(MARLIN_SNAKE)
+  #include "snake.h"
+#endif
+
+// Pool game data to save SRAM
+union MarlinGameData {
+  #if ENABLED(MARLIN_BRICKOUT)
+    brickout_data_t brickout;
+  #endif
+  #if ENABLED(MARLIN_INVADERS)
+    invaders_data_t invaders;
+  #endif
+  #if ENABLED(MARLIN_SNAKE)
+    snake_data_t snake;
+  #endif
+  #if ENABLED(MARLIN_MAZE)
+    maze_data_t maze;
+  #endif
+};
+
+extern MarlinGameData marlin_game_data;

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/game/invaders.cpp

@@ -0,0 +1,438 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../../../inc/MarlinConfigPre.h"
+
+#if ENABLED(MARLIN_INVADERS)
+
+#include "game.h"
+
+#define CANNON_W      11
+#define CANNON_H       8
+#define CANNON_VEL     4
+#define CANNON_Y      (LCD_PIXEL_HEIGHT - 1 - CANNON_H)
+
+#define INVADER_VEL    3
+
+#define INVADER_TOP   MENU_FONT_ASCENT
+#define INVADERS_WIDE ((INVADER_COL_W) * (INVADER_COLS))
+#define INVADERS_HIGH ((INVADER_ROW_H) * (INVADER_ROWS))
+
+#define UFO_H          5
+#define UFO_W         13
+
+#define LASER_H        4
+#define SHOT_H         3
+#define EXPL_W        11
+#define LIFE_W         8
+#define LIFE_H         5
+
+#define INVADER_RIGHT ((INVADER_COLS) * (INVADER_COL_W))
+
+// 11x8
+const unsigned char invader[3][2][16] PROGMEM = {
+  { { B00000110,B00000000,
+      B00001111,B00000000,
+      B00011111,B10000000,
+      B00110110,B11000000,
+      B00111111,B11000000,
+      B00001001,B00000000,
+      B00010110,B10000000,
+      B00101001,B01000000
+    }, {
+      B00000110,B00000000,
+      B00001111,B00000000,
+      B00011111,B10000000,
+      B00110110,B11000000,
+      B00111111,B11000000,
+      B00010110,B10000000,
+      B00100000,B01000000,
+      B00010000,B10000000
+    }
+  }, {
+    { B00010000,B01000000,
+      B00001000,B10000000,
+      B00011111,B11000000,
+      B00110111,B01100000,
+      B01111111,B11110000,
+      B01011111,B11010000,
+      B01010000,B01010000,
+      B00001101,B10000000
+    }, {
+      B00010000,B01000000,
+      B01001000,B10010000,
+      B01011111,B11010000,
+      B01110111,B01110000,
+      B01111111,B11110000,
+      B00011111,B11000000,
+      B00010000,B01000000,
+      B00100000,B00100000
+    }
+  }, {
+    { B00001111,B00000000,
+      B01111111,B11100000,
+      B11111111,B11110000,
+      B11100110,B01110000,
+      B11111111,B11110000,
+      B00011001,B10000000,
+      B00110110,B11000000,
+      B11000000,B00110000
+    }, {
+      B00001111,B00000000,
+      B01111111,B11100000,
+      B11111111,B11110000,
+      B11100110,B01110000,
+      B11111111,B11110000,
+      B00011001,B10000000,
+      B00110110,B11000000,
+      B00011001,B10000000
+    }
+  }
+};
+const unsigned char cannon[] PROGMEM = {
+  B00000100,B00000000,
+  B00001110,B00000000,
+  B00001110,B00000000,
+  B01111111,B11000000,
+  B11111111,B11100000,
+  B11111111,B11100000,
+  B11111111,B11100000,
+  B11111111,B11100000
+};
+const unsigned char life[] PROGMEM = {
+  B00010000,
+  B01111100,
+  B11111110,
+  B11111110,
+  B11111110
+};
+const unsigned char explosion[] PROGMEM = {
+  B01000100,B01000000,
+  B00100100,B10000000,
+  B00000000,B00000000,
+  B00110001,B10000000,
+  B00000000,B00000000,
+  B00100100,B10000000,
+  B01000100,B01000000
+};
+const unsigned char ufo[] PROGMEM = {
+  B00011111,B11000000,
+  B01111111,B11110000,
+  B11011101,B11011000,
+  B11111111,B11111000,
+  B01111111,B11110000
+};
+
+constexpr uint8_t inv_type[] = {
+  #if INVADER_ROWS == 5
+    0, 1, 1, 2, 2
+  #elif INVADER_ROWS == 4
+    0, 1, 1, 2
+  #elif INVADER_ROWS == 3
+    0, 1, 2
+  #else
+    #error "INVASION_SIZE must be 3, 4, or 5."
+  #endif
+};
+
+invaders_data_t &idat = marlin_game_data.invaders;
+
+#define INV_X_LEFT(C,T) (idat.pos.x + (C) * (INVADER_COL_W) + inv_off[T])
+#define INV_X_CTR(C,T)  (INV_X_LEFT(C,T) + inv_wide[T] / 2)
+#define INV_Y_BOT(R)    (idat.pos.y + (R + 1) * (INVADER_ROW_H) - 2)
+
+constexpr uint8_t inv_off[] = { 2, 1, 0 }, inv_wide[] = { 8, 11, 12 };
+
+inline void update_invader_data() {
+  uint8_t inv_mask = 0;
+  // Get a list of all active invaders
+  uint8_t sc = 0;
+  LOOP_L_N(y, INVADER_ROWS) {
+    uint8_t m = idat.bugs[y];
+    if (m) idat.botmost = y + 1;
+    inv_mask |= m;
+    LOOP_L_N(x, INVADER_COLS)
+      if (TEST(m, x)) idat.shooters[sc++] = (y << 4) | x;
+  }
+  idat.leftmost = 0;
+  LOOP_L_N(i, INVADER_COLS)            { if (TEST(inv_mask, i)) break; idat.leftmost -= INVADER_COL_W; }
+  idat.rightmost = LCD_PIXEL_WIDTH - (INVADERS_WIDE);
+  for (uint8_t i = INVADER_COLS; i--;) { if (TEST(inv_mask, i)) break; idat.rightmost += INVADER_COL_W; }
+  if (idat.count == 2) idat.dir = idat.dir > 0 ? INVADER_VEL + 1 : -(INVADER_VEL + 1);
+}
+
+inline void reset_bullets() {
+  LOOP_L_N(i, COUNT(idat.bullet)) idat.bullet[i].v = 0;
+}
+
+inline void reset_invaders() {
+  idat.pos.x = 0; idat.pos.y = INVADER_TOP;
+  idat.dir = INVADER_VEL;
+  idat.count = (INVADER_COLS) * (INVADER_ROWS);
+  LOOP_L_N(i, INVADER_ROWS) idat.bugs[i] = _BV(INVADER_COLS) - 1;
+  update_invader_data();
+  reset_bullets();
+}
+
+
+inline void spawn_ufo() {
+  idat.ufov = random(0, 2) ? 1 : -1;
+  idat.ufox = idat.ufov > 0 ? -(UFO_W) : LCD_PIXEL_WIDTH - 1;
+}
+
+inline void reset_player() {
+  idat.cannon_x = 0;
+  ui.encoderPosition = 0;
+}
+
+inline void fire_cannon() {
+  idat.laser.x = idat.cannon_x + CANNON_W / 2;
+  idat.laser.y = LCD_PIXEL_HEIGHT - CANNON_H - (LASER_H);
+  idat.laser.v = -(LASER_H);
+}
+
+inline void explode(const int8_t x, const int8_t y, const int8_t v=4) {
+  idat.explod.x = x - (EXPL_W) / 2;
+  idat.explod.y = y;
+  idat.explod.v = v;
+}
+
+inline void kill_cannon(uint8_t &game_state, const uint8_t st) {
+  reset_bullets();
+  explode(idat.cannon_x + (CANNON_W) / 2, CANNON_Y, 6);
+  _BUZZ(1000, 10);
+  if (--idat.cannons_left) {
+    idat.laser.v = 0;
+    game_state = st;
+    reset_player();
+  }
+  else
+    game_state = 0;
+}
+
+void InvadersGame::game_screen() {
+  ui.refresh(LCDVIEW_CALL_NO_REDRAW); // Call as often as possible
+
+  // Run game logic once per full screen
+  if (ui.first_page) {
+
+    // Update Cannon Position
+    int16_t ep = constrain(int16_t(ui.encoderPosition), 0, (LCD_PIXEL_WIDTH - (CANNON_W)) / (CANNON_VEL));
+    ui.encoderPosition = ep;
+
+    ep *= (CANNON_VEL);
+    if (ep > idat.cannon_x) { idat.cannon_x += CANNON_VEL - 1; if (ep - idat.cannon_x < 2) idat.cannon_x = ep; }
+    if (ep < idat.cannon_x) { idat.cannon_x -= CANNON_VEL - 1; if (idat.cannon_x - ep < 2) idat.cannon_x = ep; }
+
+    // Run the game logic
+    if (game_state) do {
+
+      // Move the UFO, if any
+      if (idat.ufov) { idat.ufox += idat.ufov; if (!WITHIN(idat.ufox, -(UFO_W), LCD_PIXEL_WIDTH - 1)) idat.ufov = 0; }
+
+      if (game_state > 1) { if (--game_state == 2) { reset_invaders(); } else if (game_state == 100) { game_state = 1; } break; }
+
+      const bool did_blink = (++idat.blink_count > idat.count >> 1);
+      if (did_blink) {
+        idat.game_blink = !idat.game_blink;
+        idat.blink_count = 0;
+      }
+
+      if (idat.count && did_blink) {
+        const int8_t newx = idat.pos.x + idat.dir;
+        if (!WITHIN(newx, idat.leftmost, idat.rightmost)) { // Invaders reached the edge?
+          idat.dir *= -1;                                   // Invaders change direction
+          idat.pos.y += (INVADER_ROW_H) / 2;                        // Invaders move down
+          idat.pos.x -= idat.dir;                           // ...and only move down this time.
+          if (idat.pos.y + idat.botmost * (INVADER_ROW_H) - 2 >= CANNON_Y) // Invaders reached the bottom?
+            kill_cannon(game_state, 20);                    // Kill the cannon. Reset invaders.
+        }
+
+        idat.pos.x += idat.dir; // Invaders take one step left/right
+
+        // Randomly shoot if invaders are listed
+        if (idat.count && !random(0, 20)) {
+
+          // Find a free bullet
+          laser_t *b = nullptr;
+          LOOP_L_N(i, COUNT(idat.bullet)) if (!idat.bullet[i].v) { b = &idat.bullet[i]; break; }
+          if (b) {
+            // Pick a random shooter and update the bullet
+            //SERIAL_ECHOLNPGM("free bullet found");
+            const uint8_t inv = idat.shooters[random(0, idat.count + 1)], col = inv & 0x0F, row = inv >> 4, type = inv_type[row];
+            b->x = INV_X_CTR(col, type);
+            b->y = INV_Y_BOT(row);
+            b->v = 2 + random(0, 2);
+          }
+        }
+      }
+
+      // Update the laser position
+      if (idat.laser.v) {
+        idat.laser.y += idat.laser.v;
+        if (idat.laser.y < 0) idat.laser.v = 0;
+      }
+
+      // Did the laser collide with an invader?
+      if (idat.laser.v && WITHIN(idat.laser.y, idat.pos.y, idat.pos.y + INVADERS_HIGH - 1)) {
+        const int8_t col = idat.laser_col();
+        if (WITHIN(col, 0, INVADER_COLS - 1)) {
+          const int8_t row = idat.laser_row();
+          if (WITHIN(row, 0, INVADER_ROWS - 1)) {
+            const uint8_t mask = _BV(col);
+            if (idat.bugs[row] & mask) {
+              const uint8_t type = inv_type[row];
+              const int8_t invx = INV_X_LEFT(col, type);
+              if (WITHIN(idat.laser.x, invx, invx + inv_wide[type] - 1)) {
+                // Turn off laser
+                idat.laser.v = 0;
+                // Remove the invader!
+                idat.bugs[row] &= ~mask;
+                // Score!
+                score += INVADER_ROWS - row;
+                // Explode sound!
+                _BUZZ(40, 10);
+                // Explosion bitmap!
+                explode(invx + inv_wide[type] / 2, idat.pos.y + row * (INVADER_ROW_H));
+                // If invaders are gone, go to reset invaders state
+                if (--idat.count) update_invader_data(); else { game_state = 20; reset_bullets(); }
+              } // laser x hit
+            } // invader exists
+          } // good row
+        } // good col
+      } // laser in invader zone
+
+      // Handle alien bullets
+      LOOP_L_N(s, COUNT(idat.bullet)) {
+        laser_t *b = &idat.bullet[s];
+        if (b->v) {
+          // Update alien bullet position
+          b->y += b->v;
+          if (b->y >= LCD_PIXEL_HEIGHT)
+            b->v = 0; // Offscreen
+          else if (b->y >= CANNON_Y && WITHIN(b->x, idat.cannon_x, idat.cannon_x + CANNON_W - 1))
+            kill_cannon(game_state, 120); // Hit the cannon
+        }
+      }
+
+      // Randomly spawn a UFO
+      if (!idat.ufov && !random(0,500)) spawn_ufo();
+
+      // Did the laser hit a ufo?
+      if (idat.laser.v && idat.ufov && idat.laser.y < UFO_H + 2 && WITHIN(idat.laser.x, idat.ufox, idat.ufox + UFO_W - 1)) {
+        // Turn off laser and UFO
+        idat.laser.v = idat.ufov = 0;
+        // Score!
+        score += 10;
+        // Explode!
+        _BUZZ(40, 10);
+        // Explosion bitmap
+        explode(idat.ufox + (UFO_W) / 2, 1);
+      }
+
+    } while (false);
+
+  }
+
+  // Click-and-hold to abort
+  if (ui.button_pressed()) --idat.quit_count; else idat.quit_count = 10;
+
+  // Click to fire or exit
+  if (ui.use_click()) {
+    if (!game_state)
+      idat.quit_count = 0;
+    else if (game_state == 1 && !idat.laser.v)
+      fire_cannon();
+  }
+
+  if (!idat.quit_count) exit_game();
+
+  u8g.setColorIndex(1);
+
+  // Draw invaders
+  if (PAGE_CONTAINS(idat.pos.y, idat.pos.y + idat.botmost * (INVADER_ROW_H) - 2 - 1)) {
+    int8_t yy = idat.pos.y;
+    LOOP_L_N(y, INVADER_ROWS) {
+      const uint8_t type = inv_type[y];
+      if (PAGE_CONTAINS(yy, yy + INVADER_H - 1)) {
+        int8_t xx = idat.pos.x;
+        LOOP_L_N(x, INVADER_COLS) {
+          if (TEST(idat.bugs[y], x))
+            u8g.drawBitmapP(xx, yy, 2, INVADER_H, invader[type][idat.game_blink]);
+          xx += INVADER_COL_W;
+        }
+      }
+      yy += INVADER_ROW_H;
+    }
+  }
+
+  // Draw UFO
+  if (idat.ufov && PAGE_UNDER(UFO_H + 2))
+    u8g.drawBitmapP(idat.ufox, 2, 2, UFO_H, ufo);
+
+  // Draw cannon
+  if (game_state && PAGE_CONTAINS(CANNON_Y, CANNON_Y + CANNON_H - 1) && (game_state < 2 || (game_state & 0x02)))
+    u8g.drawBitmapP(idat.cannon_x, CANNON_Y, 2, CANNON_H, cannon);
+
+  // Draw laser
+  if (idat.laser.v && PAGE_CONTAINS(idat.laser.y, idat.laser.y + LASER_H - 1))
+    u8g.drawVLine(idat.laser.x, idat.laser.y, LASER_H);
+
+  // Draw invader bullets
+  LOOP_L_N (i, COUNT(idat.bullet)) {
+    if (idat.bullet[i].v && PAGE_CONTAINS(idat.bullet[i].y - (SHOT_H - 1), idat.bullet[i].y))
+      u8g.drawVLine(idat.bullet[i].x, idat.bullet[i].y - (SHOT_H - 1), SHOT_H);
+  }
+
+  // Draw explosion
+  if (idat.explod.v && PAGE_CONTAINS(idat.explod.y, idat.explod.y + 7 - 1)) {
+    u8g.drawBitmapP(idat.explod.x, idat.explod.y, 2, 7, explosion);
+    --idat.explod.v;
+  }
+
+  // Blink GAME OVER when game is over
+  if (!game_state) draw_game_over();
+
+  if (PAGE_UNDER(MENU_FONT_ASCENT - 1)) {
+    // Draw Score
+    //const uint8_t sx = (LCD_PIXEL_WIDTH - (score >= 10 ? score >= 100 ? score >= 1000 ? 4 : 3 : 2 : 1) * MENU_FONT_WIDTH) / 2;
+    constexpr uint8_t sx = 0;
+    lcd_put_int(sx, MENU_FONT_ASCENT - 1, score);
+
+    // Draw lives
+    if (idat.cannons_left)
+      for (uint8_t i = 1; i <= idat.cannons_left; ++i)
+        u8g.drawBitmapP(LCD_PIXEL_WIDTH - i * (LIFE_W), 6 - (LIFE_H), 1, LIFE_H, life);
+  }
+
+}
+
+void InvadersGame::enter_game() {
+  init_game(20, game_screen); // countdown to reset invaders
+  idat.cannons_left = 3;
+  idat.quit_count = 10;
+  idat.laser.v = 0;
+  reset_invaders();
+  reset_player();
+}
+
+#endif // MARLIN_INVADERS

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/game/invaders.h

@@ -0,0 +1,62 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include "types.h"
+
+#define INVASION_SIZE 3
+
+#if INVASION_SIZE == 3
+  #define INVADER_COLS   5
+#elif INVASION_SIZE == 4
+  #define INVADER_COLS   6
+#else
+  #define INVADER_COLS   8
+  #undef INVASION_SIZE
+  #define INVASION_SIZE  5
+#endif
+
+#define INVADER_ROWS INVASION_SIZE
+
+#define INVADER_COL_W   14
+#define INVADER_H        8
+#define INVADER_ROW_H   (INVADER_H + 2)
+
+typedef struct { int8_t x, y, v; } laser_t;
+
+typedef struct {
+  pos_t pos;
+  uint8_t cannons_left;
+  int8_t cannon_x;
+  laser_t bullet[10], laser, explod;
+  int8_t dir, leftmost, rightmost, botmost;
+  uint8_t count, quit_count, blink_count;
+  uint8_t bugs[INVADER_ROWS], shooters[(INVADER_ROWS) * (INVADER_COLS)];
+  int8_t ufox, ufov;
+  bool game_blink;
+  int8_t laser_col() { return ((laser.x - pos.x) / (INVADER_COL_W)); };
+  int8_t laser_row() { return ((laser.y - pos.y + 2) / (INVADER_ROW_H)); };
+} invaders_data_t;
+
+class InvadersGame : MarlinGame { public: static void enter_game(), game_screen(); };
+
+extern InvadersGame invaders;

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/game/maze.cpp

@@ -0,0 +1,134 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../../../inc/MarlinConfigPre.h"
+
+#if ENABLED(MARLIN_MAZE)
+
+#include "game.h"
+
+int8_t move_dir, last_move_dir, // NESW0
+       prizex, prizey, prize_cnt, old_encoder;
+fixed_t playerx, playery;
+
+// Up to 50 lines, then you win!
+typedef struct { int8_t x, y; } pos_t;
+uint8_t head_ind;
+pos_t maze_walls[50] = {
+  { 0, 0 }
+};
+
+// Turn the player cw or ccw
+inline void turn_player(const bool cw) {
+  if (move_dir == 4) move_dir = last_move_dir;
+  move_dir += cw ? 1 : -1;
+  move_dir &= 0x03;
+  last_move_dir = move_dir;
+}
+
+// Reset the player for a new game
+void player_reset() {
+  // Init position
+  playerx = BTOF(1);
+  playery = BTOF(GAME_H / 2);
+
+  // Init motion with a ccw turn
+  move_dir = 0;
+  turn_player(false);
+
+  // Clear prize flag
+  prize_cnt = 255;
+
+  // Clear the controls
+  ui.encoderPosition = 0;
+  old_encoder = 0;
+}
+
+void MazeGame::game_screen() {
+  // Run the sprite logic
+  if (game_frame()) do {     // Run logic twice for finer resolution
+
+    // Move the man one unit in the current direction
+    // Direction index 4 is for the stopped man
+    const int8_t oldx = FTOB(playerx), oldy = FTOB(playery);
+    pos_t dir_add[] = { { 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 }, { 0, 0 } };
+    playerx += dir_add[move_dir].x;
+    playery += dir_add[move_dir].y;
+    const int8_t x = FTOB(playerx), y = FTOB(playery);
+
+  } while(0);
+
+  u8g.setColorIndex(1);
+
+  // Draw Score
+  if (PAGE_UNDER(HEADER_H)) lcd_put_int(0, HEADER_H - 1, score);
+
+  // Draw the maze
+  // LOOP_L_N(n, head_ind) {
+  //   const pos_t &p = maze_walls[n], &q = maze_walls[n + 1];
+  //   if (p.x == q.x) {
+  //     const int8_t y1 = GAMEY(_MIN(p.y, q.y)), y2 = GAMEY(_MAX(p.y, q.y));
+  //     if (PAGE_CONTAINS(y1, y2))
+  //       u8g.drawVLine(GAMEX(p.x), y1, y2 - y1 + 1);
+  //   }
+  //   else if (PAGE_CONTAINS(GAMEY(p.y), GAMEY(p.y))) {
+  //     const int8_t x1 = GAMEX(_MIN(p.x, q.x)), x2 = GAMEX(_MAX(p.x, q.x));
+  //     u8g.drawHLine(x1, GAMEY(p.y), x2 - x1 + 1);
+  //   }
+  // }
+
+  // Draw Man
+  // const int8_t fy = GAMEY(foody);
+  // if (PAGE_CONTAINS(fy, fy + FOOD_WH - 1)) {
+  //   const int8_t fx = GAMEX(foodx);
+  //   u8g.drawFrame(fx, fy, FOOD_WH, FOOD_WH);
+  //   if (FOOD_WH == 5) u8g.drawPixel(fx + 2, fy + 2);
+  // }
+
+  // Draw Ghosts
+  // const int8_t fy = GAMEY(foody);
+  // if (PAGE_CONTAINS(fy, fy + FOOD_WH - 1)) {
+  //   const int8_t fx = GAMEX(foodx);
+  //   u8g.drawFrame(fx, fy, FOOD_WH, FOOD_WH);
+  //   if (FOOD_WH == 5) u8g.drawPixel(fx + 2, fy + 2);
+  // }
+
+  // Draw Prize
+  // if (PAGE_CONTAINS(prizey, prizey + PRIZE_WH - 1)) {
+  //   u8g.drawFrame(prizex, prizey, PRIZE_WH, PRIZE_WH);
+  //   if (PRIZE_WH == 5) u8g.drawPixel(prizex + 2, prizey + 2);
+  // }
+
+  // Draw GAME OVER
+  if (!game_state) draw_game_over();
+
+  // A click always exits this game
+  if (ui.use_click()) exit_game();
+}
+
+void MazeGame::enter_game() {
+  init_game(1, game_screen); // Game running
+  reset_player();
+  reset_enemies();
+}
+
+#endif // MARLIN_MAZE

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/game/maze.h

@@ -0,0 +1,30 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include "types.h"
+
+typedef struct { pos_t pos; } maze_data_t;
+
+class MazeGame : MarlinGame { public: static void enter_game(), game_screen(); };
+
+extern MazeGame maze;

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/game/snake.cpp

@@ -0,0 +1,323 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../../../inc/MarlinConfigPre.h"
+
+#if ENABLED(MARLIN_SNAKE)
+
+#include "game.h"
+
+#define SNAKE_BOX 4
+
+#define HEADER_H  (MENU_FONT_ASCENT - 2)
+#define SNAKE_WH  (SNAKE_BOX + 1)
+
+#define IDEAL_L   2
+#define IDEAL_R   (LCD_PIXEL_WIDTH - 1 - 2)
+#define IDEAL_T   (HEADER_H + 2)
+#define IDEAL_B   (LCD_PIXEL_HEIGHT - 1 - 2)
+#define IDEAL_W   (IDEAL_R - (IDEAL_L) + 1)
+#define IDEAL_H   (IDEAL_B - (IDEAL_T) + 1)
+
+#define GAME_W    int((IDEAL_W) / (SNAKE_WH))
+#define GAME_H    int((IDEAL_H) / (SNAKE_WH))
+
+#define BOARD_W   ((SNAKE_WH) * (GAME_W) + 1)
+#define BOARD_H   ((SNAKE_WH) * (GAME_H) + 1)
+#define BOARD_L   ((LCD_PIXEL_WIDTH - (BOARD_W) + 1) / 2)
+#define BOARD_R   (BOARD_L + BOARD_W - 1)
+#define BOARD_T   (((LCD_PIXEL_HEIGHT + IDEAL_T) - (BOARD_H)) / 2)
+#define BOARD_B   (BOARD_T + BOARD_H - 1)
+
+#define GAMEX(X)  (BOARD_L + ((X) * (SNAKE_WH)))
+#define GAMEY(Y)  (BOARD_T + ((Y) * (SNAKE_WH)))
+
+#if SNAKE_BOX > 2
+  #define FOOD_WH SNAKE_BOX
+#else
+  #define FOOD_WH 2
+#endif
+
+#if SNAKE_BOX < 1
+  #define SNAKE_SIZ 1
+#else
+  #define SNAKE_SIZ SNAKE_BOX
+#endif
+
+constexpr fixed_t snakev = FTOP(0.20);
+
+snake_data_t &sdat = marlin_game_data.snake;
+
+// Remove the first pixel from the tail.
+// If needed, shift out the first segment.
+void shorten_tail() {
+  pos_t &p = sdat.snake_tail[0], &q = sdat.snake_tail[1];
+  bool shift = false;
+  if (p.x == q.x) {
+    // Vertical line
+    p.y += (q.y > p.y) ? 1 : -1;
+    shift = p.y == q.y;
+  }
+  else {
+    // Horizontal line
+    p.x += (q.x > p.x) ? 1 : -1;
+    shift = p.x == q.x;
+  }
+  if (shift) {
+    sdat.head_ind--;
+    LOOP_LE_N(i, sdat.head_ind)
+      sdat.snake_tail[i] = sdat.snake_tail[i + 1];
+  }
+}
+
+// The food is on a line
+inline bool food_on_line() {
+  LOOP_L_N(n, sdat.head_ind) {
+    pos_t &p = sdat.snake_tail[n], &q = sdat.snake_tail[n + 1];
+    if (p.x == q.x) {
+      if ((sdat.foodx == p.x - 1 || sdat.foodx == p.x) && WITHIN(sdat.foody, _MIN(p.y, q.y), _MAX(p.y, q.y)))
+        return true;
+    }
+    else if ((sdat.foody == p.y - 1 || sdat.foody == p.y) && WITHIN(sdat.foodx, _MIN(p.x, q.x), _MAX(p.x, q.x)))
+      return true;
+  }
+  return false;
+}
+
+// Add a new food blob
+void food_reset() {
+  do {
+    sdat.foodx = random(0, GAME_W);
+    sdat.foody = random(0, GAME_H);
+  } while (food_on_line());
+}
+
+// Turn the snake cw or ccw
+inline void turn_snake(const bool cw) {
+  sdat.snake_dir += cw ? 1 : -1;
+  sdat.snake_dir &= 0x03;
+  sdat.head_ind++;
+  sdat.snake_tail[sdat.head_ind].x = FTOB(sdat.snakex);
+  sdat.snake_tail[sdat.head_ind].y = FTOB(sdat.snakey);
+}
+
+// Reset the snake for a new game
+void snake_reset() {
+  // Init the head and velocity
+  sdat.snakex = BTOF(1);
+  sdat.snakey = BTOF(GAME_H / 2);
+  //snakev = FTOP(0.25);
+
+  // Init the tail with a cw turn
+  sdat.snake_dir = 0;
+  sdat.head_ind = 0;
+  sdat.snake_tail[0].x = 0;
+  sdat.snake_tail[0].y = GAME_H / 2;
+  turn_snake(true);
+
+  // Clear food flag
+  sdat.food_cnt = 5;
+
+  // Clear the controls
+  ui.encoderPosition = 0;
+  sdat.old_encoder = 0;
+}
+
+// Check if head segment overlaps another
+bool snake_overlap() {
+  // 4 lines must exist before a collision is possible
+  if (sdat.head_ind < 4) return false;
+  // Is the last segment crossing any others?
+  const pos_t &h1 = sdat.snake_tail[sdat.head_ind - 1], &h2 = sdat.snake_tail[sdat.head_ind];
+  // VERTICAL head segment?
+  if (h1.x == h2.x) {
+    // Loop from oldest to segment two away from head
+    LOOP_L_N(n, sdat.head_ind - 2) {
+      // Segment p to q
+      const pos_t &p = sdat.snake_tail[n], &q = sdat.snake_tail[n + 1];
+      if (p.x != q.x) {
+        // Crossing horizontal segment
+        if (WITHIN(h1.x, _MIN(p.x, q.x), _MAX(p.x, q.x)) && (h1.y <= p.y) == (h2.y >= p.y)) return true;
+      } // Overlapping vertical segment
+      else if (h1.x == p.x && _MIN(h1.y, h2.y) <= _MAX(p.y, q.y) && _MAX(h1.y, h2.y) >= _MIN(p.y, q.y)) return true;
+    }
+  }
+  else {
+    // Loop from oldest to segment two away from head
+    LOOP_L_N(n, sdat.head_ind - 2) {
+      // Segment p to q
+      const pos_t &p = sdat.snake_tail[n], &q = sdat.snake_tail[n + 1];
+      if (p.y != q.y) {
+        // Crossing vertical segment
+        if (WITHIN(h1.y, _MIN(p.y, q.y), _MAX(p.y, q.y)) && (h1.x <= p.x) == (h2.x >= p.x)) return true;
+      } // Overlapping horizontal segment
+      else if (h1.y == p.y && _MIN(h1.x, h2.x) <= _MAX(p.x, q.x) && _MAX(h1.x, h2.x) >= _MIN(p.x, q.x)) return true;
+    }
+  }
+  return false;
+}
+
+void SnakeGame::game_screen() {
+  // Run the snake logic
+  if (game_frame()) do {    // Run logic twice for finer resolution
+
+    // Move the snake's head one unit in the current direction
+    const int8_t oldx = FTOB(sdat.snakex), oldy = FTOB(sdat.snakey);
+    switch (sdat.snake_dir) {
+      case 0: sdat.snakey -= snakev; break;
+      case 1: sdat.snakex += snakev; break;
+      case 2: sdat.snakey += snakev; break;
+      case 3: sdat.snakex -= snakev; break;
+    }
+    const int8_t x = FTOB(sdat.snakex), y = FTOB(sdat.snakey);
+
+    // If movement took place...
+    if (oldx != x || oldy != y) {
+
+      if (!WITHIN(x, 0, GAME_W - 1) || !WITHIN(y, 0, GAME_H - 1)) {
+        game_state = 0; // Game Over
+        _BUZZ(400, 40); // Bzzzt!
+        break;          // ...out of do-while
+      }
+
+      sdat.snake_tail[sdat.head_ind].x = x;
+      sdat.snake_tail[sdat.head_ind].y = y;
+
+      // Change snake direction if set
+      const int8_t enc = int8_t(ui.encoderPosition), diff = enc - sdat.old_encoder;
+      if (diff) {
+        sdat.old_encoder = enc;
+        turn_snake(diff > 0);
+      }
+
+      if (sdat.food_cnt) --sdat.food_cnt; else shorten_tail();
+
+      // Did the snake collide with itself or go out of bounds?
+      if (snake_overlap()) {
+        game_state = 0; // Game Over
+        _BUZZ(400, 40); // Bzzzt!
+      }
+      // Is the snake at the food?
+      else if (x == sdat.foodx && y == sdat.foody) {
+        _BUZZ(5, 220);
+        _BUZZ(5, 280);
+        score++;
+        sdat.food_cnt = 2;
+        food_reset();
+      }
+    }
+
+  } while(0);
+
+  u8g.setColorIndex(1);
+
+  // Draw Score
+  if (PAGE_UNDER(HEADER_H)) lcd_put_int(0, HEADER_H - 1, score);
+
+  // DRAW THE PLAYFIELD BORDER
+  u8g.drawFrame(BOARD_L - 2, BOARD_T - 2, BOARD_R - BOARD_L + 4, BOARD_B - BOARD_T + 4);
+
+  // Draw the snake (tail)
+  #if SNAKE_WH < 2
+
+    // At this scale just draw a line
+    LOOP_L_N(n, sdat.head_ind) {
+      const pos_t &p = sdat.snake_tail[n], &q = sdat.snake_tail[n + 1];
+      if (p.x == q.x) {
+        const int8_t y1 = GAMEY(_MIN(p.y, q.y)), y2 = GAMEY(_MAX(p.y, q.y));
+        if (PAGE_CONTAINS(y1, y2))
+          u8g.drawVLine(GAMEX(p.x), y1, y2 - y1 + 1);
+      }
+      else if (PAGE_CONTAINS(GAMEY(p.y), GAMEY(p.y))) {
+        const int8_t x1 = GAMEX(_MIN(p.x, q.x)), x2 = GAMEX(_MAX(p.x, q.x));
+        u8g.drawHLine(x1, GAMEY(p.y), x2 - x1 + 1);
+      }
+    }
+
+  #elif SNAKE_WH == 2
+
+    // At this scale draw two lines
+    LOOP_L_N(n, sdat.head_ind) {
+      const pos_t &p = sdat.snake_tail[n], &q = sdat.snake_tail[n + 1];
+      if (p.x == q.x) {
+        const int8_t y1 = GAMEY(_MIN(p.y, q.y)), y2 = GAMEY(_MAX(p.y, q.y));
+        if (PAGE_CONTAINS(y1, y2 + 1))
+          u8g.drawFrame(GAMEX(p.x), y1, 2, y2 - y1 + 1 + 1);
+      }
+      else {
+        const int8_t py = GAMEY(p.y);
+        if (PAGE_CONTAINS(py, py + 1)) {
+          const int8_t x1 = GAMEX(_MIN(p.x, q.x)), x2 = GAMEX(_MAX(p.x, q.x));
+          u8g.drawFrame(x1, py, x2 - x1 + 1 + 1, 2);
+        }
+      }
+    }
+
+  #else
+
+    // Draw a series of boxes
+    LOOP_L_N(n, sdat.head_ind) {
+      const pos_t &p = sdat.snake_tail[n], &q = sdat.snake_tail[n + 1];
+      if (p.x == q.x) {
+        const int8_t y1 = _MIN(p.y, q.y), y2 = _MAX(p.y, q.y);
+        if (PAGE_CONTAINS(GAMEY(y1), GAMEY(y2) + SNAKE_SIZ - 1)) {
+          for (int8_t i = y1; i <= y2; ++i) {
+            const int8_t y = GAMEY(i);
+            if (PAGE_CONTAINS(y, y + SNAKE_SIZ - 1))
+              u8g.drawBox(GAMEX(p.x), y, SNAKE_SIZ, SNAKE_SIZ);
+          }
+        }
+      }
+      else {
+        const int8_t py = GAMEY(p.y);
+        if (PAGE_CONTAINS(py, py + SNAKE_SIZ - 1)) {
+          const int8_t x1 = _MIN(p.x, q.x), x2 = _MAX(p.x, q.x);
+          for (int8_t i = x1; i <= x2; ++i)
+            u8g.drawBox(GAMEX(i), py, SNAKE_SIZ, SNAKE_SIZ);
+        }
+      }
+    }
+
+  #endif
+
+  // Draw food
+  const int8_t fy = GAMEY(sdat.foody);
+  if (PAGE_CONTAINS(fy, fy + FOOD_WH - 1)) {
+    const int8_t fx = GAMEX(sdat.foodx);
+    u8g.drawFrame(fx, fy, FOOD_WH, FOOD_WH);
+    if (FOOD_WH == 5) u8g.drawPixel(fx + 2, fy + 2);
+  }
+
+  // Draw GAME OVER
+  if (!game_state) draw_game_over();
+
+  // A click always exits this game
+  if (ui.use_click()) exit_game();
+}
+
+void SnakeGame::enter_game() {
+  init_game(1, game_screen); // 1 = Game running
+  snake_reset();
+  food_reset();
+}
+
+#endif // MARLIN_SNAKE

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/game/snake.h

@@ -0,0 +1,38 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include "types.h"
+
+typedef struct {
+  int8_t snake_dir,     // NESW
+         foodx, foody,
+         food_cnt,
+         old_encoder;
+  pos_t snake_tail[50];
+  fixed_t snakex, snakey;
+  uint8_t head_ind;
+} snake_data_t;
+
+class SnakeGame : MarlinGame { public: static void enter_game(), game_screen(); };
+
+extern SnakeGame snake;

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/game/types.h

@@ -0,0 +1,46 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include <stdint.h>
+
+typedef struct { int8_t x, y; } pos_t;
+
+// Simple 8:8 fixed-point
+typedef int16_t fixed_t;
+#define FTOP(F) fixed_t((F)*256.0f)
+#define PTOF(P) (float(P)*(1.0f/256.0f))
+#define BTOF(X) (fixed_t(X)<<8)
+#define FTOB(X) int8_t(fixed_t(X)>>8)
+
+class MarlinGame {
+protected:
+  static int score;
+  static uint8_t game_state;
+  static millis_t next_frame;
+
+  static bool game_frame();
+  static void draw_game_over();
+  static void exit_game();
+public:
+  static void init_game(const uint8_t init_state, const screenFunc_t screen);
+};

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu.cpp

@@ -0,0 +1,385 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if HAS_LCD_MENU
+
+#include "menu.h"
+#include "../../module/planner.h"
+#include "../../module/motion.h"
+#include "../../module/printcounter.h"
+#include "../../gcode/queue.h"
+
+#if HAS_BUZZER
+  #include "../../libs/buzzer.h"
+#endif
+
+#if ENABLED(BABYSTEP_ZPROBE_OFFSET)
+  #include "../../module/probe.h"
+#endif
+
+#if EITHER(ENABLE_LEVELING_FADE_HEIGHT, AUTO_BED_LEVELING_UBL)
+  #include "../../feature/bedlevel/bedlevel.h"
+#endif
+
+////////////////////////////////////////////
+///////////// Global Variables /////////////
+////////////////////////////////////////////
+
+// Menu Navigation
+int8_t encoderTopLine, encoderLine, screen_items;
+
+typedef struct {
+  screenFunc_t menu_function;
+  uint32_t encoder_position;
+  int8_t top_line, items;
+} menuPosition;
+menuPosition screen_history[6];
+uint8_t screen_history_depth = 0;
+
+int8_t MenuItemBase::itemIndex;   // Index number for draw and action
+PGM_P MenuItemBase::itemString;   // A PSTR for substitution
+chimera_t editable;               // Value Editing
+
+// Menu Edit Items
+PGM_P        MenuEditItemBase::editLabel;
+void*        MenuEditItemBase::editValue;
+int32_t      MenuEditItemBase::minEditValue,
+             MenuEditItemBase::maxEditValue;
+screenFunc_t MenuEditItemBase::callbackFunc;
+bool         MenuEditItemBase::liveEdit;
+
+////////////////////////////////////////////
+//////// Menu Navigation & History /////////
+////////////////////////////////////////////
+
+void MarlinUI::return_to_status() { goto_screen(status_screen); }
+
+void MarlinUI::save_previous_screen() {
+  if (screen_history_depth < COUNT(screen_history))
+    screen_history[screen_history_depth++] = { currentScreen, encoderPosition, encoderTopLine, screen_items };
+}
+
+void MarlinUI::_goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, const bool is_back/*=false*/)) {
+  IF_DISABLED(TURBO_BACK_MENU_ITEM, constexpr bool is_back = false);
+  TERN_(HAS_TOUCH_BUTTONS, on_edit_screen = false);
+  if (screen_history_depth > 0) {
+    menuPosition &sh = screen_history[--screen_history_depth];
+    goto_screen(sh.menu_function,
+      is_back ? 0 : sh.encoder_position,
+      is_back ? 0 : sh.top_line,
+      sh.items
+    );
+  }
+  else
+    return_to_status();
+}
+
+////////////////////////////////////////////
+/////////// Menu Editing Actions ///////////
+////////////////////////////////////////////
+
+/**
+ * Functions for editing single values
+ *
+ * The "DEFINE_MENU_EDIT_ITEM" macro generates the classes needed to edit a numerical value.
+ *
+ * The prerequisite is that in the header the type was already declared:
+ *
+ *   DEFINE_MENU_EDIT_ITEM_TYPE(int3, int16_t, i16tostr3rj, 1)
+ *
+ * For example, DEFINE_MENU_EDIT_ITEM(int3) expands into:
+ *
+ *   template class TMenuEditItem<MenuEditItemInfo_int3>
+ *
+ * You can then use one of the menu macros to present the edit interface:
+ *   EDIT_ITEM(int3, MSG_SPEED, &feedrate_percentage, 10, 999)
+ *
+ * This expands into a more primitive menu item:
+ *  _MENU_ITEM_P(int3, false, GET_TEXT(MSG_SPEED), &feedrate_percentage, 10, 999)
+ *
+ * ...which calls:
+ *       MenuItem_int3::action(plabel, &feedrate_percentage, 10, 999)
+ *       MenuItem_int3::draw(encoderLine == _thisItemNr, _lcdLineNr, plabel, &feedrate_percentage, 10, 999)
+ */
+void MenuEditItemBase::edit_screen(strfunc_t strfunc, loadfunc_t loadfunc) {
+  TERN_(HAS_TOUCH_BUTTONS, ui.repeat_delay = BUTTON_DELAY_EDIT);
+  if (int32_t(ui.encoderPosition) < 0) ui.encoderPosition = 0;
+  if (int32_t(ui.encoderPosition) > maxEditValue) ui.encoderPosition = maxEditValue;
+  if (ui.should_draw())
+    draw_edit_screen(strfunc(ui.encoderPosition + minEditValue));
+  if (ui.lcd_clicked || (liveEdit && ui.should_draw())) {
+    if (editValue) loadfunc(editValue, ui.encoderPosition + minEditValue);
+    if (callbackFunc && (liveEdit || ui.lcd_clicked)) (*callbackFunc)();
+    if (ui.use_click()) ui.goto_previous_screen();
+  }
+}
+
+void MenuEditItemBase::goto_edit_screen(
+  PGM_P const el,         // Edit label
+  void * const ev,        // Edit value pointer
+  const int32_t minv,     // Encoder minimum
+  const int32_t maxv,     // Encoder maximum
+  const uint16_t ep,      // Initial encoder value
+  const screenFunc_t cs,  // MenuItem_type::draw_edit_screen => MenuEditItemBase::edit()
+  const screenFunc_t cb,  // Callback after edit
+  const bool le           // Flag to call cb() during editing
+) {
+  TERN_(HAS_TOUCH_BUTTONS, ui.on_edit_screen = true);
+  ui.screen_changed = true;
+  ui.save_previous_screen();
+  ui.refresh();
+  editLabel = el;
+  editValue = ev;
+  minEditValue = minv;
+  maxEditValue = maxv;
+  ui.encoderPosition = ep;
+  ui.currentScreen = cs;
+  callbackFunc = cb;
+  liveEdit = le;
+}
+
+////////////////////////////////////////////
+///////////////// Menu Tree ////////////////
+////////////////////////////////////////////
+
+#include "../../MarlinCore.h"
+
+bool printer_busy() {
+  return planner.movesplanned() || printingIsActive();
+}
+
+/**
+ * General function to go directly to a screen
+ */
+void MarlinUI::goto_screen(screenFunc_t screen, const uint16_t encoder/*=0*/, const uint8_t top/*=0*/, const uint8_t items/*=0*/) {
+  if (currentScreen != screen) {
+
+    TERN_(HAS_TOUCH_BUTTONS, repeat_delay = BUTTON_DELAY_MENU);
+
+    TERN_(LCD_SET_PROGRESS_MANUALLY, progress_reset());
+
+    #if BOTH(DOUBLECLICK_FOR_Z_BABYSTEPPING, BABYSTEPPING)
+      static millis_t doubleclick_expire_ms = 0;
+      // Going to menu_main from status screen? Remember first click time.
+      // Going back to status screen within a very short time? Go to Z babystepping.
+      if (screen == menu_main) {
+        if (on_status_screen())
+          doubleclick_expire_ms = millis() + DOUBLECLICK_MAX_INTERVAL;
+      }
+      else if (screen == status_screen && currentScreen == menu_main && PENDING(millis(), doubleclick_expire_ms)) {
+        if (BABYSTEP_ALLOWED())
+          screen = TERN(BABYSTEP_ZPROBE_OFFSET, lcd_babystep_zoffset, lcd_babystep_z);
+        else {
+          #if ENABLED(MOVE_Z_WHEN_IDLE)
+            ui.manual_move.menu_scale = MOVE_Z_IDLE_MULTIPLICATOR;
+            screen = lcd_move_z;
+          #endif
+        }
+      }
+    #endif
+
+    currentScreen = screen;
+    encoderPosition = encoder;
+    encoderTopLine = top;
+    screen_items = items;
+    if (on_status_screen()) {
+      defer_status_screen(false);
+      clear_menu_history();
+      TERN_(AUTO_BED_LEVELING_UBL, ubl.lcd_map_control = false);
+    }
+
+    clear_lcd();
+
+    // Re-initialize custom characters that may be re-used
+    #if HAS_MARLINUI_HD44780
+      if (TERN1(AUTO_BED_LEVELING_UBL, !ubl.lcd_map_control))
+        set_custom_characters(on_status_screen() ? CHARSET_INFO : CHARSET_MENU);
+    #endif
+
+    refresh(LCDVIEW_CALL_REDRAW_NEXT);
+    screen_changed = true;
+    TERN_(HAS_MARLINUI_U8GLIB, drawing_screen = false);
+
+    TERN_(HAS_LCD_MENU, encoder_direction_normal());
+
+    set_selection(false);
+  }
+}
+
+////////////////////////////////////////////
+///////////// Manual Movement //////////////
+////////////////////////////////////////////
+
+//
+// Display a "synchronize" screen with a custom message until
+// all moves are finished. Go back to calling screen when done.
+//
+void MarlinUI::synchronize(PGM_P const msg/*=nullptr*/) {
+  static PGM_P sync_message = msg ?: GET_TEXT(MSG_MOVING);
+  save_previous_screen();
+  goto_screen([]{
+    if (should_draw()) MenuItem_static::draw(LCD_HEIGHT >= 4, sync_message);
+  });
+  defer_status_screen();
+  planner.synchronize(); // idle() is called until moves complete
+  goto_previous_screen_no_defer();
+}
+
+/**
+ * Scrolling for menus and other line-based screens
+ *
+ *   encoderLine is the position based on the encoder
+ *   encoderTopLine is the top menu line to display
+ *   _lcdLineNr is the index of the LCD line (e.g., 0-3)
+ *   _menuLineNr is the menu item to draw and process
+ *   _thisItemNr is the index of each MENU_ITEM or STATIC_ITEM
+ *   screen_items is the total number of items in the menu (after one call)
+ */
+void scroll_screen(const uint8_t limit, const bool is_menu) {
+  ui.encoder_direction_menus();
+  ENCODER_RATE_MULTIPLY(false);
+  if (int32_t(ui.encoderPosition) < 0) ui.encoderPosition = 0;
+  if (ui.first_page) {
+    encoderLine = ui.encoderPosition / (ENCODER_STEPS_PER_MENU_ITEM);
+    ui.screen_changed = false;
+  }
+  if (screen_items > 0 && encoderLine >= screen_items - limit) {
+    encoderLine = _MAX(0, screen_items - limit);
+    ui.encoderPosition = encoderLine * (ENCODER_STEPS_PER_MENU_ITEM);
+  }
+  if (is_menu) {
+    NOMORE(encoderTopLine, encoderLine);
+    if (encoderLine >= encoderTopLine + LCD_HEIGHT)
+      encoderTopLine = encoderLine - LCD_HEIGHT + 1;
+  }
+  else
+    encoderTopLine = encoderLine;
+}
+
+#if HAS_BUZZER
+  void MarlinUI::completion_feedback(const bool good/*=true*/) {
+    if (good) {
+      BUZZ(100, 659);
+      BUZZ(100, 698);
+    }
+    else BUZZ(20, 440);
+  }
+#endif
+
+#if HAS_LINE_TO_Z
+
+  void line_to_z(const_float_t z) {
+    current_position.z = z;
+    line_to_current_position(manual_feedrate_mm_s.z);
+  }
+
+#endif
+
+#if ENABLED(BABYSTEP_ZPROBE_OFFSET)
+
+  #include "../../feature/babystep.h"
+
+  void lcd_babystep_zoffset() {
+    if (ui.use_click()) return ui.goto_previous_screen_no_defer();
+    ui.defer_status_screen();
+    const bool do_probe = DISABLED(BABYSTEP_HOTEND_Z_OFFSET) || active_extruder == 0;
+    if (ui.encoderPosition) {
+      const int16_t babystep_increment = int16_t(ui.encoderPosition) * (BABYSTEP_SIZE_Z);
+      ui.encoderPosition = 0;
+
+      const float diff = planner.steps_to_mm[Z_AXIS] * babystep_increment,
+                  new_probe_offset = probe.offset.z + diff,
+                  new_offs = TERN(BABYSTEP_HOTEND_Z_OFFSET
+                    , do_probe ? new_probe_offset : hotend_offset[active_extruder].z - diff
+                    , new_probe_offset
+                  );
+      if (WITHIN(new_offs, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX)) {
+
+        babystep.add_steps(Z_AXIS, babystep_increment);
+
+        if (do_probe)
+          probe.offset.z = new_offs;
+        else
+          TERN(BABYSTEP_HOTEND_Z_OFFSET, hotend_offset[active_extruder].z = new_offs, NOOP);
+
+        ui.refresh(LCDVIEW_CALL_REDRAW_NEXT);
+      }
+    }
+    if (ui.should_draw()) {
+      if (do_probe) {
+        MenuEditItemBase::draw_edit_screen(GET_TEXT(MSG_ZPROBE_ZOFFSET), BABYSTEP_TO_STR(probe.offset.z));
+        TERN_(BABYSTEP_ZPROBE_GFX_OVERLAY, _lcd_zoffset_overlay_gfx(probe.offset.z));
+      }
+      else {
+        #if ENABLED(BABYSTEP_HOTEND_Z_OFFSET)
+          MenuEditItemBase::draw_edit_screen(GET_TEXT(MSG_HOTEND_OFFSET_Z), ftostr54sign(hotend_offset[active_extruder].z));
+        #endif
+      }
+    }
+  }
+
+#endif // BABYSTEP_ZPROBE_OFFSET
+
+void _lcd_draw_homing() {
+  if (ui.should_draw()) {
+    constexpr uint8_t line = (LCD_HEIGHT - 1) / 2;
+    MenuItem_static::draw(line, GET_TEXT(MSG_LEVEL_BED_HOMING));
+  }
+}
+
+#if ENABLED(LCD_BED_LEVELING) || (HAS_LEVELING && DISABLED(SLIM_LCD_MENUS))
+  #include "../../feature/bedlevel/bedlevel.h"
+  void _lcd_toggle_bed_leveling() { set_bed_leveling_enabled(!planner.leveling_active); }
+#endif
+
+//
+// Selection screen presents a prompt and two options
+//
+bool MarlinUI::selection; // = false
+bool MarlinUI::update_selection() {
+  encoder_direction_select();
+  if (encoderPosition) {
+    selection = int16_t(encoderPosition) > 0;
+    encoderPosition = 0;
+  }
+  return selection;
+}
+
+void MenuItem_confirm::select_screen(
+  PGM_P const yes, PGM_P const no,
+  selectFunc_t yesFunc, selectFunc_t noFunc,
+  PGM_P const pref, const char * const string/*=nullptr*/, PGM_P const suff/*=nullptr*/
+) {
+  const bool ui_selection = ui.update_selection(), got_click = ui.use_click();
+  if (got_click || ui.should_draw()) {
+    draw_select_screen(yes, no, ui_selection, pref, string, suff);
+    if (got_click) {
+      selectFunc_t callFunc = ui_selection ? yesFunc : noFunc;
+      if (callFunc) callFunc(); else ui.goto_previous_screen();
+    }
+    ui.defer_status_screen();
+  }
+}
+
+#endif // HAS_LCD_MENU

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu.h

@@ -0,0 +1,252 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include "../marlinui.h"
+#include "../../libs/numtostr.h"
+#include "../../inc/MarlinConfig.h"
+
+#include "limits.h"
+
+extern int8_t encoderLine, encoderTopLine, screen_items;
+
+void scroll_screen(const uint8_t limit, const bool is_menu);
+bool printer_busy();
+
+typedef void (*selectFunc_t)();
+
+#define SS_LEFT    0x00
+#define SS_CENTER  0x01
+#define SS_INVERT  0x02
+#define SS_DEFAULT SS_CENTER
+
+#if HAS_MARLINUI_U8GLIB && EITHER(BABYSTEP_ZPROBE_GFX_OVERLAY, MESH_EDIT_GFX_OVERLAY)
+  void _lcd_zoffset_overlay_gfx(const_float_t zvalue);
+#endif
+
+#if ENABLED(BABYSTEP_ZPROBE_OFFSET) && Z_PROBE_OFFSET_RANGE_MIN >= -9 && Z_PROBE_OFFSET_RANGE_MAX <= 9
+  #define BABYSTEP_TO_STR(N) ftostr43sign(N)
+#elif ENABLED(BABYSTEPPING)
+  #define BABYSTEP_TO_STR(N) ftostr53sign(N)
+#endif
+
+////////////////////////////////////////////
+///////////// Base Menu Items //////////////
+////////////////////////////////////////////
+
+class MenuItemBase {
+  public:
+    // Index to interject in the item label and/or for use by its action.
+    static int8_t itemIndex;
+
+    // An optional pointer for use in display or by the action
+    static PGM_P itemString;
+
+    // Store the index of the item ahead of use by indexed items
+    FORCE_INLINE static void init(const int8_t ind=0, PGM_P const pstr=nullptr) { itemIndex = ind; itemString = pstr; }
+
+    // Draw an item either selected (pre_char) or not (space) with post_char
+    static void _draw(const bool sel, const uint8_t row, PGM_P const pstr, const char pre_char, const char post_char);
+
+    // Draw an item either selected ('>') or not (space) with post_char
+    FORCE_INLINE static void _draw(const bool sel, const uint8_t row, PGM_P const pstr, const char post_char) {
+      _draw(sel, row, pstr, '>', post_char);
+    }
+};
+
+// STATIC_ITEM(LABEL,...)
+class MenuItem_static : public MenuItemBase {
+  public:
+    static void draw(const uint8_t row, PGM_P const pstr, const uint8_t style=SS_DEFAULT, const char * const vstr=nullptr);
+};
+
+// BACK_ITEM(LABEL)
+class MenuItem_back : public MenuItemBase {
+  public:
+    FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr) {
+      _draw(sel, row, pstr, LCD_STR_UPLEVEL[0], LCD_STR_UPLEVEL[0]);
+    }
+    // Back Item action goes back one step in history
+    FORCE_INLINE static void action(PGM_P const=nullptr) { ui.go_back(); }
+};
+
+// CONFIRM_ITEM(LABEL,Y,N,FY,FN,...),
+// YESNO_ITEM(LABEL,FY,FN,...)
+class MenuItem_confirm : public MenuItemBase {
+  public:
+    FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, ...) {
+      _draw(sel, row, pstr, '>', LCD_STR_ARROW_RIGHT[0]);
+    }
+    // Implemented for HD44780 and DOGM
+    // Draw the prompt, buttons, and state
+    static void draw_select_screen(
+      PGM_P const yes,            // Right option label
+      PGM_P const no,             // Left option label
+      const bool yesno,           // Is "yes" selected?
+      PGM_P const pref,           // Prompt prefix
+      const char * const string,  // Prompt runtime string
+      PGM_P const suff            // Prompt suffix
+    );
+    static void select_screen(
+      PGM_P const yes, PGM_P const no,
+      selectFunc_t yesFunc, selectFunc_t noFunc,
+      PGM_P const pref, const char * const string=nullptr, PGM_P const suff=nullptr
+    );
+    static inline void select_screen(
+      PGM_P const yes, PGM_P const no,
+      selectFunc_t yesFunc, selectFunc_t noFunc,
+      PGM_P const pref, const progmem_str string, PGM_P const suff=nullptr
+    ) {
+      char str[strlen_P((PGM_P)string) + 1];
+      strcpy_P(str, (PGM_P)string);
+      select_screen(yes, no, yesFunc, noFunc, pref, str, suff);
+    }
+    // Shortcut for prompt with "NO"/ "YES" labels
+    FORCE_INLINE static void confirm_screen(selectFunc_t yesFunc, selectFunc_t noFunc, PGM_P const pref, const char * const string=nullptr, PGM_P const suff=nullptr) {
+      select_screen(GET_TEXT(MSG_YES), GET_TEXT(MSG_NO), yesFunc, noFunc, pref, string, suff);
+    }
+};
+
+////////////////////////////////////////////
+///////////// Edit Menu Items //////////////
+////////////////////////////////////////////
+
+// The Menu Edit shadow value
+typedef union {
+  bool     state;
+  float    decimal;
+  int8_t   int8;
+  int16_t  int16;
+  int32_t  int32;
+  uint8_t  uint8;
+  uint16_t uint16;
+  uint32_t uint32;
+} chimera_t;
+extern chimera_t editable;
+
+// Base class for Menu Edit Items
+class MenuEditItemBase : public MenuItemBase {
+  private:
+    // These values are statically constructed by init() via action()
+    // The action() method acts like the instantiator. The entire lifespan
+    // of a menu item is within its declaration, so all these values decompose
+    // into behavior and unused items get optimized out.
+    static PGM_P editLabel;
+    static void *editValue;
+    static int32_t minEditValue, maxEditValue;  // Encoder value range
+    static screenFunc_t callbackFunc;
+    static bool liveEdit;
+  protected:
+    typedef const char* (*strfunc_t)(const int32_t);
+    typedef void (*loadfunc_t)(void *, const int32_t);
+    static void goto_edit_screen(
+      PGM_P const el,         // Edit label
+      void * const ev,        // Edit value pointer
+      const int32_t minv,     // Encoder minimum
+      const int32_t maxv,     // Encoder maximum
+      const uint16_t ep,      // Initial encoder value
+      const screenFunc_t cs,  // MenuItem_type::draw_edit_screen => MenuEditItemBase::edit()
+      const screenFunc_t cb,  // Callback after edit
+      const bool le           // Flag to call cb() during editing
+    );
+    static void edit_screen(strfunc_t, loadfunc_t); // Edit value handler
+  public:
+    // Implemented for HD44780 and DOGM
+    // Draw the current item at specified row with edit data
+    static void draw(const bool sel, const uint8_t row, PGM_P const pstr, const char * const inStr, const bool pgm=false);
+
+    // Implemented for HD44780 and DOGM
+    // This low-level method is good to draw from anywhere
+    static void draw_edit_screen(PGM_P const pstr, const char * const value);
+
+    // This method is for the current menu item
+    static inline void draw_edit_screen(const char * const value) { draw_edit_screen(editLabel, value); }
+};
+
+#if ENABLED(SDSUPPORT)
+  class CardReader;
+  class MenuItem_sdbase {
+    public:
+      // Implemented for HD44780 and DOGM
+      static void draw(const bool sel, const uint8_t row, PGM_P const pstr, CardReader &theCard, const bool isDir);
+  };
+#endif
+
+////////////////////////////////////////////
+/////////////// Menu Screens ///////////////
+////////////////////////////////////////////
+
+void menu_main();
+void menu_move();
+
+#if ENABLED(SDSUPPORT)
+  void menu_media();
+#endif
+
+////////////////////////////////////////////
+//////// Menu Item Helper Functions ////////
+////////////////////////////////////////////
+
+void lcd_move_z();
+void _lcd_draw_homing();
+
+#define HAS_LINE_TO_Z ANY(DELTA, PROBE_MANUALLY, MESH_BED_LEVELING, LEVEL_BED_CORNERS)
+
+#if HAS_LINE_TO_Z
+  void line_to_z(const_float_t z);
+#endif
+
+#if ENABLED(PROBE_OFFSET_WIZARD)
+  void goto_probe_offset_wizard();
+#endif
+
+#if ENABLED(LCD_BED_LEVELING) || (HAS_LEVELING && DISABLED(SLIM_LCD_MENUS))
+  void _lcd_toggle_bed_leveling();
+#endif
+
+#if ENABLED(BABYSTEPPING)
+  #if ENABLED(BABYSTEP_ZPROBE_OFFSET)
+    void lcd_babystep_zoffset();
+  #else
+    void lcd_babystep_z();
+  #endif
+
+  #if ENABLED(BABYSTEP_MILLIMETER_UNITS)
+    #define BABYSTEP_SIZE_X int32_t((BABYSTEP_MULTIPLICATOR_XY) * planner.settings.axis_steps_per_mm[X_AXIS])
+    #define BABYSTEP_SIZE_Y int32_t((BABYSTEP_MULTIPLICATOR_XY) * planner.settings.axis_steps_per_mm[Y_AXIS])
+    #define BABYSTEP_SIZE_Z int32_t((BABYSTEP_MULTIPLICATOR_Z)  * planner.settings.axis_steps_per_mm[Z_AXIS])
+  #else
+    #define BABYSTEP_SIZE_X BABYSTEP_MULTIPLICATOR_XY
+    #define BABYSTEP_SIZE_Y BABYSTEP_MULTIPLICATOR_XY
+    #define BABYSTEP_SIZE_Z BABYSTEP_MULTIPLICATOR_Z
+  #endif
+
+#endif
+
+#if ENABLED(TOUCH_SCREEN_CALIBRATION)
+  void touch_screen_calibration();
+#endif
+
+extern uint8_t screen_history_depth;
+inline void clear_menu_history() { screen_history_depth = 0; }
+
+#define STICKY_SCREEN(S) []{ ui.defer_status_screen(); ui.goto_screen(S); }

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_addon.h

@@ -0,0 +1,33 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include "../lcdprint.h"
+
+#define _MENU_ITEM_ADDON_START(N,X) do{ \
+  if (ui.should_draw() && _menuLineNr == _thisItemNr - 1) { \
+    N(X)
+
+#define MENU_ITEM_ADDON_START(X)    _MENU_ITEM_ADDON_START(SETCURSOR_X,    X)
+#define MENU_ITEM_ADDON_START_RJ(X) _MENU_ITEM_ADDON_START(SETCURSOR_X_RJ, X)
+
+#define MENU_ITEM_ADDON_END() } }while(0)

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_advanced.cpp

@@ -0,0 +1,652 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Advanced Settings Menus
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if HAS_LCD_MENU
+
+#include "menu_item.h"
+#include "../../module/planner.h"
+
+#if DISABLED(NO_VOLUMETRICS)
+  #include "../../gcode/parser.h"
+#endif
+
+#if HAS_BED_PROBE
+  #include "../../module/probe.h"
+#endif
+
+#if ENABLED(PIDTEMP)
+  #include "../../module/temperature.h"
+#endif
+
+#if HAS_FILAMENT_RUNOUT_DISTANCE
+  #include "../../feature/runout.h"
+#endif
+
+#if ENABLED(SD_FIRMWARE_UPDATE)
+  #include "../../module/settings.h"
+#endif
+
+#if ENABLED(PASSWORD_FEATURE)
+  #include "../../feature/password/password.h"
+#endif
+
+void menu_tmc();
+void menu_backlash();
+
+#if ENABLED(HAS_MOTOR_CURRENT_DAC)
+
+  #include "../../feature/dac/stepper_dac.h"
+
+  void menu_dac() {
+    static xyze_uint8_t driverPercent;
+    LOOP_LOGICAL_AXES(i) driverPercent[i] = stepper_dac.get_current_percent((AxisEnum)i);
+    START_MENU();
+    BACK_ITEM(MSG_ADVANCED_SETTINGS);
+    #define EDIT_DAC_PERCENT(A) EDIT_ITEM(uint8, MSG_DAC_PERCENT_##A, &driverPercent[_AXIS(A)], 0, 100, []{ stepper_dac.set_current_percents(driverPercent); })
+    LOGICAL_AXIS_CODE(EDIT_DAC_PERCENT(E), EDIT_DAC_PERCENT(X), EDIT_DAC_PERCENT(Y), EDIT_DAC_PERCENT(Z), EDIT_DAC_PERCENT(I), EDIT_DAC_PERCENT(J), EDIT_DAC_PERCENT(K));
+    ACTION_ITEM(MSG_DAC_EEPROM_WRITE, stepper_dac.commit_eeprom);
+    END_MENU();
+  }
+
+#endif
+
+#if HAS_MOTOR_CURRENT_PWM
+
+  #include "../../module/stepper.h"
+
+  void menu_pwm() {
+    START_MENU();
+    BACK_ITEM(MSG_ADVANCED_SETTINGS);
+    #define EDIT_CURRENT_PWM(LABEL,I) EDIT_ITEM_P(long5, PSTR(LABEL), &stepper.motor_current_setting[I], 100, 2000, stepper.refresh_motor_power)
+    #if ANY_PIN(MOTOR_CURRENT_PWM_XY, MOTOR_CURRENT_PWM_X, MOTOR_CURRENT_PWM_Y)
+      EDIT_CURRENT_PWM(STR_X STR_Y, 0);
+    #endif
+    #if PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
+      EDIT_CURRENT_PWM(STR_Z, 1);
+    #endif
+    #if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
+      EDIT_CURRENT_PWM(STR_E, 2);
+    #endif
+    END_MENU();
+  }
+
+#endif
+
+#if DISABLED(NO_VOLUMETRICS) || ENABLED(ADVANCED_PAUSE_FEATURE)
+  //
+  // Advanced Settings > Filament
+  //
+  void menu_advanced_filament() {
+    START_MENU();
+    BACK_ITEM(MSG_ADVANCED_SETTINGS);
+
+    #if ENABLED(LIN_ADVANCE)
+      #if EXTRUDERS == 1
+        EDIT_ITEM(float42_52, MSG_ADVANCE_K, &planner.extruder_advance_K[0], 0, 10);
+      #elif HAS_MULTI_EXTRUDER
+        LOOP_L_N(n, EXTRUDERS)
+          EDIT_ITEM_N(float42_52, n, MSG_ADVANCE_K_E, &planner.extruder_advance_K[n], 0, 10);
+      #endif
+    #endif
+
+    #if DISABLED(NO_VOLUMETRICS)
+      EDIT_ITEM(bool, MSG_VOLUMETRIC_ENABLED, &parser.volumetric_enabled, planner.calculate_volumetric_multipliers);
+
+      #if ENABLED(VOLUMETRIC_EXTRUDER_LIMIT)
+        EDIT_ITEM_FAST(float42_52, MSG_VOLUMETRIC_LIMIT, &planner.volumetric_extruder_limit[active_extruder], 0.0f, 20.0f, planner.calculate_volumetric_extruder_limits);
+        #if HAS_MULTI_EXTRUDER
+          LOOP_L_N(n, EXTRUDERS)
+            EDIT_ITEM_FAST_N(float42_52, n, MSG_VOLUMETRIC_LIMIT_E, &planner.volumetric_extruder_limit[n], 0.0f, 20.00f, planner.calculate_volumetric_extruder_limits);
+        #endif
+      #endif
+
+      if (parser.volumetric_enabled) {
+        EDIT_ITEM_FAST(float43, MSG_FILAMENT_DIAM, &planner.filament_size[active_extruder], 1.5f, 3.25f, planner.calculate_volumetric_multipliers);
+        #if HAS_MULTI_EXTRUDER
+          LOOP_L_N(n, EXTRUDERS)
+            EDIT_ITEM_FAST_N(float43, n, MSG_FILAMENT_DIAM_E, &planner.filament_size[n], 1.5f, 3.25f, planner.calculate_volumetric_multipliers);
+        #endif
+      }
+    #endif
+
+    #if ENABLED(ADVANCED_PAUSE_FEATURE)
+      constexpr float extrude_maxlength = TERN(PREVENT_LENGTHY_EXTRUDE, EXTRUDE_MAXLENGTH, 999);
+
+      EDIT_ITEM_FAST(float4, MSG_FILAMENT_UNLOAD, &fc_settings[active_extruder].unload_length, 0, extrude_maxlength);
+      #if HAS_MULTI_EXTRUDER
+        LOOP_L_N(n, EXTRUDERS)
+          EDIT_ITEM_FAST_N(float4, n, MSG_FILAMENTUNLOAD_E, &fc_settings[n].unload_length, 0, extrude_maxlength);
+      #endif
+
+      EDIT_ITEM_FAST(float4, MSG_FILAMENT_LOAD, &fc_settings[active_extruder].load_length, 0, extrude_maxlength);
+      #if HAS_MULTI_EXTRUDER
+        LOOP_L_N(n, EXTRUDERS)
+          EDIT_ITEM_FAST_N(float4, n, MSG_FILAMENTLOAD_E, &fc_settings[n].load_length, 0, extrude_maxlength);
+      #endif
+    #endif
+
+    #if HAS_FILAMENT_RUNOUT_DISTANCE
+      editable.decimal = runout.runout_distance();
+      EDIT_ITEM_FAST(float3, MSG_RUNOUT_DISTANCE_MM, &editable.decimal, 1, 999,
+        []{ runout.set_runout_distance(editable.decimal); }, true
+      );
+    #endif
+
+    END_MENU();
+  }
+
+#endif // !NO_VOLUMETRICS || ADVANCED_PAUSE_FEATURE
+
+//
+// Advanced Settings > Temperature helpers
+//
+
+#if ENABLED(PID_AUTOTUNE_MENU)
+
+  #if ENABLED(PIDTEMP)
+    int16_t autotune_temp[HOTENDS] = ARRAY_BY_HOTENDS1(PREHEAT_1_TEMP_HOTEND);
+  #endif
+  #if ENABLED(PIDTEMPBED)
+    int16_t autotune_temp_bed = PREHEAT_1_TEMP_BED;
+  #endif
+  #if ENABLED(PIDTEMPCHAMBER)
+    int16_t autotune_temp_chamber = PREHEAT_1_TEMP_CHAMBER;
+  #endif
+
+  #include "../../gcode/queue.h"
+
+  void _lcd_autotune(const heater_id_t hid) {
+    char cmd[30];
+    int16_t tune_temp;
+    switch (hid) {
+      #if ENABLED(PIDTEMPBED)
+        case H_BED: tune_temp = autotune_temp_bed; break;
+      #endif
+      #if ENABLED(PIDTEMPCHAMBER)
+        case H_CHAMBER: tune_temp = autotune_temp_chamber; break;
+      #endif
+      default: tune_temp = autotune_temp[hid]; break;
+    }
+    sprintf_P(cmd, PSTR("M303 U1 E%i S%i"), hid, tune_temp);
+    queue.inject(cmd);
+    ui.return_to_status();
+  }
+
+#endif // PID_AUTOTUNE_MENU
+
+#if ENABLED(PID_EDIT_MENU)
+
+  float raw_Ki, raw_Kd; // place-holders for Ki and Kd edits
+
+  // Helpers for editing PID Ki & Kd values
+  // grab the PID value out of the temp variable; scale it; then update the PID driver
+  void copy_and_scalePID_i(int16_t e) {
+    UNUSED(e);
+    PID_PARAM(Ki, e) = scalePID_i(raw_Ki);
+    thermalManager.updatePID();
+  }
+  void copy_and_scalePID_d(int16_t e) {
+    UNUSED(e);
+    PID_PARAM(Kd, e) = scalePID_d(raw_Kd);
+    thermalManager.updatePID();
+  }
+
+  #define _DEFINE_PIDTEMP_BASE_FUNCS(N) \
+    void copy_and_scalePID_i_E##N() { copy_and_scalePID_i(N); } \
+    void copy_and_scalePID_d_E##N() { copy_and_scalePID_d(N); }
+
+#else
+
+  #define _DEFINE_PIDTEMP_BASE_FUNCS(N) //
+
+#endif
+
+#if ENABLED(PID_AUTOTUNE_MENU)
+  #define DEFINE_PIDTEMP_FUNCS(N) \
+    _DEFINE_PIDTEMP_BASE_FUNCS(N); \
+    void lcd_autotune_callback_E##N() { _lcd_autotune(heater_id_t(N)); }
+#else
+  #define DEFINE_PIDTEMP_FUNCS(N) _DEFINE_PIDTEMP_BASE_FUNCS(N);
+#endif
+
+#if HAS_HOTEND
+  DEFINE_PIDTEMP_FUNCS(0);
+  #if ENABLED(PID_PARAMS_PER_HOTEND)
+    REPEAT_S(1, HOTENDS, DEFINE_PIDTEMP_FUNCS)
+  #endif
+#endif
+
+#if BOTH(AUTOTEMP, HAS_TEMP_HOTEND) || EITHER(PID_AUTOTUNE_MENU, PID_EDIT_MENU)
+  #define SHOW_MENU_ADVANCED_TEMPERATURE 1
+#endif
+
+//
+// Advanced Settings > Temperature
+//
+#if SHOW_MENU_ADVANCED_TEMPERATURE
+
+  void menu_advanced_temperature() {
+    START_MENU();
+    BACK_ITEM(MSG_ADVANCED_SETTINGS);
+    //
+    // Autotemp, Min, Max, Fact
+    //
+    #if BOTH(AUTOTEMP, HAS_TEMP_HOTEND)
+      EDIT_ITEM(bool, MSG_AUTOTEMP, &planner.autotemp_enabled);
+      EDIT_ITEM(int3, MSG_MIN, &planner.autotemp_min, 0, thermalManager.hotend_max_target(0));
+      EDIT_ITEM(int3, MSG_MAX, &planner.autotemp_max, 0, thermalManager.hotend_max_target(0));
+      EDIT_ITEM(float42_52, MSG_FACTOR, &planner.autotemp_factor, 0, 10);
+    #endif
+
+    //
+    // PID-P, PID-I, PID-D, PID-C, PID Autotune
+    // PID-P E1, PID-I E1, PID-D E1, PID-C E1, PID Autotune E1
+    // PID-P E2, PID-I E2, PID-D E2, PID-C E2, PID Autotune E2
+    // PID-P E3, PID-I E3, PID-D E3, PID-C E3, PID Autotune E3
+    // PID-P E4, PID-I E4, PID-D E4, PID-C E4, PID Autotune E4
+    // PID-P E5, PID-I E5, PID-D E5, PID-C E5, PID Autotune E5
+    //
+
+    #if ENABLED(PID_EDIT_MENU)
+      #define _PID_EDIT_ITEMS_TMPL(N,T) \
+        raw_Ki = unscalePID_i(T.pid.Ki); \
+        raw_Kd = unscalePID_d(T.pid.Kd); \
+        EDIT_ITEM_FAST_N(float41sign, N, MSG_PID_P_E, &T.pid.Kp, 1, 9990); \
+        EDIT_ITEM_FAST_N(float52sign, N, MSG_PID_I_E, &raw_Ki, 0.01f, 9990, []{ copy_and_scalePID_i(N); }); \
+        EDIT_ITEM_FAST_N(float41sign, N, MSG_PID_D_E, &raw_Kd, 1, 9990, []{ copy_and_scalePID_d(N); })
+
+      #define __PID_HOTEND_MENU_ITEMS(N) \
+        raw_Ki = unscalePID_i(PID_PARAM(Ki, N)); \
+        raw_Kd = unscalePID_d(PID_PARAM(Kd, N)); \
+        EDIT_ITEM_FAST_N(float41sign, N, MSG_PID_P_E, &PID_PARAM(Kp, N), 1, 9990); \
+        EDIT_ITEM_FAST_N(float52sign, N, MSG_PID_I_E, &raw_Ki, 0.01f, 9990, []{ copy_and_scalePID_i(N); }); \
+        EDIT_ITEM_FAST_N(float41sign, N, MSG_PID_D_E, &raw_Kd, 1, 9990, []{ copy_and_scalePID_d(N); })
+
+      #if ENABLED(PID_EXTRUSION_SCALING)
+        #define _PID_HOTEND_MENU_ITEMS(N) \
+          __PID_HOTEND_MENU_ITEMS(N); \
+          EDIT_ITEM_N(float4, N, MSG_PID_C_E, &PID_PARAM(Kc, N), 1, 9990)
+      #else
+        #define _PID_HOTEND_MENU_ITEMS(N) __PID_HOTEND_MENU_ITEMS(N)
+      #endif
+
+      #if ENABLED(PID_FAN_SCALING)
+        #define _HOTEND_PID_EDIT_MENU_ITEMS(N) \
+          _PID_HOTEND_MENU_ITEMS(N); \
+          EDIT_ITEM_N(float4, N, MSG_PID_F_E, &PID_PARAM(Kf, N), 1, 9990)
+      #else
+        #define _HOTEND_PID_EDIT_MENU_ITEMS(N) _PID_HOTEND_MENU_ITEMS(N)
+      #endif
+
+    #else
+
+      #define _HOTEND_PID_EDIT_MENU_ITEMS(N) NOOP
+
+    #endif
+
+    #if ENABLED(PID_AUTOTUNE_MENU)
+      #define HOTEND_PID_EDIT_MENU_ITEMS(N) \
+        _HOTEND_PID_EDIT_MENU_ITEMS(N); \
+        EDIT_ITEM_FAST_N(int3, N, MSG_PID_AUTOTUNE_E, &autotune_temp[N], 150, thermalManager.hotend_max_target(N), []{ _lcd_autotune(heater_id_t(MenuItemBase::itemIndex)); });
+    #else
+      #define HOTEND_PID_EDIT_MENU_ITEMS(N) _HOTEND_PID_EDIT_MENU_ITEMS(N);
+    #endif
+
+    HOTEND_PID_EDIT_MENU_ITEMS(0);
+    #if ENABLED(PID_PARAMS_PER_HOTEND)
+      REPEAT_S(1, HOTENDS, HOTEND_PID_EDIT_MENU_ITEMS)
+    #endif
+
+    #if ENABLED(PIDTEMPBED)
+      #if ENABLED(PID_EDIT_MENU)
+        _PID_EDIT_ITEMS_TMPL(H_BED, thermalManager.temp_bed);
+      #endif
+      #if ENABLED(PID_AUTOTUNE_MENU)
+        EDIT_ITEM_FAST_N(int3, H_BED, MSG_PID_AUTOTUNE_E, &autotune_temp_bed, PREHEAT_1_TEMP_BED, BED_MAX_TARGET, []{ _lcd_autotune(H_BED); });
+      #endif
+    #endif
+
+    #if ENABLED(PIDTEMPCHAMBER)
+      #if ENABLED(PID_EDIT_MENU)
+        _PID_EDIT_ITEMS_TMPL(H_CHAMBER, thermalManager.temp_chamber);
+      #endif
+      #if ENABLED(PID_AUTOTUNE_MENU)
+        EDIT_ITEM_FAST_N(int3, H_CHAMBER, MSG_PID_AUTOTUNE_E, &autotune_temp_chamber, PREHEAT_1_TEMP_CHAMBER, CHAMBER_MAX_TARGET, []{ _lcd_autotune(H_CHAMBER); });
+      #endif
+    #endif
+
+    END_MENU();
+  }
+
+#endif // SHOW_MENU_ADVANCED_TEMPERATURE
+
+#if DISABLED(SLIM_LCD_MENUS)
+
+  // M203 / M205 Velocity options
+  void menu_advanced_velocity() {
+    // M203 Max Feedrate
+    constexpr xyze_feedrate_t max_fr_edit =
+      #ifdef MAX_FEEDRATE_EDIT_VALUES
+        MAX_FEEDRATE_EDIT_VALUES
+      #elif ENABLED(LIMITED_MAX_FR_EDITING)
+        DEFAULT_MAX_FEEDRATE
+      #else
+        LOGICAL_AXIS_ARRAY(9999, 9999, 9999, 9999, 9999, 9999, 9999)
+      #endif
+    ;
+    #if ENABLED(LIMITED_MAX_FR_EDITING) && !defined(MAX_FEEDRATE_EDIT_VALUES)
+      const xyze_feedrate_t max_fr_edit_scaled = max_fr_edit * 2;
+    #else
+      const xyze_feedrate_t &max_fr_edit_scaled = max_fr_edit;
+    #endif
+
+    START_MENU();
+    BACK_ITEM(MSG_ADVANCED_SETTINGS);
+
+    #define EDIT_VMAX(N) EDIT_ITEM_FAST(float5, MSG_VMAX_##N, &planner.settings.max_feedrate_mm_s[_AXIS(N)], 1, max_fr_edit_scaled[_AXIS(N)])
+    LINEAR_AXIS_CODE(EDIT_VMAX(A), EDIT_VMAX(B), EDIT_VMAX(C), EDIT_VMAX(I), EDIT_VMAX(J), EDIT_VMAX(K));
+
+    #if E_STEPPERS
+      EDIT_ITEM_FAST(float5, MSG_VMAX_E, &planner.settings.max_feedrate_mm_s[E_AXIS_N(active_extruder)], 1, max_fr_edit_scaled.e);
+    #endif
+    #if ENABLED(DISTINCT_E_FACTORS)
+      LOOP_L_N(n, E_STEPPERS)
+        EDIT_ITEM_FAST_N(float5, n, MSG_VMAX_EN, &planner.settings.max_feedrate_mm_s[E_AXIS_N(n)], 1, max_fr_edit_scaled.e);
+    #endif
+
+    // M205 S Min Feedrate
+    EDIT_ITEM_FAST(float5, MSG_VMIN, &planner.settings.min_feedrate_mm_s, 0, 9999);
+
+    // M205 T Min Travel Feedrate
+    EDIT_ITEM_FAST(float5, MSG_VTRAV_MIN, &planner.settings.min_travel_feedrate_mm_s, 0, 9999);
+
+    END_MENU();
+  }
+
+  // M201 / M204 Accelerations
+  void menu_advanced_acceleration() {
+    const 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]);
+
+    // M201 settings
+    constexpr xyze_ulong_t max_accel_edit =
+      #ifdef MAX_ACCEL_EDIT_VALUES
+        MAX_ACCEL_EDIT_VALUES
+      #elif ENABLED(LIMITED_MAX_ACCEL_EDITING)
+        DEFAULT_MAX_ACCELERATION
+      #else
+        LOGICAL_AXIS_ARRAY(99000, 99000, 99000, 99000, 99000, 99000, 99000)
+      #endif
+    ;
+    #if ENABLED(LIMITED_MAX_ACCEL_EDITING) && !defined(MAX_ACCEL_EDIT_VALUES)
+      const xyze_ulong_t max_accel_edit_scaled = max_accel_edit * 2;
+    #else
+      const xyze_ulong_t &max_accel_edit_scaled = max_accel_edit;
+    #endif
+
+    START_MENU();
+    BACK_ITEM(MSG_ADVANCED_SETTINGS);
+
+    // M204 P Acceleration
+    EDIT_ITEM_FAST(float5_25, MSG_ACC, &planner.settings.acceleration, 25, max_accel);
+
+    #if HAS_EXTRUDERS
+      // M204 R Retract Acceleration
+      EDIT_ITEM_FAST(float5, MSG_A_RETRACT, &planner.settings.retract_acceleration, 100, planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(active_extruder)]);
+    #endif
+
+    // M204 T Travel Acceleration
+    EDIT_ITEM_FAST(float5_25, MSG_A_TRAVEL, &planner.settings.travel_acceleration, 25, max_accel);
+
+    #define EDIT_AMAX(Q,L) EDIT_ITEM_FAST(long5_25, MSG_AMAX_##Q, &planner.settings.max_acceleration_mm_per_s2[_AXIS(Q)], L, max_accel_edit_scaled[_AXIS(Q)], []{ planner.reset_acceleration_rates(); })
+    LINEAR_AXIS_CODE(
+      EDIT_AMAX(A, 100), EDIT_AMAX(B, 100), EDIT_AMAX(C, 10),
+      EDIT_AMAX(I,  10), EDIT_AMAX(J,  10), EDIT_AMAX(K, 10)
+    );
+
+    #if ENABLED(DISTINCT_E_FACTORS)
+      EDIT_ITEM_FAST(long5_25, MSG_AMAX_E, &planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(active_extruder)], 100, max_accel_edit_scaled.e, []{ planner.reset_acceleration_rates(); });
+      LOOP_L_N(n, E_STEPPERS)
+        EDIT_ITEM_FAST_N(long5_25, n, MSG_AMAX_EN, &planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(n)], 100, max_accel_edit_scaled.e, []{
+          if (MenuItemBase::itemIndex == active_extruder)
+            planner.reset_acceleration_rates();
+       });
+    #elif E_STEPPERS
+      EDIT_ITEM_FAST(long5_25, MSG_AMAX_E, &planner.settings.max_acceleration_mm_per_s2[E_AXIS], 100, max_accel_edit_scaled.e, []{ planner.reset_acceleration_rates(); });
+    #endif
+
+    #ifdef XY_FREQUENCY_LIMIT
+      EDIT_ITEM(int8, MSG_XY_FREQUENCY_LIMIT, &planner.xy_freq_limit_hz, 0, 100, planner.refresh_frequency_limit, true);
+      editable.uint8 = uint8_t(LROUND(planner.xy_freq_min_speed_factor * 255)); // percent to u8
+      EDIT_ITEM(percent, MSG_XY_FREQUENCY_FEEDRATE, &editable.uint8, 3, 255, []{ planner.set_min_speed_factor_u8(editable.uint8); }, true);
+    #endif
+
+    END_MENU();
+  }
+
+  #if HAS_CLASSIC_JERK
+
+    void menu_advanced_jerk() {
+      START_MENU();
+      BACK_ITEM(MSG_ADVANCED_SETTINGS);
+
+      #if HAS_JUNCTION_DEVIATION
+        #if ENABLED(LIN_ADVANCE)
+          EDIT_ITEM(float43, MSG_JUNCTION_DEVIATION, &planner.junction_deviation_mm, 0.001f, 0.3f, planner.recalculate_max_e_jerk);
+        #else
+          EDIT_ITEM(float43, MSG_JUNCTION_DEVIATION, &planner.junction_deviation_mm, 0.001f, 0.5f);
+        #endif
+      #endif
+
+      constexpr xyze_float_t max_jerk_edit =
+        #ifdef MAX_JERK_EDIT_VALUES
+          MAX_JERK_EDIT_VALUES
+        #elif ENABLED(LIMITED_JERK_EDITING)
+          { (DEFAULT_XJERK) * 2, (DEFAULT_YJERK) * 2, (DEFAULT_ZJERK) * 2, (DEFAULT_EJERK) * 2 }
+        #else
+          { 990, 990, 990, 990 }
+        #endif
+      ;
+      #define EDIT_JERK(N) EDIT_ITEM_FAST(float3, MSG_V##N##_JERK, &planner.max_jerk[_AXIS(N)], 1, max_jerk_edit[_AXIS(N)])
+      #if ENABLED(DELTA)
+        #define EDIT_JERK_C() EDIT_JERK(C)
+      #else
+        #define EDIT_JERK_C() EDIT_ITEM_FAST(float52sign, MSG_VC_JERK, &planner.max_jerk.c, 0.1f, max_jerk_edit.c)
+      #endif
+      LINEAR_AXIS_CODE(
+        EDIT_JERK(A), EDIT_JERK(B), EDIT_JERK_C(),
+        EDIT_JERK(I), EDIT_JERK(J), EDIT_JERK(K)
+      );
+
+      #if HAS_EXTRUDERS
+        EDIT_ITEM_FAST(float52sign, MSG_VE_JERK, &planner.max_jerk.e, 0.1f, max_jerk_edit.e);
+      #endif
+
+      END_MENU();
+    }
+
+  #endif
+
+  // M851 - Z Probe Offsets
+  #if HAS_BED_PROBE
+    void menu_probe_offsets() {
+      START_MENU();
+      BACK_ITEM(MSG_ADVANCED_SETTINGS);
+      #if HAS_PROBE_XY_OFFSET
+        EDIT_ITEM(float31sign, MSG_ZPROBE_XOFFSET, &probe.offset.x, -(X_BED_SIZE), X_BED_SIZE);
+        EDIT_ITEM(float31sign, MSG_ZPROBE_YOFFSET, &probe.offset.y, -(Y_BED_SIZE), Y_BED_SIZE);
+      #endif
+      EDIT_ITEM(LCD_Z_OFFSET_TYPE, MSG_ZPROBE_ZOFFSET, &probe.offset.z, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX);
+
+      #if ENABLED(PROBE_OFFSET_WIZARD)
+        SUBMENU(MSG_PROBE_WIZARD, goto_probe_offset_wizard);
+      #endif
+
+      END_MENU();
+    }
+  #endif
+
+#endif // !SLIM_LCD_MENUS
+
+// M92 Steps-per-mm
+void menu_advanced_steps_per_mm() {
+  START_MENU();
+  BACK_ITEM(MSG_ADVANCED_SETTINGS);
+
+  #define EDIT_QSTEPS(Q) EDIT_ITEM_FAST(float51, MSG_##Q##_STEPS, &planner.settings.axis_steps_per_mm[_AXIS(Q)], 5, 9999, []{ planner.refresh_positioning(); })
+  LINEAR_AXIS_CODE(
+    EDIT_QSTEPS(A), EDIT_QSTEPS(B), EDIT_QSTEPS(C),
+    EDIT_QSTEPS(I), EDIT_QSTEPS(J), EDIT_QSTEPS(K)
+  );
+
+  #if ENABLED(DISTINCT_E_FACTORS)
+    LOOP_L_N(n, E_STEPPERS)
+      EDIT_ITEM_FAST_N(float51, n, MSG_EN_STEPS, &planner.settings.axis_steps_per_mm[E_AXIS_N(n)], 5, 9999, []{
+        const uint8_t e = MenuItemBase::itemIndex;
+        if (e == active_extruder)
+          planner.refresh_positioning();
+        else
+          planner.steps_to_mm[E_AXIS_N(e)] = 1.0f / planner.settings.axis_steps_per_mm[E_AXIS_N(e)];
+      });
+  #elif E_STEPPERS
+    EDIT_ITEM_FAST(float51, MSG_E_STEPS, &planner.settings.axis_steps_per_mm[E_AXIS], 5, 9999, []{ planner.refresh_positioning(); });
+  #endif
+
+  END_MENU();
+}
+
+void menu_advanced_settings() {
+  const bool is_busy = printer_busy();
+
+  #if ENABLED(SD_FIRMWARE_UPDATE)
+    bool sd_update_state = settings.sd_update_status();
+  #endif
+
+  START_MENU();
+  BACK_ITEM(MSG_CONFIGURATION);
+
+  #if DISABLED(SLIM_LCD_MENUS)
+
+    #if HAS_M206_COMMAND
+      //
+      // Set Home Offsets
+      //
+      ACTION_ITEM(MSG_SET_HOME_OFFSETS, []{ queue.inject_P(PSTR("M428")); ui.return_to_status(); });
+    #endif
+
+    // M203 / M205 - Feedrate items
+    SUBMENU(MSG_VELOCITY, menu_advanced_velocity);
+
+    // M201 - Acceleration items
+    SUBMENU(MSG_ACCELERATION, menu_advanced_acceleration);
+
+    #if HAS_CLASSIC_JERK
+      // M205 - Max Jerk
+      SUBMENU(MSG_JERK, menu_advanced_jerk);
+    #elif HAS_JUNCTION_DEVIATION
+      EDIT_ITEM(float43, MSG_JUNCTION_DEVIATION, &planner.junction_deviation_mm, 0.001f, 0.3f
+        #if ENABLED(LIN_ADVANCE)
+          , planner.recalculate_max_e_jerk
+        #endif
+      );
+    #endif
+
+    // M851 - Z Probe Offsets
+    #if HAS_BED_PROBE
+      if (!is_busy) SUBMENU(MSG_ZPROBE_OFFSETS, menu_probe_offsets);
+    #endif
+
+  #endif // !SLIM_LCD_MENUS
+
+  // M92 - Steps Per mm
+  if (!is_busy)
+    SUBMENU(MSG_STEPS_PER_MM, menu_advanced_steps_per_mm);
+
+  #if ENABLED(BACKLASH_GCODE)
+    SUBMENU(MSG_BACKLASH, menu_backlash);
+  #endif
+
+  #if ENABLED(HAS_MOTOR_CURRENT_DAC)
+    SUBMENU(MSG_DRIVE_STRENGTH, menu_dac);
+  #endif
+  #if HAS_MOTOR_CURRENT_PWM
+    SUBMENU(MSG_DRIVE_STRENGTH, menu_pwm);
+  #endif
+
+  #if HAS_TRINAMIC_CONFIG
+    SUBMENU(MSG_TMC_DRIVERS, menu_tmc);
+  #endif
+
+  #if SHOW_MENU_ADVANCED_TEMPERATURE
+    SUBMENU(MSG_TEMPERATURE, menu_advanced_temperature);
+  #endif
+
+  #if DISABLED(NO_VOLUMETRICS) || ENABLED(ADVANCED_PAUSE_FEATURE)
+    SUBMENU(MSG_FILAMENT, menu_advanced_filament);
+  #elif ENABLED(LIN_ADVANCE)
+    #if EXTRUDERS == 1
+      EDIT_ITEM(float42_52, MSG_ADVANCE_K, &planner.extruder_advance_K[0], 0, 10);
+    #elif HAS_MULTI_EXTRUDER
+      LOOP_L_N(n, E_STEPPERS)
+        EDIT_ITEM_N(float42_52, n, MSG_ADVANCE_K_E, &planner.extruder_advance_K[n], 0, 10);
+    #endif
+  #endif
+
+  // M540 S - Abort on endstop hit when SD printing
+  #if ENABLED(SD_ABORT_ON_ENDSTOP_HIT)
+    EDIT_ITEM(bool, MSG_ENDSTOP_ABORT, &planner.abort_on_endstop_hit);
+  #endif
+
+  #if ENABLED(SD_FIRMWARE_UPDATE)
+    EDIT_ITEM(bool, MSG_MEDIA_UPDATE, &sd_update_state, []{
+      //
+      // Toggle the SD Firmware Update state in EEPROM
+      //
+      const bool new_state = !settings.sd_update_status(),
+                 didset = settings.set_sd_update_status(new_state);
+      ui.completion_feedback(didset);
+      ui.return_to_status();
+      if (new_state) LCD_MESSAGEPGM(MSG_RESET_PRINTER); else ui.reset_status();
+    });
+  #endif
+
+  #if ENABLED(PASSWORD_FEATURE)
+    SUBMENU(MSG_PASSWORD_SETTINGS, password.access_menu_password);
+  #endif
+
+  #if ENABLED(EEPROM_SETTINGS) && DISABLED(SLIM_LCD_MENUS)
+    CONFIRM_ITEM(MSG_INIT_EEPROM,
+      MSG_BUTTON_INIT, MSG_BUTTON_CANCEL,
+      ui.init_eeprom, nullptr,
+      GET_TEXT(MSG_INIT_EEPROM), (const char *)nullptr, PSTR("?")
+    );
+  #endif
+
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_backlash.cpp

@@ -0,0 +1,71 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Backlash Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if BOTH(HAS_LCD_MENU, BACKLASH_GCODE)
+
+#include "menu_item.h"
+
+#include "../../feature/backlash.h"
+
+void menu_backlash() {
+  START_MENU();
+  BACK_ITEM(MSG_MAIN);
+
+  EDIT_ITEM_FAST(percent, MSG_BACKLASH_CORRECTION, &backlash.correction, all_off, all_on);
+
+  #if DISABLED(CORE_BACKLASH) || ENABLED(MARKFORGED_XY)
+    #define _CAN_CALI AXIS_CAN_CALIBRATE
+  #else
+    #define _CAN_CALI(A) true
+  #endif
+  #define EDIT_BACKLASH_DISTANCE(N) EDIT_ITEM_FAST(float43, MSG_BACKLASH_##N, &backlash.distance_mm[_AXIS(N)], 0.0f, 9.9f);
+  if (_CAN_CALI(A)) EDIT_BACKLASH_DISTANCE(A);
+  #if HAS_Y_AXIS && _CAN_CALI(B)
+    EDIT_BACKLASH_DISTANCE(B);
+  #endif
+  #if HAS_Z_AXIS && _CAN_CALI(C)
+    EDIT_BACKLASH_DISTANCE(C);
+  #endif
+  #if LINEAR_AXES >= 4 && _CAN_CALI(I)
+    EDIT_BACKLASH_DISTANCE(I);
+  #endif
+  #if LINEAR_AXES >= 5 && _CAN_CALI(J)
+    EDIT_BACKLASH_DISTANCE(J);
+  #endif
+  #if LINEAR_AXES >= 6 && _CAN_CALI(K)
+    EDIT_BACKLASH_DISTANCE(K);
+  #endif
+
+  #ifdef BACKLASH_SMOOTHING_MM
+    EDIT_ITEM_FAST(float43, MSG_BACKLASH_SMOOTHING, &backlash.smoothing_mm, 0.0f, 9.9f);
+  #endif
+
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU && BACKLASH_GCODE

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_bed_corners.cpp

@@ -0,0 +1,368 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Level Bed Corners menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if BOTH(HAS_LCD_MENU, LEVEL_BED_CORNERS)
+
+#include "menu_item.h"
+#include "../../module/motion.h"
+#include "../../module/planner.h"
+
+#if HAS_LEVELING
+  #include "../../feature/bedlevel/bedlevel.h"
+#endif
+
+#ifndef LEVEL_CORNERS_Z_HOP
+  #define LEVEL_CORNERS_Z_HOP 4.0
+#endif
+#ifndef LEVEL_CORNERS_HEIGHT
+  #define LEVEL_CORNERS_HEIGHT 0.0
+#endif
+
+#if ENABLED(LEVEL_CORNERS_USE_PROBE)
+  #include "../../module/probe.h"
+  #include "../../module/endstops.h"
+  #if ENABLED(BLTOUCH)
+    #include "../../feature/bltouch.h"
+  #endif
+  #ifndef LEVEL_CORNERS_PROBE_TOLERANCE
+    #define LEVEL_CORNERS_PROBE_TOLERANCE 0.2
+  #endif
+  float last_z;
+  int good_points;
+  bool corner_probing_done, wait_for_probe;
+
+  #if HAS_MARLINUI_U8GLIB
+    #include "../dogm/marlinui_DOGM.h"
+  #endif
+  #define GOOD_POINTS_TO_STR(N) ui8tostr2(N)
+  #define LAST_Z_TO_STR(N) ftostr53_63(N) //ftostr42_52(N)
+
+#endif
+
+static_assert(LEVEL_CORNERS_Z_HOP >= 0, "LEVEL_CORNERS_Z_HOP must be >= 0. Please update your configuration.");
+
+#if HAS_LEVELING
+  static bool leveling_was_active = false;
+#endif
+
+#ifndef LEVEL_CORNERS_LEVELING_ORDER
+  #define LEVEL_CORNERS_LEVELING_ORDER { LF, RF, LB, RB } // Default
+  //#define LEVEL_CORNERS_LEVELING_ORDER { LF, LB, RF  }  // 3 hard-coded points
+  //#define LEVEL_CORNERS_LEVELING_ORDER { LF, RF }       // 3-Point tramming - Rear
+  //#define LEVEL_CORNERS_LEVELING_ORDER { LF, LB }       // 3-Point tramming - Right
+  //#define LEVEL_CORNERS_LEVELING_ORDER { RF, RB }       // 3-Point tramming - Left
+  //#define LEVEL_CORNERS_LEVELING_ORDER { LB, RB }       // 3-Point tramming - Front
+#endif
+
+#define LF 1
+#define RF 2
+#define RB 3
+#define LB 4
+constexpr int lco[] = LEVEL_CORNERS_LEVELING_ORDER;
+constexpr bool level_corners_3_points = COUNT(lco) == 2;
+static_assert(level_corners_3_points || COUNT(lco) == 4, "LEVEL_CORNERS_LEVELING_ORDER must have exactly 2 or 4 corners.");
+
+constexpr int lcodiff = abs(lco[0] - lco[1]);
+static_assert(COUNT(lco) == 4 || lcodiff == 1 || lcodiff == 3, "The first two LEVEL_CORNERS_LEVELING_ORDER corners must be on the same edge.");
+
+constexpr int nr_edge_points = level_corners_3_points ? 3 : 4;
+constexpr int available_points = nr_edge_points + ENABLED(LEVEL_CENTER_TOO);
+constexpr int center_index = TERN(LEVEL_CENTER_TOO, available_points - 1, -1);
+constexpr float inset_lfrb[4] = LEVEL_CORNERS_INSET_LFRB;
+constexpr xy_pos_t lf { (X_MIN_BED) + inset_lfrb[0], (Y_MIN_BED) + inset_lfrb[1] },
+                   rb { (X_MAX_BED) - inset_lfrb[2], (Y_MAX_BED) - inset_lfrb[3] };
+
+static int8_t bed_corner;
+
+/**
+ * Select next corner coordinates
+ */
+static void _lcd_level_bed_corners_get_next_position() {
+
+  if (level_corners_3_points) {
+    if (bed_corner >= available_points) bed_corner = 0; // Above max position -> move back to first corner
+    switch (bed_corner) {
+      case 0 ... 1:
+        // First two corners set explicitly by the configuration
+        current_position = lf;                       // Left front
+        switch (lco[bed_corner]) {
+          case RF: current_position.x = rb.x; break; // Right Front
+          case RB: current_position   = rb;   break; // Right Back
+          case LB: current_position.y = rb.y; break; // Left Back
+        }
+        break;
+
+      case 2:
+        // Determine which edge to probe for 3rd point
+        current_position.set(lf.x + (rb.x - lf.x) / 2, lf.y + (rb.y - lf.y) / 2);
+        if ((lco[0] == LB && lco[1] == RB) || (lco[0] == RB && lco[1] == LB)) current_position.y = lf.y; // Front Center
+        if ((lco[0] == LF && lco[1] == LB) || (lco[0] == LB && lco[1] == LF)) current_position.x = rb.x; // Center Right
+        if ((lco[0] == RF && lco[1] == RB) || (lco[0] == RB && lco[1] == RF)) current_position.x = lf.x; // Left Center
+        if ((lco[0] == LF && lco[1] == RF) || (lco[0] == RF && lco[1] == LF)) current_position.y = rb.y; // Center Back
+        #if DISABLED(LEVEL_CENTER_TOO) && ENABLED(LEVEL_CORNERS_USE_PROBE)
+          bed_corner++;  // Must increment the count to ensure it resets the loop if the 3rd point is out of tolerance
+        #endif
+        break;
+
+      #if ENABLED(LEVEL_CENTER_TOO)
+        case 3:
+          current_position.set(X_CENTER, Y_CENTER);
+          break;
+      #endif
+    }
+  }
+  else {
+    // Four-Corner Bed Tramming with optional center
+    if (TERN0(LEVEL_CENTER_TOO, bed_corner == center_index)) {
+      current_position.set(X_CENTER, Y_CENTER);
+      TERN_(LEVEL_CORNERS_USE_PROBE, good_points--); // Decrement to allow one additional probe point
+    }
+    else {
+      current_position = lf;                       // Left front
+      switch (lco[bed_corner]) {
+        case RF: current_position.x = rb.x; break; // Right front
+        case RB: current_position   = rb;   break; // Right rear
+        case LB: current_position.y = rb.y; break; // Left rear
+      }
+    }
+  }
+}
+
+/**
+ * Level corners, starting in the front-left corner.
+ */
+#if ENABLED(LEVEL_CORNERS_USE_PROBE)
+
+  #define VALIDATE_POINT(X, Y, STR) static_assert(Probe::build_time::can_reach((X), (Y)), \
+    "LEVEL_CORNERS_INSET_LFRB " STR " inset is not reachable with the default NOZZLE_TO_PROBE offset and PROBING_MARGIN.")
+  VALIDATE_POINT(lf.x, Y_CENTER, "left"); VALIDATE_POINT(X_CENTER, lf.y, "front");
+  VALIDATE_POINT(rb.x, Y_CENTER, "right"); VALIDATE_POINT(X_CENTER, rb.y, "back");
+
+  #ifndef PAGE_CONTAINS
+    #define PAGE_CONTAINS(...) true
+  #endif
+
+  void _lcd_draw_probing() {
+    if (!ui.should_draw()) return;
+
+    TERN_(HAS_MARLINUI_U8GLIB, ui.set_font(FONT_MENU)); // Set up the font for extra info
+
+    MenuItem_static::draw(0, GET_TEXT(MSG_PROBING_MESH), SS_INVERT); // "Probing Mesh" heading
+
+    uint8_t cy = TERN(TFT_COLOR_UI, 3, LCD_HEIGHT - 1), y = LCD_ROW_Y(cy);
+
+    // Display # of good points found vs total needed
+    if (PAGE_CONTAINS(y - (MENU_FONT_HEIGHT), y)) {
+      SETCURSOR(TERN(TFT_COLOR_UI, 2, 0), cy);
+      lcd_put_u8str_P(GET_TEXT(MSG_LEVEL_CORNERS_GOOD_POINTS));
+      IF_ENABLED(TFT_COLOR_UI, lcd_moveto(12, cy));
+      lcd_put_u8str(GOOD_POINTS_TO_STR(good_points));
+      lcd_put_wchar('/');
+      lcd_put_u8str(GOOD_POINTS_TO_STR(nr_edge_points));
+    }
+
+    --cy;
+    y -= MENU_FONT_HEIGHT;
+
+    // Display the Last Z value
+    if (PAGE_CONTAINS(y - (MENU_FONT_HEIGHT), y)) {
+      SETCURSOR(TERN(TFT_COLOR_UI, 2, 0), cy);
+      lcd_put_u8str_P(GET_TEXT(MSG_LEVEL_CORNERS_LAST_Z));
+      IF_ENABLED(TFT_COLOR_UI, lcd_moveto(12, 2));
+      lcd_put_u8str(LAST_Z_TO_STR(last_z));
+    }
+  }
+
+  void _lcd_draw_raise() {
+    if (!ui.should_draw()) return;
+    MenuItem_confirm::select_screen(
+      GET_TEXT(MSG_BUTTON_DONE), GET_TEXT(MSG_BUTTON_SKIP)
+      , []{ corner_probing_done = true; wait_for_probe = false; }
+      , []{ wait_for_probe = false; }
+      , GET_TEXT(MSG_LEVEL_CORNERS_RAISE)
+      , (const char*)nullptr, NUL_STR
+    );
+  }
+
+  void _lcd_draw_level_prompt() {
+    if (!ui.should_draw()) return;
+    MenuItem_confirm::confirm_screen(
+      []{ queue.inject_P(TERN(HAS_LEVELING, PSTR("G29N"), G28_STR));
+          ui.return_to_status();
+      }
+      , []{ ui.goto_previous_screen_no_defer(); }
+      , GET_TEXT(MSG_LEVEL_CORNERS_IN_RANGE)
+      , (const char*)nullptr, PSTR("?")
+    );
+  }
+
+  bool _lcd_level_bed_corners_probe(bool verify=false) {
+    if (verify) do_blocking_move_to_z(current_position.z + LEVEL_CORNERS_Z_HOP); // do clearance if needed
+    TERN_(BLTOUCH_SLOW_MODE, bltouch.deploy()); // Deploy in LOW SPEED MODE on every probe action
+    do_blocking_move_to_z(last_z - LEVEL_CORNERS_PROBE_TOLERANCE, MMM_TO_MMS(Z_PROBE_FEEDRATE_SLOW)); // Move down to lower tolerance
+    if (TEST(endstops.trigger_state(), Z_MIN_PROBE)) { // check if probe triggered
+      endstops.hit_on_purpose();
+      set_current_from_steppers_for_axis(Z_AXIS);
+      sync_plan_position();
+      TERN_(BLTOUCH_SLOW_MODE, bltouch.stow()); // Stow in LOW SPEED MODE on every trigger
+      // Triggered outside tolerance range?
+      if (ABS(current_position.z - last_z) > LEVEL_CORNERS_PROBE_TOLERANCE) {
+        last_z = current_position.z; // Above tolerance. Set a new Z for subsequent corners.
+        good_points = 0;             // ...and start over
+      }
+      return true; // probe triggered
+    }
+    do_blocking_move_to_z(last_z); // go back to tolerance middle point before raise
+    return false; // probe not triggered
+  }
+
+  bool _lcd_level_bed_corners_raise() {
+    bool probe_triggered = false;
+    corner_probing_done = false;
+    wait_for_probe = true;
+    ui.goto_screen(_lcd_draw_raise); // show raise screen
+    ui.set_selection(true);
+    while (wait_for_probe && !probe_triggered) { // loop while waiting to bed raise and probe trigger
+      probe_triggered = PROBE_TRIGGERED();
+      if (probe_triggered) {
+        endstops.hit_on_purpose();
+        TERN_(LEVEL_CORNERS_AUDIO_FEEDBACK, ui.buzz(200, 600));
+      }
+      idle();
+    }
+    TERN_(BLTOUCH_SLOW_MODE, bltouch.stow());
+    ui.goto_screen(_lcd_draw_probing);
+    return (probe_triggered);
+  }
+
+  void _lcd_test_corners() {
+    bed_corner = TERN(LEVEL_CENTER_TOO, center_index, 0);
+    last_z = LEVEL_CORNERS_HEIGHT;
+    endstops.enable_z_probe(true);
+    good_points = 0;
+    ui.goto_screen(_lcd_draw_probing);
+    do {
+      ui.refresh(LCDVIEW_REDRAW_NOW);
+      _lcd_draw_probing();                                // update screen with # of good points
+      do_blocking_move_to_z(SUM_TERN(BLTOUCH_HS_MODE, current_position.z + LEVEL_CORNERS_Z_HOP, 7)); // clearance
+
+      _lcd_level_bed_corners_get_next_position();         // Select next corner coordinates
+      current_position -= probe.offset_xy;                // Account for probe offsets
+      do_blocking_move_to_xy(current_position);           // Goto corner
+
+      TERN_(BLTOUCH_HS_MODE, bltouch.deploy());           // Deploy in HIGH SPEED MODE
+      if (!_lcd_level_bed_corners_probe()) {              // Probe down to tolerance
+        if (_lcd_level_bed_corners_raise()) {             // Prompt user to raise bed if needed
+          #if ENABLED(LEVEL_CORNERS_VERIFY_RAISED)        // Verify
+            while (!_lcd_level_bed_corners_probe(true)) { // Loop while corner verified
+              if (!_lcd_level_bed_corners_raise()) {      // Prompt user to raise bed if needed
+                if (corner_probing_done) return;          // Done was selected
+                break;                                    // Skip was selected
+              }
+            }
+          #endif
+        }
+        else if (corner_probing_done)                     // Done was selected
+          return;
+      }
+
+      if (bed_corner != center_index) good_points++; // ignore center
+      if (++bed_corner > 3) bed_corner = 0;
+
+    } while (good_points < nr_edge_points); // loop until all points within tolerance
+
+    #if ENABLED(BLTOUCH_HS_MODE)
+      // In HIGH SPEED MODE do clearance and stow at the very end
+      do_blocking_move_to_z(current_position.z + LEVEL_CORNERS_Z_HOP);
+      bltouch.stow();
+    #endif
+
+    ui.goto_screen(_lcd_draw_level_prompt); // prompt for bed leveling
+    ui.set_selection(true);
+  }
+
+#else // !LEVEL_CORNERS_USE_PROBE
+
+  static void _lcd_goto_next_corner() {
+    line_to_z(LEVEL_CORNERS_Z_HOP);
+
+    // Select next corner coordinates
+    _lcd_level_bed_corners_get_next_position();
+
+    line_to_current_position(manual_feedrate_mm_s.x);
+    line_to_z(LEVEL_CORNERS_HEIGHT);
+    if (++bed_corner >= available_points) bed_corner = 0;
+  }
+
+#endif // !LEVEL_CORNERS_USE_PROBE
+
+static void _lcd_level_bed_corners_homing() {
+  _lcd_draw_homing();
+  if (!all_axes_homed()) return;
+  #if ENABLED(LEVEL_CORNERS_USE_PROBE)
+    _lcd_test_corners();
+    if (corner_probing_done) ui.goto_previous_screen_no_defer();
+    TERN_(HAS_LEVELING, set_bed_leveling_enabled(leveling_was_active));
+    endstops.enable_z_probe(false);
+  #else
+    bed_corner = 0;
+    ui.goto_screen([]{
+      MenuItem_confirm::select_screen(
+          GET_TEXT(MSG_BUTTON_NEXT), GET_TEXT(MSG_BUTTON_DONE)
+        , _lcd_goto_next_corner
+        , []{
+            line_to_z(LEVEL_CORNERS_Z_HOP); // Raise Z off the bed when done
+            TERN_(HAS_LEVELING, set_bed_leveling_enabled(leveling_was_active));
+            ui.goto_previous_screen_no_defer();
+          }
+        , GET_TEXT(TERN(LEVEL_CENTER_TOO, MSG_LEVEL_BED_NEXT_POINT, MSG_NEXT_CORNER))
+        , (const char*)nullptr, PSTR("?")
+      );
+    });
+    ui.set_selection(true);
+    _lcd_goto_next_corner();
+  #endif
+}
+
+void _lcd_level_bed_corners() {
+  ui.defer_status_screen();
+  if (!all_axes_trusted()) {
+    set_all_unhomed();
+    queue.inject_P(G28_STR);
+  }
+
+  // Disable leveling so the planner won't mess with us
+  #if HAS_LEVELING
+    leveling_was_active = planner.leveling_active;
+    set_bed_leveling_enabled(false);
+  #endif
+
+  ui.goto_screen(_lcd_level_bed_corners_homing);
+}
+
+#endif // HAS_LCD_MENU && LEVEL_BED_CORNERS

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_bed_leveling.cpp

@@ -0,0 +1,301 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Bed Leveling Menus
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if ENABLED(LCD_BED_LEVELING)
+
+#include "menu_item.h"
+#include "../../module/planner.h"
+#include "../../feature/bedlevel/bedlevel.h"
+
+#if HAS_BED_PROBE && DISABLED(BABYSTEP_ZPROBE_OFFSET)
+  #include "../../module/probe.h"
+#endif
+
+#if HAS_GRAPHICAL_TFT
+  #include "../tft/tft.h"
+  #if ENABLED(TOUCH_SCREEN)
+    #include "../tft/touch.h"
+  #endif
+#endif
+
+#if EITHER(PROBE_MANUALLY, MESH_BED_LEVELING)
+
+  #include "../../module/motion.h"
+  #include "../../gcode/queue.h"
+
+  //
+  // Motion > Level Bed handlers
+  //
+
+  static uint8_t manual_probe_index;
+
+  // LCD probed points are from defaults
+  constexpr uint8_t total_probe_points = TERN(AUTO_BED_LEVELING_3POINT, 3, GRID_MAX_POINTS);
+
+  //
+  // Bed leveling is done. Wait for G29 to complete.
+  // A flag is used so that this can release control
+  // and allow the command queue to be processed.
+  //
+  // When G29 finishes the last move:
+  // - Raise Z to the "Z after probing" height
+  // - Don't return until done.
+  //
+  // ** This blocks the command queue! **
+  //
+  void _lcd_level_bed_done() {
+    if (!ui.wait_for_move) {
+      #if Z_AFTER_PROBING > 0 && DISABLED(MESH_BED_LEVELING)
+        // Display "Done" screen and wait for moves to complete
+        line_to_z(Z_AFTER_PROBING);
+        ui.synchronize(GET_TEXT(MSG_LEVEL_BED_DONE));
+      #endif
+      ui.goto_previous_screen_no_defer();
+      ui.completion_feedback();
+    }
+    if (ui.should_draw()) MenuItem_static::draw(LCD_HEIGHT >= 4, GET_TEXT(MSG_LEVEL_BED_DONE));
+    ui.refresh(LCDVIEW_CALL_REDRAW_NEXT);
+  }
+
+  void _lcd_level_goto_next_point();
+
+  //
+  // Step 7: Get the Z coordinate, click goes to the next point or exits
+  //
+  void _lcd_level_bed_get_z() {
+
+    if (ui.use_click()) {
+
+      //
+      // Save the current Z position and move
+      //
+
+      // If done...
+      if (++manual_probe_index >= total_probe_points) {
+        //
+        // The last G29 records the point and enables bed leveling
+        //
+        ui.wait_for_move = true;
+        ui.goto_screen(_lcd_level_bed_done);
+        #if ENABLED(MESH_BED_LEVELING)
+          queue.inject_P(PSTR("G29S2"));
+        #elif ENABLED(PROBE_MANUALLY)
+          queue.inject_P(PSTR("G29V1"));
+        #endif
+      }
+      else
+        _lcd_level_goto_next_point();
+
+      return;
+    }
+
+    //
+    // Encoder knob or keypad buttons adjust the Z position
+    //
+    if (ui.encoderPosition) {
+      const float z = current_position.z + float(int32_t(ui.encoderPosition)) * (MESH_EDIT_Z_STEP);
+      line_to_z(constrain(z, -(LCD_PROBE_Z_RANGE) * 0.5f, (LCD_PROBE_Z_RANGE) * 0.5f));
+      ui.refresh(LCDVIEW_CALL_REDRAW_NEXT);
+      ui.encoderPosition = 0;
+    }
+
+    //
+    // Draw on first display, then only on Z change
+    //
+    if (ui.should_draw()) {
+      const float v = current_position.z;
+      MenuEditItemBase::draw_edit_screen(GET_TEXT(MSG_MOVE_Z), ftostr43sign(v + (v < 0 ? -0.0001f : 0.0001f), '+'));
+    }
+  }
+
+  //
+  // Step 6: Display "Next point: 1 / 9" while waiting for move to finish
+  //
+  void _lcd_level_bed_moving() {
+    if (ui.should_draw()) {
+      char msg[10];
+      sprintf_P(msg, PSTR("%i / %u"), int(manual_probe_index + 1), total_probe_points);
+      MenuEditItemBase::draw_edit_screen(GET_TEXT(MSG_LEVEL_BED_NEXT_POINT), msg);
+    }
+    ui.refresh(LCDVIEW_CALL_NO_REDRAW);
+    if (!ui.wait_for_move) ui.goto_screen(_lcd_level_bed_get_z);
+  }
+
+  //
+  // Step 5: Initiate a move to the next point
+  //
+  void _lcd_level_goto_next_point() {
+    ui.goto_screen(_lcd_level_bed_moving);
+
+    // G29 Records Z, moves, and signals when it pauses
+    ui.wait_for_move = true;
+    #if ENABLED(MESH_BED_LEVELING)
+      queue.inject_P(manual_probe_index ? PSTR("G29S2") : PSTR("G29S1"));
+    #elif ENABLED(PROBE_MANUALLY)
+      queue.inject_P(PSTR("G29V1"));
+    #endif
+  }
+
+  //
+  // Step 4: Display "Click to Begin", wait for click
+  //         Move to the first probe position
+  //
+  void _lcd_level_bed_homing_done() {
+    if (ui.should_draw()) {
+      MenuItem_static::draw(1, GET_TEXT(MSG_LEVEL_BED_WAITING));
+      // Color UI needs a control to detect a touch
+      #if BOTH(TOUCH_SCREEN, HAS_GRAPHICAL_TFT)
+        touch.add_control(CLICK, 0, 0, TFT_WIDTH, TFT_HEIGHT);
+      #endif
+    }
+    if (ui.use_click()) {
+      manual_probe_index = 0;
+      _lcd_level_goto_next_point();
+    }
+  }
+
+  //
+  // Step 3: Display "Homing XYZ" - Wait for homing to finish
+  //
+  void _lcd_level_bed_homing() {
+    _lcd_draw_homing();
+    if (all_axes_homed()) ui.goto_screen(_lcd_level_bed_homing_done);
+  }
+
+  #if ENABLED(PROBE_MANUALLY)
+    extern bool g29_in_progress;
+  #endif
+
+  //
+  // Step 2: Continue Bed Leveling...
+  //
+  void _lcd_level_bed_continue() {
+    ui.defer_status_screen();
+    set_all_unhomed();
+    ui.goto_screen(_lcd_level_bed_homing);
+    queue.inject_P(G28_STR);
+  }
+
+#endif // PROBE_MANUALLY || MESH_BED_LEVELING
+
+#if ENABLED(MESH_EDIT_MENU)
+
+  inline void refresh_planner() {
+    set_current_from_steppers_for_axis(ALL_AXES_ENUM);
+    sync_plan_position();
+  }
+
+  void menu_edit_mesh() {
+    static uint8_t xind, yind; // =0
+    START_MENU();
+    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();
+  }
+
+#endif // MESH_EDIT_MENU
+
+/**
+ * Step 1: Bed Level entry-point
+ *
+ * << Motion
+ *    Auto Home           (if homing needed)
+ *    Leveling On/Off     (if data exists, and homed)
+ *    Fade Height: ---    (Req: ENABLE_LEVELING_FADE_HEIGHT)
+ *    Mesh Z Offset: ---  (Req: MESH_BED_LEVELING)
+ *    Z Probe Offset: --- (Req: HAS_BED_PROBE, Opt: BABYSTEP_ZPROBE_OFFSET)
+ *    Level Bed >
+ *    Level Corners >     (if homed)
+ *    Load Settings       (Req: EEPROM_SETTINGS)
+ *    Save Settings       (Req: EEPROM_SETTINGS)
+ */
+void menu_bed_leveling() {
+  const bool is_homed = all_axes_trusted(),
+             is_valid = leveling_is_valid();
+
+  START_MENU();
+  BACK_ITEM(MSG_MOTION);
+
+  // Auto Home if not using manual probing
+  #if NONE(PROBE_MANUALLY, MESH_BED_LEVELING)
+    if (!is_homed) GCODES_ITEM(MSG_AUTO_HOME, G28_STR);
+  #endif
+
+  // Level Bed
+  #if EITHER(PROBE_MANUALLY, MESH_BED_LEVELING)
+    // Manual leveling uses a guided procedure
+    SUBMENU(MSG_LEVEL_BED, _lcd_level_bed_continue);
+  #else
+    // Automatic leveling can just run the G-code
+    GCODES_ITEM(MSG_LEVEL_BED, is_homed ? PSTR("G29") : PSTR("G29N"));
+  #endif
+
+  #if ENABLED(MESH_EDIT_MENU)
+    if (is_valid) SUBMENU(MSG_EDIT_MESH, menu_edit_mesh);
+  #endif
+
+  // Homed and leveling is valid? Then leveling can be toggled.
+  if (is_homed && is_valid) {
+    bool show_state = planner.leveling_active;
+    EDIT_ITEM(bool, MSG_BED_LEVELING, &show_state, _lcd_toggle_bed_leveling);
+  }
+
+  // Z Fade Height
+  #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
+    // Shadow for editing the fade height
+    editable.decimal = planner.z_fade_height;
+    EDIT_ITEM_FAST(float3, MSG_Z_FADE_HEIGHT, &editable.decimal, 0, 100, []{ set_z_fade_height(editable.decimal); });
+  #endif
+
+  //
+  // Mesh Bed Leveling Z-Offset
+  //
+  #if ENABLED(MESH_BED_LEVELING)
+    EDIT_ITEM(float43, MSG_BED_Z, &mbl.z_offset, -1, 1);
+  #endif
+
+  #if ENABLED(BABYSTEP_ZPROBE_OFFSET)
+    SUBMENU(MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
+  #elif HAS_BED_PROBE
+    EDIT_ITEM(LCD_Z_OFFSET_TYPE, MSG_ZPROBE_ZOFFSET, &probe.offset.z, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX);
+  #endif
+
+  #if ENABLED(LEVEL_BED_CORNERS)
+    SUBMENU(MSG_LEVEL_CORNERS, _lcd_level_bed_corners);
+  #endif
+
+  #if ENABLED(EEPROM_SETTINGS)
+    ACTION_ITEM(MSG_LOAD_EEPROM, ui.load_settings);
+    ACTION_ITEM(MSG_STORE_EEPROM, ui.store_settings);
+  #endif
+  END_MENU();
+}
+
+#endif // LCD_BED_LEVELING

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_cancelobject.cpp

@@ -0,0 +1,74 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Cancel Object Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if BOTH(HAS_LCD_MENU, CANCEL_OBJECTS)
+
+#include "menu_item.h"
+#include "menu_addon.h"
+
+#include "../../feature/cancel_object.h"
+
+static void lcd_cancel_object_confirm() {
+  const int8_t v = MenuItemBase::itemIndex;
+  const char item_num[] = {
+    ' ',
+    char((v > 9) ? '0' + (v / 10) : ' '),
+    char('0' + (v % 10)),
+    '\0'
+  };
+  MenuItem_confirm::confirm_screen(
+    []{
+      cancelable.cancel_object(MenuItemBase::itemIndex);
+      ui.completion_feedback();
+      ui.goto_previous_screen();
+    },
+    ui.goto_previous_screen,
+    GET_TEXT(MSG_CANCEL_OBJECT), item_num, PSTR("?")
+  );
+}
+
+void menu_cancelobject() {
+  const int8_t ao = cancelable.active_object;
+
+  START_MENU();
+  BACK_ITEM(MSG_MAIN);
+
+  // Draw cancelable items in a loop
+  for (int8_t i = -1; i < cancelable.object_count; i++) {
+    if (i == ao) continue;                                          // Active is drawn on -1 index
+    const int8_t j = i < 0 ? ao : i;                                // Active or index item
+    if (!cancelable.is_canceled(j)) {                               // Not canceled already?
+      SUBMENU_N(j, MSG_CANCEL_OBJECT_N, lcd_cancel_object_confirm); // Offer the option.
+      if (i < 0) SKIP_ITEM();                                       // Extra line after active
+    }
+  }
+
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU && CANCEL_OBJECTS

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_configuration.cpp

@@ -0,0 +1,589 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Configuration Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if HAS_LCD_MENU
+
+#include "menu_item.h"
+
+#if HAS_FILAMENT_SENSOR
+  #include "../../feature/runout.h"
+#endif
+
+#if ENABLED(POWER_LOSS_RECOVERY)
+  #include "../../feature/powerloss.h"
+#endif
+
+#if HAS_BED_PROBE
+  #include "../../module/probe.h"
+  #if ENABLED(BLTOUCH)
+    #include "../../feature/bltouch.h"
+  #endif
+#endif
+
+#if ENABLED(SOUND_MENU_ITEM)
+  #include "../../libs/buzzer.h"
+#endif
+
+#define HAS_DEBUG_MENU ENABLED(LCD_PROGRESS_BAR_TEST)
+
+void menu_advanced_settings();
+#if EITHER(DELTA_CALIBRATION_MENU, DELTA_AUTO_CALIBRATION)
+  void menu_delta_calibrate();
+#endif
+
+#if ENABLED(LCD_PROGRESS_BAR_TEST)
+
+  #include "../lcdprint.h"
+
+  static void progress_bar_test() {
+    static int8_t bar_percent = 0;
+    if (ui.use_click()) {
+      ui.goto_previous_screen();
+      #if HAS_MARLINUI_HD44780
+        ui.set_custom_characters(CHARSET_MENU);
+      #endif
+      return;
+    }
+    bar_percent += (int8_t)ui.encoderPosition;
+    LIMIT(bar_percent, 0, 100);
+    ui.encoderPosition = 0;
+    MenuItem_static::draw(0, GET_TEXT(MSG_PROGRESS_BAR_TEST), SS_DEFAULT|SS_INVERT);
+    lcd_put_int((LCD_WIDTH) / 2 - 2, LCD_HEIGHT - 2, bar_percent); lcd_put_wchar('%');
+    lcd_moveto(0, LCD_HEIGHT - 1); ui.draw_progress_bar(bar_percent);
+  }
+
+  void _progress_bar_test() {
+    ui.goto_screen(progress_bar_test);
+    #if HAS_MARLINUI_HD44780
+      ui.set_custom_characters(CHARSET_INFO);
+    #endif
+  }
+
+#endif // LCD_PROGRESS_BAR_TEST
+
+#if HAS_DEBUG_MENU
+
+  void menu_debug() {
+    START_MENU();
+
+    BACK_ITEM(MSG_CONFIGURATION);
+
+    #if ENABLED(LCD_PROGRESS_BAR_TEST)
+      SUBMENU(MSG_PROGRESS_BAR_TEST, _progress_bar_test);
+    #endif
+
+    END_MENU();
+  }
+
+#endif
+
+#if HAS_MULTI_EXTRUDER
+
+  #include "../../module/tool_change.h"
+
+  void menu_tool_change() {
+    START_MENU();
+    BACK_ITEM(MSG_CONFIGURATION);
+    #if ENABLED(TOOLCHANGE_FILAMENT_SWAP)
+      static constexpr float max_extrude = TERN(PREVENT_LENGTHY_EXTRUDE, EXTRUDE_MAXLENGTH, 500);
+      #if ENABLED(TOOLCHANGE_PARK)
+        EDIT_ITEM(bool, MSG_FILAMENT_PARK_ENABLED, &toolchange_settings.enable_park);
+      #endif
+      EDIT_ITEM(float3, MSG_FILAMENT_SWAP_LENGTH, &toolchange_settings.swap_length, 0, max_extrude);
+      EDIT_ITEM(float41sign, MSG_FILAMENT_SWAP_EXTRA, &toolchange_settings.extra_resume, -10, 10);
+      EDIT_ITEM_FAST(int4, MSG_SINGLENOZZLE_RETRACT_SPEED, &toolchange_settings.retract_speed, 10, 5400);
+      EDIT_ITEM_FAST(int4, MSG_SINGLENOZZLE_UNRETRACT_SPEED, &toolchange_settings.unretract_speed, 10, 5400);
+      EDIT_ITEM(float3, MSG_FILAMENT_PURGE_LENGTH, &toolchange_settings.extra_prime, 0, max_extrude);
+      EDIT_ITEM_FAST(int4, MSG_SINGLENOZZLE_PRIME_SPEED, &toolchange_settings.prime_speed, 10, 5400);
+      EDIT_ITEM_FAST(int4, MSG_SINGLENOZZLE_FAN_SPEED, &toolchange_settings.fan_speed, 0, 255);
+      EDIT_ITEM_FAST(int4, MSG_SINGLENOZZLE_FAN_TIME, &toolchange_settings.fan_time, 1, 30);
+    #endif
+    EDIT_ITEM(float3, MSG_TOOL_CHANGE_ZLIFT, &toolchange_settings.z_raise, 0, 10);
+    END_MENU();
+  }
+
+  #if ENABLED(TOOLCHANGE_MIGRATION_FEATURE)
+
+    #include "../../module/motion.h" // for active_extruder
+    #include "../../gcode/queue.h"
+
+    void menu_toolchange_migration() {
+      PGM_P const msg_migrate = GET_TEXT(MSG_TOOL_MIGRATION_SWAP);
+
+      START_MENU();
+      BACK_ITEM(MSG_CONFIGURATION);
+
+      // Auto mode ON/OFF
+      EDIT_ITEM(bool, MSG_TOOL_MIGRATION_AUTO, &migration.automode);
+      EDIT_ITEM(uint8, MSG_TOOL_MIGRATION_END, &migration.last, 0, EXTRUDERS - 1);
+
+      // Migrate to a chosen extruder
+      LOOP_L_N(s, EXTRUDERS) {
+        if (s != active_extruder) {
+          ACTION_ITEM_N_P(s, msg_migrate, []{
+            char cmd[12];
+            sprintf_P(cmd, PSTR("M217 T%i"), int(MenuItemBase::itemIndex));
+            queue.inject(cmd);
+          });
+        }
+      }
+      END_MENU();
+    }
+  #endif
+
+#endif
+
+#if HAS_HOTEND_OFFSET
+  #include "../../module/motion.h"
+  #include "../../gcode/queue.h"
+
+  void menu_tool_offsets() {
+
+    auto _recalc_offsets = []{
+      if (active_extruder && all_axes_trusted()) {  // For the 2nd extruder re-home so the next tool-change gets the new offsets.
+        queue.inject_P(G28_STR); // In future, we can babystep the 2nd extruder (if active), making homing unnecessary.
+        active_extruder = 0;
+      }
+    };
+
+    START_MENU();
+    BACK_ITEM(MSG_CONFIGURATION);
+    #if ENABLED(DUAL_X_CARRIAGE)
+      EDIT_ITEM_FAST(float42_52, MSG_HOTEND_OFFSET_X, &hotend_offset[1].x, float(X2_HOME_POS - 25), float(X2_HOME_POS + 25), _recalc_offsets);
+    #else
+      EDIT_ITEM_FAST(float42_52, MSG_HOTEND_OFFSET_X, &hotend_offset[1].x, -99.0, 99.0, _recalc_offsets);
+    #endif
+    EDIT_ITEM_FAST(float42_52, MSG_HOTEND_OFFSET_Y, &hotend_offset[1].y, -99.0, 99.0, _recalc_offsets);
+    EDIT_ITEM_FAST(float42_52, MSG_HOTEND_OFFSET_Z, &hotend_offset[1].z, Z_PROBE_LOW_POINT, 10.0, _recalc_offsets);
+    #if ENABLED(EEPROM_SETTINGS)
+      ACTION_ITEM(MSG_STORE_EEPROM, ui.store_settings);
+    #endif
+    END_MENU();
+  }
+#endif
+
+#if ENABLED(DUAL_X_CARRIAGE)
+
+  void menu_idex() {
+    const bool need_g28 = axes_should_home(_BV(Y_AXIS)|_BV(Z_AXIS));
+
+    START_MENU();
+    BACK_ITEM(MSG_CONFIGURATION);
+
+    GCODES_ITEM(MSG_IDEX_MODE_AUTOPARK,  PSTR("M605S1\nG28X\nG1X0"));
+    GCODES_ITEM(MSG_IDEX_MODE_DUPLICATE, need_g28
+      ? PSTR("M605S1\nT0\nG28\nM605S2\nG28X\nG1X0")         // If Y or Z is not homed, do a full G28 first
+      : PSTR("M605S1\nT0\nM605S2\nG28X\nG1X0")
+    );
+    GCODES_ITEM(MSG_IDEX_MODE_MIRRORED_COPY, need_g28
+      ? PSTR("M605S1\nT0\nG28\nM605S2\nG28X\nG1X0\nM605S3") // If Y or Z is not homed, do a full G28 first
+      : PSTR("M605S1\nT0\nM605S2\nG28 X\nG1X0\nM605S3")
+    );
+    GCODES_ITEM(MSG_IDEX_MODE_FULL_CTRL, PSTR("M605S0\nG28X"));
+
+    EDIT_ITEM(float42_52, MSG_IDEX_DUPE_GAP, &duplicate_extruder_x_offset, (X2_MIN_POS) - (X1_MIN_POS), (X_BED_SIZE) - 20);
+
+    END_MENU();
+  }
+
+#endif
+
+#if ENABLED(BLTOUCH)
+
+  #if ENABLED(BLTOUCH_LCD_VOLTAGE_MENU)
+    void bltouch_report() {
+      SERIAL_ECHOLNPAIR("EEPROM Last BLTouch Mode - ", bltouch.last_written_mode);
+      SERIAL_ECHOLNPGM("Configuration BLTouch Mode - " TERN(BLTOUCH_SET_5V_MODE, "5V", "OD"));
+      char mess[21];
+      strcpy_P(mess, PSTR("BLTouch Mode - "));
+      strcpy_P(&mess[15], bltouch.last_written_mode ? PSTR("5V") : PSTR("OD"));
+      ui.set_status(mess);
+      ui.return_to_status();
+    }
+  #endif
+
+  void menu_bltouch() {
+    START_MENU();
+    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)
+      CONFIRM_ITEM(MSG_BLTOUCH_5V_MODE, MSG_BLTOUCH_5V_MODE, MSG_BUTTON_CANCEL, bltouch._set_5V_mode, nullptr, GET_TEXT(MSG_BLTOUCH_MODE_CHANGE));
+      CONFIRM_ITEM(MSG_BLTOUCH_OD_MODE, MSG_BLTOUCH_OD_MODE, MSG_BUTTON_CANCEL, bltouch._set_OD_mode, nullptr, GET_TEXT(MSG_BLTOUCH_MODE_CHANGE));
+      ACTION_ITEM(MSG_BLTOUCH_MODE_STORE, bltouch._mode_store);
+      CONFIRM_ITEM(MSG_BLTOUCH_MODE_STORE_5V, MSG_BLTOUCH_MODE_STORE_5V, MSG_BUTTON_CANCEL, bltouch.mode_conv_5V, nullptr, GET_TEXT(MSG_BLTOUCH_MODE_CHANGE));
+      CONFIRM_ITEM(MSG_BLTOUCH_MODE_STORE_OD, MSG_BLTOUCH_MODE_STORE_OD, MSG_BUTTON_CANCEL, bltouch.mode_conv_OD, nullptr, GET_TEXT(MSG_BLTOUCH_MODE_CHANGE));
+      ACTION_ITEM(MSG_BLTOUCH_MODE_ECHO, bltouch_report);
+    #endif
+    END_MENU();
+  }
+
+#endif
+
+#if ENABLED(TOUCH_MI_PROBE)
+
+  void menu_touchmi() {
+    ui.defer_status_screen();
+    START_MENU();
+    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
+
+#if ENABLED(CONTROLLER_FAN_MENU)
+
+  #include "../../feature/controllerfan.h"
+
+  void menu_controller_fan() {
+    START_MENU();
+    BACK_ITEM(MSG_CONFIGURATION);
+    EDIT_ITEM_FAST(percent, MSG_CONTROLLER_FAN_IDLE_SPEED, &controllerFan.settings.idle_speed, _MAX(1, CONTROLLERFAN_SPEED_MIN) - 1, 255);
+    EDIT_ITEM(bool, MSG_CONTROLLER_FAN_AUTO_ON, &controllerFan.settings.auto_mode);
+    if (controllerFan.settings.auto_mode) {
+      EDIT_ITEM_FAST(percent, MSG_CONTROLLER_FAN_SPEED, &controllerFan.settings.active_speed, _MAX(1, CONTROLLERFAN_SPEED_MIN) - 1, 255);
+      EDIT_ITEM(uint16_4, MSG_CONTROLLER_FAN_DURATION, &controllerFan.settings.duration, 0, 4800);
+    }
+    END_MENU();
+  }
+
+#endif
+
+#if ENABLED(FWRETRACT)
+
+  #include "../../feature/fwretract.h"
+
+  void menu_config_retract() {
+    START_MENU();
+    BACK_ITEM(MSG_CONFIGURATION);
+    #if ENABLED(FWRETRACT_AUTORETRACT)
+      EDIT_ITEM(bool, MSG_AUTORETRACT, &fwretract.autoretract_enabled, fwretract.refresh_autoretract);
+    #endif
+    EDIT_ITEM(float52sign, MSG_CONTROL_RETRACT, &fwretract.settings.retract_length, 0, 100);
+    #if HAS_MULTI_EXTRUDER
+      EDIT_ITEM(float52sign, MSG_CONTROL_RETRACT_SWAP, &fwretract.settings.swap_retract_length, 0, 100);
+    #endif
+    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 HAS_MULTI_EXTRUDER
+      EDIT_ITEM(float52sign, MSG_CONTROL_RETRACT_RECOVER_SWAP, &fwretract.settings.swap_retract_recover_extra, -100, 100);
+    #endif
+    EDIT_ITEM(float3, MSG_CONTROL_RETRACT_RECOVERF, &fwretract.settings.retract_recover_feedrate_mm_s, 1, 999);
+    #if HAS_MULTI_EXTRUDER
+      EDIT_ITEM(float3, MSG_CONTROL_RETRACT_RECOVER_SWAPF, &fwretract.settings.swap_retract_recover_feedrate_mm_s, 1, 999);
+    #endif
+    END_MENU();
+  }
+
+#endif
+
+#if PREHEAT_COUNT && DISABLED(SLIM_LCD_MENUS)
+
+  void _menu_configuration_preheat_settings() {
+    #define _MINTEMP_ITEM(N) HEATER_##N##_MINTEMP,
+    #define _MAXTEMP_ITEM(N) HEATER_##N##_MAXTEMP,
+    #define MINTEMP_ALL _MIN(REPEAT(HOTENDS, _MINTEMP_ITEM) 999)
+    #define MAXTEMP_ALL _MAX(REPEAT(HOTENDS, _MAXTEMP_ITEM) 0)
+    const uint8_t m = MenuItemBase::itemIndex;
+    START_MENU();
+    STATIC_ITEM_P(ui.get_preheat_label(m), SS_DEFAULT|SS_INVERT);
+    BACK_ITEM(MSG_CONFIGURATION);
+    #if HAS_FAN
+      editable.uint8 = uint8_t(ui.material_preset[m].fan_speed);
+      EDIT_ITEM_N(percent, m, MSG_FAN_SPEED, &editable.uint8, 0, 255, []{ ui.material_preset[MenuItemBase::itemIndex].fan_speed = editable.uint8; });
+    #endif
+    #if HAS_TEMP_HOTEND
+      EDIT_ITEM(int3, MSG_NOZZLE, &ui.material_preset[m].hotend_temp, MINTEMP_ALL, MAXTEMP_ALL - (HOTEND_OVERSHOOT));
+    #endif
+    #if HAS_HEATED_BED
+      EDIT_ITEM(int3, MSG_BED, &ui.material_preset[m].bed_temp, BED_MINTEMP, BED_MAX_TARGET);
+    #endif
+    #if ENABLED(EEPROM_SETTINGS)
+      ACTION_ITEM(MSG_STORE_EEPROM, ui.store_settings);
+    #endif
+    END_MENU();
+  }
+
+#endif
+
+#if ENABLED(CUSTOM_MENU_CONFIG)
+
+  void _lcd_custom_menus_configuration_gcode(PGM_P const cmd) {
+    queue.inject_P(cmd);
+    TERN_(CUSTOM_MENU_CONFIG_SCRIPT_AUDIBLE_FEEDBACK, ui.completion_feedback());
+    TERN_(CUSTOM_MENU_CONFIG_SCRIPT_RETURN, ui.return_to_status());
+  }
+
+  void custom_menus_configuration() {
+    START_MENU();
+    BACK_ITEM(MSG_MAIN);
+
+    #define HAS_CUSTOM_ITEM_CONF(N) (defined(CONFIG_MENU_ITEM_##N##_DESC) && defined(CONFIG_MENU_ITEM_##N##_GCODE))
+
+    #define CUSTOM_TEST_CONF(N) do{ \
+      constexpr char c = CONFIG_MENU_ITEM_##N##_GCODE[strlen(CONFIG_MENU_ITEM_##N##_GCODE) - 1]; \
+      static_assert(c != '\n' && c != '\r', "CONFIG_MENU_ITEM_" STRINGIFY(N) "_GCODE cannot have a newline at the end. Please remove it."); \
+    }while(0)
+
+    #ifdef CUSTOM_MENU_CONFIG_SCRIPT_DONE
+      #define _DONE_SCRIPT "\n" CUSTOM_MENU_CONFIG_SCRIPT_DONE
+    #else
+      #define _DONE_SCRIPT ""
+    #endif
+    #define GCODE_LAMBDA_CONF(N) []{ _lcd_custom_menus_configuration_gcode(PSTR(CONFIG_MENU_ITEM_##N##_GCODE _DONE_SCRIPT)); }
+    #define _CUSTOM_ITEM_CONF(N) ACTION_ITEM_P(PSTR(CONFIG_MENU_ITEM_##N##_DESC), GCODE_LAMBDA_CONF(N));
+    #define _CUSTOM_ITEM_CONF_CONFIRM(N)             \
+      SUBMENU_P(PSTR(CONFIG_MENU_ITEM_##N##_DESC), []{ \
+          MenuItem_confirm::confirm_screen(          \
+            GCODE_LAMBDA_CONF(N),                    \
+            ui.goto_previous_screen,                 \
+            PSTR(CONFIG_MENU_ITEM_##N##_DESC "?")      \
+          );                                         \
+        })
+
+    #define CUSTOM_ITEM_CONF(N) do{ if (ENABLED(CONFIG_MENU_ITEM_##N##_CONFIRM)) _CUSTOM_ITEM_CONF_CONFIRM(N); else _CUSTOM_ITEM_CONF(N); }while(0)
+
+    #if HAS_CUSTOM_ITEM_CONF(1)
+      CUSTOM_TEST_CONF(1);
+      CUSTOM_ITEM_CONF(1);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(2)
+      CUSTOM_TEST_CONF(2);
+      CUSTOM_ITEM_CONF(2);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(3)
+      CUSTOM_TEST_CONF(3);
+      CUSTOM_ITEM_CONF(3);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(4)
+      CUSTOM_TEST_CONF(4);
+      CUSTOM_ITEM_CONF(4);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(5)
+      CUSTOM_TEST_CONF(5);
+      CUSTOM_ITEM_CONF(5);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(6)
+      CUSTOM_TEST_CONF(6);
+      CUSTOM_ITEM_CONF(6);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(7)
+      CUSTOM_TEST_CONF(7);
+      CUSTOM_ITEM_CONF(7);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(8)
+      CUSTOM_TEST_CONF(8);
+      CUSTOM_ITEM_CONF(8);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(9)
+      CUSTOM_TEST_CONF(9);
+      CUSTOM_ITEM_CONF(9);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(10)
+      CUSTOM_TEST_CONF(10);
+      CUSTOM_ITEM_CONF(10);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(11)
+      CUSTOM_TEST_CONF(11);
+      CUSTOM_ITEM_CONF(11);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(12)
+      CUSTOM_TEST_CONF(12);
+      CUSTOM_ITEM_CONF(12);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(13)
+      CUSTOM_TEST_CONF(13);
+      CUSTOM_ITEM_CONF(13);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(14)
+      CUSTOM_TEST_CONF(14);
+      CUSTOM_ITEM_CONF(14);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(15)
+      CUSTOM_TEST_CONF(15);
+      CUSTOM_ITEM_CONF(15);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(16)
+      CUSTOM_TEST_CONF(16);
+      CUSTOM_ITEM_CONF(16);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(17)
+      CUSTOM_TEST_CONF(17);
+      CUSTOM_ITEM_CONF(17);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(18)
+      CUSTOM_TEST_CONF(18);
+      CUSTOM_ITEM_CONF(18);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(19)
+      CUSTOM_TEST_CONF(19);
+      CUSTOM_ITEM_CONF(19);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(20)
+      CUSTOM_TEST_CONF(20);
+      CUSTOM_ITEM_CONF(20);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(21)
+      CUSTOM_TEST_CONF(21);
+      CUSTOM_ITEM_CONF(21);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(22)
+      CUSTOM_TEST_CONF(22);
+      CUSTOM_ITEM_CONF(22);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(23)
+      CUSTOM_TEST_CONF(23);
+      CUSTOM_ITEM_CONF(23);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(24)
+      CUSTOM_TEST_CONF(24);
+      CUSTOM_ITEM_CONF(24);
+    #endif
+    #if HAS_CUSTOM_ITEM_CONF(25)
+      CUSTOM_TEST_CONF(25);
+      CUSTOM_ITEM_CONF(25);
+    #endif
+    END_MENU();
+  }
+
+#endif // CUSTOM_MENU_CONFIG
+
+void menu_configuration() {
+  const bool busy = printer_busy();
+
+  START_MENU();
+  BACK_ITEM(MSG_MAIN);
+
+  //
+  // Debug Menu when certain options are enabled
+  //
+  #if HAS_DEBUG_MENU
+    SUBMENU(MSG_DEBUG_MENU, menu_debug);
+  #endif
+
+  #if ENABLED(CUSTOM_MENU_CONFIG)
+    if (TERN1(CUSTOM_MENU_CONFIG_ONLY_IDLE, !busy)) {
+      #ifdef CUSTOM_MENU_CONFIG_TITLE
+        SUBMENU_P(PSTR(CUSTOM_MENU_CONFIG_TITLE), custom_menus_configuration);
+      #else
+        SUBMENU(MSG_CUSTOM_COMMANDS, custom_menus_configuration);
+      #endif
+    }
+  #endif
+
+  SUBMENU(MSG_ADVANCED_SETTINGS, menu_advanced_settings);
+
+  #if ENABLED(BABYSTEP_ZPROBE_OFFSET)
+    SUBMENU(MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
+  #elif HAS_BED_PROBE
+    EDIT_ITEM(LCD_Z_OFFSET_TYPE, MSG_ZPROBE_ZOFFSET, &probe.offset.z, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX);
+  #endif
+
+  //
+  // Set Fan Controller speed
+  //
+  #if ENABLED(CONTROLLER_FAN_MENU)
+    SUBMENU(MSG_CONTROLLER_FAN, menu_controller_fan);
+  #endif
+
+  if (!busy) {
+    #if EITHER(DELTA_CALIBRATION_MENU, DELTA_AUTO_CALIBRATION)
+      SUBMENU(MSG_DELTA_CALIBRATE, menu_delta_calibrate);
+    #endif
+
+    #if HAS_HOTEND_OFFSET
+      SUBMENU(MSG_OFFSETS_MENU, menu_tool_offsets);
+    #endif
+
+    #if ENABLED(DUAL_X_CARRIAGE)
+      SUBMENU(MSG_IDEX_MENU, menu_idex);
+    #endif
+
+    #if ENABLED(BLTOUCH)
+      SUBMENU(MSG_BLTOUCH, menu_bltouch);
+    #endif
+
+    #if ENABLED(TOUCH_MI_PROBE)
+      SUBMENU(MSG_TOUCHMI_PROBE, menu_touchmi);
+    #endif
+  }
+
+  //
+  // Set single nozzle filament retract and prime length
+  //
+  #if HAS_MULTI_EXTRUDER
+    SUBMENU(MSG_TOOL_CHANGE, menu_tool_change);
+    #if ENABLED(TOOLCHANGE_MIGRATION_FEATURE)
+      SUBMENU(MSG_TOOL_MIGRATION, menu_toolchange_migration);
+    #endif
+  #endif
+
+  #if HAS_LCD_CONTRAST
+    EDIT_ITEM(int3, MSG_CONTRAST, &ui.contrast, LCD_CONTRAST_MIN, LCD_CONTRAST_MAX, ui.refresh_contrast, true);
+  #endif
+  #if ENABLED(FWRETRACT)
+    SUBMENU(MSG_RETRACT, menu_config_retract);
+  #endif
+
+  #if HAS_FILAMENT_SENSOR
+    EDIT_ITEM(bool, MSG_RUNOUT_SENSOR, &runout.enabled, runout.reset);
+  #endif
+
+  #if ENABLED(POWER_LOSS_RECOVERY)
+    EDIT_ITEM(bool, MSG_OUTAGE_RECOVERY, &recovery.enabled, recovery.changed);
+  #endif
+
+  // Preheat configurations
+  #if PREHEAT_COUNT && DISABLED(SLIM_LCD_MENUS)
+    LOOP_L_N(m, PREHEAT_COUNT)
+      SUBMENU_N_S(m, ui.get_preheat_label(m), MSG_PREHEAT_M_SETTINGS, _menu_configuration_preheat_settings);
+  #endif
+
+  #if ENABLED(SOUND_MENU_ITEM)
+    EDIT_ITEM(bool, MSG_SOUND, &ui.buzzer_enabled, []{ ui.chirp(); });
+  #endif
+
+  #if ENABLED(EEPROM_SETTINGS)
+    ACTION_ITEM(MSG_STORE_EEPROM, ui.store_settings);
+    if (!busy) ACTION_ITEM(MSG_LOAD_EEPROM, ui.load_settings);
+  #endif
+
+  if (!busy) ACTION_ITEM(MSG_RESTORE_DEFAULTS, ui.reset_settings);
+
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_delta_calibrate.cpp

@@ -0,0 +1,152 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Delta Calibrate Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if HAS_LCD_MENU && EITHER(DELTA_CALIBRATION_MENU, DELTA_AUTO_CALIBRATION)
+
+#include "menu_item.h"
+#include "../../module/delta.h"
+#include "../../module/motion.h"
+
+#if HAS_LEVELING
+  #include "../../feature/bedlevel/bedlevel.h"
+#endif
+
+#if ENABLED(EXTENSIBLE_UI)
+  #include "../extui/ui_api.h"
+#endif
+
+void _man_probe_pt(const xy_pos_t &xy) {
+  if (!ui.wait_for_move) {
+    ui.wait_for_move = true;
+    do_blocking_move_to_xy_z(xy, Z_CLEARANCE_BETWEEN_PROBES);
+    ui.wait_for_move = false;
+    ui.synchronize();
+    ui.manual_move.menu_scale = _MAX(PROBE_MANUALLY_STEP, MIN_STEPS_PER_SEGMENT / float(DEFAULT_XYZ_STEPS_PER_UNIT));
+    ui.goto_screen(lcd_move_z);
+  }
+}
+
+#if ENABLED(DELTA_AUTO_CALIBRATION)
+
+  #include "../../MarlinCore.h" // for wait_for_user_response()
+  #include "../../gcode/gcode.h"
+
+  #if ENABLED(HOST_PROMPT_SUPPORT)
+    #include "../../feature/host_actions.h" // for host_prompt_do
+  #endif
+
+  float lcd_probe_pt(const xy_pos_t &xy) {
+    _man_probe_pt(xy);
+    ui.defer_status_screen();
+    TERN_(HOST_PROMPT_SUPPORT, host_prompt_do(PROMPT_USER_CONTINUE, PSTR("Delta Calibration in progress"), CONTINUE_STR));
+    TERN_(EXTENSIBLE_UI, ExtUI::onUserConfirmRequired_P(PSTR("Delta Calibration in progress")));
+    wait_for_user_response();
+    ui.goto_previous_screen_no_defer();
+    return current_position.z;
+  }
+
+#endif
+
+#if ENABLED(DELTA_CALIBRATION_MENU)
+
+  #include "../../gcode/queue.h"
+
+  void _lcd_calibrate_homing() {
+    _lcd_draw_homing();
+    if (all_axes_homed()) ui.goto_previous_screen();
+  }
+
+  void _lcd_delta_calibrate_home() {
+    queue.inject_P(G28_STR);
+    ui.goto_screen(_lcd_calibrate_homing);
+  }
+
+  void _goto_tower_a(const_float_t a) {
+    xy_pos_t tower_vec = { cos(RADIANS(a)), sin(RADIANS(a)) };
+    _man_probe_pt(tower_vec * delta_calibration_radius());
+  }
+  void _goto_tower_x() { _goto_tower_a(210); }
+  void _goto_tower_y() { _goto_tower_a(330); }
+  void _goto_tower_z() { _goto_tower_a( 90); }
+  void _goto_center()  { xy_pos_t ctr{0}; _man_probe_pt(ctr); }
+
+#endif
+
+void lcd_delta_settings() {
+  auto _recalc_delta_settings = []{
+    TERN_(HAS_LEVELING, reset_bed_level()); // After changing kinematics bed-level data is no longer valid
+    recalc_delta_settings();
+  };
+  START_MENU();
+  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_P(float43, PSTR(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);
+  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_P(float43, PSTR(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);
+  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() {
+  #if ENABLED(DELTA_CALIBRATION_MENU)
+    const bool all_homed = all_axes_homed();  // Acquire ahead of loop
+  #endif
+
+  START_MENU();
+  BACK_ITEM(MSG_MAIN);
+
+  #if ENABLED(DELTA_AUTO_CALIBRATION)
+    GCODES_ITEM(MSG_DELTA_AUTO_CALIBRATE, PSTR("G33"));
+    #if ENABLED(EEPROM_SETTINGS)
+      ACTION_ITEM(MSG_STORE_EEPROM, ui.store_settings);
+      ACTION_ITEM(MSG_LOAD_EEPROM, ui.load_settings);
+    #endif
+  #endif
+
+  SUBMENU(MSG_DELTA_SETTINGS, lcd_delta_settings);
+
+  #if ENABLED(DELTA_CALIBRATION_MENU)
+    SUBMENU(MSG_AUTO_HOME, _lcd_delta_calibrate_home);
+    if (all_homed) {
+      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
+
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU && (DELTA_CALIBRATION_MENU || DELTA_AUTO_CALIBRATION)

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_filament.cpp

@@ -0,0 +1,336 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Filament Change Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if BOTH(HAS_LCD_MENU, ADVANCED_PAUSE_FEATURE)
+
+#include "menu_item.h"
+#include "../../module/temperature.h"
+#include "../../feature/pause.h"
+#include "../../gcode/queue.h"
+#if HAS_FILAMENT_SENSOR
+  #include "../../feature/runout.h"
+#endif
+
+//
+// Change Filament > Change/Unload/Load Filament
+//
+static PauseMode _change_filament_mode; // = PAUSE_MODE_PAUSE_PRINT
+static int8_t _change_filament_extruder; // = 0
+
+inline PGM_P _change_filament_command() {
+  switch (_change_filament_mode) {
+    case PAUSE_MODE_LOAD_FILAMENT:    return PSTR("M701 T%d");
+    case PAUSE_MODE_UNLOAD_FILAMENT:  return _change_filament_extruder >= 0
+                                           ? PSTR("M702 T%d") : PSTR("M702 ;%d");
+    case PAUSE_MODE_CHANGE_FILAMENT:
+    case PAUSE_MODE_PAUSE_PRINT:
+    default: break;
+  }
+  return PSTR("M600 B0 T%d");
+}
+
+// Initiate Filament Load/Unload/Change at the specified temperature
+static void _change_filament_with_temp(const uint16_t celsius) {
+  char cmd[11];
+  sprintf_P(cmd, _change_filament_command(), _change_filament_extruder);
+  thermalManager.setTargetHotend(celsius, _change_filament_extruder);
+  queue.inject(cmd);
+}
+
+static void _change_filament_with_preset() {
+  _change_filament_with_temp(ui.material_preset[MenuItemBase::itemIndex].hotend_temp);
+}
+
+static void _change_filament_with_custom() {
+  _change_filament_with_temp(thermalManager.degTargetHotend(MenuItemBase::itemIndex));
+}
+
+//
+// Menu to choose the temperature and start Filament Change
+//
+
+inline PGM_P change_filament_header(const PauseMode mode) {
+  switch (mode) {
+    case PAUSE_MODE_LOAD_FILAMENT:   return GET_TEXT(MSG_FILAMENTLOAD);
+    case PAUSE_MODE_UNLOAD_FILAMENT: return GET_TEXT(MSG_FILAMENTUNLOAD);
+    default: break;
+  }
+  return GET_TEXT(MSG_FILAMENTCHANGE);
+}
+
+void _menu_temp_filament_op(const PauseMode mode, const int8_t extruder) {
+  _change_filament_mode = mode;
+  _change_filament_extruder = extruder;
+  const int8_t old_index = MenuItemBase::itemIndex;
+  START_MENU();
+  if (LCD_HEIGHT >= 4) STATIC_ITEM_P(change_filament_header(mode), SS_DEFAULT|SS_INVERT);
+  BACK_ITEM(MSG_BACK);
+  #if PREHEAT_COUNT
+    LOOP_L_N(m, PREHEAT_COUNT)
+      ACTION_ITEM_N_S(m, ui.get_preheat_label(m), MSG_PREHEAT_M, _change_filament_with_preset);
+  #endif
+  EDIT_ITEM_FAST_N(int3, extruder, MSG_PREHEAT_CUSTOM, &thermalManager.temp_hotend[extruder].target,
+    EXTRUDE_MINTEMP, thermalManager.hotend_max_target(extruder),
+    _change_filament_with_custom
+  );
+  END_MENU();
+  MenuItemBase::itemIndex = old_index;
+}
+
+/**
+ * "Change Filament" submenu
+ */
+#if E_STEPPERS > 1 || ENABLED(FILAMENT_LOAD_UNLOAD_GCODES)
+
+  bool printingIsPaused();
+
+  void menu_change_filament() {
+    // Say "filament change" when no print is active
+    editable.int8 = printingIsPaused() ? PAUSE_MODE_PAUSE_PRINT : PAUSE_MODE_CHANGE_FILAMENT;
+
+    #if E_STEPPERS > 1 && ENABLED(FILAMENT_UNLOAD_ALL_EXTRUDERS)
+      bool too_cold = false;
+      for (uint8_t s = 0; !too_cold && s < E_STEPPERS; s++)
+        too_cold = thermalManager.targetTooColdToExtrude(s);
+    #endif
+
+    #if ENABLED(FILAMENT_LOAD_UNLOAD_GCODES)
+      const bool is_busy = printer_busy();
+    #endif
+
+    START_MENU();
+    BACK_ITEM(MSG_MAIN);
+
+    // Change filament
+    #if E_STEPPERS == 1
+      PGM_P const msg = GET_TEXT(MSG_FILAMENTCHANGE);
+      if (thermalManager.targetTooColdToExtrude(active_extruder))
+        SUBMENU_P(msg, []{ _menu_temp_filament_op(PAUSE_MODE_CHANGE_FILAMENT, 0); });
+      else
+        GCODES_ITEM_P(msg, PSTR("M600 B0"));
+    #else
+      PGM_P const msg = GET_TEXT(MSG_FILAMENTCHANGE_E);
+      LOOP_L_N(s, E_STEPPERS) {
+        if (thermalManager.targetTooColdToExtrude(s))
+          SUBMENU_N_P(s, msg, []{ _menu_temp_filament_op(PAUSE_MODE_CHANGE_FILAMENT, MenuItemBase::itemIndex); });
+        else {
+          ACTION_ITEM_N_P(s, msg, []{
+            PGM_P const cmdpstr = PSTR("M600 B0 T%i");
+            char cmd[strlen_P(cmdpstr) + 3 + 1];
+            sprintf_P(cmd, cmdpstr, int(MenuItemBase::itemIndex));
+            queue.inject(cmd);
+          });
+        }
+      }
+    #endif
+
+    #if ENABLED(FILAMENT_LOAD_UNLOAD_GCODES)
+      if (!is_busy) {
+        // Load filament
+        #if E_STEPPERS == 1
+          PGM_P const msg_load = GET_TEXT(MSG_FILAMENTLOAD);
+          if (thermalManager.targetTooColdToExtrude(active_extruder))
+            SUBMENU_P(msg_load, []{ _menu_temp_filament_op(PAUSE_MODE_LOAD_FILAMENT, 0); });
+          else
+            GCODES_ITEM_P(msg_load, PSTR("M701"));
+        #else
+          PGM_P const msg_load = GET_TEXT(MSG_FILAMENTLOAD_E);
+          LOOP_L_N(s, E_STEPPERS) {
+            if (thermalManager.targetTooColdToExtrude(s))
+              SUBMENU_N_P(s, msg_load, []{ _menu_temp_filament_op(PAUSE_MODE_LOAD_FILAMENT, MenuItemBase::itemIndex); });
+            else {
+              ACTION_ITEM_N_P(s, msg_load, []{
+                char cmd[12];
+                sprintf_P(cmd, PSTR("M701 T%i"), int(MenuItemBase::itemIndex));
+                queue.inject(cmd);
+              });
+            }
+          }
+        #endif
+
+        // Unload filament
+        #if E_STEPPERS == 1
+          PGM_P const msg_unload = GET_TEXT(MSG_FILAMENTUNLOAD);
+          if (thermalManager.targetTooColdToExtrude(active_extruder))
+            SUBMENU_P(msg_unload, []{ _menu_temp_filament_op(PAUSE_MODE_UNLOAD_FILAMENT, 0); });
+          else
+            GCODES_ITEM_P(msg_unload, PSTR("M702"));
+        #else
+          #if ENABLED(FILAMENT_UNLOAD_ALL_EXTRUDERS)
+            if (too_cold)
+              SUBMENU(MSG_FILAMENTUNLOAD_ALL, []{ _menu_temp_filament_op(PAUSE_MODE_UNLOAD_FILAMENT, -1); });
+            else
+              GCODES_ITEM(MSG_FILAMENTUNLOAD_ALL, PSTR("M702"));
+          #endif
+          PGM_P const msg_unload = GET_TEXT(MSG_FILAMENTUNLOAD_E);
+          LOOP_L_N(s, E_STEPPERS) {
+            if (thermalManager.targetTooColdToExtrude(s))
+              SUBMENU_N_P(s, msg_unload, []{ _menu_temp_filament_op(PAUSE_MODE_UNLOAD_FILAMENT, MenuItemBase::itemIndex); });
+            else {
+              ACTION_ITEM_N_P(s, msg_unload, []{
+                char cmd[12];
+                sprintf_P(cmd, PSTR("M702 T%i"), int(MenuItemBase::itemIndex));
+                queue.inject(cmd);
+              });
+            }
+          }
+        #endif
+      } // !printer_busy
+    #endif
+
+    END_MENU();
+  }
+#endif
+
+static uint8_t hotend_status_extruder = 0;
+
+static PGM_P pause_header() {
+  switch (pause_mode) {
+    case PAUSE_MODE_CHANGE_FILAMENT:  return GET_TEXT(MSG_FILAMENT_CHANGE_HEADER);
+    case PAUSE_MODE_LOAD_FILAMENT:    return GET_TEXT(MSG_FILAMENT_CHANGE_HEADER_LOAD);
+    case PAUSE_MODE_UNLOAD_FILAMENT:  return GET_TEXT(MSG_FILAMENT_CHANGE_HEADER_UNLOAD);
+    default: break;
+  }
+  return GET_TEXT(MSG_FILAMENT_CHANGE_HEADER_PAUSE);
+}
+
+// Portions from STATIC_ITEM...
+#define HOTEND_STATUS_ITEM() do { \
+  if (_menuLineNr == _thisItemNr) { \
+    if (ui.should_draw()) { \
+      IF_DISABLED(HAS_GRAPHICAL_TFT, MenuItem_static::draw(_lcdLineNr, GET_TEXT(MSG_FILAMENT_CHANGE_NOZZLE), SS_INVERT)); \
+      ui.draw_hotend_status(_lcdLineNr, hotend_status_extruder); \
+    } \
+    if (_skipStatic && encoderLine <= _thisItemNr) { \
+      ui.encoderPosition += ENCODER_STEPS_PER_MENU_ITEM; \
+      ++encoderLine; \
+    } \
+    ui.refresh(LCDVIEW_CALL_REDRAW_NEXT); \
+  } \
+  ++_thisItemNr; \
+}while(0)
+
+void menu_pause_option() {
+  START_MENU();
+  #if LCD_HEIGHT > 2
+    STATIC_ITEM(MSG_FILAMENT_CHANGE_OPTION_HEADER);
+  #endif
+  ACTION_ITEM(MSG_FILAMENT_CHANGE_OPTION_PURGE, []{ pause_menu_response = PAUSE_RESPONSE_EXTRUDE_MORE; });
+
+  #if HAS_FILAMENT_SENSOR
+    const bool still_out = runout.filament_ran_out;
+    if (still_out)
+      EDIT_ITEM(bool, MSG_RUNOUT_SENSOR, &runout.enabled, runout.reset);
+  #else
+    constexpr bool still_out = false;
+  #endif
+
+  if (!still_out)
+    ACTION_ITEM(MSG_FILAMENT_CHANGE_OPTION_RESUME, []{ pause_menu_response = PAUSE_RESPONSE_RESUME_PRINT; });
+
+  END_MENU();
+}
+
+//
+// ADVANCED_PAUSE_FEATURE message screens
+//
+// Warning: msg must have three null bytes to delimit lines!
+//
+void _lcd_pause_message(PGM_P const msg) {
+  PGM_P const msg1 = msg;
+  PGM_P const msg2 = msg1 + strlen_P(msg1) + 1;
+  PGM_P const msg3 = msg2 + strlen_P(msg2) + 1;
+  const bool has2 = msg2[0], has3 = msg3[0],
+             skip1 = !has2 && (LCD_HEIGHT) >= 5;
+
+  START_SCREEN();
+  STATIC_ITEM_P(pause_header(), SS_DEFAULT|SS_INVERT);          // 1: Header
+  if (skip1) SKIP_ITEM();                                       // Move a single-line message down
+  STATIC_ITEM_P(msg1);                                          // 2: Message Line 1
+  if (has2) STATIC_ITEM_P(msg2);                                // 3: Message Line 2
+  if (has3 && (LCD_HEIGHT) >= 5) STATIC_ITEM_P(msg3);           // 4: Message Line 3 (if LCD has 5 lines)
+  if (skip1 + 1 + has2 + has3 < (LCD_HEIGHT) - 2) SKIP_ITEM();  // Push Hotend Status down, if needed
+  HOTEND_STATUS_ITEM();                                         // 5: Hotend Status
+  END_SCREEN();
+}
+
+void lcd_pause_parking_message()  { _lcd_pause_message(GET_TEXT(MSG_PAUSE_PRINT_PARKING));     }
+void lcd_pause_changing_message() { _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_INIT));    }
+void lcd_pause_unload_message()   { _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_UNLOAD));  }
+void lcd_pause_heating_message()  { _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_HEATING)); }
+void lcd_pause_heat_message()     { _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_HEAT));    }
+void lcd_pause_insert_message()   { _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_INSERT));  }
+void lcd_pause_load_message()     { _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_LOAD));    }
+void lcd_pause_waiting_message()  { _lcd_pause_message(GET_TEXT(MSG_ADVANCED_PAUSE_WAITING));  }
+void lcd_pause_resume_message()   { _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_RESUME));  }
+
+void lcd_pause_purge_message() {
+  #if ENABLED(ADVANCED_PAUSE_CONTINUOUS_PURGE)
+    _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_CONT_PURGE));
+  #else
+    _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_PURGE));
+  #endif
+}
+
+FORCE_INLINE screenFunc_t ap_message_screen(const PauseMessage message) {
+  switch (message) {
+    case PAUSE_MESSAGE_PARKING:  return lcd_pause_parking_message;
+    case PAUSE_MESSAGE_CHANGING: return lcd_pause_changing_message;
+    case PAUSE_MESSAGE_UNLOAD:   return lcd_pause_unload_message;
+    case PAUSE_MESSAGE_WAITING:  return lcd_pause_waiting_message;
+    case PAUSE_MESSAGE_INSERT:   return lcd_pause_insert_message;
+    case PAUSE_MESSAGE_LOAD:     return lcd_pause_load_message;
+    case PAUSE_MESSAGE_PURGE:    return lcd_pause_purge_message;
+    case PAUSE_MESSAGE_RESUME:   return lcd_pause_resume_message;
+    case PAUSE_MESSAGE_HEAT:     return lcd_pause_heat_message;
+    case PAUSE_MESSAGE_HEATING:  return lcd_pause_heating_message;
+    case PAUSE_MESSAGE_OPTION:   pause_menu_response = PAUSE_RESPONSE_WAIT_FOR;
+                                 return menu_pause_option;
+    case PAUSE_MESSAGE_STATUS:
+    default: break;
+  }
+  return nullptr;
+}
+
+void MarlinUI::pause_show_message(
+  const PauseMessage message,
+  const PauseMode mode/*=PAUSE_MODE_SAME*/,
+  const uint8_t extruder/*=active_extruder*/
+) {
+  if (mode != PAUSE_MODE_SAME) pause_mode = mode;
+  hotend_status_extruder = extruder;
+  const screenFunc_t next_screen = ap_message_screen(message);
+  if (next_screen) {
+    ui.defer_status_screen();
+    ui.goto_screen(next_screen);
+  }
+  else
+    ui.return_to_status();
+}
+
+#endif // HAS_LCD_MENU && ADVANCED_PAUSE_FEATURE

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_game.cpp

@@ -0,0 +1,48 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if HAS_GAME_MENU
+
+#include "menu_item.h"
+#include "game/game.h"
+
+void menu_game() {
+  START_MENU();
+  BACK_ITEM(TERN(LCD_INFO_MENU, MSG_INFO_MENU, MSG_MAIN));
+  #if ENABLED(MARLIN_BRICKOUT)
+    SUBMENU(MSG_BRICKOUT, brickout.enter_game);
+  #endif
+  #if ENABLED(MARLIN_INVADERS)
+    SUBMENU(MSG_INVADERS, invaders.enter_game);
+  #endif
+  #if ENABLED(MARLIN_SNAKE)
+    SUBMENU(MSG_SNAKE, snake.enter_game);
+  #endif
+  #if ENABLED(MARLIN_MAZE)
+    SUBMENU(MSG_MAZE, maze.enter_game);
+  #endif
+  END_MENU();
+}
+
+#endif // HAS_GAME_MENU

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_info.cpp

@@ -0,0 +1,316 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Info Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if BOTH(HAS_LCD_MENU, LCD_INFO_MENU)
+
+#include "menu_item.h"
+
+#if HAS_GAMES
+  #include "game/game.h"
+#endif
+
+#define VALUE_ITEM(MSG, VALUE, STYL)    do{ char msg[21]; strcpy_P(msg, PSTR(": ")); strcpy(msg + 2, VALUE); STATIC_ITEM(MSG, STYL, msg); }while(0)
+#define VALUE_ITEM_P(MSG, PVALUE, STYL) do{ char msg[21]; strcpy_P(msg, PSTR(": ")); strcpy_P(msg + 2, PSTR(PVALUE)); STATIC_ITEM(MSG, STYL, msg); }while(0)
+
+#if ENABLED(PRINTCOUNTER)
+
+  #include "../../module/printcounter.h"
+
+  //
+  // About Printer > Printer Stats
+  //
+  void menu_info_stats() {
+    if (ui.use_click()) return ui.go_back();
+
+    printStatistics stats = print_job_timer.getStats();
+
+    char buffer[21];
+
+    START_SCREEN();                                                                         // 12345678901234567890
+    VALUE_ITEM(MSG_INFO_PRINT_COUNT, i16tostr3left(stats.totalPrints), SS_LEFT);            // Print Count: 999
+    VALUE_ITEM(MSG_INFO_COMPLETED_PRINTS, i16tostr3left(stats.finishedPrints), SS_LEFT);    // Completed  : 666
+
+    STATIC_ITEM(MSG_INFO_PRINT_TIME, SS_LEFT);                                              // Total print Time:
+    STATIC_ITEM_P(PSTR("> "), SS_LEFT, duration_t(stats.printTime).toString(buffer));       // > 99y 364d 23h 59m 59s
+
+    STATIC_ITEM(MSG_INFO_PRINT_LONGEST, SS_LEFT);                                           // Longest job time:
+    STATIC_ITEM_P(PSTR("> "), SS_LEFT, duration_t(stats.longestPrint).toString(buffer));    // > 99y 364d 23h 59m 59s
+
+    STATIC_ITEM(MSG_INFO_PRINT_FILAMENT, SS_LEFT);                                          // Extruded total:
+    sprintf_P(buffer, PSTR("%ld.%im")
+      , long(stats.filamentUsed / 1000)
+      , int16_t(stats.filamentUsed / 100) % 10
+    );
+    STATIC_ITEM_P(PSTR("> "), SS_LEFT, buffer);                                             // > 125m
+
+    #if SERVICE_INTERVAL_1 > 0 || SERVICE_INTERVAL_2 > 0 || SERVICE_INTERVAL_3 > 0
+      strcpy_P(buffer, GET_TEXT(MSG_SERVICE_IN));
+    #endif
+
+    #if SERVICE_INTERVAL_1 > 0
+      STATIC_ITEM_P(PSTR(SERVICE_NAME_1 " "), SS_LEFT, buffer);                             // Service X in:
+      STATIC_ITEM_P(PSTR("> "), SS_LEFT, duration_t(stats.nextService1).toString(buffer));  // > 7d 12h 11m 10s
+    #endif
+
+    #if SERVICE_INTERVAL_2 > 0
+      STATIC_ITEM_P(PSTR(SERVICE_NAME_2 " "), SS_LEFT, buffer);
+      STATIC_ITEM_P(PSTR("> "), SS_LEFT, duration_t(stats.nextService2).toString(buffer));
+    #endif
+
+    #if SERVICE_INTERVAL_3 > 0
+      STATIC_ITEM_P(PSTR(SERVICE_NAME_3 " "), SS_LEFT, buffer);
+      STATIC_ITEM_P(PSTR("> "), SS_LEFT, duration_t(stats.nextService3).toString(buffer));
+    #endif
+
+    END_SCREEN();
+  }
+
+#endif
+
+//
+// About Printer > Thermistors
+//
+void menu_info_thermistors() {
+  if (ui.use_click()) return ui.go_back();
+
+  START_SCREEN();
+
+  #if HAS_EXTRUDERS
+    #define THERMISTOR_ID TEMP_SENSOR_0
+    #include "../thermistornames.h"
+    STATIC_ITEM_P(PSTR(LCD_STR_E0 ": " THERMISTOR_NAME), SS_INVERT);
+    PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_0_MINTEMP), SS_LEFT);
+    PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_0_MAXTEMP), SS_LEFT);
+  #endif
+
+  #if TEMP_SENSOR_1 != 0
+    #undef THERMISTOR_ID
+    #define THERMISTOR_ID TEMP_SENSOR_1
+    #include "../thermistornames.h"
+    STATIC_ITEM_P(PSTR(LCD_STR_E1 ": " THERMISTOR_NAME), SS_INVERT);
+    PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_1_MINTEMP), SS_LEFT);
+    PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_1_MAXTEMP), SS_LEFT);
+  #endif
+
+  #if TEMP_SENSOR_2 != 0
+    #undef THERMISTOR_ID
+    #define THERMISTOR_ID TEMP_SENSOR_2
+    #include "../thermistornames.h"
+    STATIC_ITEM_P(PSTR(LCD_STR_E2 ": " THERMISTOR_NAME), SS_INVERT);
+    PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_2_MINTEMP), SS_LEFT);
+    PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_2_MAXTEMP), SS_LEFT);
+  #endif
+
+  #if TEMP_SENSOR_3 != 0
+    #undef THERMISTOR_ID
+    #define THERMISTOR_ID TEMP_SENSOR_3
+    #include "../thermistornames.h"
+    STATIC_ITEM_P(PSTR(LCD_STR_E3 ": " THERMISTOR_NAME), SS_INVERT);
+    PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_3_MINTEMP), SS_LEFT);
+    PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_3_MAXTEMP), SS_LEFT);
+  #endif
+
+  #if TEMP_SENSOR_4 != 0
+    #undef THERMISTOR_ID
+    #define THERMISTOR_ID TEMP_SENSOR_4
+    #include "../thermistornames.h"
+    STATIC_ITEM_P(PSTR(LCD_STR_E4 ": " THERMISTOR_NAME), SS_INVERT);
+    PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_4_MINTEMP), SS_LEFT);
+    PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_4_MAXTEMP), SS_LEFT);
+  #endif
+
+  #if TEMP_SENSOR_5 != 0
+    #undef THERMISTOR_ID
+    #define THERMISTOR_ID TEMP_SENSOR_5
+    #include "../thermistornames.h"
+    STATIC_ITEM_P(PSTR(LCD_STR_E5 ": " THERMISTOR_NAME), SS_INVERT);
+    PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_5_MINTEMP), SS_LEFT);
+    PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_5_MAXTEMP), SS_LEFT);
+  #endif
+
+  #if TEMP_SENSOR_6 != 0
+    #undef THERMISTOR_ID
+    #define THERMISTOR_ID TEMP_SENSOR_6
+    #include "../thermistornames.h"
+    STATIC_ITEM_P(PSTR(LCD_STR_E6 ": " THERMISTOR_NAME), SS_INVERT);
+    PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_6_MINTEMP), SS_LEFT);
+    PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_6_MAXTEMP), SS_LEFT);
+  #endif
+
+  #if TEMP_SENSOR_7 != 0
+    #undef THERMISTOR_ID
+    #define THERMISTOR_ID TEMP_SENSOR_7
+    #include "../thermistornames.h"
+    STATIC_ITEM_P(PSTR(LCD_STR_E7 ": " THERMISTOR_NAME), SS_INVERT);
+    PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_7_MINTEMP), SS_LEFT);
+    PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_7_MAXTEMP), SS_LEFT);
+  #endif
+
+  #if HAS_EXTRUDERS
+    STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
+  #endif
+
+  #if HAS_HEATED_BED
+    #undef THERMISTOR_ID
+    #define THERMISTOR_ID TEMP_SENSOR_BED
+    #include "../thermistornames.h"
+    STATIC_ITEM_P(PSTR("BED: " THERMISTOR_NAME), SS_INVERT);
+    PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(BED_MINTEMP), SS_LEFT);
+    PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(BED_MAXTEMP), SS_LEFT);
+    STATIC_ITEM(TERN(WATCH_BED, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
+  #endif
+
+  #if HAS_HEATED_CHAMBER
+    #undef THERMISTOR_ID
+    #define THERMISTOR_ID TEMP_SENSOR_CHAMBER
+    #include "../thermistornames.h"
+    STATIC_ITEM_P(PSTR("CHAM: " THERMISTOR_NAME), SS_INVERT);
+    PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(CHAMBER_MINTEMP), SS_LEFT);
+    PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(CHAMBER_MAXTEMP), SS_LEFT);
+    STATIC_ITEM(TERN(WATCH_CHAMBER, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
+  #endif
+
+  #if HAS_COOLER
+    #undef THERMISTOR_ID
+    #define THERMISTOR_ID TEMP_SENSOR_COOLER
+    #include "../thermistornames.h"
+    STATIC_ITEM_P(PSTR("COOL: " THERMISTOR_NAME), SS_INVERT);
+    PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(COOLER_MINTEMP), SS_LEFT);
+    PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(COOLER_MAXTEMP), SS_LEFT);
+    STATIC_ITEM(TERN(WATCH_COOLER, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
+  #endif
+
+  END_SCREEN();
+}
+
+//
+// About Printer > Board Info
+//
+void menu_info_board() {
+  if (ui.use_click()) return ui.go_back();
+
+  START_SCREEN();
+  STATIC_ITEM_P(PSTR(BOARD_INFO_NAME), SS_DEFAULT|SS_INVERT);      // MyPrinterController
+  #ifdef BOARD_WEBSITE_URL
+    STATIC_ITEM_P(PSTR(BOARD_WEBSITE_URL), SS_LEFT);               // www.my3dprinter.com
+  #endif
+  PSTRING_ITEM(MSG_INFO_BAUDRATE, STRINGIFY(BAUDRATE), SS_CENTER); // Baud: 250000
+  PSTRING_ITEM(MSG_INFO_PROTOCOL, PROTOCOL_VERSION, SS_CENTER);    // Protocol: 1.0
+  PSTRING_ITEM(MSG_INFO_PSU, PSU_NAME, SS_CENTER);
+  END_SCREEN();
+}
+
+//
+// About Printer > Printer Info
+//
+#if ENABLED(LCD_PRINTER_INFO_IS_BOOTSCREEN)
+
+  void menu_show_marlin_bootscreen() {
+    if (ui.use_click()) { ui.goto_previous_screen_no_defer(); }
+    ui.draw_marlin_bootscreen();
+  }
+
+  #if ENABLED(SHOW_CUSTOM_BOOTSCREEN)
+    void menu_show_custom_bootscreen() {
+      if (ui.use_click()) { ui.goto_screen(menu_show_marlin_bootscreen); }
+      ui.draw_custom_bootscreen();
+    }
+  #endif
+
+#else
+
+  void menu_info_printer() {
+    if (ui.use_click()) return ui.go_back();
+    START_SCREEN();
+    STATIC_ITEM(MSG_MARLIN, SS_DEFAULT|SS_INVERT);              // Marlin
+    STATIC_ITEM_P(PSTR(SHORT_BUILD_VERSION));                   // x.x.x-Branch
+    STATIC_ITEM_P(PSTR(STRING_DISTRIBUTION_DATE));              // YYYY-MM-DD HH:MM
+    STATIC_ITEM_P(PSTR(MACHINE_NAME));                          // My3DPrinter
+    STATIC_ITEM_P(PSTR(WEBSITE_URL));                           // www.my3dprinter.com
+    PSTRING_ITEM(MSG_INFO_EXTRUDERS, STRINGIFY(EXTRUDERS), SS_CENTER); // Extruders: 2
+    #if HAS_LEVELING
+      STATIC_ITEM(
+        TERN_(AUTO_BED_LEVELING_3POINT, MSG_3POINT_LEVELING)      // 3-Point Leveling
+        TERN_(AUTO_BED_LEVELING_LINEAR, MSG_LINEAR_LEVELING)      // Linear Leveling
+        TERN_(AUTO_BED_LEVELING_BILINEAR, MSG_BILINEAR_LEVELING)  // Bi-linear Leveling
+        TERN_(AUTO_BED_LEVELING_UBL, MSG_UBL_LEVELING)            // Unified Bed Leveling
+        TERN_(MESH_BED_LEVELING, MSG_MESH_LEVELING)               // Mesh Leveling
+      );
+    #endif
+    END_SCREEN();
+  }
+
+#endif
+
+//
+// "About Printer" submenu
+//
+void menu_info() {
+  START_MENU();
+  BACK_ITEM(MSG_MAIN);
+  #if ENABLED(LCD_PRINTER_INFO_IS_BOOTSCREEN)
+    SUBMENU(MSG_INFO_PRINTER_MENU, TERN(SHOW_CUSTOM_BOOTSCREEN, menu_show_custom_bootscreen, menu_show_marlin_bootscreen));
+  #else
+    SUBMENU(MSG_INFO_PRINTER_MENU, menu_info_printer);           // Printer Info >
+    SUBMENU(MSG_INFO_BOARD_MENU, menu_info_board);               // Board Info >
+    #if HAS_EXTRUDERS
+      SUBMENU(MSG_INFO_THERMISTOR_MENU, menu_info_thermistors);  // Thermistors >
+    #endif
+  #endif
+
+  #if ENABLED(PRINTCOUNTER)
+    SUBMENU(MSG_INFO_STATS_MENU, menu_info_stats);               // Printer Stats >
+  #endif
+
+  #if HAS_GAMES
+  {
+    #if ENABLED(GAMES_EASTER_EGG)
+      SKIP_ITEM(); SKIP_ITEM(); SKIP_ITEM();
+    #endif
+
+    // Game sub-menu or the individual game
+    SUBMENU(
+      #if HAS_GAME_MENU
+        MSG_GAMES, menu_game
+      #elif ENABLED(MARLIN_BRICKOUT)
+        MSG_BRICKOUT, brickout.enter_game
+      #elif ENABLED(MARLIN_INVADERS)
+        MSG_INVADERS, invaders.enter_game
+      #elif ENABLED(MARLIN_SNAKE)
+        MSG_SNAKE, snake.enter_game
+      #elif ENABLED(MARLIN_MAZE)
+        MSG_MAZE, maze.enter_game
+      #endif
+    );
+  }
+  #endif
+
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU && LCD_INFO_MENU

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_item.h

@@ -0,0 +1,495 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include "menu.h"
+#include "../marlinui.h"
+#include "../../gcode/queue.h" // for inject_P
+
+#include "../../inc/MarlinConfigPre.h"
+
+void lcd_move_z();
+
+////////////////////////////////////////////
+///////////// Base Menu Items //////////////
+////////////////////////////////////////////
+
+// SUBMENU(LABEL, screen_handler)
+class MenuItem_submenu : public MenuItemBase {
+  public:
+    FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, ...) {
+      _draw(sel, row, pstr, '>', LCD_STR_ARROW_RIGHT[0]);
+    }
+    static inline void action(PGM_P const, const screenFunc_t func) { ui.save_previous_screen(); ui.goto_screen(func); }
+};
+
+// Any menu item that invokes an immediate action
+class MenuItem_button : public MenuItemBase {
+  public:
+    // Button-y Items are selectable lines with no other indicator
+    static inline void draw(const bool sel, const uint8_t row, PGM_P const pstr, ...) {
+      _draw(sel, row, pstr, '>', ' ');
+    }
+};
+
+// ACTION_ITEM(LABEL, FUNC)
+class MenuItem_function : public MenuItem_button {
+  public:
+    //static inline void action(PGM_P const, const uint8_t, const menuAction_t func) { (*func)(); };
+    static inline void action(PGM_P const, const menuAction_t func) { (*func)(); };
+};
+
+// GCODES_ITEM(LABEL, GCODES)
+class MenuItem_gcode : public MenuItem_button {
+  public:
+    FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, ...) {
+      _draw(sel, row, pstr, '>', ' ');
+    }
+    static void action(PGM_P const, PGM_P const pgcode) { queue.inject_P(pgcode); }
+    static inline void action(PGM_P const pstr, const uint8_t, const char * const pgcode) { action(pstr, pgcode); }
+};
+
+////////////////////////////////////////////
+///////////// Edit Menu Items //////////////
+////////////////////////////////////////////
+
+// Template for specific Menu Edit Item Types
+template<typename NAME>
+class TMenuEditItem : MenuEditItemBase {
+  private:
+    typedef typename NAME::type_t type_t;
+    static inline float scale(const_float_t value)    { return NAME::scale(value);            }
+    static inline float unscale(const_float_t value)  { return NAME::unscale(value);          }
+    static const char* to_string(const int32_t value) { return NAME::strfunc(unscale(value)); }
+    static void load(void *ptr, const int32_t value)  { *((type_t*)ptr) = unscale(value);     }
+  public:
+    FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, type_t * const data, ...) {
+      MenuEditItemBase::draw(sel, row, pstr, NAME::strfunc(*(data)));
+    }
+    FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, type_t (*pget)(), ...) {
+      MenuEditItemBase::draw(sel, row, pstr, NAME::strfunc(pget()));
+    }
+    // Edit screen for this type of item
+    static void edit_screen() { MenuEditItemBase::edit_screen(to_string, load); }
+    static void action(
+      PGM_P const pstr,                     // Edit label
+      type_t * const ptr,                   // Value pointer
+      const type_t minValue,                // Value range
+      const type_t maxValue,
+      const screenFunc_t callback=nullptr,  // Value update callback
+      const bool live=false                 // Callback during editing
+    ) {
+      // Make sure minv and maxv fit within int32_t
+      const int32_t minv = _MAX(scale(minValue), INT32_MIN),
+                    maxv = _MIN(scale(maxValue), INT32_MAX);
+      goto_edit_screen(pstr, ptr, minv, maxv - minv, scale(*ptr) - minv,
+        edit_screen, callback, live);
+    }
+};
+
+// Provide a set of Edit Item Types which encompass a primitive
+// type, a string function, and a scale factor for edit and display.
+// These items call the Edit Item draw method passing the prepared string.
+#define __DOFIXfloat PROBE()
+#define _DOFIX(TYPE,V) TYPE(TERN(IS_PROBE(__DOFIX##TYPE),FIXFLOAT(V),(V)))
+#define DEFINE_MENU_EDIT_ITEM_TYPE(NAME, TYPE, STRFUNC, SCALE, ETC...) \
+  struct MenuEditItemInfo_##NAME { \
+    typedef TYPE type_t; \
+    static inline float scale(const_float_t value)   { return value * (SCALE) ETC; } \
+    static inline float unscale(const_float_t value) { return value / (SCALE) ETC; } \
+    static inline const char* strfunc(const_float_t value) { return STRFUNC(_DOFIX(TYPE,value)); } \
+  }; \
+  typedef TMenuEditItem<MenuEditItemInfo_##NAME> MenuItem_##NAME
+
+//                         NAME         TYPE      STRFUNC          SCALE         ROUND
+DEFINE_MENU_EDIT_ITEM_TYPE(percent     ,uint8_t  ,ui8tostr4pctrj  , 100.f/255.f, +0.5f);  // 100%   right-justified
+DEFINE_MENU_EDIT_ITEM_TYPE(percent_3   ,uint8_t  ,pcttostrpctrj   ,   1     );   // 100%   right-justified
+DEFINE_MENU_EDIT_ITEM_TYPE(int3        ,int16_t  ,i16tostr3rj     ,   1     );   // 123, -12   right-justified
+DEFINE_MENU_EDIT_ITEM_TYPE(int4        ,int16_t  ,i16tostr4signrj ,   1     );   // 1234, -123 right-justified
+DEFINE_MENU_EDIT_ITEM_TYPE(int8        ,int8_t   ,i8tostr3rj      ,   1     );   // 123, -12   right-justified
+DEFINE_MENU_EDIT_ITEM_TYPE(uint8       ,uint8_t  ,ui8tostr3rj     ,   1     );   // 123        right-justified
+DEFINE_MENU_EDIT_ITEM_TYPE(uint16_3    ,uint16_t ,ui16tostr3rj    ,   1     );   // 123        right-justified
+DEFINE_MENU_EDIT_ITEM_TYPE(uint16_4    ,uint16_t ,ui16tostr4rj    ,   0.1f  );   // 1234       right-justified
+DEFINE_MENU_EDIT_ITEM_TYPE(uint16_5    ,uint16_t ,ui16tostr5rj    ,   0.01f );   // 12345      right-justified
+DEFINE_MENU_EDIT_ITEM_TYPE(float3      ,float    ,ftostr3         ,   1     );   // 123        right-justified
+DEFINE_MENU_EDIT_ITEM_TYPE(float42_52  ,float    ,ftostr42_52     , 100     );   // _2.34, 12.34, -2.34 or 123.45, -23.45
+DEFINE_MENU_EDIT_ITEM_TYPE(float43     ,float    ,ftostr43sign    ,1000     );   // -1.234, _1.234, +1.234
+DEFINE_MENU_EDIT_ITEM_TYPE(float4      ,float    ,ftostr4sign     ,   1     );   // 1234       right-justified
+DEFINE_MENU_EDIT_ITEM_TYPE(float5      ,float    ,ftostr5rj       ,   1     );   // 12345      right-justified
+DEFINE_MENU_EDIT_ITEM_TYPE(float5_25   ,float    ,ftostr5rj       ,   0.04f );   // 12345      right-justified (25 increment)
+DEFINE_MENU_EDIT_ITEM_TYPE(float51     ,float    ,ftostr51rj      ,  10     );   // 1234.5     right-justified
+DEFINE_MENU_EDIT_ITEM_TYPE(float31sign ,float    ,ftostr31sign    ,  10     );   // +12.3
+DEFINE_MENU_EDIT_ITEM_TYPE(float41sign ,float    ,ftostr41sign    ,  10     );   // +123.4
+DEFINE_MENU_EDIT_ITEM_TYPE(float51sign ,float    ,ftostr51sign    ,  10     );   // +1234.5
+DEFINE_MENU_EDIT_ITEM_TYPE(float52sign ,float    ,ftostr52sign    , 100     );   // +123.45
+DEFINE_MENU_EDIT_ITEM_TYPE(long5       ,uint32_t ,ftostr5rj       ,   0.01f );   // 12345      right-justified
+DEFINE_MENU_EDIT_ITEM_TYPE(long5_25    ,uint32_t ,ftostr5rj       ,   0.04f );   // 12345      right-justified (25 increment)
+
+#if HAS_BED_PROBE
+  #if Z_PROBE_OFFSET_RANGE_MIN >= -9 && Z_PROBE_OFFSET_RANGE_MAX <= 9
+    #define LCD_Z_OFFSET_TYPE float43    // Values from -9.000 to +9.000
+  #else
+    #define LCD_Z_OFFSET_TYPE float42_52 // Values from -99.99 to 99.99
+  #endif
+#endif
+
+class MenuItem_bool : public MenuEditItemBase {
+  public:
+    FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, const bool onoff) {
+      MenuEditItemBase::draw(sel, row, pstr, onoff ? GET_TEXT(MSG_LCD_ON) : GET_TEXT(MSG_LCD_OFF), true);
+    }
+    FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, bool * const data, ...) {
+      draw(sel, row, pstr, *data);
+    }
+    FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, PGM_P const, bool (*pget)(), ...) {
+      draw(sel, row, pstr, pget());
+    }
+    static void action(PGM_P const pstr, bool * const ptr, const screenFunc_t callbackFunc=nullptr) {
+      *ptr ^= true; ui.refresh();
+      if (callbackFunc) (*callbackFunc)();
+    }
+};
+
+/**
+ * ////////////////////////////////////////////
+ * //////////// Menu System Macros ////////////
+ * ////////////////////////////////////////////
+ *
+ * Marlin's native menu screens work by running a loop from the top visible line index
+ * to the bottom visible line index (according to how much the screen has been scrolled).
+ * This complete loop is done on every menu screen call.
+ *
+ * The menu system is highly dynamic, so it doesn't know ahead of any menu loop which
+ * items will be visible or hidden, so menu items don't have a fixed index number.
+ *
+ * During the loop, each menu item checks to see if its line is the current one. If it is,
+ * then it checks to see if a click has arrived so it can run its action. If the action
+ * doesn't redirect to another screen then the menu item calls its draw method.
+ *
+ * Menu item add-ons can do whatever they like.
+ *
+ * This mixture of drawing and processing inside a loop has the advantage that a single
+ * line can be used to represent a menu item, and that is the rationale for this design.
+ *
+ * One of the pitfalls of this method is that DOGM displays call the screen handler 2x,
+ * 4x, or 8x per screen update to draw just one segment of the screen. As a result, any
+ * menu item that exists in two screen segments is drawn and processed twice per screen
+ * update. With each item processed 5, 10, 20, or 40 times the logic has to be simple.
+ *
+ * To avoid repetition and side-effects, function calls for testing menu item conditions
+ * should be done before the menu loop (START_MENU / START_SCREEN).
+ */
+
+/**
+ * SCREEN_OR_MENU_LOOP generates header code for a screen or menu
+ *
+ *   encoderTopLine is the top menu line to display
+ *   _lcdLineNr is the index of the LCD line (e.g., 0-3)
+ *   _menuLineNr is the menu item to draw and process
+ *   _thisItemNr is the index of each MENU_ITEM or STATIC_ITEM
+ */
+#define SCREEN_OR_MENU_LOOP(IS_MENU)                    \
+  scroll_screen(IS_MENU ? 1 : LCD_HEIGHT, IS_MENU);     \
+  int8_t _menuLineNr = encoderTopLine, _thisItemNr = 0; \
+  bool _skipStatic = IS_MENU; UNUSED(_thisItemNr);      \
+  for (int8_t _lcdLineNr = 0; _lcdLineNr < LCD_HEIGHT; _lcdLineNr++, _menuLineNr++) { \
+    _thisItemNr = 0
+
+/**
+ * START_SCREEN  Opening code for a screen having only static items.
+ *               Do simplified scrolling of the entire screen.
+ *
+ * START_MENU    Opening code for a screen with menu items.
+ *               Scroll as-needed to keep the selected line in view.
+ */
+#define START_SCREEN() SCREEN_OR_MENU_LOOP(false)
+#define START_MENU() SCREEN_OR_MENU_LOOP(true)
+#define NEXT_ITEM() (++_thisItemNr)
+#define SKIP_ITEM() NEXT_ITEM()
+#define END_SCREEN() } screen_items = _thisItemNr
+#define END_MENU() END_SCREEN(); UNUSED(_skipStatic)
+
+/**
+ * MENU_ITEM generates draw & handler code for a menu item, potentially calling:
+ *
+ *   MenuItem_<type>::draw(sel, row, label, arg3...)
+ *   MenuItem_<type>::action(arg3...)
+ *
+ * Examples:
+ *   BACK_ITEM(MSG_INFO_SCREEN)
+ *     MenuItem_back::action(plabel, ...)
+ *     MenuItem_back::draw(sel, row, plabel, ...)
+ *
+ *   ACTION_ITEM(MSG_PAUSE_PRINT, lcd_sdcard_pause)
+ *     MenuItem_function::action(plabel, lcd_sdcard_pause)
+ *     MenuItem_function::draw(sel, row, plabel, lcd_sdcard_pause)
+ *
+ *   EDIT_ITEM(int3, MSG_SPEED, &feedrate_percentage, 10, 999)
+ *     MenuItem_int3::action(plabel, &feedrate_percentage, 10, 999)
+ *     MenuItem_int3::draw(sel, row, plabel, &feedrate_percentage, 10, 999)
+ */
+
+#if ENABLED(ENCODER_RATE_MULTIPLIER)
+  #define _MENU_ITEM_MULTIPLIER_CHECK(USE_MULTIPLIER) do{ if (USE_MULTIPLIER) ui.enable_encoder_multiplier(true); }while(0)
+#else
+  #define _MENU_ITEM_MULTIPLIER_CHECK(USE_MULTIPLIER)
+#endif
+
+#define _MENU_INNER_P(TYPE, USE_MULTIPLIER, PLABEL, V...) do { \
+  PGM_P const plabel = PLABEL;                                 \
+  if (encoderLine == _thisItemNr && ui.use_click()) {          \
+    _MENU_ITEM_MULTIPLIER_CHECK(USE_MULTIPLIER);               \
+    MenuItem_##TYPE::action(plabel, ##V);                      \
+    if (ui.screen_changed) return;                             \
+  }                                                            \
+  if (ui.should_draw())                                        \
+    MenuItem_##TYPE::draw                                      \
+      (encoderLine == _thisItemNr, _lcdLineNr, plabel, ##V);   \
+}while(0)
+
+#define _MENU_ITEM_P(TYPE, V...) do { \
+  if (_menuLineNr == _thisItemNr) {   \
+    _skipStatic = false;              \
+    _MENU_INNER_P(TYPE, ##V);         \
+  }                                   \
+  NEXT_ITEM();                        \
+}while(0)
+
+// Indexed items set a global index value and optional data
+#define _MENU_ITEM_N_S_P(TYPE, N, S, V...) do{ \
+  if (_menuLineNr == _thisItemNr) {            \
+    _skipStatic = false;                       \
+    MenuItemBase::init(N, S);                  \
+    _MENU_INNER_P(TYPE, ##V);                  \
+  }                                            \
+  NEXT_ITEM();                                 \
+}while(0)
+
+// Indexed items set a global index value
+#define _MENU_ITEM_N_P(TYPE, N, V...) do{ \
+  if (_menuLineNr == _thisItemNr) {       \
+    _skipStatic = false;                  \
+    MenuItemBase::itemIndex = N;          \
+    _MENU_INNER_P(TYPE, ##V);             \
+  }                                       \
+  NEXT_ITEM();                            \
+}while(0)
+
+// Items with a unique string
+#define _MENU_ITEM_S_P(TYPE, S, V...) do{ \
+  if (_menuLineNr == _thisItemNr) {       \
+    _skipStatic = false;                  \
+    MenuItemBase::itemString = S;         \
+    _MENU_INNER_P(TYPE, ##V);             \
+  }                                       \
+  NEXT_ITEM();                            \
+}while(0)
+
+// STATIC_ITEM draws a styled string with no highlight.
+// Parameters: label [, style [, char *value] ]
+
+#define STATIC_ITEM_INNER_P(PLABEL, V...) do{           \
+  if (_skipStatic && encoderLine <= _thisItemNr) {      \
+    ui.encoderPosition += ENCODER_STEPS_PER_MENU_ITEM;  \
+    ++encoderLine;                                      \
+  }                                                     \
+  if (ui.should_draw())                                 \
+    MenuItem_static::draw(_lcdLineNr, PLABEL, ##V);     \
+} while(0)
+
+#define STATIC_ITEM_P(PLABEL, V...) do{ \
+  if (_menuLineNr == _thisItemNr)       \
+    STATIC_ITEM_INNER_P(PLABEL, ##V);   \
+  NEXT_ITEM();                          \
+} while(0)
+
+#define STATIC_ITEM_N_P(PLABEL, N, V...) do{ \
+  if (_menuLineNr == _thisItemNr) {          \
+    MenuItemBase::init(N);                   \
+    STATIC_ITEM_INNER_P(PLABEL, ##V);        \
+  }                                          \
+  NEXT_ITEM();                               \
+}while(0)
+
+// PSTRING_ITEM is like STATIC_ITEM but it takes
+// two PSTRs with the style as the last parameter.
+
+#define PSTRING_ITEM_P(PLABEL, PVAL, STYL) do{ \
+  constexpr int m = 20;                        \
+  char msg[m+1];                               \
+  msg[0] = ':'; msg[1] = ' ';                  \
+  strncpy_P(msg+2, PSTR(PVAL), m-2);           \
+  if (msg[m-1] & 0x80) msg[m-1] = '\0';        \
+  STATIC_ITEM_P(PLABEL, STYL, msg);            \
+}while(0)
+
+#define PSTRING_ITEM(LABEL, V...)                     PSTRING_ITEM_P(GET_TEXT(LABEL), ##V)
+
+#define STATIC_ITEM(LABEL, V...)                       STATIC_ITEM_P(GET_TEXT(LABEL), ##V)
+#define STATIC_ITEM_N(LABEL, N, V...)                STATIC_ITEM_N_P(GET_TEXT(LABEL), N, ##V)
+
+#define MENU_ITEM_N_S_P(TYPE, N, S, PLABEL, V...)   _MENU_ITEM_N_S_P(TYPE, N, S, false, PLABEL, ##V)
+#define MENU_ITEM_N_S(TYPE, N, S, LABEL, V...)       MENU_ITEM_N_S_P(TYPE, N, S, GET_TEXT(LABEL), ##V)
+#define MENU_ITEM_S_P(TYPE, S, PLABEL, V...)          _MENU_ITEM_S_P(TYPE, S, false, PLABEL, ##V)
+#define MENU_ITEM_S(TYPE, S, LABEL, V...)              MENU_ITEM_S_P(TYPE, S, GET_TEXT(LABEL), ##V)
+#define MENU_ITEM_N_P(TYPE, N, PLABEL, V...)          _MENU_ITEM_N_P(TYPE, N, false, PLABEL, ##V)
+#define MENU_ITEM_N(TYPE, N, LABEL, V...)              MENU_ITEM_N_P(TYPE, N, GET_TEXT(LABEL), ##V)
+#define MENU_ITEM_P(TYPE, PLABEL, V...)                 _MENU_ITEM_P(TYPE, false, PLABEL, ##V)
+#define MENU_ITEM(TYPE, LABEL, V...)                     MENU_ITEM_P(TYPE, GET_TEXT(LABEL), ##V)
+
+#define BACK_ITEM_P(PLABEL)                              MENU_ITEM_P(back, PLABEL)
+#define BACK_ITEM(LABEL)                                   MENU_ITEM(back, LABEL)
+
+#define ACTION_ITEM_N_S_P(N, S, PLABEL, ACTION)      MENU_ITEM_N_S_P(function, N, S, PLABEL, ACTION)
+#define ACTION_ITEM_N_S(N, S, LABEL, ACTION)       ACTION_ITEM_N_S_P(N, S, GET_TEXT(LABEL), ACTION)
+#define ACTION_ITEM_S_P(S, PLABEL, ACTION)             MENU_ITEM_S_P(function, S, PLABEL, ACTION)
+#define ACTION_ITEM_S(S, LABEL, ACTION)              ACTION_ITEM_S_P(S, GET_TEXT(LABEL), ACTION)
+#define ACTION_ITEM_N_P(N, PLABEL, ACTION)             MENU_ITEM_N_P(function, N, PLABEL, ACTION)
+#define ACTION_ITEM_N(N, LABEL, ACTION)              ACTION_ITEM_N_P(N, GET_TEXT(LABEL), ACTION)
+#define ACTION_ITEM_P(PLABEL, ACTION)                    MENU_ITEM_P(function, PLABEL, ACTION)
+#define ACTION_ITEM(LABEL, ACTION)                     ACTION_ITEM_P(GET_TEXT(LABEL), ACTION)
+
+#define GCODES_ITEM_N_S_P(N, S, PLABEL, GCODES)      MENU_ITEM_N_S_P(gcode, N, S, PLABEL, GCODES)
+#define GCODES_ITEM_N_S(N, S, LABEL, GCODES)       GCODES_ITEM_N_S_P(N, S, GET_TEXT(LABEL), GCODES)
+#define GCODES_ITEM_S_P(S, PLABEL, GCODES)             MENU_ITEM_S_P(gcode, S, PLABEL, GCODES)
+#define GCODES_ITEM_S(S, LABEL, GCODES)              GCODES_ITEM_S_P(S, GET_TEXT(LABEL), GCODES)
+#define GCODES_ITEM_N_P(N, PLABEL, GCODES)             MENU_ITEM_N_P(gcode, N, PLABEL, GCODES)
+#define GCODES_ITEM_N(N, LABEL, GCODES)              GCODES_ITEM_N_P(N, GET_TEXT(LABEL), GCODES)
+#define GCODES_ITEM_P(PLABEL, GCODES)                    MENU_ITEM_P(gcode, PLABEL, GCODES)
+#define GCODES_ITEM(LABEL, GCODES)                     GCODES_ITEM_P(GET_TEXT(LABEL), GCODES)
+
+#define SUBMENU_N_S_P(N, S, PLABEL, DEST)            MENU_ITEM_N_S_P(submenu, N, S, PLABEL, DEST)
+#define SUBMENU_N_S(N, S, LABEL, DEST)                 SUBMENU_N_S_P(N, S, GET_TEXT(LABEL), DEST)
+#define SUBMENU_S_P(S, PLABEL, DEST)                   MENU_ITEM_S_P(submenu, S, PLABEL, DEST)
+#define SUBMENU_S(S, LABEL, DEST)                        SUBMENU_S_P(S, GET_TEXT(LABEL), DEST)
+#define SUBMENU_N_P(N, PLABEL, DEST)                   MENU_ITEM_N_P(submenu, N, PLABEL, DEST)
+#define SUBMENU_N(N, LABEL, DEST)                        SUBMENU_N_P(N, GET_TEXT(LABEL), DEST)
+#define SUBMENU_P(PLABEL, DEST)                          MENU_ITEM_P(submenu, PLABEL, DEST)
+#define SUBMENU(LABEL, DEST)                               SUBMENU_P(GET_TEXT(LABEL), DEST)
+
+#define EDIT_ITEM_N_S_P(TYPE, N, S, PLABEL, V...)    MENU_ITEM_N_S_P(TYPE, N, S, PLABEL, ##V)
+#define EDIT_ITEM_N_S(TYPE, N, S, LABEL, V...)       EDIT_ITEM_N_S_P(TYPE, N, S, GET_TEXT(LABEL), ##V)
+#define EDIT_ITEM_S_P(TYPE, S, PLABEL, V...)           MENU_ITEM_S_P(TYPE, S, PLABEL, ##V)
+#define EDIT_ITEM_S(TYPE, S, LABEL, V...)              EDIT_ITEM_S_P(TYPE, S, GET_TEXT(LABEL), ##V)
+#define EDIT_ITEM_N_P(TYPE, N, PLABEL, V...)           MENU_ITEM_N_P(TYPE, N, PLABEL, ##V)
+#define EDIT_ITEM_N(TYPE, N, LABEL, V...)              EDIT_ITEM_N_P(TYPE, N, GET_TEXT(LABEL), ##V)
+#define EDIT_ITEM_P(TYPE, PLABEL, V...)                  MENU_ITEM_P(TYPE, PLABEL, ##V)
+#define EDIT_ITEM(TYPE, LABEL, V...)                     EDIT_ITEM_P(TYPE, GET_TEXT(LABEL), ##V)
+
+#define EDIT_ITEM_FAST_N_S_P(TYPE, N, S, PLABEL, V...)  _MENU_ITEM_N_S_P(TYPE, N, S, true, PLABEL, ##V)
+#define EDIT_ITEM_FAST_N_S(TYPE, N, S, LABEL, V...) EDIT_ITEM_FAST_N_S_P(TYPE, N, S, true, GET_TEXT(LABEL), ##V)
+#define EDIT_ITEM_FAST_S_P(TYPE, S, PLABEL, V...)         _MENU_ITEM_S_P(TYPE, S, true, PLABEL, ##V)
+#define EDIT_ITEM_FAST_S(TYPE, S, LABEL, V...)        EDIT_ITEM_FAST_S_P(TYPE, S, GET_TEXT(LABEL), ##V)
+#define EDIT_ITEM_FAST_N_P(TYPE, N, PLABEL, V...)         _MENU_ITEM_N_P(TYPE, N, true, PLABEL, ##V)
+#define EDIT_ITEM_FAST_N(TYPE, N, LABEL, V...)        EDIT_ITEM_FAST_N_P(TYPE, N, GET_TEXT(LABEL), ##V)
+#define EDIT_ITEM_FAST_P(TYPE, PLABEL, V...)                _MENU_ITEM_P(TYPE, true, PLABEL, ##V)
+#define EDIT_ITEM_FAST(TYPE, LABEL, V...)               EDIT_ITEM_FAST_P(TYPE, GET_TEXT(LABEL), ##V)
+
+#define _CONFIRM_ITEM_INNER_P(PLABEL, V...) do {             \
+  if (encoderLine == _thisItemNr && ui.use_click()) {        \
+    ui.save_previous_screen();                               \
+    ui.goto_screen([]{MenuItem_confirm::select_screen(V);}); \
+    return;                                                  \
+  }                                                          \
+  if (ui.should_draw()) MenuItem_confirm::draw               \
+    (encoderLine == _thisItemNr, _lcdLineNr, PLABEL, ##V);   \
+}while(0)
+
+// Indexed items set a global index value and optional data
+#define _CONFIRM_ITEM_P(PLABEL, V...) do { \
+  if (_menuLineNr == _thisItemNr) {        \
+    _skipStatic = false;                   \
+    _CONFIRM_ITEM_INNER_P(PLABEL, ##V);    \
+  }                                        \
+  NEXT_ITEM();                             \
+}while(0)
+
+// Indexed items set a global index value
+#define _CONFIRM_ITEM_N_S_P(N, S, V...) do{ \
+  if (_menuLineNr == _thisItemNr) {         \
+    _skipStatic = false;                    \
+    MenuItemBase::init(N, S);               \
+    _CONFIRM_ITEM_INNER_P(TYPE, ##V);       \
+  }                                         \
+  NEXT_ITEM();                              \
+}while(0)
+
+// Indexed items set a global index value
+#define _CONFIRM_ITEM_N_P(N, V...) _CONFIRM_ITEM_N_S_P(N, nullptr, V)
+
+#define CONFIRM_ITEM_P(PLABEL,A,B,V...) _CONFIRM_ITEM_P(PLABEL, GET_TEXT(A), GET_TEXT(B), ##V)
+#define CONFIRM_ITEM(LABEL, V...)        CONFIRM_ITEM_P(GET_TEXT(LABEL), ##V)
+
+#define YESNO_ITEM_P(PLABEL, V...)      _CONFIRM_ITEM_P(PLABEL, ##V)
+#define YESNO_ITEM(LABEL, V...)            YESNO_ITEM_P(GET_TEXT(LABEL), ##V)
+
+#define CONFIRM_ITEM_N_S_P(N,S,PLABEL,A,B,V...) _CONFIRM_ITEM_N_S_P(N, S, PLABEL, GET_TEXT(A), GET_TEXT(B), ##V)
+#define CONFIRM_ITEM_N_S(N,S,LABEL,V...)         CONFIRM_ITEM_N_S_P(N, S, GET_TEXT(LABEL), ##V)
+#define CONFIRM_ITEM_N_P(N,PLABEL,A,B,V...)       _CONFIRM_ITEM_N_P(N, PLABEL, GET_TEXT(A), GET_TEXT(B), ##V)
+#define CONFIRM_ITEM_N(N,LABEL, V...)              CONFIRM_ITEM_N_P(N, GET_TEXT(LABEL), ##V)
+
+#define YESNO_ITEM_N_S_P(N,S,PLABEL, V...) _CONFIRM_ITEM_N_S_P(N, S, PLABEL, ##V)
+#define YESNO_ITEM_N_S(N,S,LABEL, V...)       YESNO_ITEM_N_S_P(N, S, GET_TEXT(LABEL), ##V)
+#define YESNO_ITEM_N_P(N,PLABEL, V...)       _CONFIRM_ITEM_N_P(N, PLABEL, ##V)
+#define YESNO_ITEM_N(N,LABEL, V...)             YESNO_ITEM_N_P(N, GET_TEXT(LABEL), ##V)
+
+#if ENABLED(LEVEL_BED_CORNERS)
+  void _lcd_level_bed_corners();
+#endif
+
+#if HAS_FAN
+
+  #include "../../module/temperature.h"
+
+  inline void on_fan_update() {
+    thermalManager.set_fan_speed(MenuItemBase::itemIndex, editable.uint8);
+  }
+
+  #if ENABLED(EXTRA_FAN_SPEED)
+    #define EDIT_EXTRA_FAN_SPEED(V...) EDIT_ITEM_FAST_N(V)
+  #else
+    #define EDIT_EXTRA_FAN_SPEED(...)
+  #endif
+
+  #define _FAN_EDIT_ITEMS(F,L) do{ \
+    editable.uint8 = thermalManager.fan_speed[F]; \
+    EDIT_ITEM_FAST_N(percent, F, MSG_##L, &editable.uint8, 0, 255, on_fan_update); \
+    EDIT_EXTRA_FAN_SPEED(percent, F, MSG_EXTRA_##L, &thermalManager.extra_fan_speed[F].speed, 3, 255); \
+  }while(0)
+
+  #if FAN_COUNT > 1
+    #define FAN_EDIT_ITEMS(F) _FAN_EDIT_ITEMS(F,FAN_SPEED_N)
+  #endif
+
+  #define SNFAN(N) (ENABLED(SINGLENOZZLE_STANDBY_FAN) && !HAS_FAN##N && EXTRUDERS > N)
+
+  #if SNFAN(1) || SNFAN(2) || SNFAN(3) || SNFAN(4) || SNFAN(5) || SNFAN(6) || SNFAN(7)
+    #define DEFINE_SINGLENOZZLE_ITEM() \
+      auto singlenozzle_item = [&](const uint8_t f) { \
+        editable.uint8 = thermalManager.singlenozzle_fan_speed[f]; \
+        EDIT_ITEM_FAST_N(percent, f, MSG_STORED_FAN_N, &editable.uint8, 0, 255, on_fan_update); \
+      }
+  #else
+    #define DEFINE_SINGLENOZZLE_ITEM() NOOP
+  #endif
+
+#endif // HAS_FAN

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_job_recovery.cpp

@@ -0,0 +1,57 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Job Recovery Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if BOTH(HAS_LCD_MENU, POWER_LOSS_RECOVERY)
+
+#include "menu_item.h"
+#include "../../gcode/queue.h"
+#include "../../sd/cardreader.h"
+#include "../../feature/powerloss.h"
+
+static void lcd_power_loss_recovery_resume() {
+  ui.return_to_status();
+  queue.inject_P(PSTR("M1000"));
+}
+
+void lcd_power_loss_recovery_cancel() {
+  recovery.cancel();
+  ui.return_to_status();
+}
+
+// TODO: Display long filename with Cancel/Resume buttons
+//       Requires supporting methods in PLR class.
+void menu_job_recovery() {
+  ui.defer_status_screen();
+  START_MENU();
+  STATIC_ITEM(MSG_OUTAGE_RECOVERY);
+  ACTION_ITEM(MSG_RESUME_PRINT, lcd_power_loss_recovery_resume);
+  ACTION_ITEM(MSG_STOP_PRINT, lcd_power_loss_recovery_cancel);
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU && POWER_LOSS_RECOVERY

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_language.cpp

@@ -0,0 +1,59 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Language Selection Menu
+//
+
+#include "../../inc/MarlinConfig.h"
+
+#if HAS_MULTI_LANGUAGE
+
+#include "menu_item.h"
+#include "../../MarlinCore.h"
+#include "../../module/settings.h"
+
+static void set_lcd_language(const uint8_t inlang) {
+  ui.set_language(inlang);
+  TERN_(LCD_LANGUAGE_AUTO_SAVE, (void)settings.save());
+}
+
+void menu_language() {
+  START_MENU();
+  BACK_ITEM(MSG_MAIN);
+
+  MENU_ITEM_P(function, GET_LANG(LCD_LANGUAGE  )::LANGUAGE, []{ set_lcd_language(0); });
+  MENU_ITEM_P(function, GET_LANG(LCD_LANGUAGE_2)::LANGUAGE, []{ set_lcd_language(1); });
+  #if NUM_LANGUAGES > 2
+    MENU_ITEM_P(function, GET_LANG(LCD_LANGUAGE_3)::LANGUAGE, []{ set_lcd_language(2); });
+    #if NUM_LANGUAGES > 3
+      MENU_ITEM_P(function, GET_LANG(LCD_LANGUAGE_4)::LANGUAGE, []{ set_lcd_language(3); });
+      #if NUM_LANGUAGES > 4
+        MENU_ITEM_P(function, GET_LANG(LCD_LANGUAGE_5)::LANGUAGE, []{ set_lcd_language(4); });
+      #endif
+    #endif
+  #endif
+
+  END_MENU();
+}
+
+#endif // HAS_MULTI_LANGUAGE

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_led.cpp

@@ -0,0 +1,173 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// LED Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if HAS_LCD_MENU && EITHER(LED_CONTROL_MENU, CASE_LIGHT_MENU)
+
+#include "menu_item.h"
+
+#if ENABLED(LED_CONTROL_MENU)
+  #include "../../feature/leds/leds.h"
+
+  #if ENABLED(LED_COLOR_PRESETS)
+
+    void menu_led_presets() {
+      START_MENU();
+      #if LCD_HEIGHT > 2
+        STATIC_ITEM(MSG_LED_PRESETS, SS_DEFAULT|SS_INVERT);
+      #endif
+      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();
+    }
+
+  #endif
+
+  #if ENABLED(NEO2_COLOR_PRESETS)
+
+    void menu_leds2_presets() {
+      START_MENU();
+      #if LCD_HEIGHT > 2
+        STATIC_ITEM(MSG_NEO2_PRESETS, SS_DEFAULT|SS_INVERT);
+      #endif
+      BACK_ITEM(MSG_LED_CONTROL);
+      ACTION_ITEM(MSG_SET_LEDS_WHITE,  leds2.set_white);
+      ACTION_ITEM(MSG_SET_LEDS_RED,    leds2.set_red);
+      ACTION_ITEM(MSG_SET_LEDS_ORANGE, leds2.set_orange);
+      ACTION_ITEM(MSG_SET_LEDS_YELLOW, leds2.set_yellow);
+      ACTION_ITEM(MSG_SET_LEDS_GREEN,  leds2.set_green);
+      ACTION_ITEM(MSG_SET_LEDS_BLUE,   leds2.set_blue);
+      ACTION_ITEM(MSG_SET_LEDS_INDIGO, leds2.set_indigo);
+      ACTION_ITEM(MSG_SET_LEDS_VIOLET, leds2.set_violet);
+      END_MENU();
+    }
+
+  #endif
+
+  void menu_led_custom() {
+    START_MENU();
+    BACK_ITEM(MSG_LED_CONTROL);
+    #if ENABLED(NEOPIXEL2_SEPARATE)
+      STATIC_ITEM_N(MSG_LED_CHANNEL_N, 1, SS_DEFAULT|SS_INVERT);
+    #endif
+    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 HAS_WHITE_LED
+      EDIT_ITEM(uint8, MSG_INTENSITY_W, &leds.color.w, 0, 255, leds.update, true);
+    #endif
+    #if ENABLED(NEOPIXEL_LED)
+      EDIT_ITEM(uint8, MSG_LED_BRIGHTNESS, &leds.color.i, 0, 255, leds.update, true);
+    #endif
+    #if ENABLED(NEOPIXEL2_SEPARATE)
+      STATIC_ITEM_N(MSG_LED_CHANNEL_N, 2, SS_DEFAULT|SS_INVERT);
+      EDIT_ITEM(uint8, MSG_INTENSITY_R, &leds2.color.r, 0, 255, leds2.update, true);
+      EDIT_ITEM(uint8, MSG_INTENSITY_G, &leds2.color.g, 0, 255, leds2.update, true);
+      EDIT_ITEM(uint8, MSG_INTENSITY_B, &leds2.color.b, 0, 255, leds2.update, true);
+      #if HAS_WHITE_LED2
+        EDIT_ITEM(uint8, MSG_INTENSITY_W, &leds2.color.w, 0, 255, leds2.update, true);
+      #endif
+      EDIT_ITEM(uint8, MSG_NEO2_BRIGHTNESS, &leds2.color.i, 0, 255, leds2.update, true);
+    #endif
+    END_MENU();
+  }
+#endif
+
+#if ENABLED(CASE_LIGHT_MENU)
+  #include "../../feature/caselight.h"
+
+  #define CASELIGHT_TOGGLE_ITEM() EDIT_ITEM(bool, MSG_CASE_LIGHT, (bool*)&caselight.on, caselight.update_enabled)
+
+  #if CASELIGHT_USES_BRIGHTNESS
+    void menu_case_light() {
+      START_MENU();
+      BACK_ITEM(MSG_CONFIGURATION);
+      EDIT_ITEM(percent, MSG_CASE_LIGHT_BRIGHTNESS, &caselight.brightness, 0, 255, caselight.update_brightness, true);
+      CASELIGHT_TOGGLE_ITEM();
+      END_MENU();
+    }
+  #endif
+#endif
+
+void menu_led() {
+  START_MENU();
+  BACK_ITEM(MSG_MAIN);
+
+  #if ENABLED(LED_CONTROL_MENU)
+    #if ENABLED(PSU_CONTROL)
+      extern bool powersupply_on;
+    #else
+      constexpr bool powersupply_on = true;
+    #endif
+    if (powersupply_on) {
+      editable.state = leds.lights_on;
+      EDIT_ITEM(bool, MSG_LEDS, &editable.state, leds.toggle);
+    }
+
+    #if ENABLED(LED_COLOR_PRESETS)
+      ACTION_ITEM(MSG_SET_LEDS_DEFAULT, leds.set_default);
+    #endif
+
+    #if ENABLED(NEOPIXEL2_SEPARATE)
+      editable.state = leds2.lights_on;
+      EDIT_ITEM(bool, MSG_LEDS2, &editable.state, leds2.toggle);
+      #if ENABLED(NEO2_COLOR_PRESETS)
+        ACTION_ITEM(MSG_SET_LEDS_DEFAULT, leds2.set_default);
+      #endif
+    #endif
+    #if ENABLED(LED_COLOR_PRESETS)
+      SUBMENU(MSG_LED_PRESETS, menu_led_presets);
+    #endif
+    #if ENABLED(NEO2_COLOR_PRESETS)
+      SUBMENU(MSG_NEO2_PRESETS, menu_leds2_presets);
+    #endif
+    SUBMENU(MSG_CUSTOM_LEDS, menu_led_custom);
+  #endif
+
+  //
+  // Set Case light on/off/brightness
+  //
+  #if ENABLED(CASE_LIGHT_MENU)
+    #if CASELIGHT_USES_BRIGHTNESS
+      if (caselight.has_brightness())
+        SUBMENU(MSG_CASE_LIGHT, menu_case_light);
+      else
+    #endif
+        CASELIGHT_TOGGLE_ITEM();
+  #endif
+
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU && LED_CONTROL_MENU

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_main.cpp

@@ -0,0 +1,460 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Main Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if HAS_LCD_MENU
+
+#include "menu_item.h"
+#include "../../module/temperature.h"
+#include "../../gcode/queue.h"
+#include "../../module/printcounter.h"
+#include "../../module/stepper.h"
+#include "../../sd/cardreader.h"
+
+#if HAS_GAMES && DISABLED(LCD_INFO_MENU)
+  #include "game/game.h"
+#endif
+
+#if EITHER(SDSUPPORT, HOST_PROMPT_SUPPORT) || defined(ACTION_ON_CANCEL)
+  #define MACHINE_CAN_STOP 1
+#endif
+#if ANY(SDSUPPORT, HOST_PROMPT_SUPPORT, PARK_HEAD_ON_PAUSE) || defined(ACTION_ON_PAUSE)
+  #define MACHINE_CAN_PAUSE 1
+#endif
+
+#if ENABLED(MMU2_MENUS)
+  #include "menu_mmu2.h"
+#endif
+
+#if ENABLED(PASSWORD_FEATURE)
+  #include "../../feature/password/password.h"
+#endif
+
+#if ENABLED(HOST_START_MENU_ITEM) && defined(ACTION_ON_START)
+  #include "../../feature/host_actions.h"
+#endif
+
+#if ENABLED(GCODE_REPEAT_MARKERS)
+  #include "../../feature/repeat.h"
+#endif
+
+void menu_tune();
+void menu_cancelobject();
+void menu_motion();
+void menu_temperature();
+void menu_configuration();
+
+#if HAS_POWER_MONITOR
+  void menu_power_monitor();
+#endif
+
+#if ENABLED(MIXING_EXTRUDER)
+  void menu_mixer();
+#endif
+
+#if ENABLED(ADVANCED_PAUSE_FEATURE)
+  void _menu_temp_filament_op(const PauseMode, const int8_t);
+  void menu_change_filament();
+#endif
+
+#if ENABLED(LCD_INFO_MENU)
+  void menu_info();
+#endif
+
+#if EITHER(LED_CONTROL_MENU, CASE_LIGHT_MENU)
+  void menu_led();
+#endif
+
+#if HAS_CUTTER
+  void menu_spindle_laser();
+#endif
+
+#if ENABLED(PREHEAT_SHORTCUT_MENU_ITEM)
+  void menu_preheat_only();
+#endif
+
+#if HAS_MULTI_LANGUAGE
+  void menu_language();
+#endif
+
+#if ENABLED(CUSTOM_MENU_MAIN)
+
+  void _lcd_custom_menu_main_gcode(PGM_P const cmd) {
+    queue.inject_P(cmd);
+    TERN_(CUSTOM_MENU_MAIN_SCRIPT_AUDIBLE_FEEDBACK, ui.completion_feedback());
+    TERN_(CUSTOM_MENU_MAIN_SCRIPT_RETURN, ui.return_to_status());
+  }
+
+  void custom_menus_main() {
+    START_MENU();
+    BACK_ITEM(MSG_MAIN);
+
+    #define HAS_CUSTOM_ITEM_MAIN(N) (defined(MAIN_MENU_ITEM_##N##_DESC) && defined(MAIN_MENU_ITEM_##N##_GCODE))
+
+    #define CUSTOM_TEST_MAIN(N) do{ \
+      constexpr char c = MAIN_MENU_ITEM_##N##_GCODE[strlen(MAIN_MENU_ITEM_##N##_GCODE) - 1]; \
+      static_assert(c != '\n' && c != '\r', "MAIN_MENU_ITEM_" STRINGIFY(N) "_GCODE cannot have a newline at the end. Please remove it."); \
+    }while(0)
+
+    #ifdef MAIN_MENU_ITEM_SCRIPT_DONE
+      #define _DONE_SCRIPT "\n" MAIN_MENU_ITEM_SCRIPT_DONE
+    #else
+      #define _DONE_SCRIPT ""
+    #endif
+    #define GCODE_LAMBDA_MAIN(N) []{ _lcd_custom_menu_main_gcode(PSTR(MAIN_MENU_ITEM_##N##_GCODE _DONE_SCRIPT)); }
+    #define _CUSTOM_ITEM_MAIN(N) ACTION_ITEM_P(PSTR(MAIN_MENU_ITEM_##N##_DESC), GCODE_LAMBDA_MAIN(N));
+    #define _CUSTOM_ITEM_MAIN_CONFIRM(N)             \
+      SUBMENU_P(PSTR(MAIN_MENU_ITEM_##N##_DESC), []{ \
+          MenuItem_confirm::confirm_screen(          \
+            GCODE_LAMBDA_MAIN(N),                    \
+            ui.goto_previous_screen,                 \
+            PSTR(MAIN_MENU_ITEM_##N##_DESC "?")      \
+          );                                         \
+        })
+
+    #define CUSTOM_ITEM_MAIN(N) do{ if (ENABLED(MAIN_MENU_ITEM_##N##_CONFIRM)) _CUSTOM_ITEM_MAIN_CONFIRM(N); else _CUSTOM_ITEM_MAIN(N); }while(0)
+
+    #if HAS_CUSTOM_ITEM_MAIN(1)
+      CUSTOM_TEST_MAIN(1);
+      CUSTOM_ITEM_MAIN(1);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(2)
+      CUSTOM_TEST_MAIN(2);
+      CUSTOM_ITEM_MAIN(2);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(3)
+      CUSTOM_TEST_MAIN(3);
+      CUSTOM_ITEM_MAIN(3);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(4)
+      CUSTOM_TEST_MAIN(4);
+      CUSTOM_ITEM_MAIN(4);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(5)
+      CUSTOM_TEST_MAIN(5);
+      CUSTOM_ITEM_MAIN(5);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(6)
+      CUSTOM_TEST_MAIN(6);
+      CUSTOM_ITEM_MAIN(6);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(7)
+      CUSTOM_TEST_MAIN(7);
+      CUSTOM_ITEM_MAIN(7);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(8)
+      CUSTOM_TEST_MAIN(8);
+      CUSTOM_ITEM_MAIN(8);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(9)
+      CUSTOM_TEST_MAIN(9);
+      CUSTOM_ITEM_MAIN(9);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(10)
+      CUSTOM_TEST_MAIN(10);
+      CUSTOM_ITEM_MAIN(10);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(11)
+      CUSTOM_TEST_MAIN(11);
+      CUSTOM_ITEM_MAIN(11);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(12)
+      CUSTOM_TEST_MAIN(12);
+      CUSTOM_ITEM_MAIN(12);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(13)
+      CUSTOM_TEST_MAIN(13);
+      CUSTOM_ITEM_MAIN(13);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(14)
+      CUSTOM_TEST_MAIN(14);
+      CUSTOM_ITEM_MAIN(14);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(15)
+      CUSTOM_TEST_MAIN(15);
+      CUSTOM_ITEM_MAIN(15);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(16)
+      CUSTOM_TEST_MAIN(16);
+      CUSTOM_ITEM_MAIN(16);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(17)
+      CUSTOM_TEST_MAIN(17);
+      CUSTOM_ITEM_MAIN(17);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(18)
+      CUSTOM_TEST_MAIN(18);
+      CUSTOM_ITEM_MAIN(18);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(19)
+      CUSTOM_TEST_MAIN(19);
+      CUSTOM_ITEM_MAIN(19);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(20)
+      CUSTOM_TEST_MAIN(20);
+      CUSTOM_ITEM_MAIN(20);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(21)
+      CUSTOM_TEST_MAIN(21);
+      CUSTOM_ITEM_MAIN(21);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(22)
+      CUSTOM_TEST_MAIN(22);
+      CUSTOM_ITEM_MAIN(22);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(23)
+      CUSTOM_TEST_MAIN(23);
+      CUSTOM_ITEM_MAIN(23);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(24)
+      CUSTOM_TEST_MAIN(24);
+      CUSTOM_ITEM_MAIN(24);
+    #endif
+    #if HAS_CUSTOM_ITEM_MAIN(25)
+      CUSTOM_TEST_MAIN(25);
+      CUSTOM_ITEM_MAIN(25);
+    #endif
+    END_MENU();
+  }
+
+#endif // CUSTOM_MENU_MAIN
+
+void menu_main() {
+  const bool busy = printingIsActive()
+    #if ENABLED(SDSUPPORT)
+      , card_detected = card.isMounted()
+      , card_open = card_detected && card.isFileOpen()
+    #endif
+  ;
+
+  START_MENU();
+  BACK_ITEM(MSG_INFO_SCREEN);
+
+  #if ENABLED(SDSUPPORT)
+
+    #if !defined(MEDIA_MENU_AT_TOP) && !HAS_ENCODER_WHEEL
+      #define MEDIA_MENU_AT_TOP
+    #endif
+
+    auto sdcard_menu_items = [&]{
+      #if ENABLED(MENU_ADDAUTOSTART)
+        ACTION_ITEM(MSG_RUN_AUTO_FILES, card.autofile_begin); // Run Auto Files
+      #endif
+
+      if (card_detected) {
+        if (!card_open) {
+          #if PIN_EXISTS(SD_DETECT)
+            GCODES_ITEM(MSG_CHANGE_MEDIA, PSTR("M21"));       // M21 Change Media
+          #else                                               // - or -
+            GCODES_ITEM(MSG_RELEASE_MEDIA, PSTR("M22"));      // M22 Release Media
+          #endif
+          SUBMENU(MSG_MEDIA_MENU, MEDIA_MENU_GATEWAY);        // Media Menu (or Password First)
+        }
+      }
+      else {
+        #if PIN_EXISTS(SD_DETECT)
+          ACTION_ITEM(MSG_NO_MEDIA, nullptr);                 // "No Media"
+        #else
+          GCODES_ITEM(MSG_ATTACH_MEDIA, PSTR("M21"));         // M21 Attach Media
+        #endif
+      }
+    };
+
+  #endif
+
+  if (busy) {
+    #if MACHINE_CAN_PAUSE
+      ACTION_ITEM(MSG_PAUSE_PRINT, ui.pause_print);
+    #endif
+    #if MACHINE_CAN_STOP
+      SUBMENU(MSG_STOP_PRINT, []{
+        MenuItem_confirm::select_screen(
+          GET_TEXT(MSG_BUTTON_STOP), GET_TEXT(MSG_BACK),
+          ui.abort_print, ui.goto_previous_screen,
+          GET_TEXT(MSG_STOP_PRINT), (const char *)nullptr, PSTR("?")
+        );
+      });
+    #endif
+
+    #if ENABLED(GCODE_REPEAT_MARKERS)
+      if (repeat.is_active())
+        ACTION_ITEM(MSG_END_LOOPS, repeat.cancel);
+    #endif
+
+    SUBMENU(MSG_TUNE, menu_tune);
+
+    #if ENABLED(CANCEL_OBJECTS) && DISABLED(SLIM_LCD_MENUS)
+      SUBMENU(MSG_CANCEL_OBJECT, []{ editable.int8 = -1; ui.goto_screen(menu_cancelobject); });
+    #endif
+  }
+  else {
+
+    #if BOTH(SDSUPPORT, MEDIA_MENU_AT_TOP)
+      sdcard_menu_items();
+    #endif
+
+    if (TERN0(MACHINE_CAN_PAUSE, printingIsPaused()))
+      ACTION_ITEM(MSG_RESUME_PRINT, ui.resume_print);
+
+    #if ENABLED(HOST_START_MENU_ITEM) && defined(ACTION_ON_START)
+      ACTION_ITEM(MSG_HOST_START_PRINT, host_action_start);
+    #endif
+
+    #if ENABLED(PREHEAT_SHORTCUT_MENU_ITEM)
+      SUBMENU(MSG_PREHEAT_CUSTOM, menu_preheat_only);
+    #endif
+
+    SUBMENU(MSG_MOTION, menu_motion);
+  }
+
+  #if HAS_CUTTER
+    SUBMENU(MSG_CUTTER(MENU), STICKY_SCREEN(menu_spindle_laser));
+  #endif
+
+  #if HAS_TEMPERATURE
+    SUBMENU(MSG_TEMPERATURE, menu_temperature);
+  #endif
+
+  #if HAS_POWER_MONITOR
+    SUBMENU(MSG_POWER_MONITOR, menu_power_monitor);
+  #endif
+
+  #if ENABLED(MIXING_EXTRUDER)
+    SUBMENU(MSG_MIXER, menu_mixer);
+  #endif
+
+  #if ENABLED(MMU2_MENUS)
+    if (!busy) SUBMENU(MSG_MMU2_MENU, menu_mmu2);
+  #endif
+
+  SUBMENU(MSG_CONFIGURATION, menu_configuration);
+
+  #if ENABLED(CUSTOM_MENU_MAIN)
+    if (TERN1(CUSTOM_MENU_MAIN_ONLY_IDLE, !busy)) {
+      #ifdef CUSTOM_MENU_MAIN_TITLE
+        SUBMENU_P(PSTR(CUSTOM_MENU_MAIN_TITLE), custom_menus_main);
+      #else
+        SUBMENU(MSG_CUSTOM_COMMANDS, custom_menus_main);
+      #endif
+    }
+  #endif
+
+  #if ENABLED(ADVANCED_PAUSE_FEATURE)
+    #if E_STEPPERS == 1 && DISABLED(FILAMENT_LOAD_UNLOAD_GCODES)
+      if (thermalManager.targetHotEnoughToExtrude(active_extruder))
+        GCODES_ITEM(MSG_FILAMENTCHANGE, PSTR("M600 B0"));
+      else
+        SUBMENU(MSG_FILAMENTCHANGE, []{ _menu_temp_filament_op(PAUSE_MODE_CHANGE_FILAMENT, 0); });
+    #else
+      SUBMENU(MSG_FILAMENTCHANGE, menu_change_filament);
+    #endif
+  #endif
+
+  #if ENABLED(LCD_INFO_MENU)
+    SUBMENU(MSG_INFO_MENU, menu_info);
+  #endif
+
+  #if EITHER(LED_CONTROL_MENU, CASE_LIGHT_MENU)
+    SUBMENU(MSG_LEDS, menu_led);
+  #endif
+
+  //
+  // Switch power on/off
+  //
+  #if ENABLED(PSU_CONTROL)
+    if (powersupply_on)
+      GCODES_ITEM(MSG_SWITCH_PS_OFF, PSTR("M81"));
+    else
+      GCODES_ITEM(MSG_SWITCH_PS_ON, PSTR("M80"));
+  #endif
+
+  #if ENABLED(SDSUPPORT) && DISABLED(MEDIA_MENU_AT_TOP)
+    sdcard_menu_items();
+  #endif
+
+  #if HAS_SERVICE_INTERVALS
+    static auto _service_reset = [](const int index) {
+      print_job_timer.resetServiceInterval(index);
+      ui.completion_feedback();
+      ui.reset_status();
+      ui.return_to_status();
+    };
+    #if SERVICE_INTERVAL_1 > 0
+      CONFIRM_ITEM_P(PSTR(SERVICE_NAME_1),
+        MSG_BUTTON_RESET, MSG_BUTTON_CANCEL,
+        []{ _service_reset(1); }, ui.goto_previous_screen,
+        GET_TEXT(MSG_SERVICE_RESET), F(SERVICE_NAME_1), PSTR("?")
+      );
+    #endif
+    #if SERVICE_INTERVAL_2 > 0
+      CONFIRM_ITEM_P(PSTR(SERVICE_NAME_2),
+        MSG_BUTTON_RESET, MSG_BUTTON_CANCEL,
+        []{ _service_reset(2); }, ui.goto_previous_screen,
+        GET_TEXT(MSG_SERVICE_RESET), F(SERVICE_NAME_2), PSTR("?")
+      );
+    #endif
+    #if SERVICE_INTERVAL_3 > 0
+      CONFIRM_ITEM_P(PSTR(SERVICE_NAME_3),
+        MSG_BUTTON_RESET, MSG_BUTTON_CANCEL,
+        []{ _service_reset(3); }, ui.goto_previous_screen,
+        GET_TEXT(MSG_SERVICE_RESET), F(SERVICE_NAME_3), PSTR("?")
+      );
+    #endif
+  #endif
+
+  #if HAS_GAMES && DISABLED(LCD_INFO_MENU)
+    #if ENABLED(GAMES_EASTER_EGG)
+      SKIP_ITEM();
+      SKIP_ITEM();
+      SKIP_ITEM();
+    #endif
+    // Game sub-menu or the individual game
+    {
+      SUBMENU(
+        #if HAS_GAME_MENU
+          MSG_GAMES, menu_game
+        #elif ENABLED(MARLIN_BRICKOUT)
+          MSG_BRICKOUT, brickout.enter_game
+        #elif ENABLED(MARLIN_INVADERS)
+          MSG_INVADERS, invaders.enter_game
+        #elif ENABLED(MARLIN_SNAKE)
+          MSG_SNAKE, snake.enter_game
+        #elif ENABLED(MARLIN_MAZE)
+          MSG_MAZE, maze.enter_game
+        #endif
+      );
+    }
+  #endif
+
+  #if HAS_MULTI_LANGUAGE
+    SUBMENU(LANGUAGE, menu_language);
+  #endif
+
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_media.cpp

@@ -0,0 +1,163 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// SD Card Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if BOTH(HAS_LCD_MENU, SDSUPPORT)
+
+#include "menu_item.h"
+#include "../../sd/cardreader.h"
+
+void lcd_sd_updir() {
+  ui.encoderPosition = card.cdup() ? ENCODER_STEPS_PER_MENU_ITEM : 0;
+  encoderTopLine = 0;
+  ui.screen_changed = true;
+  ui.refresh();
+}
+
+#if ENABLED(SD_REPRINT_LAST_SELECTED_FILE)
+
+  uint16_t sd_encoder_position = 0xFFFF;
+  int8_t sd_top_line, sd_items;
+
+  void MarlinUI::reselect_last_file() {
+    if (sd_encoder_position == 0xFFFF) return;
+    goto_screen(menu_media, sd_encoder_position, sd_top_line, sd_items);
+    sd_encoder_position = 0xFFFF;
+    defer_status_screen();
+  }
+
+#endif
+
+inline void sdcard_start_selected_file() {
+  card.openAndPrintFile(card.filename);
+  ui.return_to_status();
+  ui.reset_status();
+}
+
+class MenuItem_sdfile : public MenuItem_sdbase {
+  public:
+    static inline void draw(const bool sel, const uint8_t row, PGM_P const pstr, CardReader &theCard) {
+      MenuItem_sdbase::draw(sel, row, pstr, theCard, false);
+    }
+    static void action(PGM_P const pstr, CardReader &) {
+      #if ENABLED(SD_REPRINT_LAST_SELECTED_FILE)
+        // Save menu state for the selected file
+        sd_encoder_position = ui.encoderPosition;
+        sd_top_line = encoderTopLine;
+        sd_items = screen_items;
+      #endif
+      #if ENABLED(SD_MENU_CONFIRM_START)
+        MenuItem_submenu::action(pstr, []{
+          char * const longest = card.longest_filename();
+          char buffer[strlen(longest) + 2];
+          buffer[0] = ' ';
+          strcpy(buffer + 1, longest);
+          MenuItem_confirm::select_screen(
+            GET_TEXT(MSG_BUTTON_PRINT), GET_TEXT(MSG_BUTTON_CANCEL),
+            sdcard_start_selected_file, ui.goto_previous_screen,
+            GET_TEXT(MSG_START_PRINT), buffer, PSTR("?")
+          );
+        });
+      #else
+        sdcard_start_selected_file();
+        UNUSED(pstr);
+      #endif
+    }
+};
+
+class MenuItem_sdfolder : public MenuItem_sdbase {
+  public:
+    static inline void draw(const bool sel, const uint8_t row, PGM_P const pstr, CardReader &theCard) {
+      MenuItem_sdbase::draw(sel, row, pstr, theCard, true);
+    }
+    static void action(PGM_P const, CardReader &theCard) {
+      card.cd(theCard.filename);
+      encoderTopLine = 0;
+      ui.encoderPosition = 2 * (ENCODER_STEPS_PER_MENU_ITEM);
+      ui.screen_changed = true;
+      TERN_(HAS_MARLINUI_U8GLIB, ui.drawing_screen = false);
+      ui.refresh();
+    }
+};
+
+void menu_media_filelist() {
+  ui.encoder_direction_menus();
+
+  #if HAS_MARLINUI_U8GLIB
+    static uint16_t fileCnt;
+    if (ui.first_page) fileCnt = card.get_num_Files();
+  #else
+    const uint16_t fileCnt = card.get_num_Files();
+  #endif
+
+  START_MENU();
+  #if ENABLED(MULTI_VOLUME)
+    ACTION_ITEM(MSG_BACK, []{ ui.goto_screen(menu_media); });
+  #else
+    BACK_ITEM_P(TERN1(BROWSE_MEDIA_ON_INSERT, screen_history_depth) ? GET_TEXT(MSG_MAIN) : GET_TEXT(MSG_BACK));
+  #endif
+  if (card.flag.workDirIsRoot) {
+    #if !PIN_EXISTS(SD_DETECT)
+      ACTION_ITEM(MSG_REFRESH, []{ encoderTopLine = 0; card.mount(); });
+    #endif
+  }
+  else if (card.isMounted())
+    ACTION_ITEM_P(PSTR(LCD_STR_FOLDER ".."), lcd_sd_updir);
+
+  if (ui.should_draw()) for (uint16_t i = 0; i < fileCnt; i++) {
+    if (_menuLineNr == _thisItemNr) {
+      card.getfilename_sorted(SD_ORDER(i, fileCnt));
+      if (card.flag.filenameIsDir)
+        MENU_ITEM(sdfolder, MSG_MEDIA_MENU, card);
+      else
+        MENU_ITEM(sdfile, MSG_MEDIA_MENU, card);
+    }
+    else
+      SKIP_ITEM();
+  }
+  END_MENU();
+}
+
+#if ENABLED(MULTI_VOLUME)
+  void menu_media_select() {
+    START_MENU();
+    BACK_ITEM_P(TERN1(BROWSE_MEDIA_ON_INSERT, screen_history_depth) ? GET_TEXT(MSG_MAIN) : GET_TEXT(MSG_BACK));
+    #if ENABLED(VOLUME_SD_ONBOARD)
+      ACTION_ITEM(MSG_SD_CARD, []{ card.changeMedia(&card.media_driver_sdcard); card.mount(); ui.goto_screen(menu_media_filelist); });
+    #endif
+    #if ENABLED(VOLUME_USB_FLASH_DRIVE)
+      ACTION_ITEM(MSG_USB_DISK, []{ card.changeMedia(&card.media_driver_usbFlash); card.mount(); ui.goto_screen(menu_media_filelist); });
+    #endif
+    END_MENU();
+  }
+#endif
+
+void menu_media() {
+  TERN(MULTI_VOLUME, menu_media_select, menu_media_filelist)();
+}
+
+#endif // HAS_LCD_MENU && SDSUPPORT

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_mixer.cpp

@@ -0,0 +1,278 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Mixer Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if BOTH(HAS_LCD_MENU, MIXING_EXTRUDER)
+
+#include "menu_item.h"
+#include "menu_addon.h"
+
+#include "../../feature/mixing.h"
+
+#if HAS_GRAPHICAL_TFT
+  #include "../tft/tft.h"
+#endif
+
+#define CHANNEL_MIX_EDITING !HAS_DUAL_MIXING
+
+#if ENABLED(GRADIENT_MIX)
+
+  void _lcd_mixer_gradient_z_edit(const bool isend) {
+    ui.defer_status_screen();
+    ENCODER_RATE_MULTIPLY(true);
+
+    float &zvar = isend ? mixer.gradient.end_z : mixer.gradient.start_z;
+
+    if (ui.encoderPosition) {
+      zvar += float(int32_t(ui.encoderPosition)) * 0.1;
+      ui.encoderPosition = 0;
+      NOLESS(zvar, 0);
+      NOMORE(zvar, Z_MAX_POS);
+    }
+
+    if (ui.should_draw()) {
+      char tmp[16];
+      SETCURSOR(1, (LCD_HEIGHT - 1) / 2);
+      lcd_put_u8str_P(isend ? GET_TEXT(MSG_END_Z) : GET_TEXT(MSG_START_Z));
+      sprintf_P(tmp, PSTR("%4d.%d mm"), int(zvar), int(zvar * 10) % 10);
+      SETCURSOR_RJ(9, (LCD_HEIGHT - 1) / 2);
+      lcd_put_u8str(tmp);
+    }
+
+    if (ui.lcd_clicked) {
+      if (isend && zvar < mixer.gradient.start_z)
+        mixer.gradient.start_z = zvar;
+      else if (!isend && zvar > mixer.gradient.end_z)
+        mixer.gradient.end_z = zvar;
+      mixer.refresh_gradient();
+      ui.goto_previous_screen();
+    }
+    else {
+      TERN_(HAS_GRAPHICAL_TFT, tft.draw_edit_screen_buttons());
+    }
+  }
+
+  void lcd_mixer_edit_gradient_menu() {
+    START_MENU();
+    BACK_ITEM(MSG_MIXER);
+
+    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)
+      EDIT_ITEM(int8, MSG_GRADIENT_ALIAS, &mixer.gradient.vtool_index, -1, MIXING_VIRTUAL_TOOLS - 1, mixer.refresh_gradient);
+    #endif
+
+    char tmp[18];
+
+    PGM_P const slabel = GET_TEXT(MSG_START_Z);
+    SUBMENU_P(slabel, []{ _lcd_mixer_gradient_z_edit(false); });
+    MENU_ITEM_ADDON_START_RJ(11);
+      sprintf_P(tmp, PSTR("%4d.%d mm"), int(mixer.gradient.start_z), int(mixer.gradient.start_z * 10) % 10);
+      lcd_put_u8str(tmp);
+    MENU_ITEM_ADDON_END();
+
+    PGM_P const elabel = GET_TEXT(MSG_END_Z);
+    SUBMENU_P(elabel, []{ _lcd_mixer_gradient_z_edit(true); });
+    MENU_ITEM_ADDON_START_RJ(11);
+      sprintf_P(tmp, PSTR("%4d.%d mm"), int(mixer.gradient.end_z), int(mixer.gradient.end_z * 10) % 10);
+      lcd_put_u8str(tmp);
+    MENU_ITEM_ADDON_END();
+
+    END_MENU();
+  }
+
+#endif // GRADIENT_MIX
+
+static uint8_t v_index;
+
+#if HAS_DUAL_MIXING
+  void _lcd_draw_mix(const uint8_t y) {
+    char tmp[20]; // "100%_100%"
+    sprintf_P(tmp, PSTR("%3d%% %3d%%"), int(mixer.mix[0]), int(mixer.mix[1]));
+    SETCURSOR(2, y); lcd_put_u8str_P(GET_TEXT(MSG_MIX));
+    SETCURSOR_RJ(10, y); lcd_put_u8str(tmp);
+  }
+#endif
+
+void _lcd_mixer_select_vtool() {
+  mixer.T(v_index);
+  TERN_(HAS_DUAL_MIXING, _lcd_draw_mix(LCD_HEIGHT - 1));
+}
+
+#if CHANNEL_MIX_EDITING
+
+  void _lcd_mixer_cycle_mix() {
+    uint16_t bits = 0;
+    MIXER_STEPPER_LOOP(i) if (mixer.collector[i]) SBI(bits, i);
+    bits = (bits + 1) & (_BV(MIXING_STEPPERS) - 1);
+    if (!bits) ++bits;
+    MIXER_STEPPER_LOOP(i) mixer.collector[i] = TEST(bits, i) ? 10.0f : 0.0f;
+    ui.refresh();
+  }
+
+  void _lcd_mixer_commit_vtool() {
+    mixer.normalize();
+    ui.goto_previous_screen();
+  }
+
+#endif
+
+void lcd_mixer_mix_edit() {
+
+  #if HAS_DUAL_MIXING && !CHANNEL_MIX_EDITING
+
+    // Adjust 2-channel mix from the encoder
+    if (ui.encoderPosition) {
+      mixer.mix[0] += int32_t(ui.encoderPosition);
+      ui.encoderPosition = 0;
+      if (mixer.mix[0] < 0) mixer.mix[0] += 101;
+      if (mixer.mix[0] > 100) mixer.mix[0] -= 101;
+      mixer.mix[1] = 100 - mixer.mix[0];
+    }
+    _lcd_draw_mix((LCD_HEIGHT - 1) / 2);
+
+    // Click to commit the change
+    if (ui.lcd_clicked) {
+      mixer.update_vtool_from_mix();
+      ui.goto_previous_screen();
+    }
+
+    TERN_(HAS_GRAPHICAL_TFT, tft.draw_edit_screen_buttons());
+
+  #else
+
+    START_MENU();
+    BACK_ITEM(MSG_MIXER);
+
+    #if CHANNEL_MIX_EDITING
+
+      LOOP_S_LE_N(n, 1, MIXING_STEPPERS)
+        EDIT_ITEM_FAST_N(float42_52, n, MSG_MIX_COMPONENT_N, &mixer.collector[n-1], 0, 10);
+
+      ACTION_ITEM(MSG_CYCLE_MIX, _lcd_mixer_cycle_mix);
+      ACTION_ITEM(MSG_COMMIT_VTOOL, _lcd_mixer_commit_vtool);
+
+    #endif
+
+    END_MENU();
+
+  #endif
+}
+
+#if HAS_DUAL_MIXING
+
+  //
+  // Toggle Dual-Mix
+  //
+  inline void _lcd_mixer_toggle_mix() {
+    mixer.mix[0] = mixer.mix[0] == 100 ? 0 : 100;
+    mixer.mix[1] = 100 - mixer.mix[0];
+    mixer.update_vtool_from_mix();
+    ui.refresh(LCDVIEW_CALL_REDRAW_NEXT);
+  }
+
+#endif
+
+#if CHANNEL_MIX_EDITING
+
+  //
+  // Prepare and Edit Mix
+  //
+  inline void _lcd_goto_mix_edit() {
+    mixer.refresh_collector(10, v_index);
+    ui.goto_screen(lcd_mixer_mix_edit);
+    lcd_mixer_mix_edit();
+  }
+
+#endif
+
+#if ENABLED(GRADIENT_MIX)
+  //
+  // Reverse Gradient
+  //
+  inline void _lcd_mixer_reverse_gradient() {
+    const uint8_t sv = mixer.gradient.start_vtool;
+    mixer.gradient.start_vtool = mixer.gradient.end_vtool;
+    mixer.gradient.end_vtool = sv;
+    mixer.refresh_gradient();
+    ui.refresh(LCDVIEW_CALL_REDRAW_NEXT);
+  }
+#endif
+
+void menu_mixer() {
+  START_MENU();
+  BACK_ITEM(MSG_MAIN);
+
+  v_index = mixer.get_current_vtool();
+  EDIT_ITEM(uint8, MSG_ACTIVE_VTOOL, &v_index, 0, MIXING_VIRTUAL_TOOLS - 1, _lcd_mixer_select_vtool, ENABLED(HAS_DUAL_MIXING));
+
+  #if HAS_DUAL_MIXING
+  {
+    char tmp[11];
+    SUBMENU(MSG_MIX, lcd_mixer_mix_edit);
+    MENU_ITEM_ADDON_START_RJ(9);
+      mixer.update_mix_from_vtool();
+      sprintf_P(tmp, PSTR("%3d;%3d%%"), int(mixer.mix[0]), int(mixer.mix[1]));
+      lcd_put_u8str(tmp);
+    MENU_ITEM_ADDON_END();
+    ACTION_ITEM(MSG_TOGGLE_MIX, _lcd_mixer_toggle_mix);
+  }
+  #else
+    SUBMENU(MSG_MIX, _lcd_goto_mix_edit);
+  #endif
+
+  //
+  // Reset All V-Tools
+  //
+  CONFIRM_ITEM(MSG_RESET_VTOOLS,
+    MSG_BUTTON_RESET, MSG_BUTTON_CANCEL,
+    []{
+      mixer.reset_vtools();
+      LCD_MESSAGEPGM(MSG_VTOOLS_RESET);
+      ui.return_to_status();
+    },
+    nullptr,
+    GET_TEXT(MSG_RESET_VTOOLS), (const char *)nullptr, PSTR("?")
+  );
+
+  #if ENABLED(GRADIENT_MIX)
+  {
+    char tmp[13];
+    SUBMENU(MSG_GRADIENT, lcd_mixer_edit_gradient_menu);
+    MENU_ITEM_ADDON_START_RJ(9);
+      sprintf_P(tmp, PSTR("T%i->T%i"), mixer.gradient.start_vtool, mixer.gradient.end_vtool);
+      lcd_put_u8str(tmp);
+    MENU_ITEM_ADDON_END();
+    ACTION_ITEM(MSG_REVERSE_GRADIENT, _lcd_mixer_reverse_gradient);
+  }
+  #endif
+
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU && MIXING_EXTRUDER

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_mmu2.cpp

@@ -0,0 +1,170 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../../inc/MarlinConfig.h"
+
+#if BOTH(HAS_LCD_MENU, MMU2_MENUS)
+
+#include "../../MarlinCore.h"
+#include "../../feature/mmu/mmu2.h"
+#include "menu_mmu2.h"
+#include "menu_item.h"
+
+//
+// Load Filament
+//
+
+inline void action_mmu2_load_filament_to_nozzle(const uint8_t tool) {
+  ui.reset_status();
+  ui.return_to_status();
+  ui.status_printf_P(0,  GET_TEXT(MSG_MMU2_LOADING_FILAMENT), int(tool + 1));
+  if (mmu2.load_filament_to_nozzle(tool)) ui.reset_status();
+  ui.return_to_status();
+}
+
+void _mmu2_load_filament(uint8_t index) {
+  ui.return_to_status();
+  ui.status_printf_P(0, GET_TEXT(MSG_MMU2_LOADING_FILAMENT), int(index + 1));
+  mmu2.load_filament(index);
+  ui.reset_status();
+}
+void action_mmu2_load_all() {
+  LOOP_L_N(i, EXTRUDERS) _mmu2_load_filament(i);
+  ui.return_to_status();
+}
+
+void menu_mmu2_load_filament() {
+  START_MENU();
+  BACK_ITEM(MSG_MMU2_MENU);
+  ACTION_ITEM(MSG_MMU2_ALL, action_mmu2_load_all);
+  LOOP_L_N(i, EXTRUDERS) ACTION_ITEM_N(i, MSG_MMU2_FILAMENT_N, []{ _mmu2_load_filament(MenuItemBase::itemIndex); });
+  END_MENU();
+}
+
+void menu_mmu2_load_to_nozzle() {
+  START_MENU();
+  BACK_ITEM(MSG_MMU2_MENU);
+  LOOP_L_N(i, EXTRUDERS) ACTION_ITEM_N(i, MSG_MMU2_FILAMENT_N, []{ action_mmu2_load_filament_to_nozzle(MenuItemBase::itemIndex); });
+  END_MENU();
+}
+
+//
+// Eject Filament
+//
+
+void _mmu2_eject_filament(uint8_t index) {
+  ui.reset_status();
+  ui.return_to_status();
+  ui.status_printf_P(0, GET_TEXT(MSG_MMU2_EJECTING_FILAMENT), int(index + 1));
+  if (mmu2.eject_filament(index, true)) ui.reset_status();
+}
+
+void action_mmu2_unload_filament() {
+  ui.reset_status();
+  ui.return_to_status();
+  LCD_MESSAGEPGM(MSG_MMU2_UNLOADING_FILAMENT);
+  idle();
+  if (mmu2.unload()) ui.reset_status();
+}
+
+void menu_mmu2_eject_filament() {
+  START_MENU();
+  BACK_ITEM(MSG_MMU2_MENU);
+  LOOP_L_N(i, EXTRUDERS) ACTION_ITEM_N(i, MSG_MMU2_FILAMENT_N, []{ _mmu2_eject_filament(MenuItemBase::itemIndex); });
+  END_MENU();
+}
+
+//
+// MMU2 Menu
+//
+
+void action_mmu2_reset() {
+  mmu2.init();
+  ui.reset_status();
+}
+
+void menu_mmu2() {
+  START_MENU();
+  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();
+}
+
+//
+// T* Choose Filament
+//
+
+uint8_t feeder_index;
+bool wait_for_mmu_menu;
+
+inline void action_mmu2_chosen(const uint8_t index) {
+  feeder_index = index;
+  wait_for_mmu_menu = false;
+}
+
+void menu_mmu2_choose_filament() {
+  START_MENU();
+  #if LCD_HEIGHT > 2
+    STATIC_ITEM(MSG_MMU2_CHOOSE_FILAMENT_HEADER, SS_DEFAULT|SS_INVERT);
+  #endif
+  LOOP_L_N(i, EXTRUDERS) ACTION_ITEM_N(i, MSG_MMU2_FILAMENT_N, []{ action_mmu2_chosen(MenuItemBase::itemIndex); });
+  END_MENU();
+}
+
+//
+// MMU2 Filament Runout
+//
+
+void menu_mmu2_pause() {
+  feeder_index = mmu2.get_current_tool();
+  START_MENU();
+  #if LCD_HEIGHT > 2
+    STATIC_ITEM(MSG_FILAMENT_CHANGE_HEADER, SS_DEFAULT|SS_INVERT);
+  #endif
+  ACTION_ITEM(MSG_MMU2_RESUME, []{ wait_for_mmu_menu = false; });
+  ACTION_ITEM(MSG_MMU2_UNLOAD_FILAMENT, []{ mmu2.unload(); });
+  ACTION_ITEM(MSG_MMU2_LOAD_FILAMENT, []{ mmu2.load_filament(feeder_index); });
+  ACTION_ITEM(MSG_MMU2_LOAD_TO_NOZZLE, []{ mmu2.load_filament_to_nozzle(feeder_index); });
+  END_MENU();
+}
+
+void mmu2_M600() {
+  ui.defer_status_screen();
+  ui.goto_screen(menu_mmu2_pause);
+  wait_for_mmu_menu = true;
+  while (wait_for_mmu_menu) idle();
+}
+
+uint8_t mmu2_choose_filament() {
+  ui.defer_status_screen();
+  ui.goto_screen(menu_mmu2_choose_filament);
+  wait_for_mmu_menu = true;
+  while (wait_for_mmu_menu) idle();
+  ui.return_to_status();
+  return feeder_index;
+}
+
+#endif // HAS_LCD_MENU && MMU2_MENUS

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_mmu2.h

@@ -0,0 +1,28 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include <stdint.h>
+
+void menu_mmu2();
+void mmu2_M600();
+uint8_t mmu2_choose_filament();

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_motion.cpp

@@ -0,0 +1,437 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Motion Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if HAS_LCD_MENU
+
+#define LARGE_BED_TEST ((X_BED_SIZE) >= 1000 || (Y_BED_SIZE) >= 1000)
+
+#include "menu_item.h"
+#include "menu_addon.h"
+
+#include "../../module/motion.h"
+#include "../../gcode/parser.h" // for inch support
+
+#if ENABLED(DELTA)
+  #include "../../module/delta.h"
+#endif
+
+#if ENABLED(PREVENT_COLD_EXTRUSION)
+  #include "../../module/temperature.h"
+#endif
+
+#if HAS_LEVELING
+  #include "../../module/planner.h"
+  #include "../../feature/bedlevel/bedlevel.h"
+#endif
+
+#if ENABLED(MANUAL_E_MOVES_RELATIVE)
+  float manual_move_e_origin = 0;
+#endif
+
+//
+// "Motion" > "Move Axis" submenu
+//
+
+static void _lcd_move_xyz(PGM_P const name, const AxisEnum axis) {
+  if (ui.use_click()) return ui.goto_previous_screen_no_defer();
+  if (ui.encoderPosition && !ui.manual_move.processing) {
+    // Get motion limit from software endstops, if any
+    float min, max;
+    soft_endstop.get_manual_axis_limits(axis, min, max);
+
+    // Delta limits XY based on the current offset from center
+    // This assumes the center is 0,0
+    #if ENABLED(DELTA)
+      if (axis != Z_AXIS) {
+        max = SQRT(sq((float)(DELTA_PRINTABLE_RADIUS)) - sq(current_position[Y_AXIS - axis])); // (Y_AXIS - axis) == the other axis
+        min = -max;
+      }
+    #endif
+
+    // Get the new position
+    const float diff = float(int32_t(ui.encoderPosition)) * ui.manual_move.menu_scale;
+    (void)ui.manual_move.apply_diff(axis, diff, min, max);
+    ui.manual_move.soon(axis);
+    ui.refresh(LCDVIEW_REDRAW_NOW);
+  }
+  ui.encoderPosition = 0;
+  if (ui.should_draw()) {
+    const float pos = ui.manual_move.axis_value(axis);
+    if (parser.using_inch_units()) {
+      const float imp_pos = LINEAR_UNIT(pos);
+      MenuEditItemBase::draw_edit_screen(name, ftostr63(imp_pos));
+    }
+    else
+      MenuEditItemBase::draw_edit_screen(name, ui.manual_move.menu_scale >= 0.1f ? (LARGE_BED_TEST ? ftostr51sign(pos) : ftostr41sign(pos)) : ftostr63(pos));
+  }
+}
+void lcd_move_x() { _lcd_move_xyz(GET_TEXT(MSG_MOVE_X), X_AXIS); }
+#if HAS_Y_AXIS
+  void lcd_move_y() { _lcd_move_xyz(GET_TEXT(MSG_MOVE_Y), Y_AXIS); }
+#endif
+#if HAS_Z_AXIS
+  void lcd_move_z() { _lcd_move_xyz(GET_TEXT(MSG_MOVE_Z), Z_AXIS); }
+#endif
+#if LINEAR_AXES >= 4
+  void lcd_move_i() { _lcd_move_xyz(GET_TEXT(MSG_MOVE_I), I_AXIS); }
+#endif
+#if LINEAR_AXES >= 5
+  void lcd_move_j() { _lcd_move_xyz(GET_TEXT(MSG_MOVE_J), J_AXIS); }
+#endif
+#if LINEAR_AXES >= 6
+  void lcd_move_k() { _lcd_move_xyz(GET_TEXT(MSG_MOVE_K), K_AXIS); }
+#endif
+
+#if E_MANUAL
+
+  static void lcd_move_e(TERN_(MULTI_E_MANUAL, const int8_t eindex=active_extruder)) {
+    if (ui.use_click()) return ui.goto_previous_screen_no_defer();
+    if (ui.encoderPosition) {
+      if (!ui.manual_move.processing) {
+        const float diff = float(int32_t(ui.encoderPosition)) * ui.manual_move.menu_scale;
+        TERN(IS_KINEMATIC, ui.manual_move.offset, current_position.e) += diff;
+        ui.manual_move.soon(E_AXIS OPTARG(MULTI_E_MANUAL, eindex));
+        ui.refresh(LCDVIEW_REDRAW_NOW);
+      }
+      ui.encoderPosition = 0;
+    }
+    if (ui.should_draw()) {
+      TERN_(MULTI_E_MANUAL, MenuItemBase::init(eindex));
+      MenuEditItemBase::draw_edit_screen(
+        GET_TEXT(TERN(MULTI_E_MANUAL, MSG_MOVE_EN, MSG_MOVE_E)),
+        ftostr41sign(current_position.e
+          PLUS_TERN0(IS_KINEMATIC, ui.manual_move.offset)
+          MINUS_TERN0(MANUAL_E_MOVES_RELATIVE, manual_move_e_origin)
+        )
+      );
+    } // should_draw
+  }
+
+#endif // E_MANUAL
+
+//
+// "Motion" > "Move Xmm" > "Move XYZ" submenu
+//
+
+#ifndef FINE_MANUAL_MOVE
+  #define FINE_MANUAL_MOVE 0.025
+#endif
+
+screenFunc_t _manual_move_func_ptr;
+
+void _goto_manual_move(const_float_t scale) {
+  ui.defer_status_screen();
+  ui.manual_move.menu_scale = scale;
+  ui.goto_screen(_manual_move_func_ptr);
+}
+
+void _menu_move_distance(const AxisEnum axis, const screenFunc_t func, const int8_t eindex=active_extruder) {
+  _manual_move_func_ptr = func;
+  START_MENU();
+  if (LCD_HEIGHT >= 4) {
+    switch (axis) {
+      case X_AXIS: STATIC_ITEM(MSG_MOVE_X, SS_DEFAULT|SS_INVERT); break;
+      case Y_AXIS: STATIC_ITEM(MSG_MOVE_Y, SS_DEFAULT|SS_INVERT); break;
+      case Z_AXIS: STATIC_ITEM(MSG_MOVE_Z, SS_DEFAULT|SS_INVERT); break;
+      default:
+        TERN_(MANUAL_E_MOVES_RELATIVE, manual_move_e_origin = current_position.e);
+        STATIC_ITEM(MSG_MOVE_E, SS_DEFAULT|SS_INVERT);
+        break;
+    }
+  }
+
+  BACK_ITEM(MSG_MOVE_AXIS);
+  if (parser.using_inch_units()) {
+    if (LARGE_BED_TEST) SUBMENU(MSG_MOVE_10IN, []{ _goto_manual_move(IN_TO_MM(1.000f)); });
+    SUBMENU(MSG_MOVE_01IN,   []{ _goto_manual_move(IN_TO_MM(0.100f)); });
+    SUBMENU(MSG_MOVE_001IN,  []{ _goto_manual_move(IN_TO_MM(0.010f)); });
+    SUBMENU(MSG_MOVE_0001IN, []{ _goto_manual_move(IN_TO_MM(0.001f)); });
+  }
+  else {
+    if (LARGE_BED_TEST) SUBMENU(MSG_MOVE_100MM, []{ _goto_manual_move(100); });
+    SUBMENU(MSG_MOVE_10MM, []{ _goto_manual_move(10);    });
+    SUBMENU(MSG_MOVE_1MM,  []{ _goto_manual_move( 1);    });
+    SUBMENU(MSG_MOVE_01MM, []{ _goto_manual_move( 0.1f); });
+    if (axis == Z_AXIS && (FINE_MANUAL_MOVE) > 0.0f && (FINE_MANUAL_MOVE) < 0.1f) {
+      // Determine digits needed right of decimal
+      constexpr uint8_t digs = !UNEAR_ZERO((FINE_MANUAL_MOVE) * 1000 - int((FINE_MANUAL_MOVE) * 1000)) ? 4 :
+                               !UNEAR_ZERO((FINE_MANUAL_MOVE) *  100 - int((FINE_MANUAL_MOVE) *  100)) ? 3 : 2;
+      PGM_P const label = GET_TEXT(MSG_MOVE_N_MM);
+      char tmp[strlen_P(label) + 10 + 1], numstr[10];
+      sprintf_P(tmp, label, dtostrf(FINE_MANUAL_MOVE, 1, digs, numstr));
+      #if DISABLED(HAS_GRAPHICAL_TFT)
+        SUBMENU_P(NUL_STR, []{ _goto_manual_move(float(FINE_MANUAL_MOVE)); });
+        MENU_ITEM_ADDON_START(0 + ENABLED(HAS_MARLINUI_HD44780));
+        lcd_put_u8str(tmp);
+        MENU_ITEM_ADDON_END();
+      #else
+        SUBMENU_P(tmp, []{ _goto_manual_move(float(FINE_MANUAL_MOVE)); });
+      #endif
+    }
+  }
+  END_MENU();
+}
+
+#if E_MANUAL
+
+  inline void _goto_menu_move_distance_e() {
+    ui.goto_screen([]{ _menu_move_distance(E_AXIS, []{ lcd_move_e(); }); });
+  }
+
+  inline void _menu_move_distance_e_maybe() {
+    #if ENABLED(PREVENT_COLD_EXTRUSION)
+      const bool too_cold = thermalManager.tooColdToExtrude(active_extruder);
+      if (too_cold) {
+        ui.goto_screen([]{
+          MenuItem_confirm::select_screen(
+            GET_TEXT(MSG_BUTTON_PROCEED), GET_TEXT(MSG_BACK),
+            _goto_menu_move_distance_e, ui.goto_previous_screen,
+            GET_TEXT(MSG_HOTEND_TOO_COLD), (const char *)nullptr, PSTR("!")
+          );
+        });
+        return;
+      }
+    #endif
+    _goto_menu_move_distance_e();
+  }
+
+#endif // E_MANUAL
+
+void menu_move() {
+  START_MENU();
+  BACK_ITEM(MSG_MOTION);
+
+  #if BOTH(HAS_SOFTWARE_ENDSTOPS, SOFT_ENDSTOPS_MENU_ITEM)
+    EDIT_ITEM(bool, MSG_LCD_SOFT_ENDSTOPS, &soft_endstop._enabled);
+  #endif
+
+  if (NONE(IS_KINEMATIC, NO_MOTION_BEFORE_HOMING) || all_axes_homed()) {
+    if (TERN1(DELTA, current_position.z <= delta_clip_start_height)) {
+      SUBMENU(MSG_MOVE_X, []{ _menu_move_distance(X_AXIS, lcd_move_x); });
+      #if HAS_Y_AXIS
+        SUBMENU(MSG_MOVE_Y, []{ _menu_move_distance(Y_AXIS, lcd_move_y); });
+      #endif
+    }
+    #if ENABLED(DELTA)
+      else
+        ACTION_ITEM(MSG_FREE_XY, []{ line_to_z(delta_clip_start_height); ui.synchronize(); });
+    #endif
+
+    #if HAS_Z_AXIS
+      SUBMENU(MSG_MOVE_Z, []{ _menu_move_distance(Z_AXIS, lcd_move_z); });
+    #endif
+    #if LINEAR_AXES >= 4
+      SUBMENU(MSG_MOVE_I, []{ _menu_move_distance(I_AXIS, lcd_move_i); });
+    #endif
+    #if LINEAR_AXES >= 5
+      SUBMENU(MSG_MOVE_J, []{ _menu_move_distance(J_AXIS, lcd_move_j); });
+    #endif
+    #if LINEAR_AXES >= 6
+      SUBMENU(MSG_MOVE_K, []{ _menu_move_distance(K_AXIS, lcd_move_k); });
+    #endif
+  }
+  else
+    GCODES_ITEM(MSG_AUTO_HOME, G28_STR);
+
+  #if ANY(SWITCHING_EXTRUDER, SWITCHING_NOZZLE, MAGNETIC_SWITCHING_TOOLHEAD)
+
+    #if EXTRUDERS >= 4
+      switch (active_extruder) {
+        case 0: GCODES_ITEM_N(1, MSG_SELECT_E, PSTR("T1")); break;
+        case 1: GCODES_ITEM_N(0, MSG_SELECT_E, PSTR("T0")); break;
+        case 2: GCODES_ITEM_N(3, MSG_SELECT_E, PSTR("T3")); break;
+        case 3: GCODES_ITEM_N(2, MSG_SELECT_E, PSTR("T2")); break;
+        #if EXTRUDERS == 6
+          case 4: GCODES_ITEM_N(5, MSG_SELECT_E, PSTR("T5")); break;
+          case 5: GCODES_ITEM_N(4, MSG_SELECT_E, PSTR("T4")); break;
+        #endif
+      }
+    #elif EXTRUDERS == 3
+      if (active_extruder < 2) {
+        if (active_extruder)
+          GCODES_ITEM_N(0, MSG_SELECT_E, PSTR("T0"));
+        else
+          GCODES_ITEM_N(1, MSG_SELECT_E, PSTR("T1"));
+      }
+    #else
+      if (active_extruder)
+        GCODES_ITEM_N(0, MSG_SELECT_E, PSTR("T0"));
+      else
+        GCODES_ITEM_N(1, MSG_SELECT_E, PSTR("T1"));
+    #endif
+
+  #elif ENABLED(DUAL_X_CARRIAGE)
+
+    if (active_extruder)
+      GCODES_ITEM_N(0, MSG_SELECT_E, PSTR("T0"));
+    else
+      GCODES_ITEM_N(1, MSG_SELECT_E, PSTR("T1"));
+
+  #endif
+
+  #if E_MANUAL
+
+    // The current extruder
+    SUBMENU(MSG_MOVE_E, []{ _menu_move_distance_e_maybe(); });
+
+    #define SUBMENU_MOVE_E(N) SUBMENU_N(N, MSG_MOVE_EN, []{ _menu_move_distance(E_AXIS, []{ lcd_move_e(MenuItemBase::itemIndex); }, MenuItemBase::itemIndex); });
+
+    #if EITHER(SWITCHING_EXTRUDER, SWITCHING_NOZZLE)
+
+      // ...and the non-switching
+      #if E_MANUAL == 7 || E_MANUAL == 5 || E_MANUAL == 3
+        SUBMENU_MOVE_E(E_MANUAL - 1);
+      #endif
+
+    #elif MULTI_E_MANUAL
+
+      // Independent extruders with one E-stepper per hotend
+      LOOP_L_N(n, E_MANUAL) SUBMENU_MOVE_E(n);
+
+    #endif
+
+  #endif // E_MANUAL
+
+  END_MENU();
+}
+
+#if ENABLED(AUTO_BED_LEVELING_UBL)
+  void _lcd_ubl_level_bed();
+#elif ENABLED(LCD_BED_LEVELING)
+  void menu_bed_leveling();
+#endif
+
+#if ENABLED(ASSISTED_TRAMMING_WIZARD)
+  void goto_tramming_wizard();
+#endif
+
+void menu_motion() {
+  START_MENU();
+
+  //
+  // ^ Main
+  //
+  BACK_ITEM(MSG_MAIN);
+
+  //
+  // Move Axis
+  //
+  if (TERN1(DELTA, all_axes_homed()))
+    SUBMENU(MSG_MOVE_AXIS, menu_move);
+
+  //
+  // Auto Home
+  //
+  GCODES_ITEM(MSG_AUTO_HOME, G28_STR);
+  #if ENABLED(INDIVIDUAL_AXIS_HOMING_MENU)
+    GCODES_ITEM(MSG_AUTO_HOME_X, PSTR("G28X"));
+    #if HAS_Y_AXIS
+      GCODES_ITEM(MSG_AUTO_HOME_Y, PSTR("G28Y"));
+    #endif
+    #if HAS_Z_AXIS
+      GCODES_ITEM(MSG_AUTO_HOME_Z, PSTR("G28Z"));
+    #endif
+    #if LINEAR_AXES >= 4
+      GCODES_ITEM(MSG_AUTO_HOME_I, PSTR("G28" I_STR));
+    #endif
+    #if LINEAR_AXES >= 5
+      GCODES_ITEM(MSG_AUTO_HOME_J, PSTR("G28" J_STR));
+    #endif
+    #if LINEAR_AXES >= 6
+      GCODES_ITEM(MSG_AUTO_HOME_K, PSTR("G28" K_STR));
+    #endif
+  #endif
+
+  //
+  // Auto-calibration
+  //
+  #if ENABLED(CALIBRATION_GCODE)
+    GCODES_ITEM(MSG_AUTO_CALIBRATE, PSTR("G425"));
+  #endif
+
+  //
+  // Auto Z-Align
+  //
+  #if EITHER(Z_STEPPER_AUTO_ALIGN, MECHANICAL_GANTRY_CALIBRATION)
+    GCODES_ITEM(MSG_AUTO_Z_ALIGN, PSTR("G34"));
+  #endif
+
+  //
+  // Assisted Bed Tramming
+  //
+  #if ENABLED(ASSISTED_TRAMMING_WIZARD)
+    SUBMENU(MSG_TRAMMING_WIZARD, goto_tramming_wizard);
+  #endif
+
+  //
+  // Level Bed
+  //
+  #if ENABLED(AUTO_BED_LEVELING_UBL)
+
+    SUBMENU(MSG_UBL_LEVEL_BED, _lcd_ubl_level_bed);
+
+  #elif ENABLED(LCD_BED_LEVELING)
+
+    if (!g29_in_progress)
+      SUBMENU(MSG_BED_LEVELING, menu_bed_leveling);
+
+  #elif HAS_LEVELING && DISABLED(SLIM_LCD_MENUS)
+
+    #if DISABLED(PROBE_MANUALLY)
+      GCODES_ITEM(MSG_LEVEL_BED, PSTR("G29N"));
+    #endif
+
+    if (all_axes_homed() && leveling_is_valid()) {
+      bool show_state = planner.leveling_active;
+      EDIT_ITEM(bool, MSG_BED_LEVELING, &show_state, _lcd_toggle_bed_leveling);
+    }
+
+    #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
+      editable.decimal = planner.z_fade_height;
+      EDIT_ITEM_FAST(float3, MSG_Z_FADE_HEIGHT, &editable.decimal, 0, 100, []{ set_z_fade_height(editable.decimal); });
+    #endif
+
+  #endif
+
+  #if ENABLED(LEVEL_BED_CORNERS) && DISABLED(LCD_BED_LEVELING)
+    SUBMENU(MSG_LEVEL_CORNERS, _lcd_level_bed_corners);
+  #endif
+
+  #if ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)
+    GCODES_ITEM(MSG_M48_TEST, PSTR("G28O\nM48 P10"));
+  #endif
+
+  //
+  // Disable Steppers
+  //
+  GCODES_ITEM(MSG_DISABLE_STEPPERS, PSTR("M84"));
+
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_password.cpp

@@ -0,0 +1,187 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Advanced Settings Menus
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if BOTH(HAS_LCD_MENU, PASSWORD_FEATURE)
+
+#include "../../feature/password/password.h"
+
+#include "menu_item.h"
+#include "menu_addon.h"
+
+void menu_advanced_settings();
+
+screenFunc_t success_screen, fail_screen;
+bool authenticating; // = false
+char string[(PASSWORD_LENGTH) + 1];
+static uint8_t digit_no;
+
+//
+// Screen for both editing and setting the password
+//
+void Password::menu_password_entry() {
+  ui.defer_status_screen(!did_first_run); // No timeout to status before first auth
+
+  START_MENU();
+
+  // "Login" or "New Code"
+  STATIC_ITEM_P(authenticating ? GET_TEXT(MSG_LOGIN_REQUIRED) : GET_TEXT(MSG_EDIT_PASSWORD), SS_CENTER|SS_INVERT);
+
+  STATIC_ITEM_P(NUL_STR, SS_CENTER, string);
+
+  #if HAS_MARLINUI_U8GLIB
+    STATIC_ITEM_P(NUL_STR, SS_CENTER, "");
+  #endif
+
+  // Make the digit edit item look like a sub-menu
+  PGM_P const label = GET_TEXT(MSG_ENTER_DIGIT);
+  EDIT_ITEM_P(uint8, label, &editable.uint8, 0, 9, digit_entered);
+  MENU_ITEM_ADDON_START(utf8_strlen_P(label) + 1);
+    lcd_put_wchar(' ');
+    lcd_put_wchar('1' + digit_no);
+    SETCURSOR_X(LCD_WIDTH - 2);
+    lcd_put_wchar('>');
+  MENU_ITEM_ADDON_END();
+
+  ACTION_ITEM(MSG_START_OVER, start_over);
+
+  if (!authenticating) BACK_ITEM(MSG_BUTTON_CANCEL);
+
+  END_MENU();
+}
+
+//
+// Authentication check
+//
+void Password::authentication_done() {
+  ui.goto_screen(is_locked ? fail_screen : success_screen);
+  ui.completion_feedback(!is_locked);
+}
+
+// A single digit was completed
+void Password::digit_entered() {
+  uint32_t multiplier = CAT(1e, PASSWORD_LENGTH); // 1e5 = 100000
+  LOOP_LE_N(i, digit_no) multiplier /= 10;
+  value_entry += editable.uint8 * multiplier;
+  string[digit_no++] = '0' + editable.uint8;
+
+  // Exit edit screen menu and go to another screen
+  ui.goto_previous_screen();
+  ui.use_click();
+  ui.goto_screen(menu_password_entry);
+
+  // After password has been keyed in
+  if (digit_no == PASSWORD_LENGTH) {
+    if (authenticating)
+      authentication_check();
+    else
+      set_password_done();
+  }
+}
+
+//
+// Set/Change Password
+//
+void Password::screen_password_entry() {
+  value_entry = 0;
+  digit_no = 0;
+  editable.uint8 = 0;
+  memset(string, '_', PASSWORD_LENGTH);
+  string[PASSWORD_LENGTH] = '\0';
+  menu_password_entry();
+}
+
+void Password::screen_set_password() {
+  authenticating = false;
+  screen_password_entry();
+}
+
+void Password::authenticate_user(const screenFunc_t in_succ_scr, const screenFunc_t in_fail_scr) {
+  success_screen = in_succ_scr;
+  fail_screen = in_fail_scr;
+  if (is_set) {
+    authenticating = true;
+    ui.goto_screen(screen_password_entry);
+    ui.update();
+  }
+  else {
+    ui.goto_screen(in_succ_scr);
+    is_locked = false;
+  }
+}
+
+void Password::access_menu_password() {
+  authenticate_user(menu_password, menu_advanced_settings);
+}
+
+#if ENABLED(PASSWORD_ON_SD_PRINT_MENU)
+  void Password::media_gatekeeper() {
+    authenticate_user(menu_media, menu_main);
+  }
+#endif
+
+void Password::start_over() {
+  ui.goto_previous_screen(); // Goto previous screen, if any
+  ui.goto_screen(screen_password_entry);
+}
+
+void Password::menu_password_report() {
+  START_SCREEN();
+  BACK_ITEM(MSG_PASSWORD_SETTINGS);
+  STATIC_ITEM(MSG_PASSWORD_SET, SS_LEFT, string);
+  STATIC_ITEM(MSG_REMINDER_SAVE_SETTINGS, SS_LEFT);
+  END_SCREEN();
+}
+
+void Password::set_password_done(const bool with_set/*=true*/) {
+  is_set = with_set;
+  value = value_entry;
+  ui.completion_feedback(true);
+  ui.goto_screen(menu_password_report);
+}
+
+void Password::remove_password() {
+  string[0] = '0';
+  string[1] = '\0';
+  set_password_done(false);
+}
+
+//
+// Password Menu
+//
+void Password::menu_password() {
+  START_MENU();
+  BACK_ITEM(MSG_ADVANCED_SETTINGS);
+  SUBMENU(MSG_CHANGE_PASSWORD, screen_set_password);
+  ACTION_ITEM(MSG_REMOVE_PASSWORD, []{ ui.save_previous_screen(); remove_password(); } );
+  #if ENABLED(EEPROM_SETTINGS)
+    ACTION_ITEM(MSG_STORE_EEPROM, ui.store_settings);
+  #endif
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU && PASSWORD_FEATURE

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_power_monitor.cpp

@@ -0,0 +1,62 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Power Monitor Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if HAS_LCD_MENU && HAS_POWER_MONITOR
+
+#include "menu_item.h"
+#include "../../feature/power_monitor.h"
+
+void menu_power_monitor() {
+  START_MENU();
+  BACK_ITEM(MSG_MAIN);
+
+  #if ENABLED(POWER_MONITOR_CURRENT)
+  {
+    bool ena = power_monitor.current_display_enabled();
+    EDIT_ITEM(bool, MSG_CURRENT, &ena, power_monitor.toggle_current_display);
+  }
+  #endif
+
+  #if ENABLED(POWER_MONITOR_VOLTAGE)
+  {
+    bool ena = power_monitor.voltage_display_enabled();
+    EDIT_ITEM(bool, MSG_VOLTAGE, &ena, power_monitor.toggle_voltage_display);
+  }
+  #endif
+
+  #if HAS_POWER_MONITOR_WATTS
+  {
+    bool ena = power_monitor.power_display_enabled();
+    EDIT_ITEM(bool, MSG_POWER, &ena, power_monitor.toggle_power_display);
+  }
+  #endif
+
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU && HAS_POWER_MONITOR

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_probe_offset.cpp

@@ -0,0 +1,192 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Calibrate Probe offset menu.
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if ENABLED(PROBE_OFFSET_WIZARD)
+
+#include "menu_item.h"
+#include "menu_addon.h"
+#include "../../gcode/queue.h"
+#include "../../module/motion.h"
+#include "../../module/planner.h"
+#include "../../module/probe.h"
+
+#if HAS_LEVELING
+  #include "../../feature/bedlevel/bedlevel.h"
+#endif
+
+// Global storage
+float z_offset_backup, calculated_z_offset, z_offset_ref;
+
+#if HAS_LEVELING
+  bool leveling_was_active;
+#endif
+
+inline void z_clearance_move() {
+  do_z_clearance(
+    #ifdef Z_AFTER_HOMING
+      Z_AFTER_HOMING
+    #elif defined(Z_HOMING_HEIGHT)
+      Z_HOMING_HEIGHT
+    #else
+      10
+    #endif
+  );
+}
+
+void set_offset_and_go_back(const_float_t z) {
+  probe.offset.z = z;
+  SET_SOFT_ENDSTOP_LOOSE(false);
+  TERN_(HAS_LEVELING, set_bed_leveling_enabled(leveling_was_active));
+  ui.goto_previous_screen_no_defer();
+}
+
+void _goto_manual_move_z(const_float_t scale) {
+  ui.manual_move.menu_scale = scale;
+  ui.goto_screen(lcd_move_z);
+}
+
+void probe_offset_wizard_menu() {
+  START_MENU();
+  calculated_z_offset = probe.offset.z + current_position.z - z_offset_ref;
+
+  if (LCD_HEIGHT >= 4)
+    STATIC_ITEM(MSG_MOVE_NOZZLE_TO_BED, SS_CENTER|SS_INVERT);
+
+  STATIC_ITEM_P(PSTR("Z="), SS_CENTER, ftostr42_52(current_position.z));
+  STATIC_ITEM(MSG_ZPROBE_ZOFFSET, SS_LEFT, ftostr42_52(calculated_z_offset));
+
+  SUBMENU(MSG_MOVE_1MM,  []{ _goto_manual_move_z( 1);    });
+  SUBMENU(MSG_MOVE_01MM, []{ _goto_manual_move_z( 0.1f); });
+
+  if ((FINE_MANUAL_MOVE) > 0.0f && (FINE_MANUAL_MOVE) < 0.1f) {
+    char tmp[20], numstr[10];
+    // Determine digits needed right of decimal
+    const uint8_t digs = !UNEAR_ZERO((FINE_MANUAL_MOVE) * 1000 - int((FINE_MANUAL_MOVE) * 1000)) ? 4 :
+                         !UNEAR_ZERO((FINE_MANUAL_MOVE) *  100 - int((FINE_MANUAL_MOVE) *  100)) ? 3 : 2;
+    sprintf_P(tmp, GET_TEXT(MSG_MOVE_N_MM), dtostrf(FINE_MANUAL_MOVE, 1, digs, numstr));
+    #if DISABLED(HAS_GRAPHICAL_TFT)
+      SUBMENU_P(NUL_STR, []{ _goto_manual_move_z(float(FINE_MANUAL_MOVE)); });
+      MENU_ITEM_ADDON_START(0 + ENABLED(HAS_MARLINUI_HD44780));
+      lcd_put_u8str(tmp);
+      MENU_ITEM_ADDON_END();
+    #else
+      SUBMENU_P(tmp, []{ _goto_manual_move_z(float(FINE_MANUAL_MOVE)); });
+    #endif
+  }
+
+  ACTION_ITEM(MSG_BUTTON_DONE, []{
+    set_offset_and_go_back(calculated_z_offset);
+    current_position.z = z_offset_ref;  // Set Z to z_offset_ref, as we can expect it is at probe height
+    sync_plan_position();
+    z_clearance_move();                 // Raise Z as if it was homed
+  });
+
+  ACTION_ITEM(MSG_BUTTON_CANCEL, []{
+    set_offset_and_go_back(z_offset_backup);
+    // If wizard-homing was done by probe with PROBE_OFFSET_WIZARD_START_Z
+    #if HOMING_Z_WITH_PROBE && defined(PROBE_OFFSET_WIZARD_START_Z)
+      set_axis_never_homed(Z_AXIS); // On cancel the Z position needs correction
+      queue.inject_P(PSTR("G28Z"));
+    #else // Otherwise do a Z clearance move like after Homing
+      z_clearance_move();
+    #endif
+  });
+
+  END_MENU();
+}
+
+void prepare_for_probe_offset_wizard() {
+  #if defined(PROBE_OFFSET_WIZARD_XY_POS) || !HOMING_Z_WITH_PROBE
+    if (ui.should_draw()) MenuItem_static::draw(1, GET_TEXT(MSG_PROBE_WIZARD_PROBING));
+
+    if (ui.wait_for_move) return;
+
+    #ifndef PROBE_OFFSET_WIZARD_XY_POS
+      #define PROBE_OFFSET_WIZARD_XY_POS XY_CENTER
+    #endif
+    // Get X and Y from configuration, or use center
+    constexpr xy_pos_t wizard_pos = PROBE_OFFSET_WIZARD_XY_POS;
+
+    // Probe for Z reference
+    ui.wait_for_move = true;
+    z_offset_ref = probe.probe_at_point(wizard_pos, PROBE_PT_RAISE, 0, true);
+    ui.wait_for_move = false;
+
+    // Stow the probe, as the last call to probe.probe_at_point(...) left
+    // the probe deployed if it was successful.
+    probe.stow();
+  #else
+    if (ui.wait_for_move) return;
+  #endif
+
+  // Move Nozzle to Probing/Homing Position
+  ui.wait_for_move = true;
+  current_position += probe.offset_xy;
+  line_to_current_position(MMM_TO_MMS(XY_PROBE_FEEDRATE));
+  ui.synchronize(GET_TEXT(MSG_PROBE_WIZARD_MOVING));
+  ui.wait_for_move = false;
+
+  SET_SOFT_ENDSTOP_LOOSE(true); // Disable soft endstops for free Z movement
+
+  // Go to Calibration Menu
+  ui.goto_screen(probe_offset_wizard_menu);
+  ui.defer_status_screen();
+}
+
+void goto_probe_offset_wizard() {
+  ui.defer_status_screen();
+  set_all_unhomed();
+
+  // Store probe.offset.z for Case: Cancel
+  z_offset_backup = probe.offset.z;
+
+  #ifdef PROBE_OFFSET_WIZARD_START_Z
+    probe.offset.z = PROBE_OFFSET_WIZARD_START_Z;
+  #endif
+
+  // Store Bed-Leveling-State and disable
+  #if HAS_LEVELING
+    leveling_was_active = planner.leveling_active;
+    set_bed_leveling_enabled(false);
+  #endif
+
+  // Home all axes
+  queue.inject_P(G28_STR);
+
+  ui.goto_screen([]{
+    _lcd_draw_homing();
+    if (all_axes_homed()) {
+      z_offset_ref = 0;             // Set Z Value for Wizard Position to 0
+      ui.goto_screen(prepare_for_probe_offset_wizard);
+      ui.defer_status_screen();
+    }
+  });
+
+}
+
+#endif // PROBE_OFFSET_WIZARD

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_spindle_laser.cpp

@@ -0,0 +1,84 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Spindle / Laser Menu
+//
+
+#include "../../inc/MarlinConfig.h"
+
+#if HAS_LCD_MENU && HAS_CUTTER
+
+  #include "menu_item.h"
+
+  #include "../../feature/spindle_laser.h"
+
+  void menu_spindle_laser() {
+    bool is_enabled = cutter.enabled() && cutter.isReady;
+    #if ENABLED(SPINDLE_CHANGE_DIR)
+      bool is_rev = cutter.is_reverse();
+    #endif
+
+    START_MENU();
+    BACK_ITEM(MSG_MAIN);
+
+    #if ENABLED(SPINDLE_LASER_PWM)
+      // Change the cutter's "current power" value without turning the cutter on or off
+      // Power is displayed and set in units and range according to CUTTER_POWER_UNIT
+      EDIT_ITEM_FAST(CUTTER_MENU_POWER_TYPE, MSG_CUTTER(POWER), &cutter.menuPower,
+        cutter.mpower_min(), cutter.mpower_max(), cutter.update_from_mpower);
+    #endif
+
+    editable.state = is_enabled;
+    EDIT_ITEM(bool, MSG_CUTTER(TOGGLE), &is_enabled, []{ if (editable.state) cutter.disable(); else cutter.enable_same_dir(); });
+
+    #if ENABLED(AIR_EVACUATION)
+      bool evac_state = cutter.air_evac_state();
+      EDIT_ITEM(bool, MSG_CUTTER(EVAC_TOGGLE), &evac_state, cutter.air_evac_toggle);
+    #endif
+
+    #if ENABLED(AIR_ASSIST)
+      bool air_assist_state = cutter.air_assist_state();
+      EDIT_ITEM(bool, MSG_CUTTER(ASSIST_TOGGLE), &air_assist_state, cutter.air_assist_toggle);
+    #endif
+
+    #if ENABLED(SPINDLE_CHANGE_DIR)
+      if (!is_enabled) {
+        editable.state = is_rev;
+        ACTION_ITEM_P(is_rev ? GET_TEXT(MSG_CUTTER(REVERSE)) : GET_TEXT(MSG_CUTTER(FORWARD)), []{ cutter.set_reverse(!editable.state); });
+      }
+    #endif
+
+    #if ENABLED(LASER_FEATURE)
+      // Setup and fire a test pulse using the current PWM power level for for a duration of test_pulse_min to test_pulse_max ms.
+      EDIT_ITEM_FAST(CUTTER_MENU_PULSE_TYPE, MSG_LASER_PULSE_MS, &cutter.testPulse, LASER_TEST_PULSE_MIN, LASER_TEST_PULSE_MAX);
+      ACTION_ITEM(MSG_LASER_FIRE_PULSE, cutter.test_fire_pulse);
+    #endif
+
+    #if BOTH(MARLIN_DEV_MODE, HAL_CAN_SET_PWM_FREQ) && defined(SPINDLE_LASER_FREQUENCY)
+      EDIT_ITEM_FAST(CUTTER_MENU_FREQUENCY_TYPE, MSG_CUTTER_FREQUENCY, &cutter.frequency, 2000, 80000, cutter.refresh_frequency);
+    #endif
+
+    END_MENU();
+  }
+
+#endif // HAS_LCD_MENU && HAS_CUTTER

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_temperature.cpp

@@ -0,0 +1,307 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Temperature Menu
+//
+
+#include "../../inc/MarlinConfig.h"
+
+#if HAS_LCD_MENU && HAS_TEMPERATURE
+
+#include "menu_item.h"
+#include "../../module/temperature.h"
+
+#if HAS_FAN || ENABLED(SINGLENOZZLE)
+  #include "../../module/motion.h"
+#endif
+
+#if EITHER(HAS_COOLER, LASER_COOLANT_FLOW_METER)
+  #include "../../feature/cooler.h"
+#endif
+
+#if ENABLED(SINGLENOZZLE_STANDBY_TEMP)
+  #include "../../module/tool_change.h"
+#endif
+
+//
+// "Temperature" submenu items
+//
+
+void Temperature::lcd_preheat(const uint8_t e, const int8_t indh, const int8_t indb) {
+  UNUSED(e); UNUSED(indh); UNUSED(indb);
+  #if HAS_HOTEND
+    if (indh >= 0 && ui.material_preset[indh].hotend_temp > 0)
+      setTargetHotend(_MIN(thermalManager.hotend_max_target(e), ui.material_preset[indh].hotend_temp), e);
+  #endif
+  #if HAS_HEATED_BED
+    if (indb >= 0 && ui.material_preset[indb].bed_temp > 0) setTargetBed(ui.material_preset[indb].bed_temp);
+  #endif
+  #if HAS_FAN
+    if (indh >= 0) {
+      const uint8_t fan_index = active_extruder < (FAN_COUNT) ? active_extruder : 0;
+      if (true
+        #if REDUNDANT_PART_COOLING_FAN
+          && fan_index != REDUNDANT_PART_COOLING_FAN
+        #endif
+      ) set_fan_speed(fan_index, ui.material_preset[indh].fan_speed);
+    }
+  #endif
+  ui.return_to_status();
+}
+
+#if PREHEAT_COUNT
+
+  #if HAS_TEMP_HOTEND
+    inline void _preheat_end(const uint8_t m, const uint8_t e) { thermalManager.lcd_preheat(e, m, -1); }
+    void do_preheat_end_m() { _preheat_end(editable.int8, 0); }
+  #endif
+  #if HAS_HEATED_BED
+    inline void _preheat_bed(const uint8_t m) { thermalManager.lcd_preheat(0, -1, m); }
+  #endif
+  #if HAS_COOLER
+    inline void _precool_laser(const uint8_t m, const uint8_t e) { thermalManager.lcd_preheat(e, m, -1); }
+    void do_precool_laser_m() { _precool_laser(editable.int8, thermalManager.temp_cooler.target); }
+  #endif
+
+  #if HAS_TEMP_HOTEND && HAS_HEATED_BED
+    inline void _preheat_both(const uint8_t m, const uint8_t e) { thermalManager.lcd_preheat(e, m, m); }
+
+    // Indexed "Preheat ABC" and "Heat Bed" items
+    #define PREHEAT_ITEMS(M,E) do{ \
+      ACTION_ITEM_N_S(E, ui.get_preheat_label(M), MSG_PREHEAT_M_H, []{ _preheat_both(M, MenuItemBase::itemIndex); }); \
+      ACTION_ITEM_N_S(E, ui.get_preheat_label(M), MSG_PREHEAT_M_END_E, []{ _preheat_end(M, MenuItemBase::itemIndex); }); \
+    }while(0)
+
+  #elif HAS_MULTI_HOTEND
+
+    // No heated bed, so just indexed "Preheat ABC" items
+    #define PREHEAT_ITEMS(M,E) ACTION_ITEM_N_S(E, ui.get_preheat_label(M), MSG_PREHEAT_M_H, []{ _preheat_end(M, MenuItemBase::itemIndex); })
+
+  #endif
+
+  #if HAS_MULTI_HOTEND || HAS_HEATED_BED
+
+    // Set editable.int8 to the Material index before entering this menu
+    // because MenuItemBase::itemIndex will be re-used by PREHEAT_ITEMS
+    void menu_preheat_m() {
+      const uint8_t m = editable.int8; // Don't re-use 'editable' in this menu
+
+      START_MENU();
+      BACK_ITEM(MSG_TEMPERATURE);
+
+      #if HOTENDS == 1
+
+        #if HAS_HEATED_BED
+          ACTION_ITEM_S(ui.get_preheat_label(m), MSG_PREHEAT_M, []{ _preheat_both(editable.int8, 0); });
+          ACTION_ITEM_S(ui.get_preheat_label(m), MSG_PREHEAT_M_END, do_preheat_end_m);
+        #else
+          ACTION_ITEM_S(ui.get_preheat_label(m), MSG_PREHEAT_M, do_preheat_end_m);
+        #endif
+
+      #elif HAS_MULTI_HOTEND
+
+        HOTEND_LOOP() PREHEAT_ITEMS(editable.int8, e);
+        ACTION_ITEM_S(ui.get_preheat_label(m), MSG_PREHEAT_M_ALL, []() {
+          HOTEND_LOOP() thermalManager.setTargetHotend(ui.material_preset[editable.int8].hotend_temp, e);
+          TERN(HAS_HEATED_BED, _preheat_bed(editable.int8), ui.return_to_status());
+        });
+
+      #endif
+
+      #if HAS_HEATED_BED
+        ACTION_ITEM_S(ui.get_preheat_label(m), MSG_PREHEAT_M_BEDONLY, []{ _preheat_bed(editable.int8); });
+      #endif
+
+      END_MENU();
+    }
+
+  #endif // HAS_MULTI_HOTEND || HAS_HEATED_BED
+
+#endif // PREHEAT_COUNT
+
+#if HAS_TEMP_HOTEND || HAS_HEATED_BED
+
+  void lcd_cooldown() {
+    thermalManager.zero_fan_speeds();
+    thermalManager.disable_all_heaters();
+    ui.return_to_status();
+  }
+
+#endif // HAS_TEMP_HOTEND || HAS_HEATED_BED
+
+void menu_temperature() {
+  #if HAS_TEMP_HOTEND || HAS_HEATED_BED
+    bool has_heat = false;
+    #if HAS_TEMP_HOTEND
+      HOTEND_LOOP() if (thermalManager.degTargetHotend(HOTEND_INDEX)) { has_heat = true; break; }
+    #endif
+  #endif
+
+  #if HAS_COOLER
+    if (thermalManager.temp_cooler.target == 0) thermalManager.temp_cooler.target = COOLER_DEFAULT_TEMP;
+  #endif
+
+  START_MENU();
+  BACK_ITEM(MSG_MAIN);
+
+  //
+  // Nozzle:
+  // Nozzle [1-5]:
+  //
+  #if HOTENDS == 1
+    EDIT_ITEM_FAST(int3, MSG_NOZZLE, &thermalManager.temp_hotend[0].target, 0, thermalManager.hotend_max_target(0), []{ thermalManager.start_watching_hotend(0); });
+  #elif HAS_MULTI_HOTEND
+    HOTEND_LOOP()
+      EDIT_ITEM_FAST_N(int3, e, MSG_NOZZLE_N, &thermalManager.temp_hotend[e].target, 0, thermalManager.hotend_max_target(e), []{ thermalManager.start_watching_hotend(MenuItemBase::itemIndex); });
+  #endif
+
+  #if ENABLED(SINGLENOZZLE_STANDBY_TEMP)
+    LOOP_S_L_N(e, 1, EXTRUDERS)
+      EDIT_ITEM_FAST_N(int3, e, MSG_NOZZLE_STANDBY, &thermalManager.singlenozzle_temp[e], 0, thermalManager.hotend_max_target(0));
+  #endif
+
+  //
+  // Bed:
+  //
+  #if HAS_HEATED_BED
+    EDIT_ITEM_FAST(int3, MSG_BED, &thermalManager.temp_bed.target, 0, BED_MAX_TARGET, thermalManager.start_watching_bed);
+  #endif
+
+  //
+  // Chamber:
+  //
+  #if HAS_HEATED_CHAMBER
+    EDIT_ITEM_FAST(int3, MSG_CHAMBER, &thermalManager.temp_chamber.target, 0, CHAMBER_MAX_TARGET, thermalManager.start_watching_chamber);
+  #endif
+
+  //
+  // Cooler:
+  //
+  #if HAS_COOLER
+    bool cstate = cooler.enabled;
+    EDIT_ITEM(bool, MSG_COOLER_TOGGLE, &cstate, cooler.toggle);
+    EDIT_ITEM_FAST(int3, MSG_COOLER, &thermalManager.temp_cooler.target, COOLER_MIN_TARGET, COOLER_MAX_TARGET, thermalManager.start_watching_cooler);
+  #endif
+
+  //
+  // Flow Meter Safety Shutdown:
+  //
+  #if ENABLED(FLOWMETER_SAFETY)
+    bool fstate = cooler.flowsafety_enabled;
+    EDIT_ITEM(bool, MSG_FLOWMETER_SAFETY, &fstate, cooler.flowsafety_toggle);
+  #endif
+
+  //
+  // Fan Speed:
+  //
+  #if HAS_FAN
+
+    DEFINE_SINGLENOZZLE_ITEM();
+
+    #if HAS_FAN0
+      _FAN_EDIT_ITEMS(0,FIRST_FAN_SPEED);
+    #endif
+    #if HAS_FAN1 && REDUNDANT_PART_COOLING_FAN != 1
+      FAN_EDIT_ITEMS(1);
+    #elif SNFAN(1)
+      singlenozzle_item(1);
+    #endif
+    #if HAS_FAN2 && REDUNDANT_PART_COOLING_FAN != 2
+      FAN_EDIT_ITEMS(2);
+    #elif SNFAN(2)
+      singlenozzle_item(2);
+    #endif
+    #if HAS_FAN3 && REDUNDANT_PART_COOLING_FAN != 3
+      FAN_EDIT_ITEMS(3);
+    #elif SNFAN(3)
+      singlenozzle_item(3);
+    #endif
+    #if HAS_FAN4 && REDUNDANT_PART_COOLING_FAN != 4
+      FAN_EDIT_ITEMS(4);
+    #elif SNFAN(4)
+      singlenozzle_item(4);
+    #endif
+    #if HAS_FAN5 && REDUNDANT_PART_COOLING_FAN != 5
+      FAN_EDIT_ITEMS(5);
+    #elif SNFAN(5)
+      singlenozzle_item(5);
+    #endif
+    #if HAS_FAN6 && REDUNDANT_PART_COOLING_FAN != 6
+      FAN_EDIT_ITEMS(6);
+    #elif SNFAN(6)
+      singlenozzle_item(6);
+    #endif
+    #if HAS_FAN7 && REDUNDANT_PART_COOLING_FAN != 7
+      FAN_EDIT_ITEMS(7);
+    #elif SNFAN(7)
+      singlenozzle_item(7);
+    #endif
+
+  #endif // HAS_FAN
+
+  #if PREHEAT_COUNT
+    //
+    // Preheat for all Materials
+    //
+    LOOP_L_N(m, PREHEAT_COUNT) {
+      editable.int8 = m;
+      #if HOTENDS > 1 || HAS_HEATED_BED
+        SUBMENU_S(ui.get_preheat_label(m), MSG_PREHEAT_M, menu_preheat_m);
+      #elif HAS_HOTEND
+        ACTION_ITEM_S(ui.get_preheat_label(m), MSG_PREHEAT_M, do_preheat_end_m);
+      #endif
+    }
+  #endif
+
+  #if HAS_TEMP_HOTEND || HAS_HEATED_BED
+    //
+    // Cooldown
+    //
+    if (TERN0(HAS_HEATED_BED, thermalManager.degTargetBed())) has_heat = true;
+    if (has_heat) ACTION_ITEM(MSG_COOLDOWN, lcd_cooldown);
+  #endif
+
+  END_MENU();
+}
+
+#if ENABLED(PREHEAT_SHORTCUT_MENU_ITEM)
+
+  void menu_preheat_only() {
+    START_MENU();
+    BACK_ITEM(MSG_MAIN);
+
+    LOOP_L_N(m, PREHEAT_COUNT) {
+      editable.int8 = m;
+      #if HOTENDS > 1 || HAS_HEATED_BED
+        SUBMENU_S(ui.get_preheat_label(m), MSG_PREHEAT_M, menu_preheat_m);
+      #else
+        ACTION_ITEM_S(ui.get_preheat_label(m), MSG_PREHEAT_M, do_preheat_end_m);
+      #endif
+    }
+
+    END_MENU();
+  }
+
+#endif
+
+#endif // HAS_LCD_MENU && HAS_TEMPERATURE

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_tmc.cpp

@@ -0,0 +1,181 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// TMC Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if HAS_LCD_MENU && HAS_TRINAMIC_CONFIG
+
+#include "menu_item.h"
+#include "../../module/stepper/indirection.h"
+#include "../../feature/tmc_util.h"
+
+#define TMC_EDIT_STORED_I_RMS(ST,STR) EDIT_ITEM_P(uint16_4, PSTR(STR), &stepper##ST.val_mA, 100, 3000, []{ stepper##ST.refresh_stepper_current(); })
+
+void menu_tmc_current() {
+  START_MENU();
+  BACK_ITEM(MSG_TMC_DRIVERS);
+  #if AXIS_IS_TMC(X)
+    TMC_EDIT_STORED_I_RMS(X, STR_X);
+  #endif
+  #if AXIS_IS_TMC(Y)
+    TMC_EDIT_STORED_I_RMS(Y, STR_Y);
+  #endif
+  #if AXIS_IS_TMC(Z)
+    TMC_EDIT_STORED_I_RMS(Z, STR_Z);
+  #endif
+  #if AXIS_IS_TMC(X2)
+    TMC_EDIT_STORED_I_RMS(X2, STR_X2);
+  #endif
+  #if AXIS_IS_TMC(Y2)
+    TMC_EDIT_STORED_I_RMS(Y2, STR_Y2);
+  #endif
+  #if AXIS_IS_TMC(Z2)
+    TMC_EDIT_STORED_I_RMS(Z2, STR_Z2);
+  #endif
+  #if AXIS_IS_TMC(Z3)
+    TMC_EDIT_STORED_I_RMS(Z3, STR_Z3);
+  #endif
+  #if AXIS_IS_TMC(Z4)
+    TMC_EDIT_STORED_I_RMS(Z4, STR_Z4);
+  #endif
+  #if AXIS_IS_TMC(E0)
+    TMC_EDIT_STORED_I_RMS(E0, LCD_STR_E0);
+  #endif
+  #if AXIS_IS_TMC(E1)
+    TMC_EDIT_STORED_I_RMS(E1, LCD_STR_E1);
+  #endif
+  #if AXIS_IS_TMC(E2)
+    TMC_EDIT_STORED_I_RMS(E2, LCD_STR_E2);
+  #endif
+  #if AXIS_IS_TMC(E3)
+    TMC_EDIT_STORED_I_RMS(E3, LCD_STR_E3);
+  #endif
+  #if AXIS_IS_TMC(E4)
+    TMC_EDIT_STORED_I_RMS(E4, LCD_STR_E4);
+  #endif
+  #if AXIS_IS_TMC(E5)
+    TMC_EDIT_STORED_I_RMS(E5, LCD_STR_E5);
+  #endif
+  #if AXIS_IS_TMC(E6)
+    TMC_EDIT_STORED_I_RMS(E6, LCD_STR_E6);
+  #endif
+  #if AXIS_IS_TMC(E7)
+    TMC_EDIT_STORED_I_RMS(E7, LCD_STR_E7);
+  #endif
+  END_MENU();
+}
+
+#if ENABLED(HYBRID_THRESHOLD)
+
+  #define TMC_EDIT_STORED_HYBRID_THRS(ST, STR) EDIT_ITEM_P(uint8, PSTR(STR), &stepper##ST.stored.hybrid_thrs, 0, 255, []{ stepper##ST.refresh_hybrid_thrs(); });
+
+  void menu_tmc_hybrid_thrs() {
+    START_MENU();
+    BACK_ITEM(MSG_TMC_DRIVERS);
+    TERN_(X_HAS_STEALTHCHOP,  TMC_EDIT_STORED_HYBRID_THRS(X,  STR_X));
+    TERN_(Y_HAS_STEALTHCHOP,  TMC_EDIT_STORED_HYBRID_THRS(Y,  STR_Y));
+    TERN_(Z_HAS_STEALTHCHOP,  TMC_EDIT_STORED_HYBRID_THRS(Z,  STR_Z));
+    TERN_(X2_HAS_STEALTHCHOP, TMC_EDIT_STORED_HYBRID_THRS(X2, STR_X2));
+    TERN_(Y2_HAS_STEALTHCHOP, TMC_EDIT_STORED_HYBRID_THRS(Y2, STR_Y2));
+    TERN_(Z2_HAS_STEALTHCHOP, TMC_EDIT_STORED_HYBRID_THRS(Z2, STR_Z2));
+    TERN_(Z3_HAS_STEALTHCHOP, TMC_EDIT_STORED_HYBRID_THRS(Z3, STR_Z3));
+    TERN_(Z4_HAS_STEALTHCHOP, TMC_EDIT_STORED_HYBRID_THRS(Z4, STR_Z4));
+    TERN_(E0_HAS_STEALTHCHOP, TMC_EDIT_STORED_HYBRID_THRS(E0, LCD_STR_E0));
+    TERN_(E1_HAS_STEALTHCHOP, TMC_EDIT_STORED_HYBRID_THRS(E1, LCD_STR_E1));
+    TERN_(E2_HAS_STEALTHCHOP, TMC_EDIT_STORED_HYBRID_THRS(E2, LCD_STR_E2));
+    TERN_(E3_HAS_STEALTHCHOP, TMC_EDIT_STORED_HYBRID_THRS(E3, LCD_STR_E3));
+    TERN_(E4_HAS_STEALTHCHOP, TMC_EDIT_STORED_HYBRID_THRS(E4, LCD_STR_E4));
+    TERN_(E5_HAS_STEALTHCHOP, TMC_EDIT_STORED_HYBRID_THRS(E5, LCD_STR_E5));
+    TERN_(E6_HAS_STEALTHCHOP, TMC_EDIT_STORED_HYBRID_THRS(E6, LCD_STR_E6));
+    TERN_(E7_HAS_STEALTHCHOP, TMC_EDIT_STORED_HYBRID_THRS(E7, LCD_STR_E7));
+    END_MENU();
+  }
+
+#endif
+
+#if ENABLED(SENSORLESS_HOMING)
+
+  #define TMC_EDIT_STORED_SGT(ST) EDIT_ITEM_P(int4, PSTR(STR_##ST), &stepper##ST.stored.homing_thrs, stepper##ST.sgt_min, stepper##ST.sgt_max, []{ stepper##ST.refresh_homing_thrs(); });
+
+  void menu_tmc_homing_thrs() {
+    START_MENU();
+    BACK_ITEM(MSG_TMC_DRIVERS);
+    TERN_( X_SENSORLESS, TMC_EDIT_STORED_SGT(X));
+    TERN_(X2_SENSORLESS, TMC_EDIT_STORED_SGT(X2));
+    TERN_( Y_SENSORLESS, TMC_EDIT_STORED_SGT(Y));
+    TERN_(Y2_SENSORLESS, TMC_EDIT_STORED_SGT(Y2));
+    TERN_( Z_SENSORLESS, TMC_EDIT_STORED_SGT(Z));
+    TERN_(Z2_SENSORLESS, TMC_EDIT_STORED_SGT(Z2));
+    TERN_(Z3_SENSORLESS, TMC_EDIT_STORED_SGT(Z3));
+    TERN_(Z4_SENSORLESS, TMC_EDIT_STORED_SGT(Z4));
+    TERN_( I_SENSORLESS, TMC_EDIT_STORED_SGT(I));
+    TERN_( J_SENSORLESS, TMC_EDIT_STORED_SGT(J));
+    TERN_( K_SENSORLESS, TMC_EDIT_STORED_SGT(K));
+    END_MENU();
+  }
+
+#endif
+
+#if HAS_STEALTHCHOP
+
+  #define TMC_EDIT_STEP_MODE(ST, STR) EDIT_ITEM_P(bool, PSTR(STR), &stepper##ST.stored.stealthChop_enabled, []{ stepper##ST.refresh_stepping_mode(); })
+
+  void menu_tmc_step_mode() {
+    START_MENU();
+    STATIC_ITEM(MSG_TMC_STEALTH_ENABLED);
+    BACK_ITEM(MSG_TMC_DRIVERS);
+    TERN_( X_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(X,  STR_X));
+    TERN_(X2_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(X2, STR_X2));
+    TERN_( Y_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(Y,  STR_Y));
+    TERN_(Y2_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(Y2, STR_Y2));
+    TERN_( Z_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(Z,  STR_Z));
+    TERN_(Z2_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(Z2, STR_Z2));
+    TERN_(Z3_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(Z3, STR_Z3));
+    TERN_(Z4_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(Z4, STR_Z4));
+    TERN_(E0_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(E0, LCD_STR_E0));
+    TERN_(E1_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(E1, LCD_STR_E1));
+    TERN_(E2_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(E2, LCD_STR_E2));
+    TERN_(E3_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(E3, LCD_STR_E3));
+    TERN_(E4_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(E4, LCD_STR_E4));
+    TERN_(E5_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(E5, LCD_STR_E5));
+    TERN_(E6_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(E6, LCD_STR_E6));
+    TERN_(E7_HAS_STEALTHCHOP, TMC_EDIT_STEP_MODE(E7, LCD_STR_E7));
+    END_MENU();
+  }
+
+#endif
+
+void menu_tmc() {
+  START_MENU();
+  BACK_ITEM(MSG_ADVANCED_SETTINGS);
+  SUBMENU(MSG_TMC_CURRENT, menu_tmc_current);
+  TERN_(HYBRID_THRESHOLD,   SUBMENU(MSG_TMC_HYBRID_THRS, menu_tmc_hybrid_thrs));
+  TERN_(SENSORLESS_HOMING,  SUBMENU(MSG_TMC_HOMING_THRS, menu_tmc_homing_thrs));
+  TERN_(HAS_STEALTHCHOP,    SUBMENU(MSG_TMC_STEPPING_MODE, menu_tmc_step_mode));
+  END_MENU();
+}
+
+#endif // HAS_TRINAMIC_CONFIG

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_touch_screen.cpp

@@ -0,0 +1,36 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if BOTH(HAS_LCD_MENU, TOUCH_SCREEN_CALIBRATION)
+
+#include "menu_item.h"
+#include "../marlinui.h"
+
+void touch_screen_calibration() {
+
+  ui.touch_calibration_screen();
+
+}
+
+#endif // TOUCH_SCREEN_CALIBRATION

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_tramming.cpp

@@ -0,0 +1,104 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Bed Tramming Wizard
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if BOTH(HAS_LCD_MENU, ASSISTED_TRAMMING_WIZARD)
+
+#include "menu_item.h"
+
+#include "../../feature/tramming.h"
+
+#include "../../module/motion.h"
+#include "../../module/probe.h"
+#include "../../gcode/queue.h"
+
+//#define DEBUG_OUT 1
+#include "../../core/debug_out.h"
+
+float z_measured[G35_PROBE_COUNT] = { 0 };
+static uint8_t tram_index = 0;
+
+#if HAS_LEVELING
+  #include "../../feature/bedlevel/bedlevel.h"
+#endif
+
+static bool probe_single_point() {
+  do_blocking_move_to_z(TERN(BLTOUCH, Z_CLEARANCE_DEPLOY_PROBE, Z_CLEARANCE_BETWEEN_PROBES));
+  // Stow after each point with BLTouch "HIGH SPEED" mode for push-pin safety
+  const float z_probed_height = probe.probe_at_point(screws_tilt_adjust_pos[tram_index], TERN(BLTOUCH_HS_MODE, PROBE_PT_STOW, PROBE_PT_RAISE), 0, true);
+  DEBUG_ECHOLNPAIR("probe_single_point: ", z_probed_height, "mm");
+  z_measured[tram_index] = z_probed_height;
+  move_to_tramming_wait_pos();
+
+  return !isnan(z_probed_height);
+}
+
+static void _menu_single_probe(const uint8_t point) {
+  tram_index = point;
+  DEBUG_ECHOLNPAIR("Screen: single probe screen Arg:", point);
+  START_MENU();
+  STATIC_ITEM(MSG_LEVEL_CORNERS, SS_LEFT);
+  STATIC_ITEM(MSG_LAST_VALUE_SP, SS_LEFT, ftostr42_52(z_measured[0] - z_measured[point])); // Print diff
+  ACTION_ITEM(MSG_UBL_BC_INSERT2, []{ if (probe_single_point()) ui.refresh(); });
+  ACTION_ITEM(MSG_BUTTON_DONE, []{ ui.goto_previous_screen(); }); // Back
+  END_MENU();
+}
+
+static void tramming_wizard_menu() {
+  DEBUG_ECHOLNPAIR("Screen: tramming_wizard_menu");
+  START_MENU();
+  STATIC_ITEM(MSG_SELECT_ORIGIN);
+
+  // Draw a menu item for each tramming point
+  LOOP_L_N(i, G35_PROBE_COUNT)
+    SUBMENU_N_P(i, (char*)pgm_read_ptr(&tramming_point_name[i]), []{ _menu_single_probe(MenuItemBase::itemIndex); });
+
+  ACTION_ITEM(MSG_BUTTON_DONE, []{
+    probe.stow(); // Stow before exiting Tramming Wizard
+    ui.goto_previous_screen_no_defer();
+  });
+  END_MENU();
+}
+
+// Init the wizard and enter the submenu
+void goto_tramming_wizard() {
+  DEBUG_ECHOLNPAIR("Screen: goto_tramming_wizard", 1);
+  tram_index = 0;
+  ui.defer_status_screen();
+
+  // Inject G28, wait for homing to complete,
+  set_all_unhomed();
+  queue.inject_P(TERN(CAN_SET_LEVELING_AFTER_G28, PSTR("G28L0"), G28_STR));
+
+  ui.goto_screen([]{
+    _lcd_draw_homing();
+    if (all_axes_homed())
+      ui.goto_screen(tramming_wizard_menu);
+  });
+}
+
+#endif // HAS_LCD_MENU && ASSISTED_TRAMMING_WIZARD

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_tune.cpp

@@ -0,0 +1,239 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Tune Menu
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if HAS_LCD_MENU
+
+#include "menu_item.h"
+#include "../../module/motion.h"
+#include "../../module/planner.h"
+#include "../../module/temperature.h"
+#include "../../MarlinCore.h"
+
+#if ENABLED(SINGLENOZZLE_STANDBY_TEMP)
+  #include "../../module/tool_change.h"
+#endif
+
+#if HAS_LEVELING
+  #include "../../feature/bedlevel/bedlevel.h"
+#endif
+
+#if ENABLED(BABYSTEPPING)
+
+  #include "../../feature/babystep.h"
+  #include "../lcdprint.h"
+  #if HAS_MARLINUI_U8GLIB
+    #include "../dogm/marlinui_DOGM.h"
+  #endif
+
+  void _lcd_babystep(const AxisEnum axis, PGM_P const msg) {
+    if (ui.use_click()) return ui.goto_previous_screen_no_defer();
+    if (ui.encoderPosition) {
+      const int16_t steps = int16_t(ui.encoderPosition) * (
+        #if ENABLED(BABYSTEP_XY)
+          axis == X_AXIS ? BABYSTEP_SIZE_X :
+          axis == Y_AXIS ? BABYSTEP_SIZE_Y :
+        #endif
+        BABYSTEP_SIZE_Z
+      );
+      ui.encoderPosition = 0;
+      ui.refresh(LCDVIEW_REDRAW_NOW);
+      babystep.add_steps(axis, steps);
+    }
+    if (ui.should_draw()) {
+      const float spm = planner.steps_to_mm[axis];
+      MenuEditItemBase::draw_edit_screen(msg, BABYSTEP_TO_STR(spm * babystep.accum));
+      #if ENABLED(BABYSTEP_DISPLAY_TOTAL)
+        const bool in_view = TERN1(HAS_MARLINUI_U8GLIB, PAGE_CONTAINS(LCD_PIXEL_HEIGHT - MENU_FONT_HEIGHT, LCD_PIXEL_HEIGHT - 1));
+        if (in_view) {
+          TERN_(HAS_MARLINUI_U8GLIB, ui.set_font(FONT_MENU));
+          #if ENABLED(TFT_COLOR_UI)
+            lcd_moveto(4, 3);
+            lcd_put_u8str_P(GET_TEXT(MSG_BABYSTEP_TOTAL));
+            lcd_put_wchar(':');
+            lcd_moveto(10, 3);
+          #else
+            lcd_moveto(0, TERN(HAS_MARLINUI_U8GLIB, LCD_PIXEL_HEIGHT - MENU_FONT_DESCENT, LCD_HEIGHT - 1));
+            lcd_put_u8str_P(GET_TEXT(MSG_BABYSTEP_TOTAL));
+            lcd_put_wchar(':');
+          #endif
+          lcd_put_u8str(BABYSTEP_TO_STR(spm * babystep.axis_total[BS_TOTAL_IND(axis)]));
+        }
+      #endif
+    }
+  }
+
+  inline void _lcd_babystep_go(const screenFunc_t screen) {
+    ui.goto_screen(screen);
+    ui.defer_status_screen();
+    babystep.accum = 0;
+  }
+
+  #if ENABLED(BABYSTEP_XY)
+    void _lcd_babystep_x() { _lcd_babystep(X_AXIS, GET_TEXT(MSG_BABYSTEP_X)); }
+    void _lcd_babystep_y() { _lcd_babystep(Y_AXIS, GET_TEXT(MSG_BABYSTEP_Y)); }
+  #endif
+
+  #if DISABLED(BABYSTEP_ZPROBE_OFFSET)
+    void _lcd_babystep_z() { _lcd_babystep(Z_AXIS, GET_TEXT(MSG_BABYSTEP_Z)); }
+    void lcd_babystep_z()  { _lcd_babystep_go(_lcd_babystep_z); }
+  #endif
+
+#endif // BABYSTEPPING
+
+void menu_tune() {
+  START_MENU();
+  BACK_ITEM(MSG_MAIN);
+
+  //
+  // Speed:
+  //
+  EDIT_ITEM(int3, MSG_SPEED, &feedrate_percentage, 10, 999);
+
+  //
+  // Manual bed leveling, Bed Z:
+  //
+  #if BOTH(MESH_BED_LEVELING, LCD_BED_LEVELING)
+    EDIT_ITEM(float43, MSG_BED_Z, &mbl.z_offset, -1, 1);
+  #endif
+
+  //
+  // Nozzle:
+  // Nozzle [1-4]:
+  //
+  #if HOTENDS == 1
+    EDIT_ITEM_FAST(int3, MSG_NOZZLE, &thermalManager.temp_hotend[0].target, 0, thermalManager.hotend_max_target(0), []{ thermalManager.start_watching_hotend(0); });
+  #elif HAS_MULTI_HOTEND
+    HOTEND_LOOP()
+      EDIT_ITEM_FAST_N(int3, e, MSG_NOZZLE_N, &thermalManager.temp_hotend[e].target, 0, thermalManager.hotend_max_target(e), []{ thermalManager.start_watching_hotend(MenuItemBase::itemIndex); });
+  #endif
+
+  #if ENABLED(SINGLENOZZLE_STANDBY_TEMP)
+    LOOP_S_L_N(e, 1, EXTRUDERS)
+      EDIT_ITEM_FAST_N(int3, e, MSG_NOZZLE_STANDBY, &thermalManager.singlenozzle_temp[e], 0, thermalManager.hotend_max_target(0));
+  #endif
+
+  //
+  // Bed:
+  //
+  #if HAS_HEATED_BED
+    EDIT_ITEM_FAST(int3, MSG_BED, &thermalManager.temp_bed.target, 0, BED_MAX_TARGET, thermalManager.start_watching_bed);
+  #endif
+
+  //
+  // Fan Speed:
+  //
+  #if HAS_FAN
+
+    DEFINE_SINGLENOZZLE_ITEM();
+
+    #if HAS_FAN0
+      _FAN_EDIT_ITEMS(0,FIRST_FAN_SPEED);
+    #endif
+    #if HAS_FAN1
+      FAN_EDIT_ITEMS(1);
+    #elif SNFAN(1)
+      singlenozzle_item(1);
+    #endif
+    #if HAS_FAN2
+      FAN_EDIT_ITEMS(2);
+    #elif SNFAN(2)
+      singlenozzle_item(2);
+    #endif
+    #if HAS_FAN3
+      FAN_EDIT_ITEMS(3);
+    #elif SNFAN(3)
+      singlenozzle_item(3);
+    #endif
+    #if HAS_FAN4
+      FAN_EDIT_ITEMS(4);
+    #elif SNFAN(4)
+      singlenozzle_item(4);
+    #endif
+    #if HAS_FAN5
+      FAN_EDIT_ITEMS(5);
+    #elif SNFAN(5)
+      singlenozzle_item(5);
+    #endif
+    #if HAS_FAN6
+      FAN_EDIT_ITEMS(6);
+    #elif SNFAN(6)
+      singlenozzle_item(6);
+    #endif
+    #if HAS_FAN7
+      FAN_EDIT_ITEMS(7);
+    #elif SNFAN(7)
+      singlenozzle_item(7);
+    #endif
+
+  #endif // HAS_FAN
+
+  //
+  // Flow:
+  //
+  #if HAS_EXTRUDERS
+    EDIT_ITEM(int3, MSG_FLOW, &planner.flow_percentage[active_extruder], 10, 999, []{ planner.refresh_e_factor(active_extruder); });
+    // Flow En:
+    #if HAS_MULTI_EXTRUDER
+      LOOP_L_N(n, EXTRUDERS)
+        EDIT_ITEM_N(int3, n, MSG_FLOW_N, &planner.flow_percentage[n], 10, 999, []{ planner.refresh_e_factor(MenuItemBase::itemIndex); });
+    #endif
+  #endif
+
+  //
+  // Advance K:
+  //
+  #if ENABLED(LIN_ADVANCE) && DISABLED(SLIM_LCD_MENUS)
+    #if EXTRUDERS == 1
+      EDIT_ITEM(float42_52, MSG_ADVANCE_K, &planner.extruder_advance_K[0], 0, 10);
+    #elif HAS_MULTI_EXTRUDER
+      LOOP_L_N(n, EXTRUDERS)
+        EDIT_ITEM_N(float42_52, n, MSG_ADVANCE_K_E, &planner.extruder_advance_K[n], 0, 10);
+    #endif
+  #endif
+
+  //
+  // Babystep X:
+  // Babystep Y:
+  // Babystep Z:
+  //
+  #if ENABLED(BABYSTEPPING)
+    #if ENABLED(BABYSTEP_XY)
+      SUBMENU(MSG_BABYSTEP_X, []{ _lcd_babystep_go(_lcd_babystep_x); });
+      SUBMENU(MSG_BABYSTEP_Y, []{ _lcd_babystep_go(_lcd_babystep_y); });
+    #endif
+    #if ENABLED(BABYSTEP_ZPROBE_OFFSET)
+      SUBMENU(MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
+    #else
+      SUBMENU(MSG_BABYSTEP_Z, lcd_babystep_z);
+    #endif
+  #endif
+
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU

sparky/Marlin-bugfix-2.0.x/Marlin/src/lcd/menu/menu_ubl.cpp

@@ -0,0 +1,689 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+//
+// Unified Bed Leveling Menus
+//
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if BOTH(HAS_LCD_MENU, AUTO_BED_LEVELING_UBL)
+
+#include "menu_item.h"
+#include "../../gcode/gcode.h"
+#include "../../gcode/queue.h"
+#include "../../module/motion.h"
+#include "../../module/planner.h"
+#include "../../module/settings.h"
+#include "../../feature/bedlevel/bedlevel.h"
+
+static int16_t ubl_storage_slot = 0,
+               custom_hotend_temp = 150,
+               side_points = 3,
+               ubl_fillin_amount = 5,
+               ubl_height_amount = 1;
+
+static uint8_t n_edit_pts = 1;
+static int8_t x_plot = 0, y_plot = 0; // May be negative during move
+
+#if HAS_HEATED_BED
+  static int16_t custom_bed_temp = 50;
+#endif
+
+float mesh_edit_accumulator;  // Rounded to 2.5 decimal places on use
+
+inline float rounded_mesh_value() {
+  const int32_t rounded = int32_t(mesh_edit_accumulator * 1000);
+  return float(rounded - (rounded % 5L)) / 1000;
+}
+
+/**
+ * This screen displays the temporary mesh value and updates it based on encoder
+ * movement. While this screen is active ubl.fine_tune_mesh sits in a loop getting
+ * the current value via ubl_mesh_value, moves the Z axis, and updates the mesh
+ * value until the encoder button is pressed.
+ *
+ * - Update the 'mesh_edit_accumulator' from encoder rotation
+ * - Draw the mesh value (with draw_edit_screen)
+ * - Draw the graphical overlay, if enabled.
+ * - Update the 'refresh' state according to the display type
+ */
+void _lcd_mesh_fine_tune(PGM_P const msg) {
+  constexpr float mesh_edit_step = 1.0f / 200.0f;
+  ui.defer_status_screen();
+  if (ubl.encoder_diff) {
+    mesh_edit_accumulator += TERN(IS_TFTGLCD_PANEL,
+      ubl.encoder_diff * mesh_edit_step / ENCODER_PULSES_PER_STEP,
+      ubl.encoder_diff > 0 ? mesh_edit_step : -mesh_edit_step
+    );
+    ubl.encoder_diff = 0;
+    IF_DISABLED(IS_TFTGLCD_PANEL, ui.refresh(LCDVIEW_CALL_REDRAW_NEXT));
+  }
+  TERN_(IS_TFTGLCD_PANEL, ui.refresh(LCDVIEW_CALL_REDRAW_NEXT));
+
+  if (ui.should_draw()) {
+    const float rounded_f = rounded_mesh_value();
+    MenuEditItemBase::draw_edit_screen(msg, ftostr43sign(rounded_f));
+    TERN_(MESH_EDIT_GFX_OVERLAY, _lcd_zoffset_overlay_gfx(rounded_f));
+    TERN_(HAS_GRAPHICAL_TFT, ui.refresh(LCDVIEW_NONE));
+  }
+}
+
+//
+// Init mesh editing and go to the fine tuning screen (ubl.fine_tune_mesh)
+// To capture encoder events UBL will also call ui.capture and ui.release.
+//
+void MarlinUI::ubl_mesh_edit_start(const_float_t initial) {
+  TERN_(HAS_GRAPHICAL_TFT, clear_lcd());
+  mesh_edit_accumulator = initial;
+  goto_screen([]{ _lcd_mesh_fine_tune(GET_TEXT(MSG_MESH_EDIT_Z)); });
+}
+
+//
+// Get the mesh value within a Z adjustment loop (ubl.fine_tune_mesh)
+//
+float MarlinUI::ubl_mesh_value() { return rounded_mesh_value(); }
+
+/**
+ * UBL Build Custom Mesh Command
+ */
+void _lcd_ubl_build_custom_mesh() {
+  char ubl_lcd_gcode[64];
+  #if HAS_HEATED_BED
+    sprintf_P(ubl_lcd_gcode, PSTR("G28\nM190 S%i\nM109 S%i\nG29 P1"), custom_bed_temp, custom_hotend_temp);
+  #else
+    sprintf_P(ubl_lcd_gcode, PSTR("G28\nM109 S%i\nG29 P1"), custom_hotend_temp);
+  #endif
+  queue.inject(ubl_lcd_gcode);
+}
+
+/**
+ * UBL Custom Mesh submenu
+ *
+ * << Build Mesh
+ *    Hotend Temp: ---
+ *    Bed Temp: ---
+ *    Build Custom Mesh
+ */
+void _lcd_ubl_custom_mesh() {
+  START_MENU();
+  BACK_ITEM(MSG_UBL_BUILD_MESH_MENU);
+  #if HAS_HOTEND
+    EDIT_ITEM(int3, MSG_UBL_HOTEND_TEMP_CUSTOM, &custom_hotend_temp, EXTRUDE_MINTEMP, thermalManager.hotend_max_target(0));
+  #endif
+  #if HAS_HEATED_BED
+    EDIT_ITEM(int3, MSG_UBL_BED_TEMP_CUSTOM, &custom_bed_temp, BED_MINTEMP, BED_MAX_TARGET);
+  #endif
+  ACTION_ITEM(MSG_UBL_BUILD_CUSTOM_MESH, _lcd_ubl_build_custom_mesh);
+  END_MENU();
+}
+
+/**
+ * UBL Adjust Mesh Height Command
+ */
+void _lcd_ubl_adjust_height_cmd() {
+  char ubl_lcd_gcode[13];
+  const int ind = ubl_height_amount > 0 ? 6 : 7;
+  strcpy_P(ubl_lcd_gcode, PSTR("G29P6C-"));
+  sprintf_P(&ubl_lcd_gcode[ind], PSTR(".%i"), ABS(ubl_height_amount));
+  queue.inject(ubl_lcd_gcode);
+}
+
+/**
+ * UBL Adjust Mesh Height submenu
+ *
+ * << Edit Mesh
+ *    Height Amount: ---
+ *    Adjust Mesh Height
+ * << Info Screen
+ */
+void _menu_ubl_height_adjust() {
+  START_MENU();
+  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_INFO_SCREEN, ui.return_to_status);
+  END_MENU();
+}
+
+/**
+ * UBL Edit Mesh submenu
+ *
+ * << UBL Tools
+ *    Fine Tune All
+ *    Fine Tune Closest
+ *  - Adjust Mesh Height >>
+ * << Info Screen
+ */
+void _lcd_ubl_edit_mesh() {
+  START_MENU();
+  BACK_ITEM(MSG_UBL_TOOLS);
+  GCODES_ITEM(MSG_UBL_FINE_TUNE_ALL, PSTR("G29P4RT"));
+  GCODES_ITEM(MSG_UBL_FINE_TUNE_CLOSEST, PSTR("G29P4T"));
+  SUBMENU(MSG_UBL_MESH_HEIGHT_ADJUST, _menu_ubl_height_adjust);
+  ACTION_ITEM(MSG_INFO_SCREEN, ui.return_to_status);
+  END_MENU();
+}
+
+#if ENABLED(G26_MESH_VALIDATION)
+
+  /**
+   * UBL Validate Custom Mesh Command
+   */
+  void _lcd_ubl_validate_custom_mesh() {
+    char ubl_lcd_gcode[20];
+    sprintf_P(ubl_lcd_gcode, PSTR("G28\nG26CPH%" PRIi16 TERN_(HAS_HEATED_BED, "B%" PRIi16))
+      , custom_hotend_temp
+      #if HAS_HEATED_BED
+        , custom_bed_temp
+      #endif
+    );
+    queue.inject(ubl_lcd_gcode);
+  }
+
+  /**
+   * UBL Validate Mesh submenu
+   *
+   * << UBL Tools
+   *    Mesh Validation with Material 1 up to 5
+   *    Validate Custom Mesh
+   * << Info Screen
+   */
+  void _lcd_ubl_validate_mesh() {
+    START_MENU();
+    BACK_ITEM(MSG_UBL_TOOLS);
+    #if PREHEAT_COUNT
+      #if HAS_HEATED_BED
+        #define VALIDATE_MESH_GCODE_ITEM(M) \
+          GCODES_ITEM_N_S(M, ui.get_preheat_label(M), MSG_UBL_VALIDATE_MESH_M, PSTR("G28\nG26CPI" STRINGIFY(M)))
+      #else
+        #define VALIDATE_MESH_GCODE_ITEM(M) \
+          GCODES_ITEM_N_S(M, ui.get_preheat_label(M), MSG_UBL_VALIDATE_MESH_M, PSTR("G28\nG26CPB0I" STRINGIFY(M)))
+      #endif
+
+      VALIDATE_MESH_GCODE_ITEM(0);
+      #if PREHEAT_COUNT > 1
+        VALIDATE_MESH_GCODE_ITEM(1);
+        #if PREHEAT_COUNT > 2
+          VALIDATE_MESH_GCODE_ITEM(2);
+          #if PREHEAT_COUNT > 3
+            VALIDATE_MESH_GCODE_ITEM(3);
+            #if PREHEAT_COUNT > 4
+              VALIDATE_MESH_GCODE_ITEM(4);
+            #endif
+          #endif
+        #endif
+      #endif
+    #endif // PREHEAT_COUNT
+    ACTION_ITEM(MSG_UBL_VALIDATE_CUSTOM_MESH, _lcd_ubl_validate_custom_mesh);
+    ACTION_ITEM(MSG_INFO_SCREEN, ui.return_to_status);
+    END_MENU();
+  }
+
+#endif
+
+/**
+ * UBL Grid Leveling submenu
+ *
+ * << UBL Tools
+ *    Side points: ---
+ *    Level Mesh
+ */
+void _lcd_ubl_grid_level() {
+  START_MENU();
+  BACK_ITEM(MSG_UBL_TOOLS);
+  EDIT_ITEM(int3, MSG_UBL_SIDE_POINTS, &side_points, 2, 6);
+  ACTION_ITEM(MSG_UBL_MESH_LEVEL, []{
+    char ubl_lcd_gcode[12];
+    sprintf_P(ubl_lcd_gcode, PSTR("G29J%i"), side_points);
+    queue.inject(ubl_lcd_gcode);
+  });
+  END_MENU();
+}
+
+/**
+ * UBL Mesh Leveling submenu
+ *
+ * << UBL Tools
+ *    3-Point Mesh Leveling
+ *  - Grid Mesh Leveling >>
+ * << Info Screen
+ */
+void _lcd_ubl_mesh_leveling() {
+  START_MENU();
+  BACK_ITEM(MSG_UBL_TOOLS);
+  GCODES_ITEM(MSG_UBL_3POINT_MESH_LEVELING, PSTR("G29J0"));
+  SUBMENU(MSG_UBL_GRID_MESH_LEVELING, _lcd_ubl_grid_level);
+  ACTION_ITEM(MSG_INFO_SCREEN, ui.return_to_status);
+  END_MENU();
+}
+
+/**
+ * UBL Fill-in Amount Mesh Command
+ */
+void _lcd_ubl_fillin_amount_cmd() {
+  char ubl_lcd_gcode[18];
+  sprintf_P(ubl_lcd_gcode, PSTR("G29P3RC.%i"), ubl_fillin_amount);
+  gcode.process_subcommands_now(ubl_lcd_gcode);
+}
+
+/**
+ * UBL Fill-in Mesh submenu
+ *
+ * << Build Mesh
+ *    Fill-in Amount: ---
+ *    Fill-in Mesh
+ *    Smart Fill-in
+ *    Manual Fill-in
+ * << Info Screen
+ */
+void _menu_ubl_fillin() {
+  START_MENU();
+  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("G29P3T0"));
+  GCODES_ITEM(MSG_UBL_MANUAL_FILLIN, PSTR("G29P2BT0"));
+  ACTION_ITEM(MSG_INFO_SCREEN, ui.return_to_status);
+  END_MENU();
+}
+
+void _lcd_ubl_invalidate() {
+  ubl.invalidate();
+  SERIAL_ECHOLNPGM("Mesh invalidated.");
+}
+
+/**
+ * UBL Build Mesh submenu
+ *
+ * << UBL Tools
+ *    Build Mesh with Material 1 up to 5
+ *  - Build Custom Mesh >>
+ *    Build Cold Mesh
+ *  - Fill-in Mesh >>
+ *    Continue Bed Mesh
+ *    Invalidate All
+ *    Invalidate Closest
+ * << Info Screen
+ */
+void _lcd_ubl_build_mesh() {
+  START_MENU();
+  BACK_ITEM(MSG_UBL_TOOLS);
+  #if PREHEAT_COUNT
+    #if HAS_HEATED_BED
+      #define PREHEAT_BED_GCODE(M) "M190I" STRINGIFY(M) "\n"
+    #else
+      #define PREHEAT_BED_GCODE(M) ""
+    #endif
+    #define BUILD_MESH_GCODE_ITEM(M) GCODES_ITEM_S(ui.get_preheat_label(M), MSG_UBL_BUILD_MESH_M, \
+      PSTR( \
+        "G28\n" \
+        PREHEAT_BED_GCODE(M) \
+        "M109I" STRINGIFY(M) "\n" \
+        "G29P1\n" \
+        "M104S0\n" \
+        "M140S0" \
+      ) )
+    BUILD_MESH_GCODE_ITEM(0);
+    #if PREHEAT_COUNT > 1
+      BUILD_MESH_GCODE_ITEM(1);
+      #if PREHEAT_COUNT > 2
+        BUILD_MESH_GCODE_ITEM(2);
+        #if PREHEAT_COUNT > 3
+          BUILD_MESH_GCODE_ITEM(3);
+          #if PREHEAT_COUNT > 4
+            BUILD_MESH_GCODE_ITEM(4);
+          #endif
+        #endif
+      #endif
+    #endif
+  #endif // PREHEAT_COUNT
+
+  SUBMENU(MSG_UBL_BUILD_CUSTOM_MESH, _lcd_ubl_custom_mesh);
+  GCODES_ITEM(MSG_UBL_BUILD_COLD_MESH, PSTR("G29NP1"));
+  SUBMENU(MSG_UBL_FILLIN_MESH, _menu_ubl_fillin);
+  GCODES_ITEM(MSG_UBL_CONTINUE_MESH, PSTR("G29P1C"));
+  ACTION_ITEM(MSG_UBL_INVALIDATE_ALL, _lcd_ubl_invalidate);
+  GCODES_ITEM(MSG_UBL_INVALIDATE_CLOSEST, PSTR("G29I"));
+  ACTION_ITEM(MSG_INFO_SCREEN, ui.return_to_status);
+  END_MENU();
+}
+
+/**
+ * UBL Load / Save Mesh Commands
+ */
+inline void _lcd_ubl_load_save_cmd(const char loadsave, PGM_P const msg) {
+  char ubl_lcd_gcode[40];
+  sprintf_P(ubl_lcd_gcode, PSTR("G29%c%i\nM117 "), loadsave, ubl_storage_slot);
+  sprintf_P(&ubl_lcd_gcode[strlen(ubl_lcd_gcode)], msg, ubl_storage_slot);
+  gcode.process_subcommands_now(ubl_lcd_gcode);
+}
+void _lcd_ubl_load_mesh_cmd() { _lcd_ubl_load_save_cmd('L', GET_TEXT(MSG_MESH_LOADED)); }
+void _lcd_ubl_save_mesh_cmd() { _lcd_ubl_load_save_cmd('S', GET_TEXT(MSG_MESH_SAVED)); }
+
+/**
+ * UBL Mesh Storage submenu
+ *
+ * << Unified Bed Leveling
+ *    Memory Slot: ---
+ *    Load Bed Mesh
+ *    Save Bed Mesh
+ */
+void _lcd_ubl_storage_mesh() {
+  int16_t a = settings.calc_num_meshes();
+  START_MENU();
+  BACK_ITEM(MSG_UBL_LEVEL_BED);
+  if (!WITHIN(ubl_storage_slot, 0, a - 1))
+    STATIC_ITEM(MSG_UBL_NO_STORAGE);
+  else {
+    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();
+}
+
+/**
+ * UBL LCD "radar" map point editing
+ */
+void _lcd_ubl_map_edit_cmd() {
+  char ubl_lcd_gcode[50], str[10], str2[10];
+  dtostrf(ubl.mesh_index_to_xpos(x_plot), 0, 2, str);
+  dtostrf(ubl.mesh_index_to_ypos(y_plot), 0, 2, str2);
+  snprintf_P(ubl_lcd_gcode, sizeof(ubl_lcd_gcode), PSTR("G29P4X%sY%sR%i"), str, str2, int(n_edit_pts));
+  queue.inject(ubl_lcd_gcode);
+}
+
+/**
+ * UBL LCD Map Movement
+ */
+void ubl_map_move_to_xy() {
+  const xy_pos_t xy = { ubl.mesh_index_to_xpos(x_plot), ubl.mesh_index_to_ypos(y_plot) };
+
+  // Some printers have unreachable areas in the mesh. Skip the move if unreachable.
+  if (!position_is_reachable(xy)) return;
+
+  #if ENABLED(DELTA)
+    if (current_position.z > delta_clip_start_height) { // Make sure the delta has fully free motion
+      destination = current_position;
+      destination.z = delta_clip_start_height;
+      prepare_internal_fast_move_to_destination(homing_feedrate(Z_AXIS)); // Set current_position from destination
+    }
+  #endif
+
+  // Use the built-in manual move handler to move to the mesh point.
+  ui.manual_move.set_destination(xy);
+  ui.manual_move.soon(ALL_AXES_ENUM);
+}
+
+inline int32_t grid_index(const uint8_t x, const uint8_t y) {
+  return (GRID_MAX_POINTS_X) * y + x;
+}
+
+/**
+ * UBL LCD "radar" map
+ */
+void ubl_map_screen() {
+  // static millis_t next_move = 0;
+  // const millis_t ms = millis();
+
+  uint8_t x, y;
+
+  if (ui.first_page) {
+
+    // On click send "G29 P4 ..." to edit the Z value
+    if (ui.use_click()) {
+      _lcd_ubl_map_edit_cmd();
+      return;
+    }
+
+    ui.defer_status_screen();
+
+    #if IS_KINEMATIC
+      // Index of the mesh point upon entry
+      const int32_t old_pos_index = grid_index(x_plot, y_plot);
+      // Direction from new (unconstrained) encoder value
+      const int8_t step_dir = int32_t(ui.encoderPosition) < old_pos_index ? -1 : 1;
+    #endif
+
+    do {
+      // Now, keep the encoder position within range
+      if (int32_t(ui.encoderPosition) < 0) ui.encoderPosition = GRID_MAX_POINTS + TERN(TOUCH_SCREEN, ui.encoderPosition, -1);
+      if (int32_t(ui.encoderPosition) > GRID_MAX_POINTS - 1) ui.encoderPosition = TERN(TOUCH_SCREEN, ui.encoderPosition - GRID_MAX_POINTS, 0);
+
+      // Draw the grid point based on the encoder
+      x = ui.encoderPosition % (GRID_MAX_POINTS_X);
+      y = ui.encoderPosition / (GRID_MAX_POINTS_X);
+
+      // Validate if needed
+      #if IS_KINEMATIC
+        const xy_pos_t xy = { ubl.mesh_index_to_xpos(x), ubl.mesh_index_to_ypos(y) };
+        if (position_is_reachable(xy)) break; // Found a valid point
+        ui.encoderPosition += step_dir;       // Test the next point
+      #endif
+    } while (ENABLED(IS_KINEMATIC));
+
+    // Determine number of points to edit
+    #if IS_KINEMATIC
+      n_edit_pts = 9; // TODO: Delta accessible edit points
+    #else
+      const bool xc = WITHIN(x, 1, (GRID_MAX_POINTS_X) - 2),
+                 yc = WITHIN(y, 1, (GRID_MAX_POINTS_Y) - 2);
+      n_edit_pts = yc ? (xc ? 9 : 6) : (xc ? 6 : 4); // Corners
+    #endif
+
+    // Refresh is also set by encoder movement
+    //if (int32_t(ui.encoderPosition) != grid_index(x, y))
+    //  ui.refresh(LCDVIEW_CALL_REDRAW_NEXT);
+  }
+
+  // Draw the grid point based on the encoder
+  x = ui.encoderPosition % (GRID_MAX_POINTS_X);
+  y = ui.encoderPosition / (GRID_MAX_POINTS_X);
+
+  if (ui.should_draw()) ui.ubl_plot(x, y);
+
+  // Add a move if needed to match the grid point
+  if (x != x_plot || y != y_plot) {
+    x_plot = x; y_plot = y;   // The move is always posted, so update the grid point now
+    ubl_map_move_to_xy();     // Sets up a "manual move"
+    ui.refresh(LCDVIEW_CALL_REDRAW_NEXT); // Clean up a half drawn box
+  }
+}
+
+/**
+ * UBL LCD "radar" map homing
+ */
+void _ubl_map_screen_homing() {
+  ui.defer_status_screen();
+  _lcd_draw_homing();
+  if (all_axes_homed()) {
+    ubl.lcd_map_control = true;     // Return to the map screen after editing Z
+    ui.goto_screen(ubl_map_screen, grid_index(x_plot, y_plot)); // Pre-set the encoder value
+    ui.manual_move.menu_scale = 0;  // Immediate move
+    ubl_map_move_to_xy();           // Move to current mesh point
+    ui.manual_move.menu_scale = 1;  // Delayed moves
+  }
+}
+
+/**
+ * UBL Homing before LCD map
+ */
+void _ubl_goto_map_screen() {
+  if (planner.movesplanned()) return;     // The ACTION_ITEM will do nothing
+  if (!all_axes_trusted()) {
+    set_all_unhomed();
+    queue.inject_P(G28_STR);
+  }
+  ui.goto_screen(_ubl_map_screen_homing); // Go to the "Homing" screen
+}
+
+/**
+ * UBL Output map submenu
+ *
+ * << Unified Bed Leveling
+ *  Output for Host
+ *  Output for CSV
+ *  Off Printer Backup
+ */
+void _lcd_ubl_output_map() {
+  START_MENU();
+  BACK_ITEM(MSG_UBL_LEVEL_BED);
+  GCODES_ITEM(MSG_UBL_OUTPUT_MAP_HOST, PSTR("G29T0"));
+  GCODES_ITEM(MSG_UBL_OUTPUT_MAP_CSV, PSTR("G29T1"));
+  GCODES_ITEM(MSG_UBL_OUTPUT_MAP_BACKUP, PSTR("G29S-1"));
+  END_MENU();
+}
+
+/**
+ * UBL Tools submenu
+ *
+ * << Unified Bed Leveling
+ *  - Build Mesh >>
+ *  - Validate Mesh >>
+ *  - Edit Mesh >>
+ *  - Mesh Leveling >>
+ */
+void _menu_ubl_tools() {
+  START_MENU();
+  BACK_ITEM(MSG_UBL_LEVEL_BED);
+  SUBMENU(MSG_UBL_BUILD_MESH_MENU, _lcd_ubl_build_mesh);
+  GCODES_ITEM(MSG_UBL_MANUAL_MESH, PSTR("G29I999\nG29P2BT0"));
+  #if ENABLED(G26_MESH_VALIDATION)
+    SUBMENU(MSG_UBL_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
+  #endif
+  SUBMENU(MSG_EDIT_MESH, _lcd_ubl_edit_mesh);
+  SUBMENU(MSG_UBL_MESH_LEVELING, _lcd_ubl_mesh_leveling);
+  END_MENU();
+}
+
+#if ENABLED(G26_MESH_VALIDATION)
+
+  /**
+   * UBL Step-By-Step submenu
+   *
+   * << Unified Bed Leveling
+   *    1 Build Cold Mesh
+   *    2 Smart Fill-in
+   *  - 3 Validate Mesh >>
+   *    4 Fine Tune All
+   *  - 5 Validate Mesh >>
+   *    6 Fine Tune All
+   *    7 Save Bed Mesh
+   */
+  void _lcd_ubl_step_by_step() {
+    START_MENU();
+    BACK_ITEM(MSG_UBL_LEVEL_BED);
+    GCODES_ITEM(MSG_UBL_1_BUILD_COLD_MESH, PSTR("G29NP1"));
+    GCODES_ITEM(MSG_UBL_2_SMART_FILLIN, PSTR("G29P3T0"));
+    SUBMENU(MSG_UBL_3_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
+    GCODES_ITEM(MSG_UBL_4_FINE_TUNE_ALL, PSTR("G29P4RT"));
+    SUBMENU(MSG_UBL_5_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
+    GCODES_ITEM(MSG_UBL_6_FINE_TUNE_ALL, PSTR("G29P4RT"));
+    ACTION_ITEM(MSG_UBL_7_SAVE_MESH, _lcd_ubl_save_mesh_cmd);
+    END_MENU();
+  }
+
+#endif
+
+#if ENABLED(UBL_MESH_WIZARD)
+
+  /**
+   * UBL Mesh Wizard - One-click mesh creation with or without a probe
+   */
+  void _lcd_ubl_mesh_wizard() {
+    char ubl_lcd_gcode[30];
+    #if HAS_HEATED_BED && HAS_HOTEND
+      sprintf_P(ubl_lcd_gcode, PSTR("M1004B%iH%iS%i"), custom_bed_temp, custom_hotend_temp, ubl_storage_slot);
+    #elif HAS_HOTEND
+      sprintf_P(ubl_lcd_gcode, PSTR("M1004H%iS%i"), custom_hotend_temp, ubl_storage_slot);
+    #else
+      sprintf_P(ubl_lcd_gcode, PSTR("M1004S%i"), ubl_storage_slot);
+    #endif
+    queue.inject(ubl_lcd_gcode);
+    ui.return_to_status();
+  }
+
+  void _menu_ubl_mesh_wizard() {
+    const int16_t total_slots = settings.calc_num_meshes();
+    START_MENU();
+    BACK_ITEM(MSG_UBL_LEVEL_BED);
+
+    #if HAS_HOTEND
+      EDIT_ITEM(int3, MSG_UBL_HOTEND_TEMP_CUSTOM, &custom_hotend_temp, HEATER_0_MINTEMP + 20, thermalManager.hotend_max_target(0));
+    #endif
+
+    #if HAS_HEATED_BED
+      EDIT_ITEM(int3, MSG_UBL_BED_TEMP_CUSTOM, &custom_bed_temp, BED_MINTEMP + 20, BED_MAX_TARGET);
+    #endif
+
+    EDIT_ITEM(int3, MSG_UBL_STORAGE_SLOT, &ubl_storage_slot, 0, total_slots);
+
+    ACTION_ITEM(MSG_UBL_MESH_WIZARD, _lcd_ubl_mesh_wizard);
+
+    #if ENABLED(G26_MESH_VALIDATION)
+      SUBMENU(MSG_UBL_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
+    #endif
+
+    ACTION_ITEM(MSG_INFO_SCREEN, ui.return_to_status);
+    END_MENU();
+  }
+
+#endif
+
+/**
+ * UBL System submenu
+ *
+ * << Motion
+ *  - Manually Build Mesh >>
+ *  - Activate UBL >>
+ *  - Deactivate UBL >>
+ *  - Step-By-Step UBL >>
+ *  - Mesh Storage >>
+ *  - Output Map >>
+ *  - UBL Tools >>
+ *  - Output UBL Info >>
+ */
+void _lcd_ubl_level_bed() {
+  START_MENU();
+  BACK_ITEM(MSG_MOTION);
+  if (planner.leveling_active)
+    GCODES_ITEM(MSG_UBL_DEACTIVATE_MESH, PSTR("G29D"));
+  else
+    GCODES_ITEM(MSG_UBL_ACTIVATE_MESH, PSTR("G29A"));
+  #if ENABLED(G26_MESH_VALIDATION)
+    SUBMENU(MSG_UBL_STEP_BY_STEP_MENU, _lcd_ubl_step_by_step);
+  #endif
+  #if ENABLED(UBL_MESH_WIZARD)
+    SUBMENU(MSG_UBL_MESH_WIZARD, _menu_ubl_mesh_wizard);
+  #endif
+  ACTION_ITEM(MSG_UBL_MESH_EDIT, _ubl_goto_map_screen);
+  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("G29W"));
+  #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
+    editable.decimal = planner.z_fade_height;
+    EDIT_ITEM_FAST(float3, MSG_Z_FADE_HEIGHT, &editable.decimal, 0, 100, []{ set_z_fade_height(editable.decimal); });
+  #endif
+  END_MENU();
+}
+
+#endif // HAS_LCD_MENU && AUTO_BED_LEVELING_UBL