SunRed/Marlin-Artillery-M600
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Miscellaneous LCD code renaming, reordering (#12430)

Browse source 
* Move special characters to language.h
* Apply some naming standards
* Clean up menu item draw functions
* Rename some Temperature methods
* UI => ExtUI
This commit is contained in:
Scott Lahteine 2018-11-14 13:13:51 -06:00 committed by GitHub
parent edfd106bc5
commit d82c350de7
Signed by: GitHub
GPG key ID: 4AEE18F83AFDEB23
17 changed files with 197 additions and 210 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
Marlin/src/core/language.h
View file

@ -94,6 +94,44 @@
#define WEBSITE_URL DEFAULT_WEBSITE_URL #define WEBSITE_URL DEFAULT_WEBSITE_URL
#endif #endif
#if HAS_GRAPHICAL_LCD
//
// Custom characters from Marlin_symbols.fon which was merged into ISO10646-0-3.bdf
// \x00 intentionally skipped to avoid problems in strings
//
#define LCD_STR_REFRESH "\x01"
#define LCD_STR_FOLDER "\x02"
#define LCD_STR_ARROW_RIGHT "\x03"
#define LCD_STR_UPLEVEL "\x04"
#define LCD_STR_CLOCK "\x05"
#define LCD_STR_FEEDRATE "\x06"
#define LCD_STR_BEDTEMP "\x07"
#define LCD_STR_THERMOMETER "\x08"
#define LCD_STR_DEGREE "\x09"
#define LCD_STR_SPECIAL_MAX '\x09'
// Maximum here is 0x1F because 0x20 is ' ' (space) and the normal charsets begin.
// Better stay below 0x10 because DISPLAY_CHARSET_HD44780_WESTERN begins here.
// Symbol characters
#define LCD_STR_FILAM_DIA "\xF8"
#define LCD_STR_FILAM_MUL "\xA4"
#elif HAS_CHARACTER_LCD
// Custom characters defined in the first 8 characters of the LCD
#define LCD_STR_BEDTEMP "\x00" // Print only as a char. This will have 'unexpected' results when used in a string!
#define LCD_STR_DEGREE "\x01"
#define LCD_STR_THERMOMETER "\x02" // Still used with string concatenation
#define LCD_STR_UPLEVEL "\x03"
#define LCD_STR_REFRESH "\x04"
#define LCD_STR_FOLDER "\x05"
#define LCD_STR_FEEDRATE "\x06"
#define LCD_STR_CLOCK "\x07"
#define LCD_STR_ARROW_RIGHT ">" /* from the default character set */
#endif
// Common LCD messages // Common LCD messages
/* nothing here yet */ /* nothing here yet */

2
Marlin/src/feature/runout.h
View file

@ -95,7 +95,7 @@ class TFilamentMonitor : public FilamentMonitorBase {
if (ran_out) { if (ran_out) {
filament_ran_out = true; filament_ran_out = true;
#if ENABLED(EXTENSIBLE_UI) #if ENABLED(EXTENSIBLE_UI)
UI::onFilamentRunout(); ExtUI::onFilamentRunout();
#endif #endif
enqueue_and_echo_commands_P(PSTR(FILAMENT_RUNOUT_SCRIPT)); enqueue_and_echo_commands_P(PSTR(FILAMENT_RUNOUT_SCRIPT));
planner.synchronize(); planner.synchronize();

6
Marlin/src/gcode/eeprom/M500-M504.cpp
View file

@ -45,7 +45,7 @@
void GcodeSuite::M500() { void GcodeSuite::M500() {
(void)settings.save(CHAT_PORT); (void)settings.save(CHAT_PORT);
#if ENABLED(EXTENSIBLE_UI) #if ENABLED(EXTENSIBLE_UI)
UI::onStoreSettings(); ExtUI::onStoreSettings();
#endif #endif
} }
@ -59,7 +59,7 @@ void GcodeSuite::M501() {
#endif #endif
); );
#if ENABLED(EXTENSIBLE_UI) #if ENABLED(EXTENSIBLE_UI)
UI::onLoadSettings(); ExtUI::onLoadSettings();
#endif #endif
} }
@ -69,7 +69,7 @@ void GcodeSuite::M501() {
void GcodeSuite::M502() { void GcodeSuite::M502() {
(void)settings.reset(CHAT_PORT); (void)settings.reset(CHAT_PORT);
#if ENABLED(EXTENSIBLE_UI) #if ENABLED(EXTENSIBLE_UI)
UI::onFactoryReset(); ExtUI::onFactoryReset();
#endif #endif
} }

6
Marlin/src/gcode/stats/M75-M78.cpp
View file

@ -33,7 +33,7 @@
void GcodeSuite::M75() { void GcodeSuite::M75() {
print_job_timer.start(); print_job_timer.start();
#if ENABLED(EXTENSIBLE_UI) #if ENABLED(EXTENSIBLE_UI)
UI::onPrintTimerStarted(); ExtUI::onPrintTimerStarted();
#endif #endif
} }
@ -43,7 +43,7 @@ void GcodeSuite::M75() {
void GcodeSuite::M76() { void GcodeSuite::M76() {
print_job_timer.pause(); print_job_timer.pause();
#if ENABLED(EXTENSIBLE_UI) #if ENABLED(EXTENSIBLE_UI)
UI::onPrintTimerPaused(); ExtUI::onPrintTimerPaused();
#endif #endif
} }
@ -53,7 +53,7 @@ void GcodeSuite::M76() {
void GcodeSuite::M77() { void GcodeSuite::M77() {
print_job_timer.stop(); print_job_timer.stop();
#if ENABLED(EXTENSIBLE_UI) #if ENABLED(EXTENSIBLE_UI)
UI::onPrintTimerStopped(); ExtUI::onPrintTimerStopped();
#endif #endif
} }

38
Marlin/src/inc/Conditionals_LCD.h
View file

@ -309,30 +309,8 @@
#define HAS_DIGITAL_ENCODER ENABLED(NEWPANEL) #define HAS_DIGITAL_ENCODER ENABLED(NEWPANEL)
#if HAS_GRAPHICAL_LCD #if HAS_GRAPHICAL_LCD
//
// Custom characters from Marlin_symbols.fon which was merged into ISO10646-0-3.bdf
// \x00 intentionally skipped to avoid problems in strings
//
#define LCD_STR_REFRESH "\x01"
#define LCD_STR_FOLDER "\x02"
#define LCD_STR_ARROW_RIGHT "\x03"
#define LCD_STR_UPLEVEL "\x04"
#define LCD_STR_CLOCK "\x05"
#define LCD_STR_FEEDRATE "\x06"
#define LCD_STR_BEDTEMP "\x07"
#define LCD_STR_THERMOMETER "\x08"
#define LCD_STR_DEGREE "\x09"
#define LCD_STR_SPECIAL_MAX '\x09'
// Maximum here is 0x1F because 0x20 is ' ' (space) and the normal charsets begin.
// Better stay below 0x10 because DISPLAY_CHARSET_HD44780_WESTERN begins here.
// Symbol characters
#define LCD_STR_FILAM_DIA "\xf8"
#define LCD_STR_FILAM_MUL "\xa4"
/** /**
* Default LCD contrast for dogm-like LCD displays * Default LCD contrast for Graphical LCD displays
*/ */
#define HAS_LCD_CONTRAST ( \ #define HAS_LCD_CONTRAST ( \
ENABLED(MAKRPANEL) \ ENABLED(MAKRPANEL) \
@ -353,20 +331,6 @@
#define DEFAULT_LCD_CONTRAST 32 #define DEFAULT_LCD_CONTRAST 32
#endif #endif
#endif #endif
#else
// Custom characters defined in the first 8 characters of the LCD
#define LCD_BEDTEMP_CHAR 0x00 // Print only as a char. This will have 'unexpected' results when used in a string!
#define LCD_DEGREE_CHAR 0x01
#define LCD_STR_THERMOMETER "\x02" // Still used with string concatenation
#define LCD_UPLEVEL_CHAR 0x03
#define LCD_STR_REFRESH "\x04"
#define LCD_STR_FOLDER "\x05"
#define LCD_FEEDRATE_CHAR 0x06
#define LCD_CLOCK_CHAR 0x07
#define LCD_STR_ARROW_RIGHT ">" /* from the default character set */
#endif #endif
// Boot screens // Boot screens

53
Marlin/src/lcd/HD44780/ultralcd_HD44780.cpp
View file

@ -290,11 +290,11 @@ void MarlinUI::set_custom_characters(
else else
#endif #endif
{ // Info Screen uses 5 special characters { // Info Screen uses 5 special characters
createChar_P(LCD_BEDTEMP_CHAR, bedTemp); createChar_P(LCD_STR_BEDTEMP[0], bedTemp);
createChar_P(LCD_DEGREE_CHAR, degree); createChar_P(LCD_STR_DEGREE[0], degree);
createChar_P(LCD_STR_THERMOMETER[0], thermometer); createChar_P(LCD_STR_THERMOMETER[0], thermometer);
createChar_P(LCD_FEEDRATE_CHAR, feedrate); createChar_P(LCD_STR_FEEDRATE[0], feedrate);
createChar_P(LCD_CLOCK_CHAR, clock); createChar_P(LCD_STR_CLOCK[0], clock);
#if ENABLED(LCD_PROGRESS_BAR) #if ENABLED(LCD_PROGRESS_BAR)
if (screen_charset == CHARSET_INFO) { // 3 Progress bar characters for info screen if (screen_charset == CHARSET_INFO) { // 3 Progress bar characters for info screen
@ -304,7 +304,7 @@ void MarlinUI::set_custom_characters(
else else
#endif #endif
{ {
createChar_P(LCD_UPLEVEL_CHAR, uplevel); createChar_P(LCD_STR_UPLEVEL[0], uplevel);
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
// SD Card sub-menu special characters // SD Card sub-menu special characters
createChar_P(LCD_STR_REFRESH[0], refresh); createChar_P(LCD_STR_REFRESH[0], refresh);
@ -553,7 +553,7 @@ FORCE_INLINE void _draw_heater_status(const int8_t heater, const char prefix, co
lcd_put_u8str(itostr3left(t2 + 0.5)); lcd_put_u8str(itostr3left(t2 + 0.5));
if (prefix >= 0) { if (prefix >= 0) {
lcd_put_wchar(LCD_DEGREE_CHAR); lcd_put_wchar(LCD_STR_DEGREE[0]);
lcd_put_wchar(' '); lcd_put_wchar(' ');
if (t2 < 10) lcd_put_wchar(' '); if (t2 < 10) lcd_put_wchar(' ');
} }
@ -564,7 +564,7 @@ FORCE_INLINE void _draw_bed_status(const bool blink) {
#if HAS_LEVELING #if HAS_LEVELING
planner.leveling_active && blink ? '_' : planner.leveling_active && blink ? '_' :
#endif #endif
LCD_BEDTEMP_CHAR LCD_STR_BEDTEMP[0]
), blink); ), blink);
} }
@ -769,11 +769,11 @@ void MarlinUI::draw_status_screen() {
// //
#if HOTENDS > 1 #if HOTENDS > 1
lcd_moveto(8, 0); lcd_moveto(8, 0);
lcd_put_wchar((char)LCD_STR_THERMOMETER[0]); lcd_put_wchar(LCD_STR_THERMOMETER[0]);
_draw_heater_status(1, -1, blink); _draw_heater_status(1, -1, blink);
#elif HAS_HEATED_BED #elif HAS_HEATED_BED
lcd_moveto(8, 0); lcd_moveto(8, 0);
lcd_put_wchar((char)LCD_BEDTEMP_CHAR); lcd_put_wchar(LCD_STR_BEDTEMP[0]);
_draw_heater_status(-1, -1, blink); _draw_heater_status(-1, -1, blink);
#endif #endif
@ -850,7 +850,7 @@ void MarlinUI::draw_status_screen() {
#if LCD_HEIGHT > 3 #if LCD_HEIGHT > 3
lcd_moveto(0, 2); lcd_moveto(0, 2);
lcd_put_wchar(LCD_FEEDRATE_CHAR); lcd_put_wchar(LCD_STR_FEEDRATE[0]);
lcd_put_u8str(itostr3(feedrate_percentage)); lcd_put_u8str(itostr3(feedrate_percentage));
lcd_put_wchar('%'); lcd_put_wchar('%');
@ -859,7 +859,7 @@ void MarlinUI::draw_status_screen() {
const uint8_t len = elapsed.toDigital(buffer), const uint8_t len = elapsed.toDigital(buffer),
timepos = LCD_WIDTH - len - 1; timepos = LCD_WIDTH - len - 1;
lcd_moveto(timepos, 2); lcd_moveto(timepos, 2);
lcd_put_wchar(LCD_CLOCK_CHAR); lcd_put_wchar(LCD_STR_CLOCK[0]);
lcd_put_u8str(buffer); lcd_put_u8str(buffer);
#if LCD_WIDTH >= 20 #if LCD_WIDTH >= 20
@ -921,7 +921,7 @@ void MarlinUI::draw_status_screen() {
#endif #endif
lcd_moveto(LCD_WIDTH - 9, 1); lcd_moveto(LCD_WIDTH - 9, 1);
lcd_put_wchar(LCD_FEEDRATE_CHAR); lcd_put_wchar(LCD_STR_FEEDRATE[0]);
lcd_put_u8str(itostr3(feedrate_percentage)); lcd_put_u8str(itostr3(feedrate_percentage));
lcd_put_wchar('%'); lcd_put_wchar('%');
@ -950,7 +950,7 @@ void MarlinUI::draw_status_screen() {
duration_t elapsed = print_job_timer.duration(); duration_t elapsed = print_job_timer.duration();
char buffer[14]; char buffer[14];
(void)elapsed.toDigital(buffer); (void)elapsed.toDigital(buffer);
lcd_put_wchar(LCD_CLOCK_CHAR); lcd_put_wchar(LCD_STR_CLOCK[0]);
lcd_put_u8str(buffer); lcd_put_u8str(buffer);
#endif #endif
@ -990,32 +990,23 @@ void MarlinUI::draw_status_screen() {
for (; n > 0; --n) lcd_put_wchar(' '); for (; n > 0; --n) lcd_put_wchar(' ');
} }
void draw_menu_item_generic(const bool isSelected, const uint8_t row, PGM_P pstr, const char pre_char, const char post_char) { void draw_menu_item(const bool sel, const uint8_t row, PGM_P pstr, const char pre_char, const char post_char) {
uint8_t n = LCD_WIDTH - 2; uint8_t n = LCD_WIDTH - 2;
lcd_moveto(0, row); lcd_moveto(0, row);
lcd_put_wchar(isSelected ? pre_char : ' '); lcd_put_wchar(sel ? pre_char : ' ');
n -= lcd_put_u8str_max_P(pstr, n); n -= lcd_put_u8str_max_P(pstr, n);
while (n--) lcd_put_wchar(' '); while (n--) lcd_put_wchar(' ');
lcd_put_wchar(post_char); lcd_put_wchar(post_char);
} }
void draw_menu_item_setting_edit_generic(const bool isSelected, const uint8_t row, PGM_P pstr, const char pre_char, const char* const data) { void _draw_menu_item_edit(const bool sel, const uint8_t row, PGM_P pstr, const char* const data, const bool pgm) {
uint8_t n = LCD_WIDTH - 2 - utf8_strlen(data); uint8_t n = LCD_WIDTH - 2 - (pgm ? utf8_strlen_P(data) : utf8_strlen(data));
lcd_moveto(0, row); lcd_moveto(0, row);
lcd_put_wchar(isSelected ? pre_char : ' '); lcd_put_wchar(sel ? LCD_STR_ARROW_RIGHT[0] : ' ');
n -= lcd_put_u8str_max_P(pstr, n); n -= lcd_put_u8str_max_P(pstr, n);
lcd_put_wchar(':'); lcd_put_wchar(':');
while (n--) lcd_put_wchar(' '); while (n--) lcd_put_wchar(' ');
lcd_put_u8str(data); if (pgm) lcd_put_u8str_P(data); else lcd_put_u8str(data);
}
void draw_menu_item_setting_edit_generic_P(const bool isSelected, const uint8_t row, PGM_P pstr, const char pre_char, const char* const data) {
uint8_t n = LCD_WIDTH - 2 - utf8_strlen_P(data);
lcd_moveto(0, row);
lcd_put_wchar(isSelected ? pre_char : ' ');
n -= lcd_put_u8str_max_P(pstr, n);
lcd_put_wchar(':');
while (n--) lcd_put_wchar(' ');
lcd_put_u8str_P(data);
} }
void draw_edit_screen(PGM_P const pstr, const char* const value/*=NULL*/) { void draw_edit_screen(PGM_P const pstr, const char* const value/*=NULL*/) {
@ -1033,9 +1024,9 @@ void MarlinUI::draw_status_screen() {
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
void draw_sd_menu_item(const bool isSelected, const uint8_t row, PGM_P const pstr, CardReader &theCard, const bool isDir) { void draw_sd_menu_item(const bool sel, const uint8_t row, PGM_P const pstr, CardReader &theCard, const bool isDir) {
const char post_char = isDir ? LCD_STR_FOLDER[0] : ' ', const char post_char = isDir ? LCD_STR_FOLDER[0] : ' ',
sel_char = isSelected ? '>' : ' '; sel_char = sel ? LCD_STR_ARROW_RIGHT[0] : ' ';
UNUSED(pstr); UNUSED(pstr);
lcd_moveto(0, row); lcd_moveto(0, row);
lcd_put_wchar(sel_char); lcd_put_wchar(sel_char);
@ -1045,7 +1036,7 @@ void MarlinUI::draw_status_screen() {
if (theCard.longFilename[0]) { if (theCard.longFilename[0]) {
#if ENABLED(SCROLL_LONG_FILENAMES) #if ENABLED(SCROLL_LONG_FILENAMES)
static uint8_t filename_scroll_hash; static uint8_t filename_scroll_hash;
if (isSelected) { if (sel) {
uint8_t name_hash = row; uint8_t name_hash = row;
for (uint8_t l = FILENAME_LENGTH; l--;) for (uint8_t l = FILENAME_LENGTH; l--;)
name_hash = ((name_hash << 1) | (name_hash >> 7)) ^ theCard.filename[l]; // rotate, xor name_hash = ((name_hash << 1) | (name_hash >> 7)) ^ theCard.filename[l]; // rotate, xor

18
Marlin/src/lcd/dogm/ultralcd_DOGM.cpp
View file

@ -265,13 +265,13 @@ void MarlinUI::clear_lcd() { } // Automatically cleared by Picture Loop
#endif // ADVANCED_PAUSE_FEATURE #endif // ADVANCED_PAUSE_FEATURE
// Set the colors for a menu item based on whether it is selected // Set the colors for a menu item based on whether it is selected
static bool mark_as_selected(const uint8_t row, const bool isSelected) { static bool mark_as_selected(const uint8_t row, const bool sel) {
row_y1 = row * (MENU_FONT_HEIGHT) + 1; row_y1 = row * (MENU_FONT_HEIGHT) + 1;
row_y2 = row_y1 + MENU_FONT_HEIGHT - 1; row_y2 = row_y1 + MENU_FONT_HEIGHT - 1;
if (!PAGE_CONTAINS(row_y1 + 1, row_y2 + 2)) return false; if (!PAGE_CONTAINS(row_y1 + 1, row_y2 + 2)) return false;
if (isSelected) { if (sel) {
#if ENABLED(MENU_HOLLOW_FRAME) #if ENABLED(MENU_HOLLOW_FRAME)
u8g.drawHLine(0, row_y1 + 1, LCD_PIXEL_WIDTH); u8g.drawHLine(0, row_y1 + 1, LCD_PIXEL_WIDTH);
u8g.drawHLine(0, row_y2 + 2, LCD_PIXEL_WIDTH); u8g.drawHLine(0, row_y2 + 2, LCD_PIXEL_WIDTH);
@ -314,10 +314,10 @@ void MarlinUI::clear_lcd() { } // Automatically cleared by Picture Loop
} }
// Draw a generic menu item // Draw a generic menu item
void draw_menu_item_generic(const bool isSelected, const uint8_t row, PGM_P const pstr, const char pre_char, const char post_char) { void draw_menu_item(const bool sel, const uint8_t row, PGM_P const pstr, const char pre_char, const char post_char) {
UNUSED(pre_char); UNUSED(pre_char);
if (mark_as_selected(row, isSelected)) { if (mark_as_selected(row, sel)) {
uint8_t n = LCD_WIDTH - 2; uint8_t n = LCD_WIDTH - 2;
n *= MENU_FONT_WIDTH; n *= MENU_FONT_WIDTH;
n -= lcd_put_u8str_max_P(pstr, n); n -= lcd_put_u8str_max_P(pstr, n);
@ -329,8 +329,8 @@ void MarlinUI::clear_lcd() { } // Automatically cleared by Picture Loop
} }
// Draw a menu item with an editable value // Draw a menu item with an editable value
void _drawmenu_setting_edit_generic(const bool isSelected, const uint8_t row, PGM_P const pstr, const char* const data, const bool pgm) { void _draw_menu_item_edit(const bool sel, const uint8_t row, PGM_P const pstr, const char* const data, const bool pgm) {
if (mark_as_selected(row, isSelected)) { if (mark_as_selected(row, sel)) {
const uint8_t vallen = (pgm ? utf8_strlen_P(data) : utf8_strlen((char*)data)); const uint8_t vallen = (pgm ? utf8_strlen_P(data) : utf8_strlen((char*)data));
uint8_t n = LCD_WIDTH - 2 - vallen; uint8_t n = LCD_WIDTH - 2 - vallen;
n *= MENU_FONT_WIDTH; n *= MENU_FONT_WIDTH;
@ -396,10 +396,10 @@ void MarlinUI::clear_lcd() { } // Automatically cleared by Picture Loop
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
void draw_sd_menu_item(const bool isSelected, const uint8_t row, PGM_P const pstr, CardReader &theCard, const bool isDir) { void draw_sd_menu_item(const bool sel, const uint8_t row, PGM_P const pstr, CardReader &theCard, const bool isDir) {
UNUSED(pstr); UNUSED(pstr);
mark_as_selected(row, isSelected); mark_as_selected(row, sel);
if (!PAGE_CONTAINS(row_y1, row_y2)) return; if (!PAGE_CONTAINS(row_y1, row_y2)) return;
@ -408,7 +408,7 @@ void MarlinUI::clear_lcd() { } // Automatically cleared by Picture Loop
if (theCard.longFilename[0]) { if (theCard.longFilename[0]) {
#if ENABLED(SCROLL_LONG_FILENAMES) #if ENABLED(SCROLL_LONG_FILENAMES)
static uint8_t filename_scroll_hash; static uint8_t filename_scroll_hash;
if (isSelected) { if (sel) {
uint8_t name_hash = row; uint8_t name_hash = row;
for (uint8_t l = FILENAME_LENGTH; l--;) for (uint8_t l = FILENAME_LENGTH; l--;)
name_hash = ((name_hash << 1) | (name_hash >> 7)) ^ theCard.filename[l]; // rotate, xor name_hash = ((name_hash << 1) | (name_hash >> 7)) ^ theCard.filename[l]; // rotate, xor

4
Marlin/src/lcd/extensible_ui/lib/example.cpp
View file

@ -27,13 +27,13 @@
// To implement a new UI, complete the functions below and // To implement a new UI, complete the functions below and
// read or update Marlin's state using the methods in the // read or update Marlin's state using the methods in the
// UI methods in "../ui_api.h" // ExtUI methods in "../ui_api.h"
// //
// Although it may be possible to access other state // Although it may be possible to access other state
// variables from Marlin, using the API here possibly // variables from Marlin, using the API here possibly
// helps ensure future compatibility. // helps ensure future compatibility.
namespace UI { namespace ExtUI {
void onStartup() { void onStartup() {
/* Initialize the display module here. The following /* Initialize the display module here. The following
* routines are available for access to the GPIO pins: * routines are available for access to the GPIO pins:

30
Marlin/src/lcd/extensible_ui/ui_api.cpp
View file

@ -93,7 +93,7 @@ static struct {
uint8_t manual_motion : 1; uint8_t manual_motion : 1;
} flags; } flags;
namespace UI { namespace ExtUI {
#ifdef __SAM3X8E__ #ifdef __SAM3X8E__
/** /**
* Implement a special millis() to allow time measurement * Implement a special millis() to allow time measurement
@ -593,7 +593,7 @@ namespace UI {
#if ENABLED(PARK_HEAD_ON_PAUSE) #if ENABLED(PARK_HEAD_ON_PAUSE)
enqueue_and_echo_commands_P(PSTR("M125")); enqueue_and_echo_commands_P(PSTR("M125"));
#endif #endif
UI::onStatusChanged(PSTR(MSG_PRINT_PAUSED)); ExtUI::onStatusChanged(PSTR(MSG_PRINT_PAUSED));
#endif #endif
} }
@ -605,7 +605,7 @@ namespace UI {
card.startFileprint(); card.startFileprint();
print_job_timer.start(); print_job_timer.start();
#endif #endif
UI::onStatusChanged(PSTR(MSG_PRINTING)); ExtUI::onStatusChanged(PSTR(MSG_PRINTING));
#endif #endif
} }
@ -613,7 +613,7 @@ namespace UI {
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
wait_for_heatup = wait_for_user = false; wait_for_heatup = wait_for_user = false;
card.abort_sd_printing = true; card.abort_sd_printing = true;
UI::onStatusChanged(PSTR(MSG_PRINT_ABORTED)); ExtUI::onStatusChanged(PSTR(MSG_PRINT_ABORTED));
#endif #endif
} }
@ -678,7 +678,7 @@ namespace UI {
#endif #endif
} }
} // namespace UI } // namespace ExtUI
// At the moment, we piggy-back off the ultralcd calls, but this could be cleaned up in the future // At the moment, we piggy-back off the ultralcd calls, but this could be cleaned up in the future
@ -686,7 +686,7 @@ void MarlinUI::init() {
#if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_DETECT) #if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_DETECT)
SET_INPUT_PULLUP(SD_DETECT_PIN); SET_INPUT_PULLUP(SD_DETECT_PIN);
#endif #endif
UI::onStartup(); ExtUI::onStartup();
} }
void MarlinUI::update() { void MarlinUI::update() {
@ -698,23 +698,23 @@ void MarlinUI::update() {
if (sd_status) { if (sd_status) {
card.initsd(); card.initsd();
if (card.cardOK) if (card.cardOK)
UI::onMediaInserted(); ExtUI::onMediaInserted();
else else
UI::onMediaError(); ExtUI::onMediaError();
} }
else { else {
const bool ok = card.cardOK; const bool ok = card.cardOK;
card.release(); card.release();
if (ok) UI::onMediaRemoved(); if (ok) ExtUI::onMediaRemoved();
} }
} }
#endif // SDSUPPORT #endif // SDSUPPORT
UI::_processManualMoveToDestination(); ExtUI::_processManualMoveToDestination();
UI::onIdle(); ExtUI::onIdle();
} }
void MarlinUI::setstatus(const char * const message, const bool persist/*=false*/) { UI::onStatusChanged(message); } void MarlinUI::setstatus(const char * const message, const bool persist/*=false*/) { ExtUI::onStatusChanged(message); }
void MarlinUI::setstatusPGM(PGM_P const message, int8_t level/*=0*/) { UI::onStatusChanged((progmem_str)message); } void MarlinUI::setstatusPGM(PGM_P const message, int8_t level/*=0*/) { ExtUI::onStatusChanged((progmem_str)message); }
void MarlinUI::setalertstatusPGM(PGM_P const message) { setstatusPGM(message, 0); } void MarlinUI::setalertstatusPGM(PGM_P const message) { setstatusPGM(message, 0); }
void MarlinUI::status_printf_P(const uint8_t level, const char * const fmt, ...) { void MarlinUI::status_printf_P(const uint8_t level, const char * const fmt, ...) {
@ -724,13 +724,13 @@ void MarlinUI::status_printf_P(const uint8_t level, const char * const fmt, ...)
vsnprintf_P(buff, sizeof(buff), fmt, args); vsnprintf_P(buff, sizeof(buff), fmt, args);
va_end(args); va_end(args);
buff[63] = '\0'; buff[63] = '\0';
UI::onStatusChanged(buff); ExtUI::onStatusChanged(buff);
} }
void MarlinUI::kill_screen(PGM_P const msg) { void MarlinUI::kill_screen(PGM_P const msg) {
if (!flags.printer_killed) { if (!flags.printer_killed) {
flags.printer_killed = true; flags.printer_killed = true;
UI::onPrinterKilled(msg); ExtUI::onPrinterKilled(msg);
} }
} }

6
Marlin/src/lcd/extensible_ui/ui_api.h
View file

@ -47,7 +47,7 @@
typedef const __FlashStringHelper *progmem_str; typedef const __FlashStringHelper *progmem_str;
namespace UI { namespace ExtUI {
enum axis_t : uint8_t { X, Y, Z }; enum axis_t : uint8_t { X, Y, Z };
enum extruder_t : uint8_t { E0, E1, E2, E3, E4, E5 }; enum extruder_t : uint8_t { E0, E1, E2, E3, E4, E5 };
@ -257,8 +257,8 @@ namespace UI {
* UI_INCREMENT(TargetTemp_celsius, E0) * UI_INCREMENT(TargetTemp_celsius, E0)
* *
*/ */
#define UI_INCREMENT_BY(method, inc, ...) UI::set ## method(UI::get ## method (__VA_ARGS__) + inc, ##__VA_ARGS__) #define UI_INCREMENT_BY(method, inc, ...) ExtUI::set ## method(ExtUI::get ## method (__VA_ARGS__) + inc, ##__VA_ARGS__)
#define UI_DECREMENT_BY(method, inc, ...) UI::set ## method(UI::get ## method (__VA_ARGS__) - inc, ##__VA_ARGS__) #define UI_DECREMENT_BY(method, inc, ...) ExtUI::set ## method(ExtUI::get ## method (__VA_ARGS__) - inc, ##__VA_ARGS__)
#define UI_INCREMENT(method, ...) UI_INCREMENT_BY(method, increment, ##__VA_ARGS__) #define UI_INCREMENT(method, ...) UI_INCREMENT_BY(method, increment, ##__VA_ARGS__)
#define UI_DECREMENT(method, ...) UI_DECREMENT_BY(method, increment, ##__VA_ARGS__) #define UI_DECREMENT(method, ...) UI_DECREMENT_BY(method, increment, ##__VA_ARGS__)

16
Marlin/src/lcd/menu/menu.cpp
View file

@ -102,7 +102,7 @@ void MarlinUI::goto_previous_screen() {
/////////// Common Menu Actions //////////// /////////// Common Menu Actions ////////////
//////////////////////////////////////////// ////////////////////////////////////////////
void menu_item_gcode::action(PGM_P pgcode) { enqueue_and_echo_commands_P(pgcode); } void MenuItem_gcode::action(PGM_P pgcode) { enqueue_and_echo_commands_P(pgcode); }
//////////////////////////////////////////// ////////////////////////////////////////////
/////////// Menu Editing Actions /////////// /////////// Menu Editing Actions ///////////
@ -119,18 +119,18 @@ void menu_item_gcode::action(PGM_P pgcode) { enqueue_and_echo_commands_P(pgcode)
* *
* For example, DEFINE_MENU_EDIT_ITEM(int3) expands into these functions: * For example, DEFINE_MENU_EDIT_ITEM(int3) expands into these functions:
* *
* bool menu_item_int3::_edit(); * bool MenuItem_int3::_edit();
* void menu_item_int3::edit(); // edit int16_t (interactively) * void MenuItem_int3::edit(); // edit int16_t (interactively)
* void menu_item_int3::action_setting_edit(PGM_P const pstr, int16_t * const ptr, const int16_t minValue, const int16_t maxValue, const screenFunc_t callback = null, const bool live = false); * void MenuItem_int3::action_edit(PGM_P const pstr, int16_t * const ptr, const int16_t minValue, const int16_t maxValue, const screenFunc_t callback = null, const bool live = false);
* *
* You can then use one of the menu macros to present the edit interface: * You can then use one of the menu macros to present the edit interface:
* MENU_ITEM_EDIT(int3, MSG_SPEED, &feedrate_percentage, 10, 999) * MENU_ITEM_EDIT(int3, MSG_SPEED, &feedrate_percentage, 10, 999)
* *
* This expands into a more primitive menu item: * This expands into a more primitive menu item:
* MENU_ITEM_VARIANT(int3, _setting_edit, MSG_SPEED, PSTR(MSG_SPEED), &feedrate_percentage, 10, 999) * MENU_ITEM_VARIANT(int3, _edit, MSG_SPEED, PSTR(MSG_SPEED), &feedrate_percentage, 10, 999)
* *
* ...which calls: * ...which calls:
* menu_item_int3::action_setting_edit(PSTR(MSG_SPEED), &feedrate_percentage, 10, 999) * MenuItem_int3::action_edit(PSTR(MSG_SPEED), &feedrate_percentage, 10, 999)
*/ */
void MenuItemBase::edit(strfunc_t strfunc, loadfunc_t loadfunc) { void MenuItemBase::edit(strfunc_t strfunc, loadfunc_t loadfunc) {
ui.encoder_direction_normal(); ui.encoder_direction_normal();
@ -158,7 +158,7 @@ void MenuItemBase::init(PGM_P const el, void * const ev, const int32_t minv, con
liveEdit = le; liveEdit = le;
} }
#define DEFINE_MENU_EDIT_ITEM(NAME) template class TMenuItem<NAME ## _item_info>; #define DEFINE_MENU_EDIT_ITEM(NAME) template class TMenuItem<MenuItemInfo_##NAME>;
DEFINE_MENU_EDIT_ITEM(int3); DEFINE_MENU_EDIT_ITEM(int3);
DEFINE_MENU_EDIT_ITEM(int4); DEFINE_MENU_EDIT_ITEM(int4);
@ -172,7 +172,7 @@ DEFINE_MENU_EDIT_ITEM(float52sign);
DEFINE_MENU_EDIT_ITEM(float62); DEFINE_MENU_EDIT_ITEM(float62);
DEFINE_MENU_EDIT_ITEM(long5); DEFINE_MENU_EDIT_ITEM(long5);
void menu_item_bool::action_setting_edit(PGM_P pstr, bool *ptr, screenFunc_t callback) { void MenuItem_bool::action_edit(PGM_P pstr, bool *ptr, screenFunc_t callback) {
UNUSED(pstr); *ptr ^= true; ui.refresh(); UNUSED(pstr); *ptr ^= true; ui.refresh();
if (callback) (*callback)(); if (callback) (*callback)();
} }

148
Marlin/src/lcd/menu/menu.h
View file

@ -37,109 +37,103 @@ bool printer_busy();
//////////////////////////////////////////// ////////////////////////////////////////////
#define DECLARE_MENU_EDIT_TYPE(TYPE, NAME, STRFUNC, SCALE) \ #define DECLARE_MENU_EDIT_TYPE(TYPE, NAME, STRFUNC, SCALE) \
struct NAME ## _item_info { \ struct MenuItemInfo_##NAME { \
typedef TYPE type_t; \ typedef TYPE type_t; \
static constexpr float scale = SCALE; \ static constexpr float scale = SCALE; \
static inline char* strfunc(const float value) { return STRFUNC((TYPE) value); } \ static inline char* strfunc(const float value) { return STRFUNC((TYPE) value); } \
}; };
DECLARE_MENU_EDIT_TYPE(int16_t, int3, itostr3, 1); DECLARE_MENU_EDIT_TYPE(int16_t, int3, itostr3, 1 );
DECLARE_MENU_EDIT_TYPE(int16_t, int4, itostr4sign, 1); DECLARE_MENU_EDIT_TYPE(int16_t, int4, itostr4sign, 1 );
DECLARE_MENU_EDIT_TYPE(uint8_t, int8, i8tostr3, 1); DECLARE_MENU_EDIT_TYPE(uint8_t, int8, i8tostr3, 1 );
DECLARE_MENU_EDIT_TYPE(float, float3, ftostr3, 1); DECLARE_MENU_EDIT_TYPE(float, float3, ftostr3, 1 );
DECLARE_MENU_EDIT_TYPE(float, float52, ftostr52, 100); DECLARE_MENU_EDIT_TYPE(float, float52, ftostr52, 100 );
DECLARE_MENU_EDIT_TYPE(float, float43, ftostr43sign, 1000); DECLARE_MENU_EDIT_TYPE(float, float43, ftostr43sign, 1000 );
DECLARE_MENU_EDIT_TYPE(float, float5, ftostr5rj, 0.01f); DECLARE_MENU_EDIT_TYPE(float, float5, ftostr5rj, 0.01f );
DECLARE_MENU_EDIT_TYPE(float, float51, ftostr51sign, 10); DECLARE_MENU_EDIT_TYPE(float, float51, ftostr51sign, 10 );
DECLARE_MENU_EDIT_TYPE(float, float52sign, ftostr52sign, 100); DECLARE_MENU_EDIT_TYPE(float, float52sign, ftostr52sign, 100 );
DECLARE_MENU_EDIT_TYPE(float, float62, ftostr62rj, 100); DECLARE_MENU_EDIT_TYPE(float, float62, ftostr62rj, 100 );
DECLARE_MENU_EDIT_TYPE(uint32_t, long5, ftostr5rj, 0.01f); DECLARE_MENU_EDIT_TYPE(uint32_t, long5, ftostr5rj, 0.01f );
//////////////////////////////////////////// ////////////////////////////////////////////
///////// Menu Item Draw Functions ///////// ///////// Menu Item Draw Functions /////////
//////////////////////////////////////////// ////////////////////////////////////////////
void draw_menu_item_generic(const bool isSelected, const uint8_t row, PGM_P const pstr, const char pre_char, const char post_char);
void draw_menu_item_static(const uint8_t row, PGM_P const pstr, const bool center=true, const bool invert=false, const char *valstr=NULL);
void draw_edit_screen(PGM_P const pstr, const char* const value=NULL); void draw_edit_screen(PGM_P const pstr, const char* const value=NULL);
void draw_menu_item(const bool sel, const uint8_t row, PGM_P const pstr, const char pre_char, const char post_char);
void draw_menu_item_static(const uint8_t row, PGM_P const pstr, const bool center=true, const bool invert=false, const char *valstr=NULL);
void _draw_menu_item_edit(const bool sel, const uint8_t row, PGM_P const pstr, const char* const data, const bool pgm);
FORCE_INLINE void draw_menu_item_back(const bool sel, const uint8_t row, PGM_P const pstr) { draw_menu_item(sel, row, pstr, LCD_STR_UPLEVEL[0], LCD_STR_UPLEVEL[0]); }
FORCE_INLINE void draw_menu_item_edit(const bool sel, const uint8_t row, PGM_P const pstr, const char* const data) { _draw_menu_item_edit(sel, row, pstr, data, false); }
FORCE_INLINE void draw_menu_item_edit_P(const bool sel, const uint8_t row, PGM_P const pstr, const char* const data) { _draw_menu_item_edit(sel, row, pstr, data, true); }
#define draw_menu_item_submenu(sel, row, pstr, data) draw_menu_item(sel, row, pstr, '>', LCD_STR_ARROW_RIGHT[0])
#define draw_menu_item_gcode(sel, row, pstr, gcode) draw_menu_item(sel, row, pstr, '>', ' ')
#define draw_menu_item_function(sel, row, pstr, data) draw_menu_item(sel, row, pstr, '>', ' ')
#define DRAW_MENU_ITEM_SETTING_EDIT_GENERIC(VAL) draw_menu_item_edit(sel, row, pstr, VAL)
#define DRAW_BOOL_SETTING(sel, row, pstr, data) draw_menu_item_edit_P(sel, row, pstr, (*(data))?PSTR(MSG_LCD_ON):PSTR(MSG_LCD_OFF))
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
class CardReader; class CardReader;
void draw_sd_menu_item(const bool isSelected, const uint8_t row, PGM_P const pstr, CardReader &theCard, const bool isDir); void draw_sd_menu_item(const bool sel, const uint8_t row, PGM_P const pstr, CardReader &theCard, const bool isDir);
inline void draw_menu_item_sdfile(const bool sel, const uint8_t row, PGM_P const pstr, CardReader &theCard) { draw_sd_menu_item(sel, row, pstr, theCard, false); } FORCE_INLINE void draw_menu_item_sdfile(const bool sel, const uint8_t row, PGM_P const pstr, CardReader &theCard) { draw_sd_menu_item(sel, row, pstr, theCard, false); }
inline void draw_menu_item_sdfolder(const bool sel, const uint8_t row, PGM_P const pstr, CardReader &theCard) { draw_sd_menu_item(sel, row, pstr, theCard, true); } FORCE_INLINE void draw_menu_item_sdfolder(const bool sel, const uint8_t row, PGM_P const pstr, CardReader &theCard) { draw_sd_menu_item(sel, row, pstr, theCard, true); }
#endif #endif
#if HAS_GRAPHICAL_LCD
void _drawmenu_setting_edit_generic(const bool isSelected, const uint8_t row, const char* pstr, const char* const data, const bool pgm); #if HAS_GRAPHICAL_LCD && (ENABLED(BABYSTEP_ZPROBE_GFX_OVERLAY) || ENABLED(MESH_EDIT_GFX_OVERLAY))
#define draw_menu_item_back(sel, row, pstr) draw_menu_item_generic(sel, row, pstr, LCD_STR_UPLEVEL[0], LCD_STR_UPLEVEL[0]) void _lcd_zoffset_overlay_gfx(const float zvalue);
#define draw_menu_item_setting_edit_generic(sel, row, pstr, data) _drawmenu_setting_edit_generic(sel, row, pstr, data, false)
#define draw_menu_item_setting_edit_generic_P(sel, row, pstr, data) _drawmenu_setting_edit_generic(sel, row, pstr, data, true)
#define DRAWMENU_SETTING_EDIT_GENERIC(SRC) draw_menu_item_setting_edit_generic(sel, row, pstr, SRC)
#define DRAW_BOOL_SETTING(sel, row, pstr, data) draw_menu_item_setting_edit_generic_P(sel, row, pstr, (*(data))?PSTR(MSG_LCD_ON):PSTR(MSG_LCD_OFF))
#if ENABLED(BABYSTEP_ZPROBE_GFX_OVERLAY) || ENABLED(MESH_EDIT_GFX_OVERLAY)
void _lcd_zoffset_overlay_gfx(const float zvalue);
#endif
#else
#define draw_menu_item_back(sel, row, pstr) draw_menu_item_generic(sel, row, pstr, LCD_UPLEVEL_CHAR, LCD_UPLEVEL_CHAR)
void draw_menu_item_setting_edit_generic(const bool sel, const uint8_t row, const char* pstr, const char pre_char, const char* const data);
void draw_menu_item_setting_edit_generic_P(const bool sel, const uint8_t row, const char* pstr, const char pre_char, const char* const data);
#define DRAWMENU_SETTING_EDIT_GENERIC(SRC) draw_menu_item_setting_edit_generic(sel, row, pstr, '>', SRC)
#define DRAW_BOOL_SETTING(sel, row, pstr, data) draw_menu_item_setting_edit_generic_P(sel, row, pstr, '>', (*(data))?PSTR(MSG_LCD_ON):PSTR(MSG_LCD_OFF))
#endif #endif
#define draw_menu_item_submenu(sel, row, pstr, data) draw_menu_item_generic(sel, row, pstr, '>', LCD_STR_ARROW_RIGHT[0])
#define draw_menu_item_gcode(sel, row, pstr, gcode) draw_menu_item_generic(sel, row, pstr, '>', ' ')
#define draw_menu_item_function(sel, row, pstr, data) draw_menu_item_generic(sel, row, pstr, '>', ' ')
//////////////////////////////////////////// ////////////////////////////////////////////
/////// Edit Setting Draw Functions //////// /////// Edit Setting Draw Functions ////////
//////////////////////////////////////////// ////////////////////////////////////////////
#define _DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(TYPE, NAME, STRFUNC) \ #define _DEFINE_DRAW_MENU_ITEM_SETTING_EDIT(TYPE, NAME, STRFUNC) \
FORCE_INLINE void draw_menu_item_setting_edit_ ## NAME (const bool sel, const uint8_t row, PGM_P const pstr, PGM_P const pstr2, TYPE * const data, ...) { \ FORCE_INLINE void draw_menu_item_edit_##NAME (const bool sel, const uint8_t row, PGM_P const pstr, PGM_P const pstr2, TYPE * const data, ...) { \
UNUSED(pstr2); \ UNUSED(pstr2); \
DRAWMENU_SETTING_EDIT_GENERIC(STRFUNC(*(data))); \ DRAW_MENU_ITEM_SETTING_EDIT_GENERIC(STRFUNC(*(data))); \
} \ } \
FORCE_INLINE void draw_menu_item_setting_edit_accessor_ ## NAME (const bool sel, const uint8_t row, PGM_P const pstr, PGM_P const pstr2, TYPE (*pget)(), void (*pset)(TYPE), ...) { \ FORCE_INLINE void draw_menu_item_edit_accessor_##NAME (const bool sel, const uint8_t row, PGM_P const pstr, PGM_P const pstr2, TYPE (*pget)(), void (*pset)(TYPE), ...) { \
UNUSED(pstr2); UNUSED(pset); \ UNUSED(pstr2); UNUSED(pset); \
DRAWMENU_SETTING_EDIT_GENERIC(STRFUNC(pget())); \ DRAW_MENU_ITEM_SETTING_EDIT_GENERIC(STRFUNC(pget())); \
} \ } \
typedef void NAME##_void typedef void NAME##_void
#define DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(NAME) _DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(NAME ## _item_info::type_t, NAME, NAME ## _item_info::strfunc) #define DEFINE_DRAW_MENU_ITEM_SETTING_EDIT(NAME) _DEFINE_DRAW_MENU_ITEM_SETTING_EDIT(MenuItemInfo_##NAME::type_t, NAME, MenuItemInfo_##NAME::strfunc)
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(int3); DEFINE_DRAW_MENU_ITEM_SETTING_EDIT(int3);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(int4); DEFINE_DRAW_MENU_ITEM_SETTING_EDIT(int4);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(int8); DEFINE_DRAW_MENU_ITEM_SETTING_EDIT(int8);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float3); DEFINE_DRAW_MENU_ITEM_SETTING_EDIT(float3);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float52); DEFINE_DRAW_MENU_ITEM_SETTING_EDIT(float52);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float43); DEFINE_DRAW_MENU_ITEM_SETTING_EDIT(float43);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float5); DEFINE_DRAW_MENU_ITEM_SETTING_EDIT(float5);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float51); DEFINE_DRAW_MENU_ITEM_SETTING_EDIT(float51);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float52sign); DEFINE_DRAW_MENU_ITEM_SETTING_EDIT(float52sign);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float62); DEFINE_DRAW_MENU_ITEM_SETTING_EDIT(float62);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(long5); DEFINE_DRAW_MENU_ITEM_SETTING_EDIT(long5);
#define draw_menu_item_setting_edit_bool(sel, row, pstr, pstr2, data, ...) DRAW_BOOL_SETTING(sel, row, pstr, data) #define draw_menu_item_edit_bool(sel, row, pstr, pstr2, data, ...) DRAW_BOOL_SETTING(sel, row, pstr, data)
#define draw_menu_item_setting_edit_accessor_bool(sel, row, pstr, pstr2, pget, pset) DRAW_BOOL_SETTING(sel, row, pstr, data) #define draw_menu_item_edit_accessor_bool(sel, row, pstr, pstr2, pget, pset) DRAW_BOOL_SETTING(sel, row, pstr, data)
//////////////////////////////////////////// ////////////////////////////////////////////
/////////////// Menu Actions /////////////// /////////////// Menu Actions ///////////////
//////////////////////////////////////////// ////////////////////////////////////////////
class menu_item_back { class MenuItem_back {
public: public:
static inline void action() { ui.goto_previous_screen(); } static inline void action() { ui.goto_previous_screen(); }
}; };
class menu_item_submenu { class MenuItem_submenu {
public: public:
static inline void action(const screenFunc_t func) { ui.save_previous_screen(); ui.goto_screen(func); } static inline void action(const screenFunc_t func) { ui.save_previous_screen(); ui.goto_screen(func); }
}; };
class menu_item_gcode { class MenuItem_gcode {
public: public:
static void action(const char * const pgcode); static void action(const char * const pgcode);
}; };
class menu_item_function { class MenuItem_function {
public: public:
static inline void action(const menuAction_t func) { (*func)(); }; static inline void action(const menuAction_t func) { (*func)(); };
}; };
@ -160,19 +154,19 @@ template<typename NAME>
class TMenuItem : MenuItemBase { class TMenuItem : MenuItemBase {
private: private:
typedef typename NAME::type_t type_t; typedef typename NAME::type_t type_t;
inline static float unscale(const float value) {return value * (1.0f / NAME::scale);} inline static float unscale(const float value) { return value * (1.0f / NAME::scale); }
inline static float scale(const float value) {return value * NAME::scale;} inline static float scale(const float value) { return value * NAME::scale; }
static void load(void *ptr, const int32_t value) {*((type_t*)ptr) = unscale(value);} static void load(void *ptr, const int32_t value) { *((type_t*)ptr) = unscale(value); }
static char* to_string(const int32_t value) {return NAME::strfunc(unscale(value));} static char* to_string(const int32_t value) { return NAME::strfunc(unscale(value)); }
public: public:
static void action_setting_edit(PGM_P const pstr, type_t * const ptr, const type_t minValue, const type_t maxValue, const screenFunc_t callback=NULL, const bool live=false) { static void action_edit(PGM_P const pstr, type_t * const ptr, const type_t minValue, const type_t maxValue, const screenFunc_t callback=NULL, const bool live=false) {
const int32_t minv = scale(minValue); const int32_t minv = scale(minValue);
init(pstr, ptr, minv, int32_t(scale(maxValue)) - minv, int32_t(scale(*ptr)) - minv, edit, callback, live); init(pstr, ptr, minv, int32_t(scale(maxValue)) - minv, int32_t(scale(*ptr)) - minv, edit, callback, live);
} }
static void edit() { MenuItemBase::edit(to_string, load); } static void edit() { MenuItemBase::edit(to_string, load); }
}; };
#define DECLARE_MENU_EDIT_ITEM(NAME) typedef TMenuItem<NAME ## _item_info> menu_item_ ## NAME; #define DECLARE_MENU_EDIT_ITEM(NAME) typedef TMenuItem<MenuItemInfo_##NAME> MenuItem_##NAME;
DECLARE_MENU_EDIT_ITEM(int3); DECLARE_MENU_EDIT_ITEM(int3);
DECLARE_MENU_EDIT_ITEM(int4); DECLARE_MENU_EDIT_ITEM(int4);
@ -186,9 +180,9 @@ DECLARE_MENU_EDIT_ITEM(float52sign);
DECLARE_MENU_EDIT_ITEM(float62); DECLARE_MENU_EDIT_ITEM(float62);
DECLARE_MENU_EDIT_ITEM(long5); DECLARE_MENU_EDIT_ITEM(long5);
class menu_item_bool { class MenuItem_bool {
public: public:
static void action_setting_edit(PGM_P const pstr, bool* ptr, const screenFunc_t callbackFunc=NULL); static void action_edit(PGM_P const pstr, bool* ptr, const screenFunc_t callbackFunc=NULL);
}; };
//////////////////////////////////////////// ////////////////////////////////////////////
@ -247,22 +241,22 @@ class menu_item_bool {
* MENU_ITEM generates draw & handler code for a menu item, potentially calling: * MENU_ITEM generates draw & handler code for a menu item, potentially calling:
* *
* draw_menu_item_<type>[_variant](sel, row, label, arg3...) * draw_menu_item_<type>[_variant](sel, row, label, arg3...)
* menu_item_<type>::action[_variant](arg3...) * MenuItem_<type>::action[_variant](arg3...)
* *
* Examples: * Examples:
* MENU_ITEM(back, MSG_WATCH, 0 [dummy parameter] ) * MENU_ITEM(back, MSG_WATCH, 0 [dummy parameter] )
* or * or
* MENU_BACK(MSG_WATCH) * MENU_BACK(MSG_WATCH)
* draw_menu_item_back(sel, row, PSTR(MSG_WATCH)) * draw_menu_item_back(sel, row, PSTR(MSG_WATCH))
* menu_item_back::action() * MenuItem_back::action()
* *
* MENU_ITEM(function, MSG_PAUSE_PRINT, lcd_sdcard_pause) * MENU_ITEM(function, MSG_PAUSE_PRINT, lcd_sdcard_pause)
* draw_menu_item_function(sel, row, PSTR(MSG_PAUSE_PRINT), lcd_sdcard_pause) * draw_menu_item_function(sel, row, PSTR(MSG_PAUSE_PRINT), lcd_sdcard_pause)
* menu_item_function::action(lcd_sdcard_pause) * MenuItem_function::action(lcd_sdcard_pause)
* *
* MENU_ITEM_EDIT(int3, MSG_SPEED, &feedrate_percentage, 10, 999) * MENU_ITEM_EDIT(int3, MSG_SPEED, &feedrate_percentage, 10, 999)
* draw_menu_item_setting_edit_int3(sel, row, PSTR(MSG_SPEED), PSTR(MSG_SPEED), &feedrate_percentage, 10, 999) * draw_menu_item_edit_int3(sel, row, PSTR(MSG_SPEED), PSTR(MSG_SPEED), &feedrate_percentage, 10, 999)
* menu_item_int3::action_setting_edit(PSTR(MSG_SPEED), &feedrate_percentage, 10, 999) * MenuItem_int3::action_edit(PSTR(MSG_SPEED), &feedrate_percentage, 10, 999)
* *
*/ */
#define _MENU_ITEM_VARIANT_P(TYPE, VARIANT, USE_MULTIPLIER, PLABEL, ...) do { \ #define _MENU_ITEM_VARIANT_P(TYPE, VARIANT, USE_MULTIPLIER, PLABEL, ...) do { \
@ -270,7 +264,7 @@ class menu_item_bool {
if (_menuLineNr == _thisItemNr) { \ if (_menuLineNr == _thisItemNr) { \
if (encoderLine == _thisItemNr && ui.use_click()) { \ if (encoderLine == _thisItemNr && ui.use_click()) { \
_MENU_ITEM_MULTIPLIER_CHECK(USE_MULTIPLIER); \ _MENU_ITEM_MULTIPLIER_CHECK(USE_MULTIPLIER); \
menu_item_ ## TYPE ::action ## VARIANT(__VA_ARGS__); \ MenuItem_##TYPE ::action ## VARIANT(__VA_ARGS__); \
if (screen_changed) return; \ if (screen_changed) return; \
} \ } \
if (ui.should_draw()) \ if (ui.should_draw()) \
@ -305,10 +299,10 @@ class menu_item_bool {
#define MENU_ITEM_DUMMY() do { _thisItemNr++; }while(0) #define MENU_ITEM_DUMMY() do { _thisItemNr++; }while(0)
#define MENU_ITEM_P(TYPE, PLABEL, ...) _MENU_ITEM_VARIANT_P(TYPE, , false, PLABEL, ## __VA_ARGS__) #define MENU_ITEM_P(TYPE, PLABEL, ...) _MENU_ITEM_VARIANT_P(TYPE, , false, PLABEL, ## __VA_ARGS__)
#define MENU_ITEM(TYPE, LABEL, ...) _MENU_ITEM_VARIANT_P(TYPE, , false, PSTR(LABEL), ## __VA_ARGS__) #define MENU_ITEM(TYPE, LABEL, ...) _MENU_ITEM_VARIANT_P(TYPE, , false, PSTR(LABEL), ## __VA_ARGS__)
#define MENU_ITEM_EDIT(TYPE, LABEL, ...) _MENU_ITEM_VARIANT_P(TYPE, _setting_edit, false, PSTR(LABEL), PSTR(LABEL), ## __VA_ARGS__) #define MENU_ITEM_EDIT(TYPE, LABEL, ...) _MENU_ITEM_VARIANT_P(TYPE, _edit, false, PSTR(LABEL), PSTR(LABEL), ## __VA_ARGS__)
#define MENU_ITEM_EDIT_CALLBACK(TYPE, LABEL, ...) _MENU_ITEM_VARIANT_P(TYPE, _setting_edit, false, PSTR(LABEL), PSTR(LABEL), ## __VA_ARGS__) #define MENU_ITEM_EDIT_CALLBACK(TYPE, LABEL, ...) _MENU_ITEM_VARIANT_P(TYPE, _edit, false, PSTR(LABEL), PSTR(LABEL), ## __VA_ARGS__)
#define MENU_MULTIPLIER_ITEM_EDIT(TYPE, LABEL, ...) _MENU_ITEM_VARIANT_P(TYPE, _setting_edit, true, PSTR(LABEL), PSTR(LABEL), ## __VA_ARGS__) #define MENU_MULTIPLIER_ITEM_EDIT(TYPE, LABEL, ...) _MENU_ITEM_VARIANT_P(TYPE, _edit, true, PSTR(LABEL), PSTR(LABEL), ## __VA_ARGS__)
#define MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(TYPE, LABEL, ...) _MENU_ITEM_VARIANT_P(TYPE, _setting_edit, true, PSTR(LABEL), PSTR(LABEL), ## __VA_ARGS__) #define MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(TYPE, LABEL, ...) _MENU_ITEM_VARIANT_P(TYPE, _edit, true, PSTR(LABEL), PSTR(LABEL), ## __VA_ARGS__)
//////////////////////////////////////////// ////////////////////////////////////////////
/////////////// Menu Screens /////////////// /////////////// Menu Screens ///////////////

4
Marlin/src/lcd/menu/menu_sdcard.cpp
View file

@ -72,7 +72,7 @@ void lcd_sd_updir() {
} }
#endif #endif
class menu_item_sdfile { class MenuItem_sdfile {
public: public:
static void action(CardReader &theCard) { static void action(CardReader &theCard) {
#if ENABLED(SD_REPRINT_LAST_SELECTED_FILE) #if ENABLED(SD_REPRINT_LAST_SELECTED_FILE)
@ -84,7 +84,7 @@ class menu_item_sdfile {
} }
}; };
class menu_item_sdfolder { class MenuItem_sdfolder {
public: public:
static void action(CardReader &theCard) { static void action(CardReader &theCard) {
card.chdir(theCard.filename); card.chdir(theCard.filename);

2
Marlin/src/lcd/ultralcd.cpp
View file

@ -269,7 +269,7 @@ bool MarlinUI::get_blink() {
#if HAS_LCD_MENU #if HAS_LCD_MENU
if (RRK(EN_REPRAPWORLD_KEYPAD_DOWN)) encoderPosition -= ENCODER_STEPS_PER_MENU_ITEM; if (RRK(EN_REPRAPWORLD_KEYPAD_DOWN)) encoderPosition -= ENCODER_STEPS_PER_MENU_ITEM;
else if (RRK(EN_REPRAPWORLD_KEYPAD_UP)) encoderPosition += ENCODER_STEPS_PER_MENU_ITEM; else if (RRK(EN_REPRAPWORLD_KEYPAD_UP)) encoderPosition += ENCODER_STEPS_PER_MENU_ITEM;
else if (RRK(EN_REPRAPWORLD_KEYPAD_LEFT)) { menu_item_back::action(); quick_feedback(); } else if (RRK(EN_REPRAPWORLD_KEYPAD_LEFT)) { MenuItem_back::action(); quick_feedback(); }
else if (RRK(EN_REPRAPWORLD_KEYPAD_RIGHT)) { return_to_status(); quick_feedback(); } else if (RRK(EN_REPRAPWORLD_KEYPAD_RIGHT)) { return_to_status(); quick_feedback(); }
#endif #endif
} }

2
Marlin/src/libs/buzzer.cpp
View file

@ -64,7 +64,7 @@ void Buzzer::tick() {
if (state.tone.frequency > 0) { if (state.tone.frequency > 0) {
#if ENABLED(EXTENSIBLE_UI) #if ENABLED(EXTENSIBLE_UI)
CRITICAL_SECTION_START; CRITICAL_SECTION_START;
UI::onPlayTone(state.tone.frequency, state.tone.duration); ExtUI::onPlayTone(state.tone.frequency, state.tone.duration);
CRITICAL_SECTION_END; CRITICAL_SECTION_END;
#elif ENABLED(SPEAKER) #elif ENABLED(SPEAKER)
CRITICAL_SECTION_START; CRITICAL_SECTION_START;

26
Marlin/src/module/temperature.cpp
View file

@ -943,7 +943,7 @@ void Temperature::manage_heater() {
// Derived from RepRap FiveD extruder::getTemperature() // Derived from RepRap FiveD extruder::getTemperature()
// For hot end temperature measurement. // For hot end temperature measurement.
float Temperature::analog2temp(const int raw, const uint8_t e) { float Temperature::analog_to_celsius_hotend(const int raw, const uint8_t e) {
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT) #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
if (e > HOTENDS) if (e > HOTENDS)
#else #else
@ -1015,7 +1015,7 @@ float Temperature::analog2temp(const int raw, const uint8_t e) {
#if HAS_HEATED_BED #if HAS_HEATED_BED
// Derived from RepRap FiveD extruder::getTemperature() // Derived from RepRap FiveD extruder::getTemperature()
// For bed temperature measurement. // For bed temperature measurement.
float Temperature::analog2tempBed(const int raw) { float Temperature::analog_to_celsius_bed(const int raw) {
#if ENABLED(HEATER_BED_USES_THERMISTOR) #if ENABLED(HEATER_BED_USES_THERMISTOR)
SCAN_THERMISTOR_TABLE(BEDTEMPTABLE, BEDTEMPTABLE_LEN); SCAN_THERMISTOR_TABLE(BEDTEMPTABLE, BEDTEMPTABLE_LEN);
#elif ENABLED(HEATER_BED_USES_AD595) #elif ENABLED(HEATER_BED_USES_AD595)
@ -1031,7 +1031,7 @@ float Temperature::analog2temp(const int raw, const uint8_t e) {
#if HAS_TEMP_CHAMBER #if HAS_TEMP_CHAMBER
// Derived from RepRap FiveD extruder::getTemperature() // Derived from RepRap FiveD extruder::getTemperature()
// For chamber temperature measurement. // For chamber temperature measurement.
float Temperature::analog2tempChamber(const int raw) { float Temperature::analog_to_celsiusChamber(const int raw) {
#if ENABLED(HEATER_CHAMBER_USES_THERMISTOR) #if ENABLED(HEATER_CHAMBER_USES_THERMISTOR)
SCAN_THERMISTOR_TABLE(CHAMBERTEMPTABLE, CHAMBERTEMPTABLE_LEN); SCAN_THERMISTOR_TABLE(CHAMBERTEMPTABLE, CHAMBERTEMPTABLE_LEN);
#elif ENABLED(HEATER_CHAMBER_USES_AD595) #elif ENABLED(HEATER_CHAMBER_USES_AD595)
@ -1054,18 +1054,18 @@ void Temperature::updateTemperaturesFromRawValues() {
#if ENABLED(HEATER_0_USES_MAX6675) #if ENABLED(HEATER_0_USES_MAX6675)
current_temperature_raw[0] = read_max6675(); current_temperature_raw[0] = read_max6675();
#endif #endif
HOTEND_LOOP() current_temperature[e] = Temperature::analog2temp(current_temperature_raw[e], e); HOTEND_LOOP() current_temperature[e] = analog_to_celsius_hotend(current_temperature_raw[e], e);
#if HAS_HEATED_BED #if HAS_HEATED_BED
current_temperature_bed = Temperature::analog2tempBed(current_temperature_bed_raw); current_temperature_bed = analog_to_celsius_bed(current_temperature_bed_raw);
#endif #endif
#if HAS_TEMP_CHAMBER #if HAS_TEMP_CHAMBER
current_temperature_chamber = Temperature::analog2tempChamber(current_temperature_chamber_raw); current_temperature_chamber = analog_to_celsiusChamber(current_temperature_chamber_raw);
#endif #endif
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT) #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
redundant_temperature = Temperature::analog2temp(redundant_temperature_raw, 1); redundant_temperature = analog_to_celsius_hotend(redundant_temperature_raw, 1);
#endif #endif
#if ENABLED(FILAMENT_WIDTH_SENSOR) #if ENABLED(FILAMENT_WIDTH_SENSOR)
filament_width_meas = analog2widthFil(); filament_width_meas = analog_to_mm_fil_width();
#endif #endif
#if ENABLED(USE_WATCHDOG) #if ENABLED(USE_WATCHDOG)
@ -1080,7 +1080,7 @@ void Temperature::updateTemperaturesFromRawValues() {
#if ENABLED(FILAMENT_WIDTH_SENSOR) #if ENABLED(FILAMENT_WIDTH_SENSOR)
// Convert raw Filament Width to millimeters // Convert raw Filament Width to millimeters
float Temperature::analog2widthFil() { float Temperature::analog_to_mm_fil_width() {
return current_raw_filwidth * 5.0f * (1.0f / 16383.0f); return current_raw_filwidth * 5.0f * (1.0f / 16383.0f);
} }
@ -1299,7 +1299,7 @@ void Temperature::init() {
#define TEMP_MIN_ROUTINE(NR) \ #define TEMP_MIN_ROUTINE(NR) \
minttemp[NR] = HEATER_ ##NR## _MINTEMP; \ minttemp[NR] = HEATER_ ##NR## _MINTEMP; \
while (analog2temp(minttemp_raw[NR], NR) < HEATER_ ##NR## _MINTEMP) { \ while (analog_to_celsius_hotend(minttemp_raw[NR], NR) < HEATER_ ##NR## _MINTEMP) { \
if (HEATER_ ##NR## _RAW_LO_TEMP < HEATER_ ##NR## _RAW_HI_TEMP) \ if (HEATER_ ##NR## _RAW_LO_TEMP < HEATER_ ##NR## _RAW_HI_TEMP) \
minttemp_raw[NR] += OVERSAMPLENR; \ minttemp_raw[NR] += OVERSAMPLENR; \
else \ else \
@ -1307,7 +1307,7 @@ void Temperature::init() {
} }
#define TEMP_MAX_ROUTINE(NR) \ #define TEMP_MAX_ROUTINE(NR) \
maxttemp[NR] = HEATER_ ##NR## _MAXTEMP; \ maxttemp[NR] = HEATER_ ##NR## _MAXTEMP; \
while (analog2temp(maxttemp_raw[NR], NR) > HEATER_ ##NR## _MAXTEMP) { \ while (analog_to_celsius_hotend(maxttemp_raw[NR], NR) > HEATER_ ##NR## _MAXTEMP) { \
if (HEATER_ ##NR## _RAW_LO_TEMP < HEATER_ ##NR## _RAW_HI_TEMP) \ if (HEATER_ ##NR## _RAW_LO_TEMP < HEATER_ ##NR## _RAW_HI_TEMP) \
maxttemp_raw[NR] -= OVERSAMPLENR; \ maxttemp_raw[NR] -= OVERSAMPLENR; \
else \ else \
@ -1363,7 +1363,7 @@ void Temperature::init() {
#if HAS_HEATED_BED #if HAS_HEATED_BED
#ifdef BED_MINTEMP #ifdef BED_MINTEMP
while (analog2tempBed(bed_minttemp_raw) < BED_MINTEMP) { while (analog_to_celsius_bed(bed_minttemp_raw) < BED_MINTEMP) {
#if HEATER_BED_RAW_LO_TEMP < HEATER_BED_RAW_HI_TEMP #if HEATER_BED_RAW_LO_TEMP < HEATER_BED_RAW_HI_TEMP
bed_minttemp_raw += OVERSAMPLENR; bed_minttemp_raw += OVERSAMPLENR;
#else #else
@ -1372,7 +1372,7 @@ void Temperature::init() {
} }
#endif // BED_MINTEMP #endif // BED_MINTEMP
#ifdef BED_MAXTEMP #ifdef BED_MAXTEMP
while (analog2tempBed(bed_maxttemp_raw) > BED_MAXTEMP) { while (analog_to_celsius_bed(bed_maxttemp_raw) > BED_MAXTEMP) {
#if HEATER_BED_RAW_LO_TEMP < HEATER_BED_RAW_HI_TEMP #if HEATER_BED_RAW_LO_TEMP < HEATER_BED_RAW_HI_TEMP
bed_maxttemp_raw -= OVERSAMPLENR; bed_maxttemp_raw -= OVERSAMPLENR;
#else #else

8
Marlin/src/module/temperature.h
View file

@ -311,13 +311,13 @@ class Temperature {
/** /**
* Static (class) methods * Static (class) methods
*/ */
static float analog2temp(const int raw, const uint8_t e); static float analog_to_celsius_hotend(const int raw, const uint8_t e);
#if HAS_HEATED_BED #if HAS_HEATED_BED
static float analog2tempBed(const int raw); static float analog_to_celsius_bed(const int raw);
#endif #endif
#if HAS_TEMP_CHAMBER #if HAS_TEMP_CHAMBER
static float analog2tempChamber(const int raw); static float analog_to_celsiusChamber(const int raw);
#endif #endif
/** /**
@ -358,7 +358,7 @@ class Temperature {
#endif #endif
#if ENABLED(FILAMENT_WIDTH_SENSOR) #if ENABLED(FILAMENT_WIDTH_SENSOR)
static float analog2widthFil(); // Convert raw Filament Width to millimeters static float analog_to_mm_fil_width(); // Convert raw Filament Width to millimeters
static int8_t widthFil_to_size_ratio(); // Convert Filament Width (mm) to an extrusion ratio static int8_t widthFil_to_size_ratio(); // Convert Filament Width (mm) to an extrusion ratio
#endif #endif