ExtUI homing / leveling additions

Marlin/src/MarlinCore.cpp

   #include "lcd/dwin/e3v2/rotary_encoder.h"
 #endif
 
+#if ENABLED(EXTENSIBLE_UI)
+  #include "lcd/extui/ui_api.h"
+#endif
+
 #if HAS_ETHERNET
   #include "feature/ethernet.h"
 #endif
   ENABLE_AXIS_Y();
   ENABLE_AXIS_Z();
   enable_e_steppers();
+
+  TERN_(EXTENSIBLE_UI, ExtUI::onSteppersEnabled());
 }
 
 void disable_e_steppers() {
   DISABLE_AXIS_Y();
   DISABLE_AXIS_Z();
   disable_e_steppers();
+
+  TERN_(EXTENSIBLE_UI, ExtUI::onSteppersDisabled());
 }
 
 #if ENABLED(G29_RETRY_AND_RECOVER)

Marlin/src/gcode/bedlevel/abl/G29.cpp

     if (DISABLED(PROBE_MANUALLY) && seenQ) G29_RETURN(false);
   #endif
 
+  TERN_(EXTENSIBLE_UI, ExtUI::onMeshLevelingStart());
+
   const bool seenA = TERN0(PROBE_MANUALLY, parser.seen('A')),
          no_action = seenA || seenQ,
               faux = ENABLED(DEBUG_LEVELING_FEATURE) && DISABLED(PROBE_MANUALLY) ? parser.boolval('C') : no_action;

Marlin/src/gcode/calibrate/G28.cpp

   #include "../../lcd/dwin/e3v2/dwin.h"
 #endif
 
+#if ENABLED(EXTENSIBLE_UI)
+  #include "../../lcd/extui/ui_api.h"
+#endif
+
 #if HAS_L64XX                         // set L6470 absolute position registers to counts
   #include "../../libs/L64XX/L64XX_Marlin.h"
 #endif
 
   TERN_(DWIN_CREALITY_LCD, HMI_flag.home_flag = true);
 
+  TERN_(EXTENSIBLE_UI, ExtUI::onHomingStart());
+
   #if ENABLED(DUAL_X_CARRIAGE)
     bool IDEX_saved_duplication_state = extruder_duplication_enabled;
     DualXMode IDEX_saved_mode = dual_x_carriage_mode;
 
   TERN_(DWIN_CREALITY_LCD, DWIN_CompletedHoming());
 
+  TERN_(EXTENSIBLE_UI, ExtUI::onHomingComplete());
+
   report_current_position();
 
   if (ENABLED(NANODLP_Z_SYNC) && (doZ || ENABLED(NANODLP_ALL_AXIS)))

Marlin/src/gcode/sd/M1001.cpp

     queue.inject_P(PSTR(SD_FINISHED_RELEASECOMMAND));
   #endif
 
+  TERN_(EXTENSIBLE_UI, ExtUI::onPrintFinished());
+
   // Re-select the last printed file in the UI
   TERN_(SD_REPRINT_LAST_SELECTED_FILE, ui.reselect_last_file());
 }

Marlin/src/lcd/extui/anycubic_chiron_lcd.cpp

   void onUserConfirmRequired(const char * const msg) { Chiron.ConfirmationRequest(msg);     }
   void onStatusChanged(const char * const msg)       { Chiron.StatusChange(msg);            }
 
+  void onHomingStart() {}
+  void onHomingComplete() {}
+  void onPrintFinished() {}
+
   void onFactoryReset() {}
 
   void onStoreSettings(char *buff) {
   }
 
   #if HAS_MESH
+    void onMeshLevelingStart() {}
+
     void onMeshUpdate(const int8_t xpos, const int8_t ypos, const float zval) {
       // Called when any mesh points are updated
       //SERIAL_ECHOLNPAIR("onMeshUpdate() x:", xpos, " y:", ypos, " z:", zval);
       // Called for temperature PID tuning result
     }
   #endif
+
+  void onSteppersDisabled() {}
+  void onSteppersEnabled()  {}
 }
 
 #endif // ANYCUBIC_LCD_CHIRON

Marlin/src/lcd/extui/anycubic_i3mega_lcd.cpp

   void onFilamentRunout(const extruder_t extruder)   { AnycubicTFT.OnFilamentRunout(); }
   void onUserConfirmRequired(const char * const msg) { AnycubicTFT.OnUserConfirmRequired(msg); }
   void onStatusChanged(const char * const msg) {}
+
+  void onHomingStart() {}
+  void onHomingComplete() {}
+  void onPrintFinished() {}
+
   void onFactoryReset() {}
 
   void onStoreSettings(char *buff) {
     // whether successful or not.
   }
 
-  void onMeshUpdate(const int8_t xpos, const int8_t ypos, const float zval) {
-    // Called when any mesh points are updated
-  }
+  #if HAS_MESH
+
+    void onMeshLevelingStart() {}
+
+    void onMeshUpdate(const int8_t xpos, const int8_t ypos, const float zval) {
+      // Called when any mesh points are updated
+    }
+  #endif
 
   #if ENABLED(POWER_LOSS_RECOVERY)
     void onPowerLossResume() {
       // Called for temperature PID tuning result
     }
   #endif
+
+  void onSteppersDisabled() {}
+  void onSteppersEnabled()  {}
 }
 
 #endif // ANYCUBIC_LCD_I3MEGA

Marlin/src/lcd/extui/dgus_lcd.cpp

 
   void onStatusChanged(const char * const msg) { ScreenHandler.setstatusmessage(msg); }
 
+  void onHomingStart() {}
+  void onHomingComplete() {}
+  void onPrintFinished() {}
+
   void onFactoryReset() {}
+
   void onStoreSettings(char *buff) {
     // Called when saving to EEPROM (i.e. M500). If the ExtUI needs
     // permanent data to be stored, it can write up to eeprom_data_size bytes
   }
 
   #if HAS_MESH
+    void onMeshLevelingStart() {}
+
     void onMeshUpdate(const int8_t xpos, const int8_t ypos, const float zval) {
       // Called when any mesh points are updated
     }
     }
   #endif
 
+  void onSteppersDisabled() {}
+  void onSteppersEnabled()  {}
 }
+
 #endif // HAS_DGUS_LCD

Marlin/src/lcd/extui/example.cpp

   }
   void onIdle() {}
   void onPrinterKilled(PGM_P const error, PGM_P const component) {}
-  void onMediaInserted() {};
-  void onMediaError() {};
-  void onMediaRemoved() {};
+  void onMediaInserted() {}
+  void onMediaError() {}
+  void onMediaRemoved() {}
   void onPlayTone(const uint16_t frequency, const uint16_t duration) {}
   void onPrintTimerStarted() {}
   void onPrintTimerPaused() {}
   void onFilamentRunout(const extruder_t extruder) {}
   void onUserConfirmRequired(const char * const msg) {}
   void onStatusChanged(const char * const msg) {}
+
+  void onHomingStart() {}
+  void onHomingComplete() {}
+  void onPrintFinished() {}
+
   void onFactoryReset() {}
 
   void onStoreSettings(char *buff) {
   }
 
   #if HAS_MESH
+    void onMeshLevelingStart() {}
+
     void onMeshUpdate(const int8_t xpos, const int8_t ypos, const float zval) {
       // Called when any mesh points are updated
     }
       // Called for temperature PID tuning result
     }
   #endif
+
+  void onSteppersDisabled() {}
+  void onSteppersEnabled()  {}
 }
 
 #endif // EXTUI_EXAMPLE && EXTENSIBLE_UI

Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/marlin_events.cpp

     InterfaceSoundsScreen::playEventSound(InterfaceSoundsScreen::PRINTING_FINISHED);
   }
 
-  void onPrintTimerPaused() {
-  }
+  void onPrintTimerPaused() {}
+
+  void onPrintFinished() {}
 
   void onFilamentRunout(const extruder_t extruder) {
     char lcd_msg[30];
     InterfaceSoundsScreen::playEventSound(InterfaceSoundsScreen::PRINTING_FAILED, FTDI::PLAY_SYNCHRONOUS);
   }
 
+  void onHomingStart() {}
+  void onHomingComplete() {}
+
   void onFactoryReset() {
     InterfaceSettingsScreen::defaultSettings();
   }
   }
 
   #if HAS_LEVELING && HAS_MESH
+    void onMeshLevelingStart() {}
+
     void onMeshUpdate(const int8_t x, const int8_t y, const float val) {
       BedMeshScreen::onMeshUpdate(x, y, val);
     }
       GOTO_SCREEN(StatusScreen);
     }
   #endif // HAS_PID_HEATING
+
+  void onSteppersDisabled() {}
+  void onSteppersEnabled()  {}
 }
 
 #endif // TOUCH_UI_FTDI_EVE

Marlin/src/lcd/extui/malyan_lcd.cpp

 
   // Not needed for Malyan LCD
   void onStatusChanged(const char * const) {}
-  void onMediaInserted() {};
-  void onMediaError() {};
-  void onMediaRemoved() {};
+  void onMediaInserted() {}
+  void onMediaError() {}
+  void onMediaRemoved() {}
   void onPlayTone(const uint16_t, const uint16_t) {}
   void onFilamentRunout(const extruder_t extruder) {}
   void onUserConfirmRequired(const char * const) {}
+  void onHomingStart() {}
+  void onHomingComplete() {}
+  void onPrintFinished() {}
   void onFactoryReset() {}
   void onStoreSettings(char*) {}
   void onLoadSettings(const char*) {}
   void onConfigurationStoreRead(bool) {}
 
   #if HAS_MESH
+    void onMeshLevelingStart() {}
     void onMeshUpdate(const int8_t xpos, const int8_t ypos, const float zval) {}
     void onMeshUpdate(const int8_t xpos, const int8_t ypos, const ExtUI::probe_state_t state) {}
   #endif
   #if ENABLED(POWER_LOSS_RECOVERY)
     void onPowerLossResume() {}
   #endif
+
+  void onSteppersDisabled() {}
+  void onSteppersEnabled()  {}
 }
 
 #endif // MALYAN_LCD

Marlin/src/lcd/extui/ui_api.h

       bed_mesh_t& getMeshArray();
       float getMeshPoint(const xy_uint8_t &pos);
       void setMeshPoint(const xy_uint8_t &pos, const float zval);
+      void onMeshLevelingStart();
       void onMeshUpdate(const int8_t xpos, const int8_t ypos, const float zval);
       inline void onMeshUpdate(const xy_int8_t &pos, const float zval) { onMeshUpdate(pos.x, pos.y, zval); }
 
   void onPrintTimerStarted();
   void onPrintTimerPaused();
   void onPrintTimerStopped();
+  void onPrintFinished();
   void onFilamentRunout(const extruder_t extruder);
   void onUserConfirmRequired(const char * const msg);
   void onUserConfirmRequired_P(PGM_P const pstr);
   void onStatusChanged(const char * const msg);
   void onStatusChanged_P(PGM_P const pstr);
+  void onHomingStart();
+  void onHomingComplete();
+  void onSteppersDisabled();
+  void onSteppersEnabled();
   void onFactoryReset();
   void onStoreSettings(char *);
   void onLoadSettings(const char *);