Initial commit

1 files changed, 637 insertions, 0 deletions

diff --git a/Marlin/src/lcd/marlinui.h b/Marlin/src/lcd/marlinui.h
new file mode 100644
index 0000000..2e55c9a
--- /dev/null
+++ b/Marlin/src/lcd/marlinui.h
@@ -0,0 +1,637 @@
+/**
+ * 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/MarlinConfig.h"
+
+#include "../module/motion.h"
+
+#include "buttons.h"
+
+#if HAS_BUZZER
+  #include "../libs/buzzer.h"
+#endif
+
+#if ENABLED(SDSUPPORT)
+  #include "../sd/cardreader.h"
+#endif
+
+#if ENABLED(TOUCH_SCREEN_CALIBRATION)
+  #include "tft_io/touch_calibration.h"
+#endif
+
+#if EITHER(HAS_LCD_MENU, ULTIPANEL_FEEDMULTIPLY)
+  #define HAS_ENCODER_ACTION 1
+#endif
+
+#if E_MANUAL > 1
+  #define MULTI_MANUAL 1
+#endif
+
+#if HAS_DISPLAY
+  #include "../module/printcounter.h"
+#endif
+
+#if BOTH(HAS_LCD_MENU, ADVANCED_PAUSE_FEATURE)
+  #include "../feature/pause.h"
+  #include "../module/motion.h" // for active_extruder
+#endif
+
+#if HAS_WIRED_LCD
+
+  enum LCDViewAction : uint8_t {
+    LCDVIEW_NONE,
+    LCDVIEW_REDRAW_NOW,
+    LCDVIEW_CALL_REDRAW_NEXT,
+    LCDVIEW_CLEAR_CALL_REDRAW,
+    LCDVIEW_CALL_NO_REDRAW
+  };
+
+  #if HAS_ADC_BUTTONS
+    uint8_t get_ADC_keyValue();
+  #endif
+
+  #define LCD_UPDATE_INTERVAL TERN(HAS_TOUCH_BUTTONS, 50, 100)
+
+  #if HAS_LCD_MENU
+
+    #include "lcdprint.h"
+
+    #if !HAS_GRAPHICAL_TFT
+      void _wrap_string(uint8_t &col, uint8_t &row, const char * const string, read_byte_cb_t cb_read_byte, const bool wordwrap=false);
+      inline void wrap_string_P(uint8_t &col, uint8_t &row, PGM_P const pstr, const bool wordwrap=false) { _wrap_string(col, row, pstr, read_byte_rom, wordwrap); }
+      inline void wrap_string(uint8_t &col, uint8_t &row, const char * const string, const bool wordwrap=false) { _wrap_string(col, row, string, read_byte_ram, wordwrap); }
+    #endif
+
+    typedef void (*screenFunc_t)();
+    typedef void (*menuAction_t)();
+
+    #if ENABLED(AUTO_BED_LEVELING_UBL)
+      void lcd_mesh_edit_setup(const float &initial);
+      float lcd_mesh_edit();
+    #endif
+
+  #endif // HAS_LCD_MENU
+
+#endif // HAS_WIRED_LCD
+
+#if HAS_MARLINUI_U8GLIB
+  enum MarlinFont : uint8_t {
+    FONT_STATUSMENU = 1,
+    FONT_EDIT,
+    FONT_MENU
+  };
+#else
+  enum HD44780CharSet : uint8_t {
+    CHARSET_MENU,
+    CHARSET_INFO,
+    CHARSET_BOOT
+  };
+#endif
+
+#if PREHEAT_COUNT
+  typedef struct {
+    TERN_(HAS_HOTEND,     uint16_t hotend_temp);
+    TERN_(HAS_HEATED_BED, uint16_t bed_temp   );
+    TERN_(HAS_FAN,        uint16_t fan_speed  );
+  } preheat_t;
+#endif
+
+#if HAS_LCD_MENU
+
+  // Manual Movement class
+  class ManualMove {
+  private:
+    static AxisEnum axis;
+    #if MULTI_MANUAL
+      static int8_t e_index;
+    #else
+      static int8_t constexpr e_index = 0;
+    #endif
+    static millis_t start_time;
+    TERN_(IS_KINEMATIC, static xyze_pos_t all_axes_destination);
+  public:
+    static float menu_scale;
+    TERN_(IS_KINEMATIC, static float offset);
+    template <typename T>
+    void set_destination(const T& dest) {
+      #if IS_KINEMATIC
+        // Moves are segmented, so the entire move is not submitted at once.
+        // Using a separate variable prevents corrupting the in-progress move.
+        all_axes_destination = current_position;
+        all_axes_destination.set(dest);
+      #else
+        // Moves are submitted as single line to the planner using buffer_line.
+        current_position.set(dest);
+      #endif
+    }
+    #if IS_KINEMATIC
+      static bool processing;
+    #else
+      static bool constexpr processing = false;
+    #endif
+    static void task();
+    static void soon(AxisEnum axis
+      #if MULTI_MANUAL
+        , const int8_t eindex=-1
+      #endif
+    );
+  };
+
+#endif
+
+////////////////////////////////////////////
+//////////// MarlinUI Singleton ////////////
+////////////////////////////////////////////
+
+class MarlinUI {
+public:
+
+  MarlinUI() {
+    TERN_(HAS_LCD_MENU, currentScreen = status_screen);
+  }
+
+  #if HAS_MULTI_LANGUAGE
+    static uint8_t language;
+    static inline void set_language(const uint8_t lang) {
+      if (lang < NUM_LANGUAGES) {
+        language = lang;
+        return_to_status();
+        refresh();
+      }
+    }
+  #endif
+
+  #if ENABLED(SOUND_MENU_ITEM)
+    static bool buzzer_enabled; // Initialized by settings.load()
+  #else
+    static constexpr bool buzzer_enabled = true;
+  #endif
+
+  #if HAS_BUZZER
+    static void buzz(const long duration, const uint16_t freq);
+  #endif
+
+  FORCE_INLINE static void chirp() {
+    TERN_(HAS_CHIRP, buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ));
+  }
+
+  #if ENABLED(LCD_HAS_STATUS_INDICATORS)
+    static void update_indicators();
+  #endif
+
+  // LCD implementations
+  static void clear_lcd();
+
+  #if BOTH(HAS_LCD_MENU, TOUCH_SCREEN_CALIBRATION)
+    static void check_touch_calibration() {
+      if (touch_calibration.need_calibration()) currentScreen = touch_calibration_screen;
+    }
+  #endif
+
+  #if ENABLED(SDSUPPORT)
+    #define MEDIA_MENU_GATEWAY TERN(PASSWORD_ON_SD_PRINT_MENU, password.media_gatekeeper, menu_media)
+    static void media_changed(const uint8_t old_stat, const uint8_t stat);
+  #endif
+
+  #if ENABLED(DWIN_CREALITY_LCD)
+    static void refresh();
+  #else
+    FORCE_INLINE static void refresh() {
+      TERN_(HAS_WIRED_LCD, refresh(LCDVIEW_CLEAR_CALL_REDRAW));
+    }
+  #endif
+
+  #if HAS_WIRED_LCD
+    static bool detected();
+    static void init_lcd();
+  #else
+    static inline bool detected() { return true; }
+    static inline void init_lcd() {}
+  #endif
+
+  #if HAS_PRINT_PROGRESS
+    #if HAS_PRINT_PROGRESS_PERMYRIAD
+      typedef uint16_t progress_t;
+      #define PROGRESS_SCALE 100U
+      #define PROGRESS_MASK 0x7FFF
+    #else
+      typedef uint8_t progress_t;
+      #define PROGRESS_SCALE 1U
+      #define PROGRESS_MASK 0x7F
+    #endif
+    #if ENABLED(LCD_SET_PROGRESS_MANUALLY)
+      static progress_t progress_override;
+      static void set_progress(const progress_t p) { progress_override = _MIN(p, 100U * (PROGRESS_SCALE)); }
+      static void set_progress_done() { progress_override = (PROGRESS_MASK + 1U) + 100U * (PROGRESS_SCALE); }
+      static void progress_reset() { if (progress_override & (PROGRESS_MASK + 1U)) set_progress(0); }
+      #if ENABLED(SHOW_REMAINING_TIME)
+        static inline uint32_t _calculated_remaining_time() {
+          const duration_t elapsed = print_job_timer.duration();
+          const progress_t progress = _get_progress();
+          return elapsed.value * (100 * (PROGRESS_SCALE) - progress) / progress;
+        }
+        #if ENABLED(USE_M73_REMAINING_TIME)
+          static uint32_t remaining_time;
+          FORCE_INLINE static void set_remaining_time(const uint32_t r) { remaining_time = r; }
+          FORCE_INLINE static uint32_t get_remaining_time() { return remaining_time ?: _calculated_remaining_time(); }
+          FORCE_INLINE static void reset_remaining_time() { set_remaining_time(0); }
+        #else
+          FORCE_INLINE static uint32_t get_remaining_time() { return _calculated_remaining_time(); }
+        #endif
+      #endif
+    #endif
+    static progress_t _get_progress();
+    #if HAS_PRINT_PROGRESS_PERMYRIAD
+      FORCE_INLINE static uint16_t get_progress_permyriad() { return _get_progress(); }
+    #endif
+    static uint8_t get_progress_percent() { return uint8_t(_get_progress() / (PROGRESS_SCALE)); }
+  #else
+    static constexpr uint8_t get_progress_percent() { return 0; }
+  #endif
+
+  #if HAS_STATUS_MESSAGE
+    static char status_message[];
+    static uint8_t alert_level; // Higher levels block lower levels
+
+    #if ENABLED(STATUS_MESSAGE_SCROLLING)
+      static uint8_t status_scroll_offset;
+      static void advance_status_scroll();
+      static char* status_and_len(uint8_t &len);
+    #endif
+
+    static bool has_status();
+    static void reset_status(const bool no_welcome=false);
+    static void set_status(const char* const message, const bool persist=false);
+    static void set_status_P(PGM_P const message, const int8_t level=0);
+    static void status_printf_P(const uint8_t level, PGM_P const fmt, ...);
+    static void set_alert_status_P(PGM_P const message);
+    static inline void reset_alert_level() { alert_level = 0; }
+  #else
+    static constexpr bool has_status() { return false; }
+    static inline void reset_status(const bool=false) {}
+    static void set_status(const char* message, const bool=false);
+    static void set_status_P(PGM_P message, const int8_t=0);
+    static void status_printf_P(const uint8_t, PGM_P message, ...);
+    static inline void set_alert_status_P(PGM_P const) {}
+    static inline void reset_alert_level() {}
+  #endif
+
+  #if HAS_DISPLAY
+
+    static void init();
+    static void update();
+
+    static void abort_print();
+    static void pause_print();
+    static void resume_print();
+
+    #if HAS_WIRED_LCD
+
+      static millis_t next_button_update_ms;
+
+      static LCDViewAction lcdDrawUpdate;
+      FORCE_INLINE static bool should_draw() { return bool(lcdDrawUpdate); }
+      FORCE_INLINE static void refresh(const LCDViewAction type) { lcdDrawUpdate = type; }
+
+      #if ENABLED(SHOW_CUSTOM_BOOTSCREEN)
+        static void draw_custom_bootscreen(const uint8_t frame=0);
+        static void show_custom_bootscreen();
+      #endif
+
+      #if ENABLED(SHOW_BOOTSCREEN)
+        #ifndef BOOTSCREEN_TIMEOUT
+          #define BOOTSCREEN_TIMEOUT 2500
+        #endif
+        static void draw_marlin_bootscreen(const bool line2=false);
+        static void show_marlin_bootscreen();
+        static void show_bootscreen();
+      #endif
+
+      #if HAS_MARLINUI_U8GLIB
+
+        static void set_font(const MarlinFont font_nr);
+
+      #else
+
+        static void set_custom_characters(const HD44780CharSet screen_charset=CHARSET_INFO);
+
+        #if ENABLED(LCD_PROGRESS_BAR)
+          static millis_t progress_bar_ms;  // Start time for the current progress bar cycle
+          static void draw_progress_bar(const uint8_t percent);
+          #if PROGRESS_MSG_EXPIRE > 0
+            static millis_t expire_status_ms; // = 0
+            FORCE_INLINE static void reset_progress_bar_timeout() { expire_status_ms = 0; }
+          #endif
+        #endif
+
+      #endif
+
+      static uint8_t lcd_status_update_delay;
+
+      #if HAS_LCD_CONTRAST
+        static int16_t contrast;
+        static void set_contrast(const int16_t value);
+        FORCE_INLINE static void refresh_contrast() { set_contrast(contrast); }
+      #endif
+
+      #if BOTH(FILAMENT_LCD_DISPLAY, SDSUPPORT)
+        static millis_t next_filament_display;
+      #endif
+
+      static void quick_feedback(const bool clear_buttons=true);
+      #if HAS_BUZZER
+        static void completion_feedback(const bool good=true);
+      #else
+        static inline void completion_feedback(const bool=true) {}
+      #endif
+
+      #if DISABLED(LIGHTWEIGHT_UI)
+        static void draw_status_message(const bool blink);
+      #endif
+
+      #if ENABLED(ADVANCED_PAUSE_FEATURE)
+        static void draw_hotend_status(const uint8_t row, const uint8_t extruder);
+      #endif
+
+      #if HAS_TOUCH_BUTTONS
+        static bool on_edit_screen;
+        static void screen_click(const uint8_t row, const uint8_t col, const uint8_t x, const uint8_t y);
+      #endif
+
+      static void status_screen();
+
+    #endif
+
+    #if HAS_MARLINUI_U8GLIB
+      static bool drawing_screen, first_page;
+    #else
+      static constexpr bool drawing_screen = false, first_page = true;
+    #endif
+
+    static bool get_blink();
+    static void kill_screen(PGM_P const lcd_error, PGM_P const lcd_component);
+    static void draw_kill_screen();
+
+  #else // No LCD
+
+    static inline void init() {}
+    static inline void update() {}
+    static inline void return_to_status() {}
+
+  #endif
+
+  #if ENABLED(SDSUPPORT)
+    #if BOTH(SCROLL_LONG_FILENAMES, HAS_LCD_MENU)
+      #define MARLINUI_SCROLL_NAME 1
+    #endif
+    #if MARLINUI_SCROLL_NAME
+      static uint8_t filename_scroll_pos, filename_scroll_max;
+    #endif
+    static const char * scrolled_filename(CardReader &theCard, const uint8_t maxlen, uint8_t hash, const bool doScroll);
+  #endif
+
+  #if PREHEAT_COUNT
+    static preheat_t material_preset[PREHEAT_COUNT];
+    static PGM_P get_preheat_label(const uint8_t m);
+  #endif
+
+  #if HAS_LCD_MENU
+    #if LCD_TIMEOUT_TO_STATUS
+      static millis_t return_to_status_ms;
+    #endif
+
+    #if HAS_TOUCH_BUTTONS
+      static uint8_t touch_buttons;
+      static uint8_t repeat_delay;
+    #else
+      static constexpr uint8_t touch_buttons = 0;
+    #endif
+
+    #if ENABLED(ENCODER_RATE_MULTIPLIER)
+      static bool encoderRateMultiplierEnabled;
+      static millis_t lastEncoderMovementMillis;
+      static void enable_encoder_multiplier(const bool onoff);
+      #define ENCODER_RATE_MULTIPLY(F) (ui.encoderRateMultiplierEnabled = F)
+    #else
+      #define ENCODER_RATE_MULTIPLY(F) NOOP
+    #endif
+
+    // Manual Movement
+    static ManualMove manual_move;
+
+    // Select Screen (modal NO/YES style dialog)
+    static bool selection;
+    static void set_selection(const bool sel) { selection = sel; }
+    static bool update_selection();
+
+    static bool lcd_clicked;
+    static bool use_click();
+
+    static void synchronize(PGM_P const msg=nullptr);
+
+    static screenFunc_t currentScreen;
+    static bool screen_changed;
+    static void goto_screen(const screenFunc_t screen, const uint16_t encoder=0, const uint8_t top=0, const uint8_t items=0);
+    static void save_previous_screen();
+
+    // goto_previous_screen and go_back may also be used as menu item callbacks
+    static void _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, const bool is_back));
+    static inline void goto_previous_screen() { _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, false)); }
+    static inline void go_back()              { _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, true)); }
+
+    static void return_to_status();
+    static inline bool on_status_screen() { return currentScreen == status_screen; }
+    FORCE_INLINE static void run_current_screen() { (*currentScreen)(); }
+
+    #if ENABLED(LIGHTWEIGHT_UI)
+      static void lcd_in_status(const bool inStatus);
+    #endif
+
+    FORCE_INLINE static void defer_status_screen(const bool defer=true) {
+      #if LCD_TIMEOUT_TO_STATUS > 0
+        defer_return_to_status = defer;
+      #else
+        UNUSED(defer);
+      #endif
+    }
+
+    static inline void goto_previous_screen_no_defer() {
+      defer_status_screen(false);
+      goto_previous_screen();
+    }
+
+    #if ENABLED(SD_REPRINT_LAST_SELECTED_FILE)
+      static void reselect_last_file();
+    #endif
+
+    #if ENABLED(AUTO_BED_LEVELING_UBL)
+      static void ubl_plot(const uint8_t x_plot, const uint8_t y_plot);
+    #endif
+
+    static void draw_select_screen_prompt(PGM_P const pref, const char * const string=nullptr, PGM_P const suff=nullptr);
+
+  #elif HAS_WIRED_LCD
+
+    static constexpr bool lcd_clicked = false;
+    static constexpr bool on_status_screen() { return true; }
+    FORCE_INLINE static void run_current_screen() { status_screen(); }
+
+  #endif
+
+  #if BOTH(HAS_LCD_MENU, ADVANCED_PAUSE_FEATURE)
+    static void pause_show_message(const PauseMessage message, const PauseMode mode=PAUSE_MODE_SAME, const uint8_t extruder=active_extruder);
+  #else
+    static inline void _pause_show_message() {}
+    #define pause_show_message(...) _pause_show_message()
+  #endif
+
+  //
+  // EEPROM: Reset / Init / Load / Store
+  //
+  #if HAS_LCD_MENU
+    static void reset_settings();
+  #endif
+
+  #if ENABLED(EEPROM_SETTINGS)
+    #if HAS_LCD_MENU
+      static void init_eeprom();
+      static void load_settings();
+      static void store_settings();
+    #endif
+    #if DISABLED(EEPROM_AUTO_INIT)
+      static void eeprom_alert(const uint8_t msgid);
+      static inline void eeprom_alert_crc()     { eeprom_alert(0); }
+      static inline void eeprom_alert_index()   { eeprom_alert(1); }
+      static inline void eeprom_alert_version() { eeprom_alert(2); }
+    #endif
+  #endif
+
+  //
+  // Special handling if a move is underway
+  //
+  #if ANY(DELTA_CALIBRATION_MENU, DELTA_AUTO_CALIBRATION, PROBE_OFFSET_WIZARD) || (ENABLED(LCD_BED_LEVELING) && EITHER(PROBE_MANUALLY, MESH_BED_LEVELING))
+    #define LCD_HAS_WAIT_FOR_MOVE 1
+    static bool wait_for_move;
+  #else
+    static constexpr bool wait_for_move = false;
+  #endif
+
+  //
+  // Block interaction while under external control
+  //
+  #if HAS_LCD_MENU && EITHER(AUTO_BED_LEVELING_UBL, G26_MESH_VALIDATION)
+    static bool external_control;
+    FORCE_INLINE static void capture() { external_control = true; }
+    FORCE_INLINE static void release() { external_control = false; }
+    #if ENABLED(AUTO_BED_LEVELING_UBL)
+      static void external_encoder();
+    #endif
+  #else
+    static constexpr bool external_control = false;
+  #endif
+
+  #if HAS_ENCODER_ACTION
+
+    static volatile uint8_t buttons;
+    #if IS_RRW_KEYPAD
+      static volatile uint8_t keypad_buttons;
+      static bool handle_keypad();
+    #endif
+    #if HAS_SLOW_BUTTONS
+      static volatile uint8_t slow_buttons;
+      static uint8_t read_slow_buttons();
+    #endif
+
+    static void update_buttons();
+    static inline bool button_pressed() { return BUTTON_CLICK() || TERN(TOUCH_SCREEN, touch_pressed(), false); }
+    #if EITHER(AUTO_BED_LEVELING_UBL, G26_MESH_VALIDATION)
+      static void wait_for_release();
+    #endif
+
+    static uint32_t encoderPosition;
+
+    #define ENCODERBASE (TERN(REVERSE_ENCODER_DIRECTION, -1, +1))
+
+    #if EITHER(REVERSE_MENU_DIRECTION, REVERSE_SELECT_DIRECTION)
+      static int8_t encoderDirection;
+    #else
+      static constexpr int8_t encoderDirection = ENCODERBASE;
+    #endif
+
+    FORCE_INLINE static void encoder_direction_normal() {
+      #if EITHER(REVERSE_MENU_DIRECTION, REVERSE_SELECT_DIRECTION)
+        encoderDirection = ENCODERBASE;
+      #endif
+    }
+
+    FORCE_INLINE static void encoder_direction_menus() {
+      TERN_(REVERSE_MENU_DIRECTION, encoderDirection = -(ENCODERBASE));
+    }
+
+    FORCE_INLINE static void encoder_direction_select() {
+      TERN_(REVERSE_SELECT_DIRECTION, encoderDirection = -(ENCODERBASE));
+    }
+
+  #else
+
+    static inline void update_buttons() {}
+
+  #endif
+
+  #if ENABLED(TOUCH_SCREEN_CALIBRATION)
+    static void touch_calibration_screen();
+  #endif
+
+  #if HAS_GRAPHICAL_TFT
+    static void move_axis_screen();
+  #endif
+
+private:
+
+  #if HAS_STATUS_MESSAGE
+    static void finish_status(const bool persist);
+  #endif
+
+  #if HAS_WIRED_LCD
+    #if HAS_LCD_MENU && LCD_TIMEOUT_TO_STATUS > 0
+      static bool defer_return_to_status;
+    #else
+      static constexpr bool defer_return_to_status = false;
+    #endif
+    static void draw_status_screen();
+    #if HAS_GRAPHICAL_TFT
+      static void tft_idle();
+      #if ENABLED(TOUCH_SCREEN)
+        static bool touch_pressed();
+      #endif
+    #endif
+  #endif
+};
+
+extern MarlinUI ui;
+
+#define LCD_MESSAGEPGM_P(x)      ui.set_status_P(x)
+#define LCD_ALERTMESSAGEPGM_P(x) ui.set_alert_status_P(x)
+
+#define LCD_MESSAGEPGM(x)        LCD_MESSAGEPGM_P(GET_TEXT(x))
+#define LCD_ALERTMESSAGEPGM(x)   LCD_ALERTMESSAGEPGM_P(GET_TEXT(x))