zaubentrucker/muele-marlin
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

♻️ Apply F() to more LCD code (#24228)

Browse source
This commit is contained in:
Scott Lahteine 2022-05-22 19:56:46 -05:00 committed by Scott Lahteine
parent 9a74bcd4cf
commit 28f8646aa6
44 changed files with 622 additions and 609 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Marlin/src/core/multi_language.h
View file

@ -45,6 +45,7 @@ typedef const char Language_Str[];
// Set unused languages equal to each other so the // Set unused languages equal to each other so the
// compiler can optimize away the conditionals. // compiler can optimize away the conditionals.
#define LCD_LANGUAGE_1 LCD_LANGUAGE
#ifndef LCD_LANGUAGE_2 #ifndef LCD_LANGUAGE_2
#define LCD_LANGUAGE_2 LCD_LANGUAGE #define LCD_LANGUAGE_2 LCD_LANGUAGE
#endif #endif

40
Marlin/src/lcd/HD44780/marlinui_HD44780.cpp
View file

@ -410,7 +410,7 @@ void MarlinUI::clear_lcd() { lcd.clear(); }
// Scroll the PSTR 'text' in a 'len' wide field for 'time' milliseconds at position col,line // Scroll the PSTR 'text' in a 'len' wide field for 'time' milliseconds at position col,line
void lcd_scroll(const lcd_uint_t col, const lcd_uint_t line, FSTR_P const ftxt, const uint8_t len, const int16_t time) { void lcd_scroll(const lcd_uint_t col, const lcd_uint_t line, FSTR_P const ftxt, const uint8_t len, const int16_t time) {
uint8_t slen = utf8_strlen_P(FTOP(ftxt)); uint8_t slen = utf8_strlen(ftxt);
if (slen < len) { if (slen < len) {
lcd_put_u8str_max(col, line, ftxt, len); lcd_put_u8str_max(col, line, ftxt, len);
for (; slen < len; ++slen) lcd_put_wchar(' '); for (; slen < len; ++slen) lcd_put_wchar(' ');
@ -437,10 +437,10 @@ void MarlinUI::clear_lcd() { lcd.clear(); }
} }
} }
static void logo_lines(PGM_P const extra) { static void logo_lines(FSTR_P const extra) {
int16_t indent = (LCD_WIDTH - 8 - utf8_strlen_P(extra)) / 2; int16_t indent = (LCD_WIDTH - 8 - utf8_strlen(extra)) / 2;
lcd_put_wchar(indent, 0, '\x00'); lcd_put_u8str(F( "------" )); lcd_put_wchar('\x01'); lcd_put_wchar(indent, 0, '\x00'); lcd_put_u8str(F( "------" )); lcd_put_wchar('\x01');
lcd_put_u8str(indent, 1, F("|Marlin|")); lcd_put_u8str_P(extra); lcd_put_u8str(indent, 1, F("|Marlin|")); lcd_put_u8str(extra);
lcd_put_wchar(indent, 2, '\x02'); lcd_put_u8str(F( "------" )); lcd_put_wchar('\x03'); lcd_put_wchar(indent, 2, '\x02'); lcd_put_u8str(F( "------" )); lcd_put_wchar('\x03');
} }
@ -468,7 +468,7 @@ void MarlinUI::clear_lcd() { lcd.clear(); }
// //
// Show the Marlin logo, splash line1, and splash line 2 // Show the Marlin logo, splash line1, and splash line 2
// //
logo_lines(PSTR(" " SHORT_BUILD_VERSION)); logo_lines(F(" " SHORT_BUILD_VERSION));
CENTER_OR_SCROLL(MARLIN_WEBSITE_URL, 2000); CENTER_OR_SCROLL(MARLIN_WEBSITE_URL, 2000);
} }
else { else {
@ -476,7 +476,7 @@ void MarlinUI::clear_lcd() { lcd.clear(); }
// Show the Marlin logo and short build version // Show the Marlin logo and short build version
// After a delay show the website URL // After a delay show the website URL
// //
logo_lines(NUL_STR); logo_lines(FPSTR(NUL_STR));
CENTER_OR_SCROLL(SHORT_BUILD_VERSION, 1500); CENTER_OR_SCROLL(SHORT_BUILD_VERSION, 1500);
CENTER_OR_SCROLL(MARLIN_WEBSITE_URL, 1500); CENTER_OR_SCROLL(MARLIN_WEBSITE_URL, 1500);
#ifdef STRING_SPLASH_LINE3 #ifdef STRING_SPLASH_LINE3
@ -1067,33 +1067,33 @@ void MarlinUI::draw_status_screen() {
#endif // ADVANCED_PAUSE_FEATURE #endif // ADVANCED_PAUSE_FEATURE
// Draw a static item with no left-right margin required. Centered by default. // Draw a static item with no left-right margin required. Centered by default.
void MenuItem_static::draw(const uint8_t row, PGM_P const pstr, const uint8_t style/*=SS_DEFAULT*/, const char * const vstr/*=nullptr*/) { void MenuItem_static::draw(const uint8_t row, FSTR_P const fstr, const uint8_t style/*=SS_DEFAULT*/, const char * const vstr/*=nullptr*/) {
int8_t n = LCD_WIDTH; int8_t n = LCD_WIDTH;
lcd_moveto(0, row); lcd_moveto(0, row);
const int8_t plen = pstr ? utf8_strlen_P(pstr) : 0, const int8_t plen = fstr ? utf8_strlen(fstr) : 0,
vlen = vstr ? utf8_strlen(vstr) : 0; vlen = vstr ? utf8_strlen(vstr) : 0;
if (style & SS_CENTER) { if (style & SS_CENTER) {
int8_t pad = (LCD_WIDTH - plen - vlen) / 2; int8_t pad = (LCD_WIDTH - plen - vlen) / 2;
while (--pad >= 0) { lcd_put_wchar(' '); n--; } while (--pad >= 0) { lcd_put_wchar(' '); n--; }
} }
if (plen) n = lcd_put_u8str_ind_P(pstr, itemIndex, itemString, n); if (plen) n = lcd_put_u8str_ind(fstr, itemIndex, itemString, n);
if (vlen) n -= lcd_put_u8str_max(vstr, n); if (vlen) n -= lcd_put_u8str_max(vstr, n);
for (; n > 0; --n) lcd_put_wchar(' '); for (; n > 0; --n) lcd_put_wchar(' ');
} }
// Draw a generic menu item with pre_char (if selected) and post_char // Draw a generic menu item with pre_char (if selected) and post_char
void MenuItemBase::_draw(const bool sel, const uint8_t row, PGM_P const pstr, const char pre_char, const char post_char) { void MenuItemBase::_draw(const bool sel, const uint8_t row, FSTR_P const fstr, const char pre_char, const char post_char) {
lcd_put_wchar(0, row, sel ? pre_char : ' '); lcd_put_wchar(0, row, sel ? pre_char : ' ');
uint8_t n = lcd_put_u8str_ind_P(pstr, itemIndex, itemString, LCD_WIDTH - 2); uint8_t n = lcd_put_u8str_ind(fstr, itemIndex, itemString, LCD_WIDTH - 2);
for (; n; --n) lcd_put_wchar(' '); for (; n; --n) lcd_put_wchar(' ');
lcd_put_wchar(post_char); lcd_put_wchar(post_char);
} }
// Draw a menu item with a (potentially) editable value // Draw a menu item with a (potentially) editable value
void MenuEditItemBase::draw(const bool sel, const uint8_t row, PGM_P const pstr, const char * const inStr, const bool pgm) { void MenuEditItemBase::draw(const bool sel, const uint8_t row, FSTR_P const fstr, const char * const inStr, const bool pgm) {
const uint8_t vlen = inStr ? (pgm ? utf8_strlen_P(inStr) : utf8_strlen(inStr)) : 0; const uint8_t vlen = inStr ? (pgm ? utf8_strlen_P(inStr) : utf8_strlen(inStr)) : 0;
lcd_put_wchar(0, row, sel ? LCD_STR_ARROW_RIGHT[0] : ' '); lcd_put_wchar(0, row, sel ? LCD_STR_ARROW_RIGHT[0] : ' ');
uint8_t n = lcd_put_u8str_ind_P(pstr, itemIndex, itemString, LCD_WIDTH - 2 - vlen); uint8_t n = lcd_put_u8str_ind(fstr, itemIndex, itemString, LCD_WIDTH - 2 - vlen);
if (vlen) { if (vlen) {
lcd_put_wchar(':'); lcd_put_wchar(':');
for (; n; --n) lcd_put_wchar(' '); for (; n; --n) lcd_put_wchar(' ');
@ -1102,9 +1102,9 @@ void MarlinUI::draw_status_screen() {
} }
// Low-level draw_edit_screen can be used to draw an edit screen from anyplace // Low-level draw_edit_screen can be used to draw an edit screen from anyplace
void MenuEditItemBase::draw_edit_screen(PGM_P const pstr, const char * const value/*=nullptr*/) { void MenuEditItemBase::draw_edit_screen(FSTR_P const fstr, const char * const value/*=nullptr*/) {
ui.encoder_direction_normal(); ui.encoder_direction_normal();
uint8_t n = lcd_put_u8str_ind_P(0, 1, pstr, itemIndex, itemString, LCD_WIDTH - 1); uint8_t n = lcd_put_u8str_ind(0, 1, fstr, itemIndex, itemString, LCD_WIDTH - 1);
if (value) { if (value) {
lcd_put_wchar(':'); n--; lcd_put_wchar(':'); n--;
const uint8_t len = utf8_strlen(value) + 1; // Plus one for a leading space const uint8_t len = utf8_strlen(value) + 1; // Plus one for a leading space
@ -1115,21 +1115,21 @@ void MarlinUI::draw_status_screen() {
} }
// The Select Screen presents a prompt and two "buttons" // The Select Screen presents a prompt and two "buttons"
void MenuItem_confirm::draw_select_screen(PGM_P const yes, PGM_P const no, const bool yesno, PGM_P const pref, const char * const string/*=nullptr*/, PGM_P const suff/*=nullptr*/) { void MenuItem_confirm::draw_select_screen(FSTR_P const yes, FSTR_P const no, const bool yesno, FSTR_P const pref, const char * const string/*=nullptr*/, FSTR_P const suff/*=nullptr*/) {
ui.draw_select_screen_prompt(pref, string, suff); ui.draw_select_screen_prompt(pref, string, suff);
if (no) { if (no) {
SETCURSOR(0, LCD_HEIGHT - 1); SETCURSOR(0, LCD_HEIGHT - 1);
lcd_put_wchar(yesno ? ' ' : '['); lcd_put_u8str_P(no); lcd_put_wchar(yesno ? ' ' : ']'); lcd_put_wchar(yesno ? ' ' : '['); lcd_put_u8str(no); lcd_put_wchar(yesno ? ' ' : ']');
} }
if (yes) { if (yes) {
SETCURSOR_RJ(utf8_strlen_P(yes) + 2, LCD_HEIGHT - 1); SETCURSOR_RJ(utf8_strlen(yes) + 2, LCD_HEIGHT - 1);
lcd_put_wchar(yesno ? '[' : ' '); lcd_put_u8str_P(yes); lcd_put_wchar(yesno ? ']' : ' '); lcd_put_wchar(yesno ? '[' : ' '); lcd_put_u8str(yes); lcd_put_wchar(yesno ? ']' : ' ');
} }
} }
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
void MenuItem_sdbase::draw(const bool sel, const uint8_t row, PGM_P const, CardReader &theCard, const bool isDir) { void MenuItem_sdbase::draw(const bool sel, const uint8_t row, FSTR_P const, CardReader &theCard, const bool isDir) {
lcd_put_wchar(0, row, sel ? LCD_STR_ARROW_RIGHT[0] : ' '); lcd_put_wchar(0, row, sel ? LCD_STR_ARROW_RIGHT[0] : ' ');
constexpr uint8_t maxlen = LCD_WIDTH - 2; constexpr uint8_t maxlen = LCD_WIDTH - 2;
uint8_t n = maxlen - lcd_put_u8str_max(ui.scrolled_filename(theCard, maxlen, row, sel), maxlen); uint8_t n = maxlen - lcd_put_u8str_max(ui.scrolled_filename(theCard, maxlen, row, sel), maxlen);

49
Marlin/src/lcd/TFTGLCD/marlinui_TFTGLCD.cpp
View file

@ -380,13 +380,10 @@ void MarlinUI::clear_lcd() {
void MarlinUI::_set_contrast() { lcd.setContrast(contrast); } void MarlinUI::_set_contrast() { lcd.setContrast(contrast); }
#endif #endif
static void center_text_P(PGM_P pstart, uint8_t y) { static void center_text(FSTR_P const fstart, const uint8_t y) {
uint8_t len = utf8_strlen_P(pstart); const uint8_t len = utf8_strlen(fstart);
if (len < LCD_WIDTH) lcd.setCursor(len < LCD_WIDTH ? (LCD_WIDTH - len) / 2 : 0, y);
lcd.setCursor((LCD_WIDTH - len) / 2, y); lcd_put_u8str(fstart);
else
lcd.setCursor(0, y);
lcd_put_u8str_P(pstart);
} }
#if ENABLED(SHOW_BOOTSCREEN) #if ENABLED(SHOW_BOOTSCREEN)
@ -402,8 +399,8 @@ static void center_text_P(PGM_P pstart, uint8_t y) {
lcd.setCursor(indent, 0); lcd.write(TLC); lcd_put_u8str(F("------")); lcd.write(TRC); lcd.setCursor(indent, 0); lcd.write(TLC); lcd_put_u8str(F("------")); lcd.write(TRC);
lcd.setCursor(indent, 1); lcd.write(LR); lcd_put_u8str(F("Marlin")); lcd.write(LR); lcd.setCursor(indent, 1); lcd.write(LR); lcd_put_u8str(F("Marlin")); lcd.write(LR);
lcd.setCursor(indent, 2); lcd.write(BLC); lcd_put_u8str(F("------")); lcd.write(BRC); lcd.setCursor(indent, 2); lcd.write(BLC); lcd_put_u8str(F("------")); lcd.write(BRC);
center_text_P(PSTR(SHORT_BUILD_VERSION), 3); center_text(F(SHORT_BUILD_VERSION), 3);
center_text_P(PSTR(MARLIN_WEBSITE_URL), 4); center_text(F(MARLIN_WEBSITE_URL), 4);
picBits = ICON_LOGO; picBits = ICON_LOGO;
lcd.print_screen(); lcd.print_screen();
} }
@ -420,8 +417,8 @@ void MarlinUI::draw_kill_screen() {
lcd.setCursor(0, 3); lcd.write(COLOR_ERROR); lcd.setCursor(0, 3); lcd.write(COLOR_ERROR);
lcd.setCursor((LCD_WIDTH - utf8_strlen(status_message)) / 2 + 1, 3); lcd.setCursor((LCD_WIDTH - utf8_strlen(status_message)) / 2 + 1, 3);
lcd_put_u8str(status_message); lcd_put_u8str(status_message);
center_text_P(GET_TEXT(MSG_HALTED), 5); center_text(GET_TEXT_F(MSG_HALTED), 5);
center_text_P(GET_TEXT(MSG_PLEASE_RESET), 6); center_text(GET_TEXT_F(MSG_PLEASE_RESET), 6);
lcd.print_screen(); lcd.print_screen();
} }
@ -940,38 +937,38 @@ void MarlinUI::draw_status_screen() {
#endif #endif
// Draw a static item with no left-right margin required. Centered by default. // Draw a static item with no left-right margin required. Centered by default.
void MenuItem_static::draw(const uint8_t row, PGM_P const pstr, const uint8_t style/*=SS_DEFAULT*/, const char * const valstr/*=nullptr*/) { void MenuItem_static::draw(const uint8_t row, FSTR_P const fstr, const uint8_t style/*=SS_DEFAULT*/, const char * const valstr/*=nullptr*/) {
if (!PanelDetected) return; if (!PanelDetected) return;
uint8_t n = LCD_WIDTH; uint8_t n = LCD_WIDTH;
lcd.setCursor(0, row); lcd.setCursor(0, row);
if ((style & SS_CENTER) && !valstr) { if ((style & SS_CENTER) && !valstr) {
int8_t pad = (LCD_WIDTH - utf8_strlen_P(pstr)) / 2; int8_t pad = (LCD_WIDTH - utf8_strlen(fstr)) / 2;
while (--pad >= 0) { lcd.write(' '); n--; } while (--pad >= 0) { lcd.write(' '); n--; }
} }
n = lcd_put_u8str_ind_P(pstr, itemIndex, itemString, n); n = lcd_put_u8str_ind(fstr, itemIndex, itemString, n);
if (valstr) n -= lcd_put_u8str_max(valstr, n); if (valstr) n -= lcd_put_u8str_max(valstr, n);
for (; n; --n) lcd.write(' '); for (; n; --n) lcd.write(' ');
lcd.print_line(); lcd.print_line();
} }
// Draw a generic menu item with pre_char (if selected) and post_char // Draw a generic menu item with pre_char (if selected) and post_char
void MenuItemBase::_draw(const bool sel, const uint8_t row, PGM_P const pstr, const char pre_char, const char post_char) { void MenuItemBase::_draw(const bool sel, const uint8_t row, FSTR_P const fstr, const char pre_char, const char post_char) {
if (!PanelDetected) return; if (!PanelDetected) return;
lcd.setCursor(0, row); lcd.setCursor(0, row);
lcd.write(sel ? pre_char : ' '); lcd.write(sel ? pre_char : ' ');
uint8_t n = lcd_put_u8str_ind_P(pstr, itemIndex, itemString, LCD_WIDTH - 2); uint8_t n = lcd_put_u8str_ind(fstr, itemIndex, itemString, LCD_WIDTH - 2);
for (; n; --n) lcd.write(' '); for (; n; --n) lcd.write(' ');
lcd.write(post_char); lcd.write(post_char);
lcd.print_line(); lcd.print_line();
} }
// Draw a menu item with a (potentially) editable value // Draw a menu item with a (potentially) editable value
void MenuEditItemBase::draw(const bool sel, const uint8_t row, PGM_P const pstr, const char * const data, const bool pgm) { void MenuEditItemBase::draw(const bool sel, const uint8_t row, FSTR_P const fstr, const char * const data, const bool pgm) {
if (!PanelDetected) return; if (!PanelDetected) return;
const uint8_t vlen = data ? (pgm ? utf8_strlen_P(data) : utf8_strlen(data)) : 0; const uint8_t vlen = data ? (pgm ? utf8_strlen_P(data) : utf8_strlen(data)) : 0;
lcd.setCursor(0, row); lcd.setCursor(0, row);
lcd.write(sel ? LCD_STR_ARROW_RIGHT[0] : ' '); lcd.write(sel ? LCD_STR_ARROW_RIGHT[0] : ' ');
uint8_t n = lcd_put_u8str_ind_P(pstr, itemIndex, itemString, LCD_WIDTH - 2 - vlen); uint8_t n = lcd_put_u8str_ind(fstr, itemIndex, itemString, LCD_WIDTH - 2 - vlen);
if (vlen) { if (vlen) {
lcd.write(':'); lcd.write(':');
for (; n; --n) lcd.write(' '); for (; n; --n) lcd.write(' ');
@ -982,13 +979,13 @@ void MarlinUI::draw_status_screen() {
// Low-level draw_edit_screen can be used to draw an edit screen from anyplace // Low-level draw_edit_screen can be used to draw an edit screen from anyplace
// This line moves to the last line of the screen for UBL plot screen on the panel side // This line moves to the last line of the screen for UBL plot screen on the panel side
void MenuEditItemBase::draw_edit_screen(PGM_P const pstr, const char * const value/*=nullptr*/) { void MenuEditItemBase::draw_edit_screen(FSTR_P const fstr, const char * const value/*=nullptr*/) {
if (!PanelDetected) return; if (!PanelDetected) return;
ui.encoder_direction_normal(); ui.encoder_direction_normal();
const uint8_t y = TERN0(AUTO_BED_LEVELING_UBL, ui.external_control) ? LCD_HEIGHT - 1 : MIDDLE_Y; const uint8_t y = TERN0(AUTO_BED_LEVELING_UBL, ui.external_control) ? LCD_HEIGHT - 1 : MIDDLE_Y;
lcd.setCursor(0, y); lcd.setCursor(0, y);
lcd.write(COLOR_EDIT); lcd.write(COLOR_EDIT);
lcd_put_u8str_P(pstr); lcd_put_u8str(fstr);
if (value) { if (value) {
lcd.write(':'); lcd.write(':');
lcd.setCursor((LCD_WIDTH - 1) - (utf8_strlen(value) + 1), y); // Right-justified, padded by spaces lcd.setCursor((LCD_WIDTH - 1) - (utf8_strlen(value) + 1), y); // Right-justified, padded by spaces
@ -1000,24 +997,24 @@ void MarlinUI::draw_status_screen() {
} }
// The Select Screen presents a prompt and two "buttons" // The Select Screen presents a prompt and two "buttons"
void MenuItem_confirm::draw_select_screen(PGM_P const yes, PGM_P const no, const bool yesno, PGM_P const pref, const char * const string, PGM_P const suff) { void MenuItem_confirm::draw_select_screen(FSTR_P const yes, FSTR_P const no, const bool yesno, FSTR_P const pref, const char * const string, FSTR_P const suff) {
if (!PanelDetected) return; if (!PanelDetected) return;
ui.draw_select_screen_prompt(pref, string, suff); ui.draw_select_screen_prompt(pref, string, suff);
lcd.write(COLOR_EDIT); lcd.write(COLOR_EDIT);
if (no) { if (no) {
lcd.setCursor(0, MIDDLE_Y); lcd.setCursor(0, MIDDLE_Y);
lcd.write(yesno ? ' ' : '['); lcd_put_u8str_P(no); lcd.write(yesno ? ' ' : ']'); lcd.write(yesno ? ' ' : '['); lcd_put_u8str(no); lcd.write(yesno ? ' ' : ']');
} }
if (yes) { if (yes) {
lcd.setCursor(LCD_WIDTH - utf8_strlen_P(yes) - 3, MIDDLE_Y); lcd.setCursor(LCD_WIDTH - utf8_strlen(yes) - 3, MIDDLE_Y);
lcd.write(yesno ? '[' : ' '); lcd_put_u8str_P(yes); lcd.write(yesno ? ']' : ' '); lcd.write(yesno ? '[' : ' '); lcd_put_u8str(yes); lcd.write(yesno ? ']' : ' ');
} }
lcd.print_line(); lcd.print_line();
} }
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
void MenuItem_sdbase::draw(const bool sel, const uint8_t row, PGM_P const, CardReader &theCard, const bool isDir) { void MenuItem_sdbase::draw(const bool sel, const uint8_t row, FSTR_P const, CardReader &theCard, const bool isDir) {
if (!PanelDetected) return; if (!PanelDetected) return;
lcd.setCursor(0, row); lcd.setCursor(0, row);
lcd.write(sel ? LCD_STR_ARROW_RIGHT[0] : ' '); lcd.write(sel ? LCD_STR_ARROW_RIGHT[0] : ' ');
@ -1081,7 +1078,7 @@ void MarlinUI::draw_status_screen() {
else else
lcd_put_u8str(F(" -----")); lcd_put_u8str(F(" -----"));
center_text_P(GET_TEXT(MSG_UBL_FINE_TUNE_MESH), 8); center_text(GET_TEXT_F(MSG_UBL_FINE_TUNE_MESH), 8);
lcd.print_screen(); lcd.print_screen();
} }

32
Marlin/src/lcd/dogm/marlinui_DOGM.cpp
View file

@ -412,28 +412,28 @@ void MarlinUI::clear_lcd() { } // Automatically cleared by Picture Loop
} }
// Draw a static line of text in the same idiom as a menu item // Draw a static line of text in the same idiom as a menu item
void MenuItem_static::draw(const uint8_t row, PGM_P const pstr, const uint8_t style/*=SS_DEFAULT*/, const char * const vstr/*=nullptr*/) { void MenuItem_static::draw(const uint8_t row, FSTR_P const fstr, const uint8_t style/*=SS_DEFAULT*/, const char * const vstr/*=nullptr*/) {
if (mark_as_selected(row, style & SS_INVERT)) { if (mark_as_selected(row, style & SS_INVERT)) {
pixel_len_t n = LCD_PIXEL_WIDTH; // pixel width of string allowed pixel_len_t n = LCD_PIXEL_WIDTH; // pixel width of string allowed
const int plen = pstr ? calculateWidth(pstr) : 0, const int plen = fstr ? calculateWidth(FTOP(fstr)) : 0,
vlen = vstr ? utf8_strlen(vstr) : 0; vlen = vstr ? utf8_strlen(vstr) : 0;
if (style & SS_CENTER) { if (style & SS_CENTER) {
int pad = (LCD_PIXEL_WIDTH - plen - vlen * MENU_FONT_WIDTH) / MENU_FONT_WIDTH / 2; int pad = (LCD_PIXEL_WIDTH - plen - vlen * MENU_FONT_WIDTH) / MENU_FONT_WIDTH / 2;
while (--pad >= 0) n -= lcd_put_wchar(' '); while (--pad >= 0) n -= lcd_put_wchar(' ');
} }
if (plen) n = lcd_put_u8str_ind_P(pstr, itemIndex, itemString, n / (MENU_FONT_WIDTH)) * (MENU_FONT_WIDTH); if (plen) n = lcd_put_u8str_ind(fstr, itemIndex, itemString, n / (MENU_FONT_WIDTH)) * (MENU_FONT_WIDTH);
if (vlen) n -= lcd_put_u8str_max(vstr, n); if (vlen) n -= lcd_put_u8str_max(vstr, n);
while (n > MENU_FONT_WIDTH) n -= lcd_put_wchar(' '); while (n > MENU_FONT_WIDTH) n -= lcd_put_wchar(' ');
} }
} }
// Draw a generic menu item // Draw a generic menu item
void MenuItemBase::_draw(const bool sel, const uint8_t row, PGM_P const pstr, const char, const char post_char) { void MenuItemBase::_draw(const bool sel, const uint8_t row, FSTR_P const fstr, const char, const char post_char) {
if (mark_as_selected(row, sel)) { if (mark_as_selected(row, sel)) {
pixel_len_t n = lcd_put_u8str_ind_P(pstr, itemIndex, itemString, LCD_WIDTH - 1) * (MENU_FONT_WIDTH); pixel_len_t n = lcd_put_u8str_ind(fstr, itemIndex, itemString, LCD_WIDTH - 1) * (MENU_FONT_WIDTH);
while (n > MENU_FONT_WIDTH) n -= lcd_put_wchar(' '); while (n > MENU_FONT_WIDTH) n -= lcd_put_wchar(' ');
lcd_put_wchar(LCD_PIXEL_WIDTH - (MENU_FONT_WIDTH), row_y2, post_char); lcd_put_wchar(LCD_PIXEL_WIDTH - (MENU_FONT_WIDTH), row_y2, post_char);
lcd_put_wchar(' '); lcd_put_wchar(' ');
@ -441,13 +441,13 @@ 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 MenuEditItemBase::draw(const bool sel, const uint8_t row, PGM_P const pstr, const char * const inStr, const bool pgm) { void MenuEditItemBase::draw(const bool sel, const uint8_t row, FSTR_P const fstr, const char * const inStr, const bool pgm) {
if (mark_as_selected(row, sel)) { if (mark_as_selected(row, sel)) {
const uint8_t vallen = (pgm ? utf8_strlen_P(inStr) : utf8_strlen((char*)inStr)), const uint8_t vallen = (pgm ? utf8_strlen_P(inStr) : utf8_strlen((char*)inStr)),
pixelwidth = (pgm ? uxg_GetUtf8StrPixelWidthP(u8g.getU8g(), inStr) : uxg_GetUtf8StrPixelWidth(u8g.getU8g(), (char*)inStr)); pixelwidth = (pgm ? uxg_GetUtf8StrPixelWidthP(u8g.getU8g(), inStr) : uxg_GetUtf8StrPixelWidth(u8g.getU8g(), (char*)inStr));
const u8g_uint_t prop = USE_WIDE_GLYPH ? 2 : 1; const u8g_uint_t prop = USE_WIDE_GLYPH ? 2 : 1;
pixel_len_t n = lcd_put_u8str_ind_P(pstr, itemIndex, itemString, LCD_WIDTH - 2 - vallen * prop) * (MENU_FONT_WIDTH); pixel_len_t n = lcd_put_u8str_ind(fstr, itemIndex, itemString, LCD_WIDTH - 2 - vallen * prop) * (MENU_FONT_WIDTH);
if (vallen) { if (vallen) {
lcd_put_wchar(':'); lcd_put_wchar(':');
while (n > MENU_FONT_WIDTH) n -= lcd_put_wchar(' '); while (n > MENU_FONT_WIDTH) n -= lcd_put_wchar(' ');
@ -457,11 +457,11 @@ void MarlinUI::clear_lcd() { } // Automatically cleared by Picture Loop
} }
} }
void MenuEditItemBase::draw_edit_screen(PGM_P const pstr, const char * const value/*=nullptr*/) { void MenuEditItemBase::draw_edit_screen(FSTR_P const fstr, const char * const value/*=nullptr*/) {
ui.encoder_direction_normal(); ui.encoder_direction_normal();
const u8g_uint_t prop = USE_WIDE_GLYPH ? 2 : 1; const u8g_uint_t prop = USE_WIDE_GLYPH ? 2 : 1;
const u8g_uint_t labellen = utf8_strlen_P(pstr), vallen = utf8_strlen(value); const u8g_uint_t labellen = utf8_strlen(fstr), vallen = utf8_strlen(value);
bool extra_row = labellen * prop > LCD_WIDTH - 2 - vallen * prop; bool extra_row = labellen * prop > LCD_WIDTH - 2 - vallen * prop;
#if ENABLED(USE_BIG_EDIT_FONT) #if ENABLED(USE_BIG_EDIT_FONT)
@ -490,7 +490,7 @@ void MarlinUI::clear_lcd() { } // Automatically cleared by Picture Loop
// Assume the label is alpha-numeric (with a descender) // Assume the label is alpha-numeric (with a descender)
bool onpage = PAGE_CONTAINS(baseline - (EDIT_FONT_ASCENT - 1), baseline + EDIT_FONT_DESCENT); bool onpage = PAGE_CONTAINS(baseline - (EDIT_FONT_ASCENT - 1), baseline + EDIT_FONT_DESCENT);
if (onpage) lcd_put_u8str_ind_P(0, baseline, pstr, itemIndex, itemString); if (onpage) lcd_put_u8str_ind(0, baseline, fstr, itemIndex, itemString);
// If a value is included, print a colon, then print the value right-justified // If a value is included, print a colon, then print the value right-justified
if (value) { if (value) {
@ -508,8 +508,8 @@ void MarlinUI::clear_lcd() { } // Automatically cleared by Picture Loop
TERN_(USE_BIG_EDIT_FONT, ui.set_font(FONT_MENU)); TERN_(USE_BIG_EDIT_FONT, ui.set_font(FONT_MENU));
} }
inline void draw_boxed_string(const u8g_uint_t x, const u8g_uint_t y, PGM_P const pstr, const bool inv) { inline void draw_boxed_string(const u8g_uint_t x, const u8g_uint_t y, FSTR_P const fstr, const bool inv) {
const u8g_uint_t len = utf8_strlen_P(pstr), const u8g_uint_t len = utf8_strlen(fstr),
by = (y + 1) * (MENU_FONT_HEIGHT); by = (y + 1) * (MENU_FONT_HEIGHT);
const u8g_uint_t prop = USE_WIDE_GLYPH ? 2 : 1; const u8g_uint_t prop = USE_WIDE_GLYPH ? 2 : 1;
const pixel_len_t bw = len * prop * (MENU_FONT_WIDTH), bx = x * prop * (MENU_FONT_WIDTH); const pixel_len_t bw = len * prop * (MENU_FONT_WIDTH), bx = x * prop * (MENU_FONT_WIDTH);
@ -518,19 +518,19 @@ void MarlinUI::clear_lcd() { } // Automatically cleared by Picture Loop
u8g.drawBox(bx / prop - 1, by - (MENU_FONT_ASCENT), bw + 2, MENU_FONT_HEIGHT); u8g.drawBox(bx / prop - 1, by - (MENU_FONT_ASCENT), bw + 2, MENU_FONT_HEIGHT);
u8g.setColorIndex(0); u8g.setColorIndex(0);
} }
lcd_put_u8str_P(bx / prop, by, pstr); lcd_put_u8str(bx / prop, by, fstr);
if (inv) u8g.setColorIndex(1); if (inv) u8g.setColorIndex(1);
} }
void MenuItem_confirm::draw_select_screen(PGM_P const yes, PGM_P const no, const bool yesno, PGM_P const pref, const char * const string/*=nullptr*/, PGM_P const suff/*=nullptr*/) { void MenuItem_confirm::draw_select_screen(FSTR_P const yes, FSTR_P const no, const bool yesno, FSTR_P const pref, const char * const string/*=nullptr*/, FSTR_P const suff/*=nullptr*/) {
ui.draw_select_screen_prompt(pref, string, suff); ui.draw_select_screen_prompt(pref, string, suff);
if (no) draw_boxed_string(1, LCD_HEIGHT - 1, no, !yesno); if (no) draw_boxed_string(1, LCD_HEIGHT - 1, no, !yesno);
if (yes) draw_boxed_string(LCD_WIDTH - (utf8_strlen_P(yes) * (USE_WIDE_GLYPH ? 2 : 1) + 1), LCD_HEIGHT - 1, yes, yesno); if (yes) draw_boxed_string(LCD_WIDTH - (utf8_strlen(yes) * (USE_WIDE_GLYPH ? 2 : 1) + 1), LCD_HEIGHT - 1, yes, yesno);
} }
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
void MenuItem_sdbase::draw(const bool sel, const uint8_t row, PGM_P const, CardReader &theCard, const bool isDir) { void MenuItem_sdbase::draw(const bool sel, const uint8_t row, FSTR_P const, CardReader &theCard, const bool isDir) {
if (mark_as_selected(row, sel)) { if (mark_as_selected(row, sel)) {
const uint8_t maxlen = LCD_WIDTH - isDir; const uint8_t maxlen = LCD_WIDTH - isDir;
if (isDir) lcd_put_wchar(LCD_STR_FOLDER[0]); if (isDir) lcd_put_wchar(LCD_STR_FOLDER[0]);

12
Marlin/src/lcd/dogm/u8g_dev_tft_upscale_from_128x64.cpp
View file

@ -517,14 +517,14 @@ U8G_PB_DEV(u8g_dev_tft_320x240_upscale_from_128x64, WIDTH, HEIGHT, PAGE_HEIGHT,
drawCross(x, y, TFT_MARLINBG_COLOR); drawCross(x, y, TFT_MARLINBG_COLOR);
} }
const char *str = nullptr; FSTR_P str = nullptr;
if (calibration_stage < CALIBRATION_SUCCESS) { if (calibration_stage < CALIBRATION_SUCCESS) {
// handle current state // handle current state
switch (calibration_stage) { switch (calibration_stage) {
case CALIBRATION_TOP_LEFT: str = GET_TEXT(MSG_TOP_LEFT); break; case CALIBRATION_TOP_LEFT: str = GET_TEXT_F(MSG_TOP_LEFT); break;
case CALIBRATION_BOTTOM_LEFT: str = GET_TEXT(MSG_BOTTOM_LEFT); break; case CALIBRATION_BOTTOM_LEFT: str = GET_TEXT_F(MSG_BOTTOM_LEFT); break;
case CALIBRATION_TOP_RIGHT: str = GET_TEXT(MSG_TOP_RIGHT); break; case CALIBRATION_TOP_RIGHT: str = GET_TEXT_F(MSG_TOP_RIGHT); break;
case CALIBRATION_BOTTOM_RIGHT: str = GET_TEXT(MSG_BOTTOM_RIGHT); break; case CALIBRATION_BOTTOM_RIGHT: str = GET_TEXT_F(MSG_BOTTOM_RIGHT); break;
default: break; default: break;
} }
@ -534,7 +534,7 @@ U8G_PB_DEV(u8g_dev_tft_320x240_upscale_from_128x64, WIDTH, HEIGHT, PAGE_HEIGHT,
} }
else { else {
// end calibration // end calibration
str = calibration_stage == CALIBRATION_SUCCESS ? GET_TEXT(MSG_CALIBRATION_COMPLETED) : GET_TEXT(MSG_CALIBRATION_FAILED); str = calibration_stage == CALIBRATION_SUCCESS ? GET_TEXT_F(MSG_CALIBRATION_COMPLETED) : GET_TEXT_F(MSG_CALIBRATION_FAILED);
defer_status_screen(false); defer_status_screen(false);
touch_calibration.calibration_end(); touch_calibration.calibration_end();
TERN_(HAS_TOUCH_BUTTONS, redrawTouchButtons = true); TERN_(HAS_TOUCH_BUTTONS, redrawTouchButtons = true);

2
Marlin/src/lcd/e3v2/common/dwin_api.h
View file

@ -74,7 +74,7 @@ inline void DWIN_Text(size_t &i, const char * const string, uint16_t rlimit=0xFF
inline void DWIN_Text(size_t &i, FSTR_P string, uint16_t rlimit=0xFFFF) { inline void DWIN_Text(size_t &i, FSTR_P string, uint16_t rlimit=0xFFFF) {
if (!string) return; if (!string) return;
const size_t len = _MIN(sizeof(DWIN_SendBuf) - i, _MIN(rlimit, strlen_P((PGM_P)string))); // cast to PGM_P (const char*) measure with strlen_P. const size_t len = _MIN(sizeof(DWIN_SendBuf) - i, _MIN(rlimit, strlen_P(FTOP(string))));
if (len == 0) return; if (len == 0) return;
memcpy_P(&DWIN_SendBuf[i+1], string, len); memcpy_P(&DWIN_SendBuf[i+1], string, len);
i += len; i += len;

4
Marlin/src/lcd/e3v2/jyersui/dwin.cpp
View file

@ -2944,7 +2944,7 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/
break; break;
case LEVELING_VIEW: case LEVELING_VIEW:
if (draw) if (draw)
Draw_Menu_Item(row, ICON_Mesh, GET_TEXT(MSG_MESH_VIEW), nullptr, true); Draw_Menu_Item(row, ICON_Mesh, GET_TEXT_F(MSG_MESH_VIEW), nullptr, true);
else { else {
#if ENABLED(AUTO_BED_LEVELING_UBL) #if ENABLED(AUTO_BED_LEVELING_UBL)
if (bedlevel.storage_slot < 0) { if (bedlevel.storage_slot < 0) {
@ -3017,7 +3017,7 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/
break; break;
case LEVELING_VIEW_MESH: case LEVELING_VIEW_MESH:
if (draw) if (draw)
Draw_Menu_Item(row, ICON_PrintSize, GET_TEXT(MSG_MESH_VIEW), nullptr, true); Draw_Menu_Item(row, ICON_PrintSize, GET_TEXT_F(MSG_MESH_VIEW), nullptr, true);
else else
Draw_Menu(MeshViewer); Draw_Menu(MeshViewer);
break; break;

8
Marlin/src/lcd/e3v2/marlinui/dwin_string.cpp
View file

@ -43,13 +43,13 @@ uint8_t read_byte(uint8_t *byte) { return *byte; }
/** /**
* Add a string, applying substitutions for the following characters: * Add a string, applying substitutions for the following characters:
* *
* $ displays the clipped C-string given by the itemString argument * $ displays the clipped C-string given by the inStr argument
* = displays '0'....'10' for indexes 0 - 10 * = displays '0'....'10' for indexes 0 - 10
* ~ displays '1'....'11' for indexes 0 - 10 * ~ displays '1'....'11' for indexes 0 - 10
* * displays 'E1'...'E11' for indexes 0 - 10 (By default. Uses LCD_FIRST_TOOL) * * displays 'E1'...'E11' for indexes 0 - 10 (By default. Uses LCD_FIRST_TOOL)
* @ displays an axis name such as XYZUVW, or E for an extruder * @ displays an axis name such as XYZUVW, or E for an extruder
*/ */
void DWIN_String::add(uint8_t *string, const int8_t index, uint8_t *itemString/*=nullptr*/) { void DWIN_String::add(uint8_t *string, const int8_t index, uint8_t *inStr/*=nullptr*/) {
wchar_t wchar; wchar_t wchar;
while (*string) { while (*string) {
@ -67,8 +67,8 @@ void DWIN_String::add(uint8_t *string, const int8_t index, uint8_t *itemString/*
else else
add(index == -2 ? GET_TEXT(MSG_CHAMBER) : GET_TEXT(MSG_BED)); add(index == -2 ? GET_TEXT(MSG_CHAMBER) : GET_TEXT(MSG_BED));
} }
else if (ch == '$' && itemString) else if (ch == '$' && inStr)
add(itemString); add(inStr);
else if (ch == '@') else if (ch == '@')
add_character(axis_codes[index]); add_character(axis_codes[index]);
else else

13
Marlin/src/lcd/e3v2/marlinui/dwin_string.h
View file

@ -61,15 +61,20 @@ class DWIN_String {
//static void add(uint8_t character) { add_character(character); eol(); } //static void add(uint8_t character) { add_character(character); eol(); }
static void add(wchar_t character); static void add(wchar_t character);
static void add(uint8_t *string, uint8_t max_len=MAX_STRING_LENGTH); static void add(uint8_t *string, uint8_t max_len=MAX_STRING_LENGTH);
static void add(uint8_t *string, const int8_t index, uint8_t *itemString=nullptr); static void add(uint8_t *string, const int8_t index, uint8_t *inStr=nullptr);
static void set(uint8_t *string) { set(); add(string); } static void set(uint8_t *string) { set(); add(string); }
static void set(wchar_t character) { set(); add(character); } static void set(wchar_t character) { set(); add(character); }
static void set(uint8_t *string, int8_t index, const char *itemString=nullptr) { set(); add(string, index, (uint8_t *)itemString); } static void set(uint8_t *string, int8_t index, const char *inStr=nullptr) { set(); add(string, index, (uint8_t *)inStr); }
static void set(FSTR_P fstring) { set((uint8_t *)fstring); }
static void set(const char *string) { set((uint8_t *)string); } static void set(const char *string) { set((uint8_t *)string); }
static void set(const char *string, int8_t index, const char *itemString=nullptr) { set((uint8_t *)string, index, itemString); } static void set(const char *string, int8_t index, const char *inStr=nullptr) { set((uint8_t *)string, index, inStr); }
static void add(const char *string) { add((uint8_t *)string); } static void add(const char *string) { add((uint8_t *)string); }
static void add(FSTR_P const string, uint8_t max_len=MAX_STRING_LENGTH) { add((uint8_t *)FTOP(string), max_len); }
static void add(FSTR_P const string, int8_t index, uint8_t *inStr=nullptr) { add((uint8_t *)FTOP(string), index, inStr); }
static void set(FSTR_P const string) { set((uint8_t *)FTOP(string)); }
static void set(FSTR_P const string, int8_t index, const char *inStr=nullptr) { set((uint8_t *)FTOP(string), index, inStr); }
static void add(FSTR_P const string) { add((uint8_t *)FTOP(string)); }
static void trim(const uint8_t character=0x20); static void trim(const uint8_t character=0x20);
static void rtrim(const uint8_t character=0x20); static void rtrim(const uint8_t character=0x20);
static void ltrim(const uint8_t character=0x20); static void ltrim(const uint8_t character=0x20);

36
Marlin/src/lcd/e3v2/marlinui/ui_common.cpp
View file

@ -311,7 +311,7 @@ void MarlinUI::draw_status_message(const bool blink) {
// Draw a static line of text in the same idiom as a menu item // Draw a static line of text in the same idiom as a menu item
void MenuItem_static::draw(const uint8_t row, PGM_P const pstr, const uint8_t style/*=SS_DEFAULT*/, const char * const vstr/*=nullptr*/) { void MenuItem_static::draw(const uint8_t row, FSTR_P const fstr, const uint8_t style/*=SS_DEFAULT*/, const char * const vstr/*=nullptr*/) {
// Call mark_as_selected to draw a bigger selection box // Call mark_as_selected to draw a bigger selection box
// and draw the text without a background // and draw the text without a background
if (mark_as_selected(row, (bool)(style & SS_INVERT), true)) { if (mark_as_selected(row, (bool)(style & SS_INVERT), true)) {
@ -320,14 +320,14 @@ void MarlinUI::draw_status_message(const bool blink) {
dwin_font.fg = Color_White; dwin_font.fg = Color_White;
dwin_string.set(); dwin_string.set();
const int8_t plen = pstr ? utf8_strlen_P(pstr) : 0, const int8_t plen = fstr ? utf8_strlen(fstr) : 0,
vlen = vstr ? utf8_strlen(vstr) : 0; vlen = vstr ? utf8_strlen(vstr) : 0;
if (style & SS_CENTER) { if (style & SS_CENTER) {
int8_t pad = (LCD_WIDTH - 1 - plen - vlen) / 2; int8_t pad = (LCD_WIDTH - 1 - plen - vlen) / 2;
while (--pad) dwin_string.add(' '); while (--pad) dwin_string.add(' ');
} }
if (plen) dwin_string.add((uint8_t*)pstr, itemIndex, (uint8_t*)itemString); if (plen) dwin_string.add((uint8_t*)FTOP(fstr), itemIndex, (uint8_t*)FTOP(itemString));
if (vlen) dwin_string.add((uint8_t*)vstr); if (vlen) dwin_string.add((uint8_t*)vstr);
if (style & SS_CENTER) { if (style & SS_CENTER) {
int8_t pad = (LCD_WIDTH - 1 - plen - vlen) / 2; int8_t pad = (LCD_WIDTH - 1 - plen - vlen) / 2;
@ -340,13 +340,13 @@ void MarlinUI::draw_status_message(const bool blink) {
} }
// Draw a generic menu item // Draw a generic menu item
void MenuItemBase::_draw(const bool sel, const uint8_t row, PGM_P const pstr, const char, const char post_char) { void MenuItemBase::_draw(const bool sel, const uint8_t row, FSTR_P const fstr, const char, const char post_char) {
if (mark_as_selected(row, sel)) { if (mark_as_selected(row, sel)) {
ui.set_font(DWIN_FONT_MENU); ui.set_font(DWIN_FONT_MENU);
dwin_font.solid = false; dwin_font.solid = false;
dwin_font.fg = Color_White; dwin_font.fg = Color_White;
dwin_string.set(pstr, itemIndex, itemString); dwin_string.set(fstr, itemIndex, FTOP(itemString));
pixel_len_t n = LCD_WIDTH - 1 - dwin_string.length(); pixel_len_t n = LCD_WIDTH - 1 - dwin_string.length();
while (--n > 1) dwin_string.add(' '); while (--n > 1) dwin_string.add(' ');
@ -361,15 +361,15 @@ void MarlinUI::draw_status_message(const bool blink) {
// //
// Draw a menu item with an editable value // Draw a menu item with an editable value
// //
void MenuEditItemBase::draw(const bool sel, const uint8_t row, PGM_P const pstr, const char* const data, const bool pgm) { void MenuEditItemBase::draw(const bool sel, const uint8_t row, FSTR_P const fstr, const char * const inStr, const bool pgm) {
if (mark_as_selected(row, sel)) { if (mark_as_selected(row, sel)) {
ui.set_font(DWIN_FONT_MENU); ui.set_font(DWIN_FONT_MENU);
dwin_font.solid = false; dwin_font.solid = false;
dwin_font.fg = Color_White; dwin_font.fg = Color_White;
const uint8_t vallen = (pgm ? utf8_strlen_P(data) : utf8_strlen(S(data))); const uint8_t vallen = (pgm ? utf8_strlen_P(inStr) : utf8_strlen(S(inStr)));
dwin_string.set(pstr, itemIndex, itemString); dwin_string.set(fstr, itemIndex, FTOP(itemString));
if (vallen) dwin_string.add(':'); if (vallen) dwin_string.add(':');
lcd_moveto(1, row); lcd_moveto(1, row);
@ -377,7 +377,7 @@ void MarlinUI::draw_status_message(const bool blink) {
if (vallen) { if (vallen) {
dwin_font.fg = Color_Yellow; dwin_font.fg = Color_Yellow;
dwin_string.set(data); dwin_string.set(inStr);
lcd_moveto(LCD_WIDTH - vallen - 1, row); lcd_moveto(LCD_WIDTH - vallen - 1, row);
lcd_put_dwin_string(); lcd_put_dwin_string();
} }
@ -387,13 +387,13 @@ void MarlinUI::draw_status_message(const bool blink) {
// //
// Draw an edit screen with label and current value // Draw an edit screen with label and current value
// //
void MenuEditItemBase::draw_edit_screen(PGM_P const pstr, const char* const value/*=nullptr*/) { void MenuEditItemBase::draw_edit_screen(FSTR_P const fstr, const char* const value/*=nullptr*/) {
ui.encoder_direction_normal(); ui.encoder_direction_normal();
const dwin_coord_t labellen = utf8_strlen_P(pstr), vallen = utf8_strlen(value); const dwin_coord_t labellen = utf8_strlen(fstr), vallen = utf8_strlen(value);
dwin_string.set(); dwin_string.set();
dwin_string.add((uint8_t*)pstr, itemIndex); dwin_string.add((uint8_t*)FTOP(fstr), itemIndex);
if (vallen) dwin_string.add(':'); // If a value is included, add a colon if (vallen) dwin_string.add(':'); // If a value is included, add a colon
// Assume the label is alpha-numeric (with a descender) // Assume the label is alpha-numeric (with a descender)
@ -430,19 +430,19 @@ void MarlinUI::draw_status_message(const bool blink) {
} }
} }
inline void draw_boxed_string(const bool yesopt, PGM_P const pstr, const bool inv) { inline void draw_boxed_string(const bool yesopt, FSTR_P const fstr, const bool inv) {
const uint8_t len = utf8_strlen_P(pstr), const uint8_t len = utf8_strlen(fstr),
mar = TERN(DWIN_MARLINUI_PORTRAIT, 1, 4), mar = TERN(DWIN_MARLINUI_PORTRAIT, 1, 4),
col = yesopt ? LCD_WIDTH - mar - len : mar, col = yesopt ? LCD_WIDTH - mar - len : mar,
row = (LCD_HEIGHT >= 8 ? LCD_HEIGHT / 2 + 3 : LCD_HEIGHT - 1); row = (LCD_HEIGHT >= 8 ? LCD_HEIGHT / 2 + 3 : LCD_HEIGHT - 1);
lcd_moveto(col, row); lcd_moveto(col, row);
DWIN_Draw_Box(1, inv ? Select_Color : Color_Bg_Black, cursor.x - dwin_font.width, cursor.y + 1, dwin_font.width * (len + 2), dwin_font.height + 2); DWIN_Draw_Box(1, inv ? Select_Color : Color_Bg_Black, cursor.x - dwin_font.width, cursor.y + 1, dwin_font.width * (len + 2), dwin_font.height + 2);
lcd_put_u8str_P(col, row, pstr); lcd_put_u8str(col, row, fstr);
} }
void MenuItem_confirm::draw_select_screen( void MenuItem_confirm::draw_select_screen(
PGM_P const yes, PGM_P const no, const bool yesno, FSTR_P const yes, FSTR_P const no, const bool yesno,
PGM_P const pref, const char * const string/*=nullptr*/, PGM_P const suff/*=nullptr*/ FSTR_P const pref, const char * const string/*=nullptr*/, FSTR_P const suff/*=nullptr*/
) { ) {
ui.set_font(DWIN_FONT_MENU); ui.set_font(DWIN_FONT_MENU);
dwin_font.solid = false; dwin_font.solid = false;
@ -454,7 +454,7 @@ void MarlinUI::draw_status_message(const bool blink) {
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
void MenuItem_sdbase::draw(const bool sel, const uint8_t row, PGM_P const, CardReader &theCard, const bool isDir) { void MenuItem_sdbase::draw(const bool sel, const uint8_t row, FSTR_P const, CardReader &theCard, const bool isDir) {
if (mark_as_selected(row, sel)) { if (mark_as_selected(row, sel)) {
dwin_string.set(); dwin_string.set();

2
Marlin/src/lcd/extui/ftdi_eve_touch_ui/bioprinter/advanced_settings.cpp
View file

@ -64,7 +64,7 @@ void AdvancedSettingsMenu::onRedraw(draw_mode_t what) {
.tag(13) .button(BTN_POS(1,7), BTN_SIZE(2,1), GET_TEXT_F(MSG_INTERFACE)) .tag(13) .button(BTN_POS(1,7), BTN_SIZE(2,1), GET_TEXT_F(MSG_INTERFACE))
.tag(14) .button(BTN_POS(1,8), BTN_SIZE(2,1), GET_TEXT_F(MSG_RESTORE_DEFAULTS)) .tag(14) .button(BTN_POS(1,8), BTN_SIZE(2,1), GET_TEXT_F(MSG_RESTORE_DEFAULTS))
.colors(action_btn) .colors(action_btn)
.tag(1). button( BTN_POS(1,9), BTN_SIZE(2,1), GET_TEXT_F(MSG_BUTTON_DONE)); .tag(1) .button( BTN_POS(1,9), BTN_SIZE(2,1), GET_TEXT_F(MSG_BUTTON_DONE));
} }
} }

48
Marlin/src/lcd/marlinui.cpp
View file

@ -140,12 +140,12 @@ constexpr uint8_t epps = ENCODER_PULSES_PER_STEP;
preheat_t MarlinUI::material_preset[PREHEAT_COUNT]; // Initialized by settings.load() preheat_t MarlinUI::material_preset[PREHEAT_COUNT]; // Initialized by settings.load()
PGM_P MarlinUI::get_preheat_label(const uint8_t m) { FSTR_P MarlinUI::get_preheat_label(const uint8_t m) {
#define _PDEF(N) static PGMSTR(preheat_##N##_label, PREHEAT_##N##_LABEL); #define _PDEF(N) static PGMSTR(preheat_##N##_label, PREHEAT_##N##_LABEL);
#define _PLBL(N) preheat_##N##_label, #define _PLBL(N) preheat_##N##_label,
REPEAT_1(PREHEAT_COUNT, _PDEF); REPEAT_1(PREHEAT_COUNT, _PDEF);
static PGM_P const preheat_labels[PREHEAT_COUNT] PROGMEM = { REPEAT_1(PREHEAT_COUNT, _PLBL) }; static PGM_P const preheat_labels[PREHEAT_COUNT] PROGMEM = { REPEAT_1(PREHEAT_COUNT, _PLBL) };
return (PGM_P)pgm_read_ptr(&preheat_labels[m]); return FPSTR((PGM_P)pgm_read_ptr(&preheat_labels[m]));
} }
void MarlinUI::apply_preheat(const uint8_t m, const uint8_t pmask, const uint8_t e/*=active_extruder*/) { void MarlinUI::apply_preheat(const uint8_t m, const uint8_t pmask, const uint8_t e/*=active_extruder*/) {
@ -454,20 +454,20 @@ void MarlinUI::init() {
} }
} }
void MarlinUI::draw_select_screen_prompt(PGM_P const pref, const char * const string/*=nullptr*/, PGM_P const suff/*=nullptr*/) { void MarlinUI::draw_select_screen_prompt(FSTR_P const pref, const char * const string/*=nullptr*/, FSTR_P const suff/*=nullptr*/) {
const uint8_t plen = utf8_strlen_P(pref), slen = suff ? utf8_strlen_P(suff) : 0; const uint8_t plen = utf8_strlen(pref), slen = suff ? utf8_strlen(suff) : 0;
uint8_t col = 0, row = 0; uint8_t col = 0, row = 0;
if (!string && plen + slen <= LCD_WIDTH) { if (!string && plen + slen <= LCD_WIDTH) {
col = (LCD_WIDTH - plen - slen) / 2; col = (LCD_WIDTH - plen - slen) / 2;
row = LCD_HEIGHT > 3 ? 1 : 0; row = LCD_HEIGHT > 3 ? 1 : 0;
} }
if (LCD_HEIGHT >= 8) row = LCD_HEIGHT / 2 - 2; if (LCD_HEIGHT >= 8) row = LCD_HEIGHT / 2 - 2;
wrap_string_P(col, row, pref, true); wrap_string_P(col, row, FTOP(pref), true);
if (string) { if (string) {
if (col) { col = 0; row++; } // Move to the start of the next line if (col) { col = 0; row++; } // Move to the start of the next line
wrap_string(col, row, string); wrap_string(col, row, string);
} }
if (suff) wrap_string_P(col, row, suff); if (suff) wrap_string_P(col, row, FTOP(suff));
} }
#endif // !HAS_GRAPHICAL_TFT #endif // !HAS_GRAPHICAL_TFT
@ -484,17 +484,17 @@ void MarlinUI::init() {
#if HAS_MARLINUI_MENU && !HAS_ADC_BUTTONS #if HAS_MARLINUI_MENU && !HAS_ADC_BUTTONS
void lcd_move_x();
void lcd_move_y();
void lcd_move_z();
void _reprapworld_keypad_move(const AxisEnum axis, const int16_t dir) { void _reprapworld_keypad_move(const AxisEnum axis, const int16_t dir) {
ui.manual_move.menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP; ui.manual_move.menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
ui.encoderPosition = dir; ui.encoderPosition = dir;
switch (axis) { switch (axis) {
case X_AXIS: lcd_move_x(); break; case X_AXIS: { void lcd_move_x(); lcd_move_x(); } break;
case Y_AXIS: lcd_move_y(); break; #if HAS_Y_AXIS
case Z_AXIS: lcd_move_z(); case Y_AXIS: { void lcd_move_y(); lcd_move_y(); } break;
#endif
#if HAS_Z_AXIS
case Z_AXIS: { void lcd_move_z(); lcd_move_z(); } break;
#endif
default: break; default: break;
} }
} }
@ -1651,7 +1651,7 @@ void MarlinUI::init() {
void MarlinUI::pause_print() { void MarlinUI::pause_print() {
#if HAS_MARLINUI_MENU #if HAS_MARLINUI_MENU
synchronize(GET_TEXT(MSG_PAUSING)); synchronize(GET_TEXT_F(MSG_PAUSING));
defer_status_screen(); defer_status_screen();
#endif #endif
@ -1855,12 +1855,12 @@ void MarlinUI::init() {
#if DISABLED(EEPROM_AUTO_INIT) #if DISABLED(EEPROM_AUTO_INIT)
static inline PGM_P eeprom_err(const uint8_t msgid) { static inline FSTR_P eeprom_err(const uint8_t msgid) {
switch (msgid) { switch (msgid) {
default: default:
case 0: return GET_TEXT(MSG_ERR_EEPROM_CRC); case 0: return GET_TEXT_F(MSG_ERR_EEPROM_CRC);
case 1: return GET_TEXT(MSG_ERR_EEPROM_INDEX); case 1: return GET_TEXT_F(MSG_ERR_EEPROM_INDEX);
case 2: return GET_TEXT(MSG_ERR_EEPROM_VERSION); case 2: return GET_TEXT_F(MSG_ERR_EEPROM_VERSION);
} }
} }
@ -1868,17 +1868,17 @@ void MarlinUI::init() {
#if HAS_MARLINUI_MENU #if HAS_MARLINUI_MENU
editable.uint8 = msgid; editable.uint8 = msgid;
goto_screen([]{ goto_screen([]{
PGM_P const restore_msg = GET_TEXT(MSG_INIT_EEPROM); FSTR_P const restore_msg = GET_TEXT_F(MSG_INIT_EEPROM);
char msg[utf8_strlen_P(restore_msg) + 1]; char msg[utf8_strlen(restore_msg) + 1];
strcpy_P(msg, restore_msg); strcpy_P(msg, FTOP(restore_msg));
MenuItem_confirm::select_screen( MenuItem_confirm::select_screen(
GET_TEXT(MSG_BUTTON_RESET), GET_TEXT(MSG_BUTTON_IGNORE), GET_TEXT_F(MSG_BUTTON_RESET), GET_TEXT_F(MSG_BUTTON_IGNORE),
init_eeprom, return_to_status, init_eeprom, return_to_status,
eeprom_err(editable.uint8), msg, PSTR("?") eeprom_err(editable.uint8), msg, F("?")
); );
}); });
#else #else
set_status(FPSTR(eeprom_err(msgid))); set_status(eeprom_err(msgid));
#endif #endif
} }

6
Marlin/src/lcd/marlinui.h
View file

@ -520,7 +520,7 @@ public:
#if HAS_PREHEAT #if HAS_PREHEAT
enum PreheatTarget : uint8_t { PT_HOTEND, PT_BED, PT_FAN, PT_CHAMBER, PT_ALL = 0xFF }; enum PreheatTarget : uint8_t { PT_HOTEND, PT_BED, PT_FAN, PT_CHAMBER, PT_ALL = 0xFF };
static preheat_t material_preset[PREHEAT_COUNT]; static preheat_t material_preset[PREHEAT_COUNT];
static PGM_P get_preheat_label(const uint8_t m); static FSTR_P get_preheat_label(const uint8_t m);
static void apply_preheat(const uint8_t m, const uint8_t pmask, const uint8_t e=active_extruder); static void apply_preheat(const uint8_t m, const uint8_t pmask, const uint8_t e=active_extruder);
static void preheat_set_fan(const uint8_t m) { TERN_(HAS_FAN, apply_preheat(m, _BV(PT_FAN))); } static void preheat_set_fan(const uint8_t m) { TERN_(HAS_FAN, apply_preheat(m, _BV(PT_FAN))); }
static void preheat_hotend(const uint8_t m, const uint8_t e=active_extruder) { TERN_(HAS_HOTEND, apply_preheat(m, _BV(PT_HOTEND))); } static void preheat_hotend(const uint8_t m, const uint8_t e=active_extruder) { TERN_(HAS_HOTEND, apply_preheat(m, _BV(PT_HOTEND))); }
@ -559,7 +559,7 @@ public:
static void set_selection(const bool sel) { selection = sel; } static void set_selection(const bool sel) { selection = sel; }
static bool update_selection(); static bool update_selection();
static void synchronize(PGM_P const msg=nullptr); static void synchronize(FSTR_P const msg=nullptr);
static screenFunc_t currentScreen; static screenFunc_t currentScreen;
static bool screen_changed; static bool screen_changed;
@ -605,7 +605,7 @@ public:
static float ubl_mesh_value(); static float ubl_mesh_value();
#endif #endif
static void draw_select_screen_prompt(PGM_P const pref, const char * const string=nullptr, PGM_P const suff=nullptr); static void draw_select_screen_prompt(FSTR_P const pref, const char * const string=nullptr, FSTR_P const suff=nullptr);
#else #else

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

@ -69,11 +69,11 @@ menuPosition screen_history[6];
uint8_t screen_history_depth = 0; uint8_t screen_history_depth = 0;
int8_t MenuItemBase::itemIndex; // Index number for draw and action int8_t MenuItemBase::itemIndex; // Index number for draw and action
PGM_P MenuItemBase::itemString; // A PSTR for substitution FSTR_P MenuItemBase::itemString; // A string for substitution
chimera_t editable; // Value Editing chimera_t editable; // Value Editing
// Menu Edit Items // Menu Edit Items
PGM_P MenuEditItemBase::editLabel; FSTR_P MenuEditItemBase::editLabel;
void* MenuEditItemBase::editValue; void* MenuEditItemBase::editValue;
int32_t MenuEditItemBase::minEditValue, int32_t MenuEditItemBase::minEditValue,
MenuEditItemBase::maxEditValue; MenuEditItemBase::maxEditValue;
@ -134,7 +134,7 @@ void MenuEditItemBase::edit_screen(strfunc_t strfunc, loadfunc_t loadfunc) {
// Going to an edit screen sets up some persistent values first // Going to an edit screen sets up some persistent values first
void MenuEditItemBase::goto_edit_screen( void MenuEditItemBase::goto_edit_screen(
PGM_P const el, // Edit label FSTR_P const el, // Edit label
void * const ev, // Edit value pointer void * const ev, // Edit value pointer
const int32_t minv, // Encoder minimum const int32_t minv, // Encoder minimum
const int32_t maxv, // Encoder maximum const int32_t maxv, // Encoder maximum
@ -232,8 +232,8 @@ void MarlinUI::goto_screen(screenFunc_t screen, const uint16_t encoder/*=0*/, co
// Display a "synchronize" screen with a custom message until // Display a "synchronize" screen with a custom message until
// all moves are finished. Go back to calling screen when done. // all moves are finished. Go back to calling screen when done.
// //
void MarlinUI::synchronize(PGM_P const msg/*=nullptr*/) { void MarlinUI::synchronize(FSTR_P const fmsg/*=nullptr*/) {
static PGM_P sync_message = msg ?: GET_TEXT(MSG_MOVING); static FSTR_P sync_message = fmsg ?: GET_TEXT_F(MSG_MOVING);
push_current_screen(); push_current_screen();
goto_screen([]{ goto_screen([]{
if (should_draw()) MenuItem_static::draw(LCD_HEIGHT >= 4, sync_message); if (should_draw()) MenuItem_static::draw(LCD_HEIGHT >= 4, sync_message);
@ -319,12 +319,12 @@ void scroll_screen(const uint8_t limit, const bool is_menu) {
} }
if (ui.should_draw()) { if (ui.should_draw()) {
if (do_probe) { if (do_probe) {
MenuEditItemBase::draw_edit_screen(GET_TEXT(MSG_ZPROBE_ZOFFSET), BABYSTEP_TO_STR(probe.offset.z)); MenuEditItemBase::draw_edit_screen(GET_TEXT_F(MSG_ZPROBE_ZOFFSET), BABYSTEP_TO_STR(probe.offset.z));
TERN_(BABYSTEP_ZPROBE_GFX_OVERLAY, ui.zoffset_overlay(probe.offset.z)); TERN_(BABYSTEP_ZPROBE_GFX_OVERLAY, ui.zoffset_overlay(probe.offset.z));
} }
else { else {
#if ENABLED(BABYSTEP_HOTEND_Z_OFFSET) #if ENABLED(BABYSTEP_HOTEND_Z_OFFSET)
MenuEditItemBase::draw_edit_screen(GET_TEXT(MSG_HOTEND_OFFSET_Z), ftostr54sign(hotend_offset[active_extruder].z)); MenuEditItemBase::draw_edit_screen(GET_TEXT_F(MSG_HOTEND_OFFSET_Z), ftostr54sign(hotend_offset[active_extruder].z));
#endif #endif
} }
} }
@ -335,7 +335,7 @@ void scroll_screen(const uint8_t limit, const bool is_menu) {
void _lcd_draw_homing() { void _lcd_draw_homing() {
if (ui.should_draw()) { if (ui.should_draw()) {
constexpr uint8_t line = (LCD_HEIGHT - 1) / 2; constexpr uint8_t line = (LCD_HEIGHT - 1) / 2;
MenuItem_static::draw(line, GET_TEXT(MSG_LEVEL_BED_HOMING)); MenuItem_static::draw(line, GET_TEXT_F(MSG_LEVEL_BED_HOMING));
} }
} }
@ -357,9 +357,9 @@ bool MarlinUI::update_selection() {
} }
void MenuItem_confirm::select_screen( void MenuItem_confirm::select_screen(
PGM_P const yes, PGM_P const no, FSTR_P const yes, FSTR_P const no,
selectFunc_t yesFunc, selectFunc_t noFunc, selectFunc_t yesFunc, selectFunc_t noFunc,
PGM_P const pref, const char * const string/*=nullptr*/, PGM_P const suff/*=nullptr*/ FSTR_P const pref, const char * const string/*=nullptr*/, FSTR_P const suff/*=nullptr*/
) { ) {
ui.defer_status_screen(); ui.defer_status_screen();
const bool ui_selection = !yes ? false : !no || ui.update_selection(), const bool ui_selection = !yes ? false : !no || ui.update_selection(),

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

@ -54,72 +54,72 @@ class MenuItemBase {
static int8_t itemIndex; static int8_t itemIndex;
// An optional pointer for use in display or by the action // An optional pointer for use in display or by the action
static PGM_P itemString; static FSTR_P itemString;
// Store the index of the item ahead of use by indexed items // 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; } FORCE_INLINE static void init(const int8_t ind=0, FSTR_P const fstr=nullptr) { itemIndex = ind; itemString = fstr; }
// Implementation-specific: // Implementation-specific:
// Draw an item either selected (pre_char) or not (space) with post_char // Draw an item either selected (pre_char) or not (space) with post_char
// Menus may set up itemIndex, itemString and pass them to string-building or string-emitting functions // Menus may set up itemIndex, itemString and pass them to string-building or string-emitting functions
static void _draw(const bool sel, const uint8_t row, PGM_P const pstr, const char pre_char, const char post_char); static void _draw(const bool sel, const uint8_t row, FSTR_P const fstr, const char pre_char, const char post_char);
// Draw an item either selected ('>') or not (space) with 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) { FORCE_INLINE static void _draw(const bool sel, const uint8_t row, FSTR_P const fstr, const char post_char) {
_draw(sel, row, pstr, '>', post_char); _draw(sel, row, fstr, '>', post_char);
} }
}; };
// STATIC_ITEM(LABEL,...) // STATIC_ITEM(LABEL,...)
class MenuItem_static : public MenuItemBase { class MenuItem_static : public MenuItemBase {
public: public:
static void draw(const uint8_t row, PGM_P const pstr, const uint8_t style=SS_DEFAULT, const char * const vstr=nullptr); static void draw(const uint8_t row, FSTR_P const fstr, const uint8_t style=SS_DEFAULT, const char * const vstr=nullptr);
}; };
// BACK_ITEM(LABEL) // BACK_ITEM(LABEL)
class MenuItem_back : public MenuItemBase { class MenuItem_back : public MenuItemBase {
public: public:
FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr) { FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr) {
_draw(sel, row, pstr, LCD_STR_UPLEVEL[0], LCD_STR_UPLEVEL[0]); _draw(sel, row, fstr, LCD_STR_UPLEVEL[0], LCD_STR_UPLEVEL[0]);
} }
// Back Item action goes back one step in history // Back Item action goes back one step in history
FORCE_INLINE static void action(PGM_P const=nullptr) { ui.go_back(); } FORCE_INLINE static void action(FSTR_P const=nullptr) { ui.go_back(); }
}; };
// CONFIRM_ITEM(LABEL,Y,N,FY,FN,...), // CONFIRM_ITEM(LABEL,Y,N,FY,FN,...),
// YESNO_ITEM(LABEL,FY,FN,...) // YESNO_ITEM(LABEL,FY,FN,...)
class MenuItem_confirm : public MenuItemBase { class MenuItem_confirm : public MenuItemBase {
public: public:
FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, ...) { FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, ...) {
_draw(sel, row, pstr, '>', LCD_STR_ARROW_RIGHT[0]); _draw(sel, row, fstr, '>', LCD_STR_ARROW_RIGHT[0]);
} }
// Implemented for HD44780 and DOGM // Implemented for HD44780 and DOGM
// Draw the prompt, buttons, and state // Draw the prompt, buttons, and state
static void draw_select_screen( static void draw_select_screen(
PGM_P const yes, // Right option label FSTR_P const yes, // Right option label
PGM_P const no, // Left option label FSTR_P const no, // Left option label
const bool yesno, // Is "yes" selected? const bool yesno, // Is "yes" selected?
PGM_P const pref, // Prompt prefix FSTR_P const pref, // Prompt prefix
const char * const string, // Prompt runtime string const char * const string, // Prompt runtime string
PGM_P const suff // Prompt suffix FSTR_P const suff // Prompt suffix
); );
static void select_screen( static void select_screen(
PGM_P const yes, PGM_P const no, FSTR_P const yes, FSTR_P const no,
selectFunc_t yesFunc, selectFunc_t noFunc, selectFunc_t yesFunc, selectFunc_t noFunc,
PGM_P const pref, const char * const string=nullptr, PGM_P const suff=nullptr FSTR_P const pref, const char * const string=nullptr, FSTR_P const suff=nullptr
); );
static void select_screen( static void select_screen(
PGM_P const yes, PGM_P const no, FSTR_P const yes, FSTR_P const no,
selectFunc_t yesFunc, selectFunc_t noFunc, selectFunc_t yesFunc, selectFunc_t noFunc,
PGM_P const pref, FSTR_P const string, PGM_P const suff=nullptr FSTR_P const pref, FSTR_P const string, FSTR_P const suff=nullptr
) { ) {
char str[strlen_P(FTOP(string)) + 1]; char str[strlen_P(FTOP(string)) + 1];
strcpy_P(str, FTOP(string)); strcpy_P(str, FTOP(string));
select_screen(yes, no, yesFunc, noFunc, pref, str, suff); select_screen(yes, no, yesFunc, noFunc, pref, str, suff);
} }
// Shortcut for prompt with "NO"/ "YES" labels // 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) { FORCE_INLINE static void confirm_screen(selectFunc_t yesFunc, selectFunc_t noFunc, FSTR_P const pref, const char * const string=nullptr, FSTR_P const suff=nullptr) {
select_screen(GET_TEXT(MSG_YES), GET_TEXT(MSG_NO), yesFunc, noFunc, pref, string, suff); select_screen(GET_TEXT_F(MSG_YES), GET_TEXT_F(MSG_NO), yesFunc, noFunc, pref, string, suff);
} }
}; };
@ -148,7 +148,7 @@ class MenuEditItemBase : public MenuItemBase {
// The action() method acts like the instantiator. The entire lifespan // The action() method acts like the instantiator. The entire lifespan
// of a menu item is within its declaration, so all these values decompose // of a menu item is within its declaration, so all these values decompose
// into behavior and unused items get optimized out. // into behavior and unused items get optimized out.
static PGM_P editLabel; static FSTR_P editLabel;
static void *editValue; static void *editValue;
static int32_t minEditValue, maxEditValue; // Encoder value range static int32_t minEditValue, maxEditValue; // Encoder value range
static screenFunc_t callbackFunc; static screenFunc_t callbackFunc;
@ -157,7 +157,7 @@ class MenuEditItemBase : public MenuItemBase {
typedef const char* (*strfunc_t)(const int32_t); typedef const char* (*strfunc_t)(const int32_t);
typedef void (*loadfunc_t)(void *, const int32_t); typedef void (*loadfunc_t)(void *, const int32_t);
static void goto_edit_screen( static void goto_edit_screen(
PGM_P const el, // Edit label FSTR_P const el, // Edit label
void * const ev, // Edit value pointer void * const ev, // Edit value pointer
const int32_t minv, // Encoder minimum const int32_t minv, // Encoder minimum
const int32_t maxv, // Encoder maximum const int32_t maxv, // Encoder maximum
@ -170,11 +170,15 @@ class MenuEditItemBase : public MenuItemBase {
public: public:
// Implementation-specific: // Implementation-specific:
// Draw the current item at specified row with edit data // 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); static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, const char * const inStr, const bool pgm=false);
static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, FSTR_P const inStr) {
draw(sel, row, fstr, FTOP(inStr), true);
}
// Implementation-specific: // Implementation-specific:
// This low-level method is good to draw from anywhere // This low-level method is good to draw from anywhere
static void draw_edit_screen(PGM_P const pstr, const char * const value); static void draw_edit_screen(FSTR_P const fstr, const char * const value);
// This method is for the current menu item // This method is for the current menu item
static void draw_edit_screen(const char * const value) { draw_edit_screen(editLabel, value); } static void draw_edit_screen(const char * const value) { draw_edit_screen(editLabel, value); }
@ -185,7 +189,7 @@ class MenuEditItemBase : public MenuItemBase {
class MenuItem_sdbase { class MenuItem_sdbase {
public: public:
// Implemented for HD44780 and DOGM // Implemented for HD44780 and DOGM
static void draw(const bool sel, const uint8_t row, PGM_P const pstr, CardReader &theCard, const bool isDir); static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, CardReader &theCard, const bool isDir);
}; };
#endif #endif

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

@ -83,7 +83,7 @@ void menu_backlash();
void menu_pwm() { void menu_pwm() {
START_MENU(); START_MENU();
BACK_ITEM(MSG_ADVANCED_SETTINGS); 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) #define EDIT_CURRENT_PWM(LABEL,I) EDIT_ITEM_F(long5, F(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) #if ANY_PIN(MOTOR_CURRENT_PWM_XY, MOTOR_CURRENT_PWM_X, MOTOR_CURRENT_PWM_Y)
EDIT_CURRENT_PWM(STR_A STR_B, 0); EDIT_CURRENT_PWM(STR_A STR_B, 0);
#endif #endif
@ -705,7 +705,7 @@ void menu_advanced_settings() {
CONFIRM_ITEM(MSG_INIT_EEPROM, CONFIRM_ITEM(MSG_INIT_EEPROM,
MSG_BUTTON_INIT, MSG_BUTTON_CANCEL, MSG_BUTTON_INIT, MSG_BUTTON_CANCEL,
ui.init_eeprom, nullptr, ui.init_eeprom, nullptr,
GET_TEXT(MSG_INIT_EEPROM), (const char *)nullptr, PSTR("?") GET_TEXT_F(MSG_INIT_EEPROM), (const char *)nullptr, F("?")
); );
#endif #endif

18
Marlin/src/lcd/menu/menu_bed_corners.cpp
View file

@ -168,7 +168,7 @@ static void _lcd_level_bed_corners_get_next_position() {
TERN_(HAS_MARLINUI_U8GLIB, ui.set_font(FONT_MENU)); // Set up the font for extra info TERN_(HAS_MARLINUI_U8GLIB, ui.set_font(FONT_MENU)); // Set up the font for extra info
MenuItem_static::draw(0, GET_TEXT(MSG_PROBING_POINT), SS_INVERT); // "Probing Mesh" heading MenuItem_static::draw(0, GET_TEXT_F(MSG_PROBING_POINT), SS_INVERT); // "Probing Mesh" heading
uint8_t cy = TERN(TFT_COLOR_UI, 3, LCD_HEIGHT - 1), y = LCD_ROW_Y(cy); uint8_t cy = TERN(TFT_COLOR_UI, 3, LCD_HEIGHT - 1), y = LCD_ROW_Y(cy);
@ -197,10 +197,10 @@ static void _lcd_level_bed_corners_get_next_position() {
void _lcd_draw_raise() { void _lcd_draw_raise() {
if (!ui.should_draw()) return; if (!ui.should_draw()) return;
MenuItem_confirm::select_screen( MenuItem_confirm::select_screen(
GET_TEXT(MSG_BUTTON_DONE), GET_TEXT(MSG_BUTTON_SKIP) GET_TEXT_F(MSG_BUTTON_DONE), GET_TEXT_F(MSG_BUTTON_SKIP)
, []{ corner_probing_done = true; wait_for_probe = false; } , []{ corner_probing_done = true; wait_for_probe = false; }
, []{ wait_for_probe = false; } , []{ wait_for_probe = false; }
, GET_TEXT(MSG_BED_TRAMMING_RAISE) , GET_TEXT_F(MSG_BED_TRAMMING_RAISE)
, (const char*)nullptr, NUL_STR , (const char*)nullptr, NUL_STR
); );
} }
@ -208,11 +208,11 @@ static void _lcd_level_bed_corners_get_next_position() {
void _lcd_draw_level_prompt() { void _lcd_draw_level_prompt() {
if (!ui.should_draw()) return; if (!ui.should_draw()) return;
MenuItem_confirm::select_screen( MenuItem_confirm::select_screen(
GET_TEXT(TERN(HAS_LEVELING, MSG_BUTTON_LEVEL, MSG_BUTTON_DONE)), GET_TEXT_F(TERN(HAS_LEVELING, MSG_BUTTON_LEVEL, MSG_BUTTON_DONE)),
TERN(HAS_LEVELING, GET_TEXT(MSG_BUTTON_BACK), nullptr) TERN(HAS_LEVELING, GET_TEXT_F(MSG_BUTTON_BACK), nullptr)
, []{ queue.inject(TERN(HAS_LEVELING, F("G29N"), FPSTR(G28_STR))); ui.return_to_status(); } , []{ queue.inject(TERN(HAS_LEVELING, F("G29N"), FPSTR(G28_STR))); ui.return_to_status(); }
, TERN(HAS_LEVELING, ui.goto_previous_screen_no_defer, []{}) , TERN(HAS_LEVELING, ui.goto_previous_screen_no_defer, []{})
, GET_TEXT(MSG_BED_TRAMMING_IN_RANGE) , GET_TEXT_F(MSG_BED_TRAMMING_IN_RANGE)
, (const char*)nullptr, NUL_STR , (const char*)nullptr, NUL_STR
); );
} }
@ -332,15 +332,15 @@ static void _lcd_level_bed_corners_homing() {
bed_corner = 0; bed_corner = 0;
ui.goto_screen([]{ ui.goto_screen([]{
MenuItem_confirm::select_screen( MenuItem_confirm::select_screen(
GET_TEXT(MSG_BUTTON_NEXT), GET_TEXT(MSG_BUTTON_DONE) GET_TEXT_F(MSG_BUTTON_NEXT), GET_TEXT_F(MSG_BUTTON_DONE)
, _lcd_goto_next_corner , _lcd_goto_next_corner
, []{ , []{
line_to_z(LEVEL_CORNERS_Z_HOP); // Raise Z off the bed when done line_to_z(LEVEL_CORNERS_Z_HOP); // Raise Z off the bed when done
TERN_(HAS_LEVELING, set_bed_leveling_enabled(leveling_was_active)); TERN_(HAS_LEVELING, set_bed_leveling_enabled(leveling_was_active));
ui.goto_previous_screen_no_defer(); ui.goto_previous_screen_no_defer();
} }
, GET_TEXT(TERN(LEVEL_CENTER_TOO, MSG_LEVEL_BED_NEXT_POINT, MSG_NEXT_CORNER)) , GET_TEXT_F(TERN(LEVEL_CENTER_TOO, MSG_LEVEL_BED_NEXT_POINT, MSG_NEXT_CORNER))
, (const char*)nullptr, PSTR("?") , (const char*)nullptr, F("?")
); );
}); });
ui.set_selection(true); ui.set_selection(true);

14
Marlin/src/lcd/menu/menu_bed_leveling.cpp
View file

@ -71,12 +71,12 @@
#if Z_AFTER_PROBING > 0 && DISABLED(MESH_BED_LEVELING) #if Z_AFTER_PROBING > 0 && DISABLED(MESH_BED_LEVELING)
// Display "Done" screen and wait for moves to complete // Display "Done" screen and wait for moves to complete
line_to_z(Z_AFTER_PROBING); line_to_z(Z_AFTER_PROBING);
ui.synchronize(GET_TEXT(MSG_LEVEL_BED_DONE)); ui.synchronize(GET_TEXT_F(MSG_LEVEL_BED_DONE));
#endif #endif
ui.goto_previous_screen_no_defer(); ui.goto_previous_screen_no_defer();
ui.completion_feedback(); ui.completion_feedback();
} }
if (ui.should_draw()) MenuItem_static::draw(LCD_HEIGHT >= 4, GET_TEXT(MSG_LEVEL_BED_DONE)); if (ui.should_draw()) MenuItem_static::draw(LCD_HEIGHT >= 4, GET_TEXT_F(MSG_LEVEL_BED_DONE));
ui.refresh(LCDVIEW_CALL_REDRAW_NEXT); ui.refresh(LCDVIEW_CALL_REDRAW_NEXT);
} }
@ -127,7 +127,7 @@
// //
if (ui.should_draw()) { if (ui.should_draw()) {
const float v = current_position.z; const float v = current_position.z;
MenuEditItemBase::draw_edit_screen(GET_TEXT(MSG_MOVE_Z), ftostr43sign(v + (v < 0 ? -0.0001f : 0.0001f), '+')); MenuEditItemBase::draw_edit_screen(GET_TEXT_F(MSG_MOVE_Z), ftostr43sign(v + (v < 0 ? -0.0001f : 0.0001f), '+'));
} }
} }
@ -138,7 +138,7 @@
if (ui.should_draw()) { if (ui.should_draw()) {
char msg[10]; char msg[10];
sprintf_P(msg, PSTR("%i / %u"), int(manual_probe_index + 1), total_probe_points); 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); MenuEditItemBase::draw_edit_screen(GET_TEXT_F(MSG_LEVEL_BED_NEXT_POINT), msg);
} }
ui.refresh(LCDVIEW_CALL_NO_REDRAW); ui.refresh(LCDVIEW_CALL_NO_REDRAW);
if (!ui.wait_for_move) ui.goto_screen(_lcd_level_bed_get_z); if (!ui.wait_for_move) ui.goto_screen(_lcd_level_bed_get_z);
@ -165,7 +165,7 @@
// //
void _lcd_level_bed_homing_done() { void _lcd_level_bed_homing_done() {
if (ui.should_draw()) { if (ui.should_draw()) {
MenuItem_static::draw(1, GET_TEXT(MSG_LEVEL_BED_WAITING)); MenuItem_static::draw(1, GET_TEXT_F(MSG_LEVEL_BED_WAITING));
// Color UI needs a control to detect a touch // Color UI needs a control to detect a touch
#if BOTH(TOUCH_SCREEN, HAS_GRAPHICAL_TFT) #if BOTH(TOUCH_SCREEN, HAS_GRAPHICAL_TFT)
touch.add_control(CLICK, 0, 0, TFT_WIDTH, TFT_HEIGHT); touch.add_control(CLICK, 0, 0, TFT_WIDTH, TFT_HEIGHT);
@ -243,7 +243,7 @@ void menu_bed_leveling() {
// Auto Home if not using manual probing // Auto Home if not using manual probing
#if NONE(PROBE_MANUALLY, MESH_BED_LEVELING) #if NONE(PROBE_MANUALLY, MESH_BED_LEVELING)
if (!is_homed) GCODES_ITEM(MSG_AUTO_HOME, G28_STR); if (!is_homed) GCODES_ITEM(MSG_AUTO_HOME, FPSTR(G28_STR));
#endif #endif
// Level Bed // Level Bed
@ -252,7 +252,7 @@ void menu_bed_leveling() {
SUBMENU(MSG_LEVEL_BED, _lcd_level_bed_continue); SUBMENU(MSG_LEVEL_BED, _lcd_level_bed_continue);
#else #else
// Automatic leveling can just run the G-code // Automatic leveling can just run the G-code
GCODES_ITEM(MSG_LEVEL_BED, is_homed ? PSTR("G29") : PSTR("G29N")); GCODES_ITEM(MSG_LEVEL_BED, is_homed ? F("G29") : F("G29N"));
#endif #endif
#if ENABLED(MESH_EDIT_MENU) #if ENABLED(MESH_EDIT_MENU)

2
Marlin/src/lcd/menu/menu_cancelobject.cpp
View file

@ -48,7 +48,7 @@ static void lcd_cancel_object_confirm() {
ui.goto_previous_screen(); ui.goto_previous_screen();
}, },
nullptr, nullptr,
GET_TEXT(MSG_CANCEL_OBJECT), item_num, PSTR("?") GET_TEXT_F(MSG_CANCEL_OBJECT), item_num, F("?")
); );
} }

50
Marlin/src/lcd/menu/menu_configuration.cpp
View file

@ -78,7 +78,7 @@ void menu_advanced_settings();
bar_percent += (int8_t)ui.encoderPosition; bar_percent += (int8_t)ui.encoderPosition;
LIMIT(bar_percent, 0, 100); LIMIT(bar_percent, 0, 100);
ui.encoderPosition = 0; ui.encoderPosition = 0;
MenuItem_static::draw(0, GET_TEXT(MSG_PROGRESS_BAR_TEST), SS_DEFAULT|SS_INVERT); MenuItem_static::draw(0, GET_TEXT_F(MSG_PROGRESS_BAR_TEST), SS_DEFAULT|SS_INVERT);
lcd_put_int((LCD_WIDTH) / 2 - 2, LCD_HEIGHT - 2, bar_percent); lcd_put_wchar('%'); 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); lcd_moveto(0, LCD_HEIGHT - 1); ui.draw_progress_bar(bar_percent);
} }
@ -137,7 +137,7 @@ void menu_advanced_settings();
#include "../../gcode/queue.h" #include "../../gcode/queue.h"
void menu_toolchange_migration() { void menu_toolchange_migration() {
PGM_P const msg_migrate = GET_TEXT(MSG_TOOL_MIGRATION_SWAP); FSTR_P const msg_migrate = GET_TEXT_F(MSG_TOOL_MIGRATION_SWAP);
START_MENU(); START_MENU();
BACK_ITEM(MSG_CONFIGURATION); BACK_ITEM(MSG_CONFIGURATION);
@ -149,7 +149,7 @@ void menu_advanced_settings();
// Migrate to a chosen extruder // Migrate to a chosen extruder
EXTRUDER_LOOP() { EXTRUDER_LOOP() {
if (e != active_extruder) { if (e != active_extruder) {
ACTION_ITEM_N_P(e, msg_migrate, []{ ACTION_ITEM_N_F(e, msg_migrate, []{
char cmd[12]; char cmd[12];
sprintf_P(cmd, PSTR("M217 T%i"), int(MenuItemBase::itemIndex)); sprintf_P(cmd, PSTR("M217 T%i"), int(MenuItemBase::itemIndex));
queue.inject(cmd); queue.inject(cmd);
@ -199,16 +199,16 @@ void menu_advanced_settings();
START_MENU(); START_MENU();
BACK_ITEM(MSG_CONFIGURATION); BACK_ITEM(MSG_CONFIGURATION);
GCODES_ITEM(MSG_IDEX_MODE_AUTOPARK, PSTR("M605S1\nG28X\nG1X0")); GCODES_ITEM(MSG_IDEX_MODE_AUTOPARK, F("M605S1\nG28X\nG1X0"));
GCODES_ITEM(MSG_IDEX_MODE_DUPLICATE, need_g28 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 ? F("M605S1\nT0\nG28\nM605S2\nG28X\nG1X0") // If Y or Z is not homed, do a full G28 first
: PSTR("M605S1\nT0\nM605S2\nG28X\nG1X0") : F("M605S1\nT0\nM605S2\nG28X\nG1X0")
); );
GCODES_ITEM(MSG_IDEX_MODE_MIRRORED_COPY, need_g28 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 ? F("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") : F("M605S1\nT0\nM605S2\nG28 X\nG1X0\nM605S3")
); );
GCODES_ITEM(MSG_IDEX_MODE_FULL_CTRL, PSTR("M605S0\nG28X")); GCODES_ITEM(MSG_IDEX_MODE_FULL_CTRL, F("M605S0\nG28X"));
EDIT_ITEM(float42_52, MSG_IDEX_DUPE_GAP, &duplicate_extruder_x_offset, (X2_MIN_POS) - (X1_MIN_POS), (X_BED_SIZE) - 20); EDIT_ITEM(float42_52, MSG_IDEX_DUPE_GAP, &duplicate_extruder_x_offset, (X2_MIN_POS) - (X1_MIN_POS), (X_BED_SIZE) - 20);
@ -246,11 +246,11 @@ void menu_advanced_settings();
EDIT_ITEM(bool, MSG_BLTOUCH_SPEED_MODE, &bltouch.high_speed_mode); EDIT_ITEM(bool, MSG_BLTOUCH_SPEED_MODE, &bltouch.high_speed_mode);
#endif #endif
#if ENABLED(BLTOUCH_LCD_VOLTAGE_MENU) #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_5V_MODE, MSG_BLTOUCH_5V_MODE, MSG_BUTTON_CANCEL, bltouch._set_5V_mode, nullptr, GET_TEXT_F(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)); CONFIRM_ITEM(MSG_BLTOUCH_OD_MODE, MSG_BLTOUCH_OD_MODE, MSG_BUTTON_CANCEL, bltouch._set_OD_mode, nullptr, GET_TEXT_F(MSG_BLTOUCH_MODE_CHANGE));
ACTION_ITEM(MSG_BLTOUCH_MODE_STORE, bltouch._mode_store); 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_5V, MSG_BLTOUCH_MODE_STORE_5V, MSG_BUTTON_CANCEL, bltouch.mode_conv_5V, nullptr, GET_TEXT_F(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)); CONFIRM_ITEM(MSG_BLTOUCH_MODE_STORE_OD, MSG_BLTOUCH_MODE_STORE_OD, MSG_BUTTON_CANCEL, bltouch.mode_conv_OD, nullptr, GET_TEXT_F(MSG_BLTOUCH_MODE_CHANGE));
ACTION_ITEM(MSG_BLTOUCH_MODE_ECHO, bltouch_report); ACTION_ITEM(MSG_BLTOUCH_MODE_ECHO, bltouch_report);
#endif #endif
END_MENU(); END_MENU();
@ -264,10 +264,10 @@ void menu_advanced_settings();
ui.defer_status_screen(); ui.defer_status_screen();
START_MENU(); START_MENU();
BACK_ITEM(MSG_CONFIGURATION); BACK_ITEM(MSG_CONFIGURATION);
GCODES_ITEM(MSG_TOUCHMI_INIT, PSTR("M851 Z0\nG28\nG1 F200 Z0")); GCODES_ITEM(MSG_TOUCHMI_INIT, F("M851 Z0\nG28\nG1 F200 Z0"));
SUBMENU(MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset); SUBMENU(MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
GCODES_ITEM(MSG_TOUCHMI_SAVE, PSTR("M500\nG1 F200 Z10")); GCODES_ITEM(MSG_TOUCHMI_SAVE, F("M500\nG1 F200 Z10"));
GCODES_ITEM(MSG_TOUCHMI_ZTEST, PSTR("G28\nG1 F200 Z0")); GCODES_ITEM(MSG_TOUCHMI_ZTEST, F("G28\nG1 F200 Z0"));
END_MENU(); END_MENU();
} }
@ -329,7 +329,7 @@ void menu_advanced_settings();
#define MAXTEMP_ALL _MAX(REPEAT(HOTENDS, _MAXTEMP_ITEM) 0) #define MAXTEMP_ALL _MAX(REPEAT(HOTENDS, _MAXTEMP_ITEM) 0)
const uint8_t m = MenuItemBase::itemIndex; const uint8_t m = MenuItemBase::itemIndex;
START_MENU(); START_MENU();
STATIC_ITEM_P(ui.get_preheat_label(m), SS_DEFAULT|SS_INVERT); STATIC_ITEM_F(ui.get_preheat_label(m), SS_DEFAULT|SS_INVERT);
BACK_ITEM(MSG_CONFIGURATION); BACK_ITEM(MSG_CONFIGURATION);
#if HAS_FAN #if HAS_FAN
editable.uint8 = uint8_t(ui.material_preset[m].fan_speed); editable.uint8 = uint8_t(ui.material_preset[m].fan_speed);
@ -369,13 +369,13 @@ void menu_advanced_settings();
#define _DONE_SCRIPT "" #define _DONE_SCRIPT ""
#endif #endif
#define GCODE_LAMBDA_CONF(N) []{ _lcd_custom_menus_configuration_gcode(F(CONFIG_MENU_ITEM_##N##_GCODE _DONE_SCRIPT)); } #define GCODE_LAMBDA_CONF(N) []{ _lcd_custom_menus_configuration_gcode(F(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(N) ACTION_ITEM_F(F(CONFIG_MENU_ITEM_##N##_DESC), GCODE_LAMBDA_CONF(N));
#define _CUSTOM_ITEM_CONF_CONFIRM(N) \ #define _CUSTOM_ITEM_CONF_CONFIRM(N) \
SUBMENU_P(PSTR(CONFIG_MENU_ITEM_##N##_DESC), []{ \ SUBMENU_F(F(CONFIG_MENU_ITEM_##N##_DESC), []{ \
MenuItem_confirm::confirm_screen( \ MenuItem_confirm::confirm_screen( \
GCODE_LAMBDA_CONF(N), nullptr, \ GCODE_LAMBDA_CONF(N), nullptr, \
PSTR(CONFIG_MENU_ITEM_##N##_DESC "?") \ F(CONFIG_MENU_ITEM_##N##_DESC "?") \
); \ ); \
}) })
#define CUSTOM_ITEM_CONF(N) do{ \ #define CUSTOM_ITEM_CONF(N) do{ \
@ -483,7 +483,7 @@ void menu_configuration() {
#if ENABLED(CUSTOM_MENU_CONFIG) #if ENABLED(CUSTOM_MENU_CONFIG)
if (TERN1(CUSTOM_MENU_CONFIG_ONLY_IDLE, !busy)) { if (TERN1(CUSTOM_MENU_CONFIG_ONLY_IDLE, !busy)) {
#ifdef CUSTOM_MENU_CONFIG_TITLE #ifdef CUSTOM_MENU_CONFIG_TITLE
SUBMENU_P(PSTR(CUSTOM_MENU_CONFIG_TITLE), custom_menus_configuration); SUBMENU_F(F(CUSTOM_MENU_CONFIG_TITLE), custom_menus_configuration);
#else #else
SUBMENU(MSG_CUSTOM_COMMANDS, custom_menus_configuration); SUBMENU(MSG_CUSTOM_COMMANDS, custom_menus_configuration);
#endif #endif

6
Marlin/src/lcd/menu/menu_delta_calibrate.cpp
View file

@ -107,12 +107,12 @@ void lcd_delta_settings() {
START_MENU(); START_MENU();
BACK_ITEM(MSG_DELTA_CALIBRATE); BACK_ITEM(MSG_DELTA_CALIBRATE);
EDIT_ITEM(float52sign, MSG_DELTA_HEIGHT, &delta_height, delta_height - 10, delta_height + 10, _recalc_delta_settings); 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, 0, _recalc_delta_settings) #define EDIT_ENDSTOP_ADJ(LABEL,N) EDIT_ITEM_F(float43, F(LABEL), &delta_endstop_adj.N, -5, 0, _recalc_delta_settings)
EDIT_ENDSTOP_ADJ("Ex", a); EDIT_ENDSTOP_ADJ("Ex", a);
EDIT_ENDSTOP_ADJ("Ey", b); EDIT_ENDSTOP_ADJ("Ey", b);
EDIT_ENDSTOP_ADJ("Ez", c); EDIT_ENDSTOP_ADJ("Ez", c);
EDIT_ITEM(float52sign, MSG_DELTA_RADIUS, &delta_radius, delta_radius - 5, delta_radius + 5, _recalc_delta_settings); 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) #define EDIT_ANGLE_TRIM(LABEL,N) EDIT_ITEM_F(float43, F(LABEL), &delta_tower_angle_trim.N, -5, 5, _recalc_delta_settings)
EDIT_ANGLE_TRIM("Tx", a); EDIT_ANGLE_TRIM("Tx", a);
EDIT_ANGLE_TRIM("Ty", b); EDIT_ANGLE_TRIM("Ty", b);
EDIT_ANGLE_TRIM("Tz", c); EDIT_ANGLE_TRIM("Tz", c);
@ -129,7 +129,7 @@ void menu_delta_calibrate() {
BACK_ITEM(MSG_MAIN); BACK_ITEM(MSG_MAIN);
#if ENABLED(DELTA_AUTO_CALIBRATION) #if ENABLED(DELTA_AUTO_CALIBRATION)
GCODES_ITEM(MSG_DELTA_AUTO_CALIBRATE, PSTR("G33")); GCODES_ITEM(MSG_DELTA_AUTO_CALIBRATE, F("G33"));
#if ENABLED(EEPROM_SETTINGS) #if ENABLED(EEPROM_SETTINGS)
ACTION_ITEM(MSG_STORE_EEPROM, ui.store_settings); ACTION_ITEM(MSG_STORE_EEPROM, ui.store_settings);
ACTION_ITEM(MSG_LOAD_EEPROM, ui.load_settings); ACTION_ITEM(MSG_LOAD_EEPROM, ui.load_settings);

104
Marlin/src/lcd/menu/menu_filament.cpp
View file

@ -45,22 +45,22 @@
static PauseMode _change_filament_mode; // = PAUSE_MODE_PAUSE_PRINT static PauseMode _change_filament_mode; // = PAUSE_MODE_PAUSE_PRINT
static int8_t _change_filament_extruder; // = 0 static int8_t _change_filament_extruder; // = 0
inline PGM_P _change_filament_command() { inline FSTR_P _change_filament_command() {
switch (_change_filament_mode) { switch (_change_filament_mode) {
case PAUSE_MODE_LOAD_FILAMENT: return PSTR("M701 T%d"); case PAUSE_MODE_LOAD_FILAMENT: return F("M701 T%d");
case PAUSE_MODE_UNLOAD_FILAMENT: return _change_filament_extruder >= 0 case PAUSE_MODE_UNLOAD_FILAMENT: return _change_filament_extruder >= 0
? PSTR("M702 T%d") : PSTR("M702 ;%d"); ? F("M702 T%d") : F("M702 ;%d");
case PAUSE_MODE_CHANGE_FILAMENT: case PAUSE_MODE_CHANGE_FILAMENT:
case PAUSE_MODE_PAUSE_PRINT: case PAUSE_MODE_PAUSE_PRINT:
default: break; default: break;
} }
return PSTR("M600 B0 T%d"); return F("M600 B0 T%d");
} }
// Initiate Filament Load/Unload/Change at the specified temperature // Initiate Filament Load/Unload/Change at the specified temperature
static void _change_filament_with_temp(const uint16_t celsius) { static void _change_filament_with_temp(const uint16_t celsius) {
char cmd[11]; char cmd[11];
sprintf_P(cmd, _change_filament_command(), _change_filament_extruder); sprintf_P(cmd, FTOP(_change_filament_command()), _change_filament_extruder);
thermalManager.setTargetHotend(celsius, _change_filament_extruder); thermalManager.setTargetHotend(celsius, _change_filament_extruder);
queue.inject(cmd); queue.inject(cmd);
} }
@ -77,13 +77,13 @@ static void _change_filament_with_custom() {
// Menu to choose the temperature and start Filament Change // Menu to choose the temperature and start Filament Change
// //
inline PGM_P change_filament_header(const PauseMode mode) { inline FSTR_P change_filament_header(const PauseMode mode) {
switch (mode) { switch (mode) {
case PAUSE_MODE_LOAD_FILAMENT: return GET_TEXT(MSG_FILAMENTLOAD); case PAUSE_MODE_LOAD_FILAMENT: return GET_TEXT_F(MSG_FILAMENTLOAD);
case PAUSE_MODE_UNLOAD_FILAMENT: return GET_TEXT(MSG_FILAMENTUNLOAD); case PAUSE_MODE_UNLOAD_FILAMENT: return GET_TEXT_F(MSG_FILAMENTUNLOAD);
default: break; default: break;
} }
return GET_TEXT(MSG_FILAMENTCHANGE); return GET_TEXT_F(MSG_FILAMENTCHANGE);
} }
void _menu_temp_filament_op(const PauseMode mode, const int8_t extruder) { void _menu_temp_filament_op(const PauseMode mode, const int8_t extruder) {
@ -91,7 +91,7 @@ void _menu_temp_filament_op(const PauseMode mode, const int8_t extruder) {
_change_filament_extruder = extruder; _change_filament_extruder = extruder;
const int8_t old_index = MenuItemBase::itemIndex; const int8_t old_index = MenuItemBase::itemIndex;
START_MENU(); START_MENU();
if (LCD_HEIGHT >= 4) STATIC_ITEM_P(change_filament_header(mode), SS_DEFAULT|SS_INVERT); if (LCD_HEIGHT >= 4) STATIC_ITEM_F(change_filament_header(mode), SS_DEFAULT|SS_INVERT);
BACK_ITEM(MSG_BACK); BACK_ITEM(MSG_BACK);
#if HAS_PREHEAT #if HAS_PREHEAT
LOOP_L_N(m, PREHEAT_COUNT) LOOP_L_N(m, PREHEAT_COUNT)
@ -132,18 +132,18 @@ void menu_change_filament() {
// Change filament // Change filament
#if E_STEPPERS == 1 #if E_STEPPERS == 1
PGM_P const msg = GET_TEXT(MSG_FILAMENTCHANGE); FSTR_P const msg = GET_TEXT_F(MSG_FILAMENTCHANGE);
if (thermalManager.targetTooColdToExtrude(active_extruder)) if (thermalManager.targetTooColdToExtrude(active_extruder))
SUBMENU_P(msg, []{ _menu_temp_filament_op(PAUSE_MODE_CHANGE_FILAMENT, 0); }); SUBMENU_F(msg, []{ _menu_temp_filament_op(PAUSE_MODE_CHANGE_FILAMENT, 0); });
else else
GCODES_ITEM_P(msg, PSTR("M600 B0")); GCODES_ITEM_F(msg, F("M600 B0"));
#else #else
PGM_P const msg = GET_TEXT(MSG_FILAMENTCHANGE_E); FSTR_P const msg = GET_TEXT_F(MSG_FILAMENTCHANGE_E);
LOOP_L_N(s, E_STEPPERS) { LOOP_L_N(s, E_STEPPERS) {
if (thermalManager.targetTooColdToExtrude(s)) if (thermalManager.targetTooColdToExtrude(s))
SUBMENU_N_P(s, msg, []{ _menu_temp_filament_op(PAUSE_MODE_CHANGE_FILAMENT, MenuItemBase::itemIndex); }); SUBMENU_N_F(s, msg, []{ _menu_temp_filament_op(PAUSE_MODE_CHANGE_FILAMENT, MenuItemBase::itemIndex); });
else { else {
ACTION_ITEM_N_P(s, msg, []{ ACTION_ITEM_N_F(s, msg, []{
PGM_P const cmdpstr = PSTR("M600 B0 T%i"); PGM_P const cmdpstr = PSTR("M600 B0 T%i");
char cmd[strlen_P(cmdpstr) + 3 + 1]; char cmd[strlen_P(cmdpstr) + 3 + 1];
sprintf_P(cmd, cmdpstr, int(MenuItemBase::itemIndex)); sprintf_P(cmd, cmdpstr, int(MenuItemBase::itemIndex));
@ -157,18 +157,18 @@ void menu_change_filament() {
if (!is_busy) { if (!is_busy) {
// Load filament // Load filament
#if E_STEPPERS == 1 #if E_STEPPERS == 1
PGM_P const msg_load = GET_TEXT(MSG_FILAMENTLOAD); FSTR_P const msg_load = GET_TEXT_F(MSG_FILAMENTLOAD);
if (thermalManager.targetTooColdToExtrude(active_extruder)) if (thermalManager.targetTooColdToExtrude(active_extruder))
SUBMENU_P(msg_load, []{ _menu_temp_filament_op(PAUSE_MODE_LOAD_FILAMENT, 0); }); SUBMENU_F(msg_load, []{ _menu_temp_filament_op(PAUSE_MODE_LOAD_FILAMENT, 0); });
else else
GCODES_ITEM_P(msg_load, PSTR("M701")); GCODES_ITEM_F(msg_load, F("M701"));
#else #else
PGM_P const msg_load = GET_TEXT(MSG_FILAMENTLOAD_E); FSTR_P const msg_load = GET_TEXT_F(MSG_FILAMENTLOAD_E);
LOOP_L_N(s, E_STEPPERS) { LOOP_L_N(s, E_STEPPERS) {
if (thermalManager.targetTooColdToExtrude(s)) if (thermalManager.targetTooColdToExtrude(s))
SUBMENU_N_P(s, msg_load, []{ _menu_temp_filament_op(PAUSE_MODE_LOAD_FILAMENT, MenuItemBase::itemIndex); }); SUBMENU_N_F(s, msg_load, []{ _menu_temp_filament_op(PAUSE_MODE_LOAD_FILAMENT, MenuItemBase::itemIndex); });
else { else {
ACTION_ITEM_N_P(s, msg_load, []{ ACTION_ITEM_N_F(s, msg_load, []{
char cmd[12]; char cmd[12];
sprintf_P(cmd, PSTR("M701 T%i"), int(MenuItemBase::itemIndex)); sprintf_P(cmd, PSTR("M701 T%i"), int(MenuItemBase::itemIndex));
queue.inject(cmd); queue.inject(cmd);
@ -179,24 +179,24 @@ void menu_change_filament() {
// Unload filament // Unload filament
#if E_STEPPERS == 1 #if E_STEPPERS == 1
PGM_P const msg_unload = GET_TEXT(MSG_FILAMENTUNLOAD); FSTR_P const msg_unload = GET_TEXT_F(MSG_FILAMENTUNLOAD);
if (thermalManager.targetTooColdToExtrude(active_extruder)) if (thermalManager.targetTooColdToExtrude(active_extruder))
SUBMENU_P(msg_unload, []{ _menu_temp_filament_op(PAUSE_MODE_UNLOAD_FILAMENT, 0); }); SUBMENU_F(msg_unload, []{ _menu_temp_filament_op(PAUSE_MODE_UNLOAD_FILAMENT, 0); });
else else
GCODES_ITEM_P(msg_unload, PSTR("M702")); GCODES_ITEM_F(msg_unload, F("M702"));
#else #else
#if ENABLED(FILAMENT_UNLOAD_ALL_EXTRUDERS) #if ENABLED(FILAMENT_UNLOAD_ALL_EXTRUDERS)
if (too_cold) if (too_cold)
SUBMENU(MSG_FILAMENTUNLOAD_ALL, []{ _menu_temp_filament_op(PAUSE_MODE_UNLOAD_FILAMENT, -1); }); SUBMENU(MSG_FILAMENTUNLOAD_ALL, []{ _menu_temp_filament_op(PAUSE_MODE_UNLOAD_FILAMENT, -1); });
else else
GCODES_ITEM(MSG_FILAMENTUNLOAD_ALL, PSTR("M702")); GCODES_ITEM(MSG_FILAMENTUNLOAD_ALL, F("M702"));
#endif #endif
PGM_P const msg_unload = GET_TEXT(MSG_FILAMENTUNLOAD_E); FSTR_P const msg_unload = GET_TEXT_F(MSG_FILAMENTUNLOAD_E);
LOOP_L_N(s, E_STEPPERS) { LOOP_L_N(s, E_STEPPERS) {
if (thermalManager.targetTooColdToExtrude(s)) if (thermalManager.targetTooColdToExtrude(s))
SUBMENU_N_P(s, msg_unload, []{ _menu_temp_filament_op(PAUSE_MODE_UNLOAD_FILAMENT, MenuItemBase::itemIndex); }); SUBMENU_N_F(s, msg_unload, []{ _menu_temp_filament_op(PAUSE_MODE_UNLOAD_FILAMENT, MenuItemBase::itemIndex); });
else { else {
ACTION_ITEM_N_P(s, msg_unload, []{ ACTION_ITEM_N_F(s, msg_unload, []{
char cmd[12]; char cmd[12];
sprintf_P(cmd, PSTR("M702 T%i"), int(MenuItemBase::itemIndex)); sprintf_P(cmd, PSTR("M702 T%i"), int(MenuItemBase::itemIndex));
queue.inject(cmd); queue.inject(cmd);
@ -221,21 +221,21 @@ void menu_change_filament() {
static uint8_t hotend_status_extruder = 0; static uint8_t hotend_status_extruder = 0;
static PGM_P pause_header() { static FSTR_P pause_header() {
switch (pause_mode) { switch (pause_mode) {
case PAUSE_MODE_CHANGE_FILAMENT: return GET_TEXT(MSG_FILAMENT_CHANGE_HEADER); case PAUSE_MODE_CHANGE_FILAMENT: return GET_TEXT_F(MSG_FILAMENT_CHANGE_HEADER);
case PAUSE_MODE_LOAD_FILAMENT: return GET_TEXT(MSG_FILAMENT_CHANGE_HEADER_LOAD); case PAUSE_MODE_LOAD_FILAMENT: return GET_TEXT_F(MSG_FILAMENT_CHANGE_HEADER_LOAD);
case PAUSE_MODE_UNLOAD_FILAMENT: return GET_TEXT(MSG_FILAMENT_CHANGE_HEADER_UNLOAD); case PAUSE_MODE_UNLOAD_FILAMENT: return GET_TEXT_F(MSG_FILAMENT_CHANGE_HEADER_UNLOAD);
default: break; default: break;
} }
return GET_TEXT(MSG_FILAMENT_CHANGE_HEADER_PAUSE); return GET_TEXT_F(MSG_FILAMENT_CHANGE_HEADER_PAUSE);
} }
// Portions from STATIC_ITEM... // Portions from STATIC_ITEM...
#define HOTEND_STATUS_ITEM() do { \ #define HOTEND_STATUS_ITEM() do { \
if (_menuLineNr == _thisItemNr) { \ if (_menuLineNr == _thisItemNr) { \
if (ui.should_draw()) { \ if (ui.should_draw()) { \
IF_DISABLED(HAS_GRAPHICAL_TFT, MenuItem_static::draw(_lcdLineNr, GET_TEXT(MSG_FILAMENT_CHANGE_NOZZLE), SS_INVERT)); \ IF_DISABLED(HAS_GRAPHICAL_TFT, MenuItem_static::draw(_lcdLineNr, GET_TEXT_F(MSG_FILAMENT_CHANGE_NOZZLE), SS_INVERT)); \
ui.draw_hotend_status(_lcdLineNr, hotend_status_extruder); \ ui.draw_hotend_status(_lcdLineNr, hotend_status_extruder); \
} \ } \
if (_skipStatic && encoderLine <= _thisItemNr) { \ if (_skipStatic && encoderLine <= _thisItemNr) { \
@ -273,39 +273,39 @@ void menu_pause_option() {
// //
// Warning: msg must have three null bytes to delimit lines! // Warning: msg must have three null bytes to delimit lines!
// //
void _lcd_pause_message(PGM_P const msg) { void _lcd_pause_message(FSTR_P const msg) {
PGM_P const msg1 = msg; PGM_P const msg1 = FTOP(msg);
PGM_P const msg2 = msg1 + strlen_P(msg1) + 1; PGM_P const msg2 = msg1 + strlen_P(msg1) + 1;
PGM_P const msg3 = msg2 + strlen_P(msg2) + 1; PGM_P const msg3 = msg2 + strlen_P(msg2) + 1;
const bool has2 = msg2[0], has3 = msg3[0], const bool has2 = msg2[0], has3 = msg3[0],
skip1 = !has2 && (LCD_HEIGHT) >= 5; skip1 = !has2 && (LCD_HEIGHT) >= 5;
START_SCREEN(); START_SCREEN();
STATIC_ITEM_P(pause_header(), SS_DEFAULT|SS_INVERT); // 1: Header STATIC_ITEM_F(pause_header(), SS_DEFAULT|SS_INVERT); // 1: Header
if (skip1) SKIP_ITEM(); // Move a single-line message down if (skip1) SKIP_ITEM(); // Move a single-line message down
STATIC_ITEM_P(msg1); // 2: Message Line 1 STATIC_ITEM_F(FPSTR(msg1)); // 2: Message Line 1
if (has2) STATIC_ITEM_P(msg2); // 3: Message Line 2 if (has2) STATIC_ITEM_F(FPSTR(msg2)); // 3: Message Line 2
if (has3 && (LCD_HEIGHT) >= 5) STATIC_ITEM_P(msg3); // 4: Message Line 3 (if LCD has 5 lines) if (has3 && (LCD_HEIGHT) >= 5) STATIC_ITEM_F(FPSTR(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 if (skip1 + 1 + has2 + has3 < (LCD_HEIGHT) - 2) SKIP_ITEM(); // Push Hotend Status down, if needed
HOTEND_STATUS_ITEM(); // 5: Hotend Status HOTEND_STATUS_ITEM(); // 5: Hotend Status
END_SCREEN(); END_SCREEN();
} }
void lcd_pause_parking_message() { _lcd_pause_message(GET_TEXT(MSG_PAUSE_PRINT_PARKING)); } void lcd_pause_parking_message() { _lcd_pause_message(GET_TEXT_F(MSG_PAUSE_PRINT_PARKING)); }
void lcd_pause_changing_message() { _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_INIT)); } void lcd_pause_changing_message() { _lcd_pause_message(GET_TEXT_F(MSG_FILAMENT_CHANGE_INIT)); }
void lcd_pause_unload_message() { _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_UNLOAD)); } void lcd_pause_unload_message() { _lcd_pause_message(GET_TEXT_F(MSG_FILAMENT_CHANGE_UNLOAD)); }
void lcd_pause_heating_message() { _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_HEATING)); } void lcd_pause_heating_message() { _lcd_pause_message(GET_TEXT_F(MSG_FILAMENT_CHANGE_HEATING)); }
void lcd_pause_heat_message() { _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_HEAT)); } void lcd_pause_heat_message() { _lcd_pause_message(GET_TEXT_F(MSG_FILAMENT_CHANGE_HEAT)); }
void lcd_pause_insert_message() { _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_INSERT)); } void lcd_pause_insert_message() { _lcd_pause_message(GET_TEXT_F(MSG_FILAMENT_CHANGE_INSERT)); }
void lcd_pause_load_message() { _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_LOAD)); } void lcd_pause_load_message() { _lcd_pause_message(GET_TEXT_F(MSG_FILAMENT_CHANGE_LOAD)); }
void lcd_pause_waiting_message() { _lcd_pause_message(GET_TEXT(MSG_ADVANCED_PAUSE_WAITING)); } void lcd_pause_waiting_message() { _lcd_pause_message(GET_TEXT_F(MSG_ADVANCED_PAUSE_WAITING)); }
void lcd_pause_resume_message() { _lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_RESUME)); } void lcd_pause_resume_message() { _lcd_pause_message(GET_TEXT_F(MSG_FILAMENT_CHANGE_RESUME)); }
void lcd_pause_purge_message() { void lcd_pause_purge_message() {
#if ENABLED(ADVANCED_PAUSE_CONTINUOUS_PURGE) #if ENABLED(ADVANCED_PAUSE_CONTINUOUS_PURGE)
_lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_CONT_PURGE)); _lcd_pause_message(GET_TEXT_F(MSG_FILAMENT_CHANGE_CONT_PURGE));
#else #else
_lcd_pause_message(GET_TEXT(MSG_FILAMENT_CHANGE_PURGE)); _lcd_pause_message(GET_TEXT_F(MSG_FILAMENT_CHANGE_PURGE));
#endif #endif
} }

56
Marlin/src/lcd/menu/menu_info.cpp
View file

@ -35,7 +35,7 @@
#endif #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(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) #define VALUE_ITEM_F(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) #if ENABLED(PRINTCOUNTER)
@ -56,35 +56,35 @@
VALUE_ITEM(MSG_INFO_COMPLETED_PRINTS, i16tostr3left(stats.finishedPrints), SS_LEFT); // Completed : 666 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(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_F(F("> "), 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(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_F(F("> "), SS_LEFT, duration_t(stats.longestPrint).toString(buffer)); // > 99y 364d 23h 59m 59s
STATIC_ITEM(MSG_INFO_PRINT_FILAMENT, SS_LEFT); // Extruded total: STATIC_ITEM(MSG_INFO_PRINT_FILAMENT, SS_LEFT); // Extruded total:
sprintf_P(buffer, PSTR("%ld.%im") sprintf_P(buffer, PSTR("%ld.%im")
, long(stats.filamentUsed / 1000) , long(stats.filamentUsed / 1000)
, int16_t(stats.filamentUsed / 100) % 10 , int16_t(stats.filamentUsed / 100) % 10
); );
STATIC_ITEM_P(PSTR("> "), SS_LEFT, buffer); // > 125m STATIC_ITEM_F(F("> "), SS_LEFT, buffer); // > 125m
#if SERVICE_INTERVAL_1 > 0 || SERVICE_INTERVAL_2 > 0 || SERVICE_INTERVAL_3 > 0 #if SERVICE_INTERVAL_1 > 0 || SERVICE_INTERVAL_2 > 0 || SERVICE_INTERVAL_3 > 0
strcpy_P(buffer, GET_TEXT(MSG_SERVICE_IN)); strcpy_P(buffer, GET_TEXT(MSG_SERVICE_IN));
#endif #endif
#if SERVICE_INTERVAL_1 > 0 #if SERVICE_INTERVAL_1 > 0
STATIC_ITEM_P(PSTR(SERVICE_NAME_1 " "), SS_LEFT, buffer); // Service X in: STATIC_ITEM_F(F(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 STATIC_ITEM_F(F("> "), SS_LEFT, duration_t(stats.nextService1).toString(buffer)); // > 7d 12h 11m 10s
#endif #endif
#if SERVICE_INTERVAL_2 > 0 #if SERVICE_INTERVAL_2 > 0
STATIC_ITEM_P(PSTR(SERVICE_NAME_2 " "), SS_LEFT, buffer); STATIC_ITEM_F(F(SERVICE_NAME_2 " "), SS_LEFT, buffer);
STATIC_ITEM_P(PSTR("> "), SS_LEFT, duration_t(stats.nextService2).toString(buffer)); STATIC_ITEM_F(F("> "), SS_LEFT, duration_t(stats.nextService2).toString(buffer));
#endif #endif
#if SERVICE_INTERVAL_3 > 0 #if SERVICE_INTERVAL_3 > 0
STATIC_ITEM_P(PSTR(SERVICE_NAME_3 " "), SS_LEFT, buffer); STATIC_ITEM_F(F(SERVICE_NAME_3 " "), SS_LEFT, buffer);
STATIC_ITEM_P(PSTR("> "), SS_LEFT, duration_t(stats.nextService3).toString(buffer)); STATIC_ITEM_F(F("> "), SS_LEFT, duration_t(stats.nextService3).toString(buffer));
#endif #endif
END_SCREEN(); END_SCREEN();
@ -103,7 +103,7 @@ void menu_info_thermistors() {
#if HAS_EXTRUDERS #if HAS_EXTRUDERS
#define THERMISTOR_ID TEMP_SENSOR_0 #define THERMISTOR_ID TEMP_SENSOR_0
#include "../thermistornames.h" #include "../thermistornames.h"
STATIC_ITEM_P(PSTR(STR_E0 ": " THERMISTOR_NAME), SS_INVERT); STATIC_ITEM_F(F(STR_E0 ": " THERMISTOR_NAME), SS_INVERT);
PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_0_MINTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_0_MINTEMP), SS_LEFT);
PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_0_MAXTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_0_MAXTEMP), SS_LEFT);
STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT); STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
@ -113,7 +113,7 @@ void menu_info_thermistors() {
#undef THERMISTOR_ID #undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_1 #define THERMISTOR_ID TEMP_SENSOR_1
#include "../thermistornames.h" #include "../thermistornames.h"
STATIC_ITEM_P(PSTR(STR_E1 ": " THERMISTOR_NAME), SS_INVERT); STATIC_ITEM_F(F(STR_E1 ": " THERMISTOR_NAME), SS_INVERT);
PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_1_MINTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_1_MINTEMP), SS_LEFT);
PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_1_MAXTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_1_MAXTEMP), SS_LEFT);
STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT); STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
@ -123,7 +123,7 @@ void menu_info_thermistors() {
#undef THERMISTOR_ID #undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_2 #define THERMISTOR_ID TEMP_SENSOR_2
#include "../thermistornames.h" #include "../thermistornames.h"
STATIC_ITEM_P(PSTR(STR_E2 ": " THERMISTOR_NAME), SS_INVERT); STATIC_ITEM_F(F(STR_E2 ": " THERMISTOR_NAME), SS_INVERT);
PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_2_MINTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_2_MINTEMP), SS_LEFT);
PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_2_MAXTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_2_MAXTEMP), SS_LEFT);
STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT); STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
@ -133,7 +133,7 @@ void menu_info_thermistors() {
#undef THERMISTOR_ID #undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_3 #define THERMISTOR_ID TEMP_SENSOR_3
#include "../thermistornames.h" #include "../thermistornames.h"
STATIC_ITEM_P(PSTR(STR_E3 ": " THERMISTOR_NAME), SS_INVERT); STATIC_ITEM_F(F(STR_E3 ": " THERMISTOR_NAME), SS_INVERT);
PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_3_MINTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_3_MINTEMP), SS_LEFT);
PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_3_MAXTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_3_MAXTEMP), SS_LEFT);
STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT); STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
@ -143,7 +143,7 @@ void menu_info_thermistors() {
#undef THERMISTOR_ID #undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_4 #define THERMISTOR_ID TEMP_SENSOR_4
#include "../thermistornames.h" #include "../thermistornames.h"
STATIC_ITEM_P(PSTR(STR_E4 ": " THERMISTOR_NAME), SS_INVERT); STATIC_ITEM_F(F(STR_E4 ": " THERMISTOR_NAME), SS_INVERT);
PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_4_MINTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_4_MINTEMP), SS_LEFT);
PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_4_MAXTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_4_MAXTEMP), SS_LEFT);
STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT); STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
@ -153,7 +153,7 @@ void menu_info_thermistors() {
#undef THERMISTOR_ID #undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_5 #define THERMISTOR_ID TEMP_SENSOR_5
#include "../thermistornames.h" #include "../thermistornames.h"
STATIC_ITEM_P(PSTR(STR_E5 ": " THERMISTOR_NAME), SS_INVERT); STATIC_ITEM_F(F(STR_E5 ": " THERMISTOR_NAME), SS_INVERT);
PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_5_MINTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_5_MINTEMP), SS_LEFT);
PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_5_MAXTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_5_MAXTEMP), SS_LEFT);
STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT); STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
@ -163,7 +163,7 @@ void menu_info_thermistors() {
#undef THERMISTOR_ID #undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_6 #define THERMISTOR_ID TEMP_SENSOR_6
#include "../thermistornames.h" #include "../thermistornames.h"
STATIC_ITEM_P(PSTR(STR_E6 ": " THERMISTOR_NAME), SS_INVERT); STATIC_ITEM_F(F(STR_E6 ": " THERMISTOR_NAME), SS_INVERT);
PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_6_MINTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_6_MINTEMP), SS_LEFT);
PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_6_MAXTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_6_MAXTEMP), SS_LEFT);
STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT); STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
@ -173,7 +173,7 @@ void menu_info_thermistors() {
#undef THERMISTOR_ID #undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_7 #define THERMISTOR_ID TEMP_SENSOR_7
#include "../thermistornames.h" #include "../thermistornames.h"
STATIC_ITEM_P(PSTR(STR_E7 ": " THERMISTOR_NAME), SS_INVERT); STATIC_ITEM_F(F(STR_E7 ": " THERMISTOR_NAME), SS_INVERT);
PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_7_MINTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(HEATER_7_MINTEMP), SS_LEFT);
PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_7_MAXTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(HEATER_7_MAXTEMP), SS_LEFT);
STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT); STATIC_ITEM(TERN(WATCH_HOTENDS, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
@ -183,7 +183,7 @@ void menu_info_thermistors() {
#undef THERMISTOR_ID #undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_BED #define THERMISTOR_ID TEMP_SENSOR_BED
#include "../thermistornames.h" #include "../thermistornames.h"
STATIC_ITEM_P(PSTR("BED: " THERMISTOR_NAME), SS_INVERT); STATIC_ITEM_F(F("BED: " THERMISTOR_NAME), SS_INVERT);
PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(BED_MINTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(BED_MINTEMP), SS_LEFT);
PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(BED_MAXTEMP), 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); STATIC_ITEM(TERN(WATCH_BED, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
@ -193,7 +193,7 @@ void menu_info_thermistors() {
#undef THERMISTOR_ID #undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_CHAMBER #define THERMISTOR_ID TEMP_SENSOR_CHAMBER
#include "../thermistornames.h" #include "../thermistornames.h"
STATIC_ITEM_P(PSTR("CHAM: " THERMISTOR_NAME), SS_INVERT); STATIC_ITEM_F(F("CHAM: " THERMISTOR_NAME), SS_INVERT);
PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(CHAMBER_MINTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(CHAMBER_MINTEMP), SS_LEFT);
PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(CHAMBER_MAXTEMP), 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); STATIC_ITEM(TERN(WATCH_CHAMBER, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
@ -203,7 +203,7 @@ void menu_info_thermistors() {
#undef THERMISTOR_ID #undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_COOLER #define THERMISTOR_ID TEMP_SENSOR_COOLER
#include "../thermistornames.h" #include "../thermistornames.h"
STATIC_ITEM_P(PSTR("COOL: " THERMISTOR_NAME), SS_INVERT); STATIC_ITEM_F(F("COOL: " THERMISTOR_NAME), SS_INVERT);
PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(COOLER_MINTEMP), SS_LEFT); PSTRING_ITEM(MSG_INFO_MIN_TEMP, STRINGIFY(COOLER_MINTEMP), SS_LEFT);
PSTRING_ITEM(MSG_INFO_MAX_TEMP, STRINGIFY(COOLER_MAXTEMP), 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); STATIC_ITEM(TERN(WATCH_COOLER, MSG_INFO_RUNAWAY_ON, MSG_INFO_RUNAWAY_OFF), SS_LEFT);
@ -219,9 +219,9 @@ void menu_info_board() {
if (ui.use_click()) return ui.go_back(); if (ui.use_click()) return ui.go_back();
START_SCREEN(); START_SCREEN();
STATIC_ITEM_P(PSTR(BOARD_INFO_NAME), SS_DEFAULT|SS_INVERT); // MyPrinterController STATIC_ITEM_F(F(BOARD_INFO_NAME), SS_DEFAULT|SS_INVERT); // MyPrinterController
#ifdef BOARD_WEBSITE_URL #ifdef BOARD_WEBSITE_URL
STATIC_ITEM_P(PSTR(BOARD_WEBSITE_URL), SS_LEFT); // www.my3dprinter.com STATIC_ITEM_F(F(BOARD_WEBSITE_URL), SS_LEFT); // www.my3dprinter.com
#endif #endif
PSTRING_ITEM(MSG_INFO_BAUDRATE, STRINGIFY(BAUDRATE), SS_CENTER); // Baud: 250000 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_PROTOCOL, PROTOCOL_VERSION, SS_CENTER); // Protocol: 1.0
@ -251,11 +251,11 @@ void menu_info_board() {
void menu_info_printer() { void menu_info_printer() {
if (ui.use_click()) return ui.go_back(); if (ui.use_click()) return ui.go_back();
START_SCREEN(); START_SCREEN();
STATIC_ITEM(MSG_MARLIN, SS_DEFAULT|SS_INVERT); // Marlin STATIC_ITEM(MSG_MARLIN, SS_DEFAULT|SS_INVERT); // Marlin
STATIC_ITEM_P(PSTR(SHORT_BUILD_VERSION)); // x.x.x-Branch STATIC_ITEM_F(F(SHORT_BUILD_VERSION)); // x.x.x-Branch
STATIC_ITEM_P(PSTR(STRING_DISTRIBUTION_DATE)); // YYYY-MM-DD HH:MM STATIC_ITEM_F(F(STRING_DISTRIBUTION_DATE)); // YYYY-MM-DD HH:MM
STATIC_ITEM_P(PSTR(MACHINE_NAME), SS_DEFAULT|SS_INVERT); // My3DPrinter STATIC_ITEM_F(F(MACHINE_NAME), SS_DEFAULT|SS_INVERT); // My3DPrinter
STATIC_ITEM_P(PSTR(WEBSITE_URL)); // www.my3dprinter.com STATIC_ITEM_F(F(WEBSITE_URL)); // www.my3dprinter.com
PSTRING_ITEM(MSG_INFO_EXTRUDERS, STRINGIFY(EXTRUDERS), SS_CENTER); // Extruders: 2 PSTRING_ITEM(MSG_INFO_EXTRUDERS, STRINGIFY(EXTRUDERS), SS_CENTER); // Extruders: 2
#if HAS_LEVELING #if HAS_LEVELING
STATIC_ITEM( STATIC_ITEM(

234
Marlin/src/lcd/menu/menu_item.h
View file

@ -36,36 +36,36 @@ void lcd_move_z();
// SUBMENU(LABEL, screen_handler) // SUBMENU(LABEL, screen_handler)
class MenuItem_submenu : public MenuItemBase { class MenuItem_submenu : public MenuItemBase {
public: public:
FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, ...) { FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, ...) {
_draw(sel, row, pstr, '>', LCD_STR_ARROW_RIGHT[0]); _draw(sel, row, fstr, '>', LCD_STR_ARROW_RIGHT[0]);
} }
static void action(PGM_P const, const screenFunc_t func) { ui.push_current_screen(); ui.goto_screen(func); } static void action(FSTR_P const, const screenFunc_t func) { ui.push_current_screen(); ui.goto_screen(func); }
}; };
// Any menu item that invokes an immediate action // Any menu item that invokes an immediate action
class MenuItem_button : public MenuItemBase { class MenuItem_button : public MenuItemBase {
public: public:
// Button-y Items are selectable lines with no other indicator // Button-y Items are selectable lines with no other indicator
static void draw(const bool sel, const uint8_t row, PGM_P const pstr, ...) { static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, ...) {
_draw(sel, row, pstr, '>', ' '); _draw(sel, row, fstr, '>', ' ');
} }
}; };
// ACTION_ITEM(LABEL, FUNC) // ACTION_ITEM(LABEL, FUNC)
class MenuItem_function : public MenuItem_button { class MenuItem_function : public MenuItem_button {
public: public:
//static void action(PGM_P const, const uint8_t, const menuAction_t func) { (*func)(); }; //static void action(FSTR_P const, const uint8_t, const menuAction_t func) { (*func)(); };
static void action(PGM_P const, const menuAction_t func) { if (func) (*func)(); }; static void action(FSTR_P const, const menuAction_t func) { if (func) (*func)(); };
}; };
// GCODES_ITEM(LABEL, GCODES) // GCODES_ITEM(LABEL, GCODES)
class MenuItem_gcode : public MenuItem_button { class MenuItem_gcode : public MenuItem_button {
public: public:
FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, ...) { FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, ...) {
_draw(sel, row, pstr, '>', ' '); _draw(sel, row, fstr, '>', ' ');
} }
static void action(PGM_P const, PGM_P const pgcode) { queue.inject(FPSTR(pgcode)); } static void action(FSTR_P const, FSTR_P const fgcode) { queue.inject(fgcode); }
static void action(PGM_P const pstr, const uint8_t, PGM_P const pgcode) { action(pstr, pgcode); } static void action(FSTR_P const fstr, const uint8_t, FSTR_P const fgcode) { action(fstr, fgcode); }
}; };
//////////////////////////////////////////// ////////////////////////////////////////////
@ -82,16 +82,16 @@ class TMenuEditItem : MenuEditItemBase {
static const char* to_string(const int32_t value) { return NAME::strfunc(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); } static void load(void *ptr, const int32_t value) { *((type_t*)ptr) = unscale(value); }
public: public:
FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, type_t * const data, ...) { FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, type_t * const data, ...) {
MenuEditItemBase::draw(sel, row, pstr, NAME::strfunc(*(data))); MenuEditItemBase::draw(sel, row, fstr, NAME::strfunc(*(data)));
} }
FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, type_t (*pget)(), ...) { FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, type_t (*pget)(), ...) {
MenuEditItemBase::draw(sel, row, pstr, NAME::strfunc(pget())); MenuEditItemBase::draw(sel, row, fstr, NAME::strfunc(pget()));
} }
// Edit screen for this type of item // Edit screen for this type of item
static void edit_screen() { MenuEditItemBase::edit_screen(to_string, load); } static void edit_screen() { MenuEditItemBase::edit_screen(to_string, load); }
static void action( static void action(
PGM_P const pstr, // Edit label FSTR_P const fstr, // Edit label
type_t * const ptr, // Value pointer type_t * const ptr, // Value pointer
const type_t minValue, // Value range const type_t minValue, // Value range
const type_t maxValue, const type_t maxValue,
@ -101,7 +101,7 @@ class TMenuEditItem : MenuEditItemBase {
// Make sure minv and maxv fit within int32_t // Make sure minv and maxv fit within int32_t
const int32_t minv = _MAX(scale(minValue), INT32_MIN), const int32_t minv = _MAX(scale(minValue), INT32_MIN),
maxv = _MIN(scale(maxValue), INT32_MAX); maxv = _MIN(scale(maxValue), INT32_MAX);
goto_edit_screen(pstr, ptr, minv, maxv - minv, scale(*ptr) - minv, goto_edit_screen(fstr, ptr, minv, maxv - minv, scale(*ptr) - minv,
edit_screen, callback, live); edit_screen, callback, live);
} }
}; };
@ -168,16 +168,16 @@ DEFINE_MENU_EDIT_ITEM_TYPE(long5_25 ,uint32_t ,ftostr5rj , 0.04f );
class MenuItem_bool : public MenuEditItemBase { class MenuItem_bool : public MenuEditItemBase {
public: public:
FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, const bool onoff) { FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, const bool onoff) {
MenuEditItemBase::draw(sel, row, pstr, onoff ? GET_TEXT(MSG_LCD_ON) : GET_TEXT(MSG_LCD_OFF), true); MenuEditItemBase::draw(sel, row, fstr, onoff ? GET_TEXT_F(MSG_LCD_ON) : GET_TEXT_F(MSG_LCD_OFF));
} }
FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, bool * const data, ...) { FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, bool * const data, ...) {
draw(sel, row, pstr, *data); draw(sel, row, fstr, *data);
} }
FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, PGM_P const, bool (*pget)(), ...) { FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, FSTR_P const, bool (*pget)(), ...) {
draw(sel, row, pstr, pget()); draw(sel, row, fstr, pget());
} }
static void action(PGM_P const pstr, bool * const ptr, const screenFunc_t callbackFunc=nullptr) { static void action(FSTR_P const fstr, bool * const ptr, const screenFunc_t callbackFunc=nullptr) {
*ptr ^= true; ui.refresh(); *ptr ^= true; ui.refresh();
if (callbackFunc) (*callbackFunc)(); if (callbackFunc) (*callbackFunc)();
} }
@ -250,16 +250,16 @@ class MenuItem_bool : public MenuEditItemBase {
* *
* Examples: * Examples:
* BACK_ITEM(MSG_INFO_SCREEN) * BACK_ITEM(MSG_INFO_SCREEN)
* MenuItem_back::action(plabel, ...) * MenuItem_back::action(flabel, ...)
* MenuItem_back::draw(sel, row, plabel, ...) * MenuItem_back::draw(sel, row, flabel, ...)
* *
* ACTION_ITEM(MSG_PAUSE_PRINT, lcd_sdcard_pause) * ACTION_ITEM(MSG_PAUSE_PRINT, lcd_sdcard_pause)
* MenuItem_function::action(plabel, lcd_sdcard_pause) * MenuItem_function::action(flabel, lcd_sdcard_pause)
* MenuItem_function::draw(sel, row, plabel, lcd_sdcard_pause) * MenuItem_function::draw(sel, row, flabel, lcd_sdcard_pause)
* *
* EDIT_ITEM(int3, MSG_SPEED, &feedrate_percentage, 10, 999) * EDIT_ITEM(int3, MSG_SPEED, &feedrate_percentage, 10, 999)
* MenuItem_int3::action(plabel, &feedrate_percentage, 10, 999) * MenuItem_int3::action(flabel, &feedrate_percentage, 10, 999)
* MenuItem_int3::draw(sel, row, plabel, &feedrate_percentage, 10, 999) * MenuItem_int3::draw(sel, row, flabel, &feedrate_percentage, 10, 999)
*/ */
#if ENABLED(ENCODER_RATE_MULTIPLIER) #if ENABLED(ENCODER_RATE_MULTIPLIER)
@ -268,19 +268,19 @@ class MenuItem_bool : public MenuEditItemBase {
#define _MENU_ITEM_MULTIPLIER_CHECK(USE_MULTIPLIER) #define _MENU_ITEM_MULTIPLIER_CHECK(USE_MULTIPLIER)
#endif #endif
#define _MENU_INNER_P(TYPE, USE_MULTIPLIER, PLABEL, V...) do { \ #define _MENU_INNER_P(TYPE, USE_MULTIPLIER, FLABEL, V...) do { \
PGM_P const plabel = PLABEL; \ FSTR_P const flabel = FLABEL; \
if (encoderLine == _thisItemNr && ui.use_click()) { \ if (encoderLine == _thisItemNr && ui.use_click()) { \
_MENU_ITEM_MULTIPLIER_CHECK(USE_MULTIPLIER); \ _MENU_ITEM_MULTIPLIER_CHECK(USE_MULTIPLIER); \
MenuItem_##TYPE::action(plabel, ##V); \ MenuItem_##TYPE::action(flabel, ##V); \
if (ui.screen_changed) return; \ if (ui.screen_changed) return; \
} \ } \
if (ui.should_draw()) \ if (ui.should_draw()) \
MenuItem_##TYPE::draw \ MenuItem_##TYPE::draw \
(encoderLine == _thisItemNr, _lcdLineNr, plabel, ##V); \ (encoderLine == _thisItemNr, _lcdLineNr, flabel, ##V); \
}while(0) }while(0)
#define _MENU_ITEM_P(TYPE, V...) do { \ #define _MENU_ITEM_F(TYPE, V...) do { \
if (_menuLineNr == _thisItemNr) { \ if (_menuLineNr == _thisItemNr) { \
_skipStatic = false; \ _skipStatic = false; \
_MENU_INNER_P(TYPE, ##V); \ _MENU_INNER_P(TYPE, ##V); \
@ -289,7 +289,7 @@ class MenuItem_bool : public MenuEditItemBase {
}while(0) }while(0)
// Indexed items set a global index value and optional data // Indexed items set a global index value and optional data
#define _MENU_ITEM_N_S_P(TYPE, N, S, V...) do{ \ #define _MENU_ITEM_N_S_F(TYPE, N, S, V...) do{ \
if (_menuLineNr == _thisItemNr) { \ if (_menuLineNr == _thisItemNr) { \
_skipStatic = false; \ _skipStatic = false; \
MenuItemBase::init(N, S); \ MenuItemBase::init(N, S); \
@ -299,7 +299,7 @@ class MenuItem_bool : public MenuEditItemBase {
}while(0) }while(0)
// Indexed items set a global index value // Indexed items set a global index value
#define _MENU_ITEM_N_P(TYPE, N, V...) do{ \ #define _MENU_ITEM_N_F(TYPE, N, V...) do{ \
if (_menuLineNr == _thisItemNr) { \ if (_menuLineNr == _thisItemNr) { \
_skipStatic = false; \ _skipStatic = false; \
MenuItemBase::itemIndex = N; \ MenuItemBase::itemIndex = N; \
@ -309,7 +309,7 @@ class MenuItem_bool : public MenuEditItemBase {
}while(0) }while(0)
// Items with a unique string // Items with a unique string
#define _MENU_ITEM_S_P(TYPE, S, V...) do{ \ #define _MENU_ITEM_S_F(TYPE, S, V...) do{ \
if (_menuLineNr == _thisItemNr) { \ if (_menuLineNr == _thisItemNr) { \
_skipStatic = false; \ _skipStatic = false; \
MenuItemBase::itemString = S; \ MenuItemBase::itemString = S; \
@ -321,25 +321,25 @@ class MenuItem_bool : public MenuEditItemBase {
// STATIC_ITEM draws a styled string with no highlight. // STATIC_ITEM draws a styled string with no highlight.
// Parameters: label [, style [, char *value] ] // Parameters: label [, style [, char *value] ]
#define STATIC_ITEM_INNER_P(PLABEL, V...) do{ \ #define STATIC_ITEM_INNER_F(FLABEL, V...) do{ \
if (_skipStatic && encoderLine <= _thisItemNr) { \ if (_skipStatic && encoderLine <= _thisItemNr) { \
ui.encoderPosition += ENCODER_STEPS_PER_MENU_ITEM; \ ui.encoderPosition += ENCODER_STEPS_PER_MENU_ITEM; \
++encoderLine; \ ++encoderLine; \
} \ } \
if (ui.should_draw()) \ if (ui.should_draw()) \
MenuItem_static::draw(_lcdLineNr, PLABEL, ##V); \ MenuItem_static::draw(_lcdLineNr, FLABEL, ##V); \
} while(0) } while(0)
#define STATIC_ITEM_P(PLABEL, V...) do{ \ #define STATIC_ITEM_F(FLABEL, V...) do{ \
if (_menuLineNr == _thisItemNr) \ if (_menuLineNr == _thisItemNr) \
STATIC_ITEM_INNER_P(PLABEL, ##V); \ STATIC_ITEM_INNER_F(FLABEL, ##V); \
NEXT_ITEM(); \ NEXT_ITEM(); \
} while(0) } while(0)
#define STATIC_ITEM_N_P(PLABEL, N, V...) do{ \ #define STATIC_ITEM_N_F(FLABEL, N, V...) do{ \
if (_menuLineNr == _thisItemNr) { \ if (_menuLineNr == _thisItemNr) { \
MenuItemBase::init(N); \ MenuItemBase::init(N); \
STATIC_ITEM_INNER_P(PLABEL, ##V); \ STATIC_ITEM_INNER_F(FLABEL, ##V); \
} \ } \
NEXT_ITEM(); \ NEXT_ITEM(); \
}while(0) }while(0)
@ -347,124 +347,124 @@ class MenuItem_bool : public MenuEditItemBase {
// PSTRING_ITEM is like STATIC_ITEM but it takes // PSTRING_ITEM is like STATIC_ITEM but it takes
// two PSTRs with the style as the last parameter. // two PSTRs with the style as the last parameter.
#define PSTRING_ITEM_P(PLABEL, PVAL, STYL) do{ \ #define PSTRING_ITEM_F(FLABEL, PVAL, STYL) do{ \
constexpr int m = 20; \ constexpr int m = 20; \
char msg[m+1]; \ char msg[m+1]; \
msg[0] = ':'; msg[1] = ' '; \ msg[0] = ':'; msg[1] = ' '; \
strncpy_P(msg+2, PSTR(PVAL), m-2); \ strncpy_P(msg+2, PSTR(PVAL), m-2); \
if (msg[m-1] & 0x80) msg[m-1] = '\0'; \ if (msg[m-1] & 0x80) msg[m-1] = '\0'; \
STATIC_ITEM_P(PLABEL, STYL, msg); \ STATIC_ITEM_F(FLABEL, STYL, msg); \
}while(0) }while(0)
#define PSTRING_ITEM(LABEL, V...) PSTRING_ITEM_P(GET_TEXT(LABEL), ##V) #define PSTRING_ITEM(LABEL, V...) PSTRING_ITEM_F(GET_TEXT_F(LABEL), ##V)
#define STATIC_ITEM(LABEL, V...) STATIC_ITEM_P(GET_TEXT(LABEL), ##V) #define STATIC_ITEM(LABEL, V...) STATIC_ITEM_F(GET_TEXT_F(LABEL), ##V)
#define STATIC_ITEM_N(LABEL, N, V...) STATIC_ITEM_N_P(GET_TEXT(LABEL), N, ##V) #define STATIC_ITEM_N(LABEL, N, V...) STATIC_ITEM_N_F(GET_TEXT_F(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_F(TYPE, N, S, FLABEL, V...) _MENU_ITEM_N_S_F(TYPE, N, S, false, FLABEL, ##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_N_S(TYPE, N, S, LABEL, V...) MENU_ITEM_N_S_F(TYPE, N, S, GET_TEXT_F(LABEL), ##V)
#define MENU_ITEM_S_P(TYPE, S, PLABEL, V...) _MENU_ITEM_S_P(TYPE, S, false, PLABEL, ##V) #define MENU_ITEM_S_F(TYPE, S, FLABEL, V...) _MENU_ITEM_S_F(TYPE, S, false, FLABEL, ##V)
#define MENU_ITEM_S(TYPE, S, LABEL, V...) MENU_ITEM_S_P(TYPE, S, GET_TEXT(LABEL), ##V) #define MENU_ITEM_S(TYPE, S, LABEL, V...) MENU_ITEM_S_F(TYPE, S, GET_TEXT_F(LABEL), ##V)
#define MENU_ITEM_N_P(TYPE, N, PLABEL, V...) _MENU_ITEM_N_P(TYPE, N, false, PLABEL, ##V) #define MENU_ITEM_N_F(TYPE, N, FLABEL, V...) _MENU_ITEM_N_F(TYPE, N, false, FLABEL, ##V)
#define MENU_ITEM_N(TYPE, N, LABEL, V...) MENU_ITEM_N_P(TYPE, N, GET_TEXT(LABEL), ##V) #define MENU_ITEM_N(TYPE, N, LABEL, V...) MENU_ITEM_N_F(TYPE, N, GET_TEXT_F(LABEL), ##V)
#define MENU_ITEM_P(TYPE, PLABEL, V...) _MENU_ITEM_P(TYPE, false, PLABEL, ##V) #define MENU_ITEM_F(TYPE, FLABEL, V...) _MENU_ITEM_F(TYPE, false, FLABEL, ##V)
#define MENU_ITEM(TYPE, LABEL, V...) MENU_ITEM_P(TYPE, GET_TEXT(LABEL), ##V) #define MENU_ITEM(TYPE, LABEL, V...) MENU_ITEM_F(TYPE, GET_TEXT_F(LABEL), ##V)
#define BACK_ITEM_P(PLABEL) MENU_ITEM_P(back, PLABEL) #define BACK_ITEM_F(FLABEL) MENU_ITEM_F(back, FLABEL)
#define BACK_ITEM(LABEL) MENU_ITEM(back, LABEL) #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_F(N, S, FLABEL, ACTION) MENU_ITEM_N_S_F(function, N, S, FLABEL, ACTION)
#define ACTION_ITEM_N_S(N, S, LABEL, ACTION) ACTION_ITEM_N_S_P(N, S, GET_TEXT(LABEL), ACTION) #define ACTION_ITEM_N_S(N, S, LABEL, ACTION) ACTION_ITEM_N_S_F(N, S, GET_TEXT_F(LABEL), ACTION)
#define ACTION_ITEM_S_P(S, PLABEL, ACTION) MENU_ITEM_S_P(function, S, PLABEL, ACTION) #define ACTION_ITEM_S_F(S, FLABEL, ACTION) MENU_ITEM_S_F(function, S, FLABEL, ACTION)
#define ACTION_ITEM_S(S, LABEL, ACTION) ACTION_ITEM_S_P(S, GET_TEXT(LABEL), ACTION) #define ACTION_ITEM_S(S, LABEL, ACTION) ACTION_ITEM_S_F(S, GET_TEXT_F(LABEL), ACTION)
#define ACTION_ITEM_N_P(N, PLABEL, ACTION) MENU_ITEM_N_P(function, N, PLABEL, ACTION) #define ACTION_ITEM_N_F(N, FLABEL, ACTION) MENU_ITEM_N_F(function, N, FLABEL, ACTION)
#define ACTION_ITEM_N(N, LABEL, ACTION) ACTION_ITEM_N_P(N, GET_TEXT(LABEL), ACTION) #define ACTION_ITEM_N(N, LABEL, ACTION) ACTION_ITEM_N_F(N, GET_TEXT_F(LABEL), ACTION)
#define ACTION_ITEM_P(PLABEL, ACTION) MENU_ITEM_P(function, PLABEL, ACTION) #define ACTION_ITEM_F(FLABEL, ACTION) MENU_ITEM_F(function, FLABEL, ACTION)
#define ACTION_ITEM(LABEL, ACTION) ACTION_ITEM_P(GET_TEXT(LABEL), ACTION) #define ACTION_ITEM(LABEL, ACTION) ACTION_ITEM_F(GET_TEXT_F(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_F(N, S, FLABEL, GCODES) MENU_ITEM_N_S_F(gcode, N, S, FLABEL, GCODES)
#define GCODES_ITEM_N_S(N, S, LABEL, GCODES) GCODES_ITEM_N_S_P(N, S, GET_TEXT(LABEL), GCODES) #define GCODES_ITEM_N_S(N, S, LABEL, GCODES) GCODES_ITEM_N_S_F(N, S, GET_TEXT_F(LABEL), GCODES)
#define GCODES_ITEM_S_P(S, PLABEL, GCODES) MENU_ITEM_S_P(gcode, S, PLABEL, GCODES) #define GCODES_ITEM_S_F(S, FLABEL, GCODES) MENU_ITEM_S_F(gcode, S, FLABEL, GCODES)
#define GCODES_ITEM_S(S, LABEL, GCODES) GCODES_ITEM_S_P(S, GET_TEXT(LABEL), GCODES) #define GCODES_ITEM_S(S, LABEL, GCODES) GCODES_ITEM_S_F(S, GET_TEXT_F(LABEL), GCODES)
#define GCODES_ITEM_N_P(N, PLABEL, GCODES) MENU_ITEM_N_P(gcode, N, PLABEL, GCODES) #define GCODES_ITEM_N_F(N, FLABEL, GCODES) MENU_ITEM_N_F(gcode, N, FLABEL, GCODES)
#define GCODES_ITEM_N(N, LABEL, GCODES) GCODES_ITEM_N_P(N, GET_TEXT(LABEL), GCODES) #define GCODES_ITEM_N(N, LABEL, GCODES) GCODES_ITEM_N_F(N, GET_TEXT_F(LABEL), GCODES)
#define GCODES_ITEM_P(PLABEL, GCODES) MENU_ITEM_P(gcode, PLABEL, GCODES) #define GCODES_ITEM_F(FLABEL, GCODES) MENU_ITEM_F(gcode, FLABEL, GCODES)
#define GCODES_ITEM(LABEL, GCODES) GCODES_ITEM_P(GET_TEXT(LABEL), GCODES) #define GCODES_ITEM(LABEL, GCODES) GCODES_ITEM_F(GET_TEXT_F(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_F(N, S, FLABEL, DEST) MENU_ITEM_N_S_F(submenu, N, S, FLABEL, DEST)
#define SUBMENU_N_S(N, S, LABEL, DEST) SUBMENU_N_S_P(N, S, GET_TEXT(LABEL), DEST) #define SUBMENU_N_S(N, S, LABEL, DEST) SUBMENU_N_S_F(N, S, GET_TEXT_F(LABEL), DEST)
#define SUBMENU_S_P(S, PLABEL, DEST) MENU_ITEM_S_P(submenu, S, PLABEL, DEST) #define SUBMENU_S_F(S, FLABEL, DEST) MENU_ITEM_S_F(submenu, S, FLABEL, DEST)
#define SUBMENU_S(S, LABEL, DEST) SUBMENU_S_P(S, GET_TEXT(LABEL), DEST) #define SUBMENU_S(S, LABEL, DEST) SUBMENU_S_F(S, GET_TEXT_F(LABEL), DEST)
#define SUBMENU_N_P(N, PLABEL, DEST) MENU_ITEM_N_P(submenu, N, PLABEL, DEST) #define SUBMENU_N_F(N, FLABEL, DEST) MENU_ITEM_N_F(submenu, N, FLABEL, DEST)
#define SUBMENU_N(N, LABEL, DEST) SUBMENU_N_P(N, GET_TEXT(LABEL), DEST) #define SUBMENU_N(N, LABEL, DEST) SUBMENU_N_F(N, GET_TEXT_F(LABEL), DEST)
#define SUBMENU_P(PLABEL, DEST) MENU_ITEM_P(submenu, PLABEL, DEST) #define SUBMENU_F(FLABEL, DEST) MENU_ITEM_F(submenu, FLABEL, DEST)
#define SUBMENU(LABEL, DEST) SUBMENU_P(GET_TEXT(LABEL), DEST) #define SUBMENU(LABEL, DEST) SUBMENU_F(GET_TEXT_F(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_F(TYPE, N, S, FLABEL, V...) MENU_ITEM_N_S_F(TYPE, N, S, FLABEL, ##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_N_S(TYPE, N, S, LABEL, V...) EDIT_ITEM_N_S_F(TYPE, N, S, GET_TEXT_F(LABEL), ##V)
#define EDIT_ITEM_S_P(TYPE, S, PLABEL, V...) MENU_ITEM_S_P(TYPE, S, PLABEL, ##V) #define EDIT_ITEM_S_F(TYPE, S, FLABEL, V...) MENU_ITEM_S_F(TYPE, S, FLABEL, ##V)
#define EDIT_ITEM_S(TYPE, S, LABEL, V...) EDIT_ITEM_S_P(TYPE, S, GET_TEXT(LABEL), ##V) #define EDIT_ITEM_S(TYPE, S, LABEL, V...) EDIT_ITEM_S_F(TYPE, S, GET_TEXT_F(LABEL), ##V)
#define EDIT_ITEM_N_P(TYPE, N, PLABEL, V...) MENU_ITEM_N_P(TYPE, N, PLABEL, ##V) #define EDIT_ITEM_N_F(TYPE, N, FLABEL, V...) MENU_ITEM_N_F(TYPE, N, FLABEL, ##V)
#define EDIT_ITEM_N(TYPE, N, LABEL, V...) EDIT_ITEM_N_P(TYPE, N, GET_TEXT(LABEL), ##V) #define EDIT_ITEM_N(TYPE, N, LABEL, V...) EDIT_ITEM_N_F(TYPE, N, GET_TEXT_F(LABEL), ##V)
#define EDIT_ITEM_P(TYPE, PLABEL, V...) MENU_ITEM_P(TYPE, PLABEL, ##V) #define EDIT_ITEM_F(TYPE, FLABEL, V...) MENU_ITEM_F(TYPE, FLABEL, ##V)
#define EDIT_ITEM(TYPE, LABEL, V...) EDIT_ITEM_P(TYPE, GET_TEXT(LABEL), ##V) #define EDIT_ITEM(TYPE, LABEL, V...) EDIT_ITEM_F(TYPE, GET_TEXT_F(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_F(TYPE, N, S, FLABEL, V...) _MENU_ITEM_N_S_F(TYPE, N, S, true, FLABEL, ##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_N_S(TYPE, N, S, LABEL, V...) EDIT_ITEM_FAST_N_S_F(TYPE, N, S, true, GET_TEXT_F(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_F(TYPE, S, FLABEL, V...) _MENU_ITEM_S_F(TYPE, S, true, FLABEL, ##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_S(TYPE, S, LABEL, V...) EDIT_ITEM_FAST_S_F(TYPE, S, GET_TEXT_F(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_F(TYPE, N, FLABEL, V...) _MENU_ITEM_N_F(TYPE, N, true, FLABEL, ##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_N(TYPE, N, LABEL, V...) EDIT_ITEM_FAST_N_F(TYPE, N, GET_TEXT_F(LABEL), ##V)
#define EDIT_ITEM_FAST_P(TYPE, PLABEL, V...) _MENU_ITEM_P(TYPE, true, PLABEL, ##V) #define EDIT_ITEM_FAST_F(TYPE, FLABEL, V...) _MENU_ITEM_F(TYPE, true, FLABEL, ##V)
#define EDIT_ITEM_FAST(TYPE, LABEL, V...) EDIT_ITEM_FAST_P(TYPE, GET_TEXT(LABEL), ##V) #define EDIT_ITEM_FAST(TYPE, LABEL, V...) EDIT_ITEM_FAST_F(TYPE, GET_TEXT_F(LABEL), ##V)
#define _CONFIRM_ITEM_INNER_P(PLABEL, V...) do { \ #define _CONFIRM_ITEM_INNER_F(FLABEL, V...) do { \
if (encoderLine == _thisItemNr && ui.use_click()) { \ if (encoderLine == _thisItemNr && ui.use_click()) { \
ui.push_current_screen(); \ ui.push_current_screen(); \
ui.goto_screen([]{MenuItem_confirm::select_screen(V);}); \ ui.goto_screen([]{MenuItem_confirm::select_screen(V);}); \
return; \ return; \
} \ } \
if (ui.should_draw()) MenuItem_confirm::draw \ if (ui.should_draw()) MenuItem_confirm::draw \
(encoderLine == _thisItemNr, _lcdLineNr, PLABEL, ##V); \ (encoderLine == _thisItemNr, _lcdLineNr, FLABEL, ##V); \
}while(0) }while(0)
// Indexed items set a global index value and optional data // Indexed items set a global index value and optional data
#define _CONFIRM_ITEM_P(PLABEL, V...) do { \ #define _CONFIRM_ITEM_F(FLABEL, V...) do { \
if (_menuLineNr == _thisItemNr) { \ if (_menuLineNr == _thisItemNr) { \
_skipStatic = false; \ _skipStatic = false; \
_CONFIRM_ITEM_INNER_P(PLABEL, ##V); \ _CONFIRM_ITEM_INNER_F(FLABEL, ##V); \
} \ } \
NEXT_ITEM(); \ NEXT_ITEM(); \
}while(0) }while(0)
// Indexed items set a global index value // Indexed items set a global index value
#define _CONFIRM_ITEM_N_S_P(N, S, V...) do{ \ #define _CONFIRM_ITEM_N_S_F(N, S, V...) do{ \
if (_menuLineNr == _thisItemNr) { \ if (_menuLineNr == _thisItemNr) { \
_skipStatic = false; \ _skipStatic = false; \
MenuItemBase::init(N, S); \ MenuItemBase::init(N, S); \
_CONFIRM_ITEM_INNER_P(TYPE, ##V); \ _CONFIRM_ITEM_INNER_F(TYPE, ##V); \
} \ } \
NEXT_ITEM(); \ NEXT_ITEM(); \
}while(0) }while(0)
// Indexed items set a global index value // 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_N_F(N, V...) _CONFIRM_ITEM_N_S_F(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_F(FLABEL,A,B,V...) _CONFIRM_ITEM_F(FLABEL, GET_TEXT_F(A), GET_TEXT_F(B), ##V)
#define CONFIRM_ITEM(LABEL, V...) CONFIRM_ITEM_P(GET_TEXT(LABEL), ##V) #define CONFIRM_ITEM(LABEL, V...) CONFIRM_ITEM_F(GET_TEXT_F(LABEL), ##V)
#define YESNO_ITEM_P(PLABEL, V...) CONFIRM_ITEM_P(PLABEL, MSG_YES, MSG_NO, ##V) #define YESNO_ITEM_F(FLABEL, V...) CONFIRM_ITEM_F(FLABEL, MSG_YES, MSG_NO, ##V)
#define YESNO_ITEM(LABEL, V...) YESNO_ITEM_P(GET_TEXT(LABEL), ##V) #define YESNO_ITEM(LABEL, V...) YESNO_ITEM_F(GET_TEXT_F(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_F(N,S,FLABEL,A,B,V...) _CONFIRM_ITEM_N_S_F(N, S, FLABEL, GET_TEXT_F(A), GET_TEXT_F(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_S(N,S,LABEL,V...) CONFIRM_ITEM_N_S_F(N, S, GET_TEXT_F(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_F(N,FLABEL,A,B,V...) _CONFIRM_ITEM_N_F(N, FLABEL, GET_TEXT_F(A), GET_TEXT_F(B), ##V)
#define CONFIRM_ITEM_N(N,LABEL, V...) CONFIRM_ITEM_N_P(N, GET_TEXT(LABEL), ##V) #define CONFIRM_ITEM_N(N,LABEL, V...) CONFIRM_ITEM_N_F(N, GET_TEXT_F(LABEL), ##V)
#define YESNO_ITEM_N_S_P(N,S,PLABEL, V...) _CONFIRM_ITEM_N_S_P(N, S, PLABEL, MSG_YES, MSG_NO, ##V) #define YESNO_ITEM_N_S_F(N,S,FLABEL, V...) _CONFIRM_ITEM_N_S_F(N, S, FLABEL, MSG_YES, MSG_NO, ##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_S(N,S,LABEL, V...) YESNO_ITEM_N_S_F(N, S, GET_TEXT_F(LABEL), ##V)
#define YESNO_ITEM_N_P(N,PLABEL, V...) CONFIRM_ITEM_N_P(N, PLABEL, MSG_YES, MSG_NO, ##V) #define YESNO_ITEM_N_F(N,FLABEL, V...) CONFIRM_ITEM_N_F(N, FLABEL, MSG_YES, MSG_NO, ##V)
#define YESNO_ITEM_N(N,LABEL, V...) YESNO_ITEM_N_P(N, GET_TEXT(LABEL), ##V) #define YESNO_ITEM_N(N,LABEL, V...) YESNO_ITEM_N_F(N, GET_TEXT_F(LABEL), ##V)
#if ENABLED(LEVEL_BED_CORNERS) #if ENABLED(LEVEL_BED_CORNERS)
void _lcd_level_bed_corners(); void _lcd_level_bed_corners();

10
Marlin/src/lcd/menu/menu_language.cpp
View file

@ -41,14 +41,14 @@ void menu_language() {
START_MENU(); START_MENU();
BACK_ITEM(MSG_MAIN); BACK_ITEM(MSG_MAIN);
MENU_ITEM_P(function, GET_LANG(LCD_LANGUAGE )::LANGUAGE, []{ set_lcd_language(0); }); MENU_ITEM_F(function, FPSTR(GET_LANGUAGE_NAME(1)), []{ set_lcd_language(0); });
MENU_ITEM_P(function, GET_LANG(LCD_LANGUAGE_2)::LANGUAGE, []{ set_lcd_language(1); }); MENU_ITEM_F(function, FPSTR(GET_LANGUAGE_NAME(2)), []{ set_lcd_language(1); });
#if NUM_LANGUAGES > 2 #if NUM_LANGUAGES > 2
MENU_ITEM_P(function, GET_LANG(LCD_LANGUAGE_3)::LANGUAGE, []{ set_lcd_language(2); }); MENU_ITEM_F(function, FPSTR(GET_LANGUAGE_NAME(3)), []{ set_lcd_language(2); });
#if NUM_LANGUAGES > 3 #if NUM_LANGUAGES > 3
MENU_ITEM_P(function, GET_LANG(LCD_LANGUAGE_4)::LANGUAGE, []{ set_lcd_language(3); }); MENU_ITEM_F(function, FPSTR(GET_LANGUAGE_NAME(4)), []{ set_lcd_language(3); });
#if NUM_LANGUAGES > 4 #if NUM_LANGUAGES > 4
MENU_ITEM_P(function, GET_LANG(LCD_LANGUAGE_5)::LANGUAGE, []{ set_lcd_language(4); }); MENU_ITEM_F(function, FPSTR(GET_LANGUAGE_NAME(5)), []{ set_lcd_language(4); });
#endif #endif
#endif #endif
#endif #endif

56
Marlin/src/lcd/menu/menu_main.cpp
View file

@ -124,13 +124,13 @@ void menu_configuration();
#define _DONE_SCRIPT "" #define _DONE_SCRIPT ""
#endif #endif
#define GCODE_LAMBDA_MAIN(N) []{ _lcd_custom_menu_main_gcode(F(MAIN_MENU_ITEM_##N##_GCODE _DONE_SCRIPT)); } #define GCODE_LAMBDA_MAIN(N) []{ _lcd_custom_menu_main_gcode(F(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(N) ACTION_ITEM_F(F(MAIN_MENU_ITEM_##N##_DESC), GCODE_LAMBDA_MAIN(N));
#define _CUSTOM_ITEM_MAIN_CONFIRM(N) \ #define _CUSTOM_ITEM_MAIN_CONFIRM(N) \
SUBMENU_P(PSTR(MAIN_MENU_ITEM_##N##_DESC), []{ \ SUBMENU_F(F(MAIN_MENU_ITEM_##N##_DESC), []{ \
MenuItem_confirm::confirm_screen( \ MenuItem_confirm::confirm_screen( \
GCODE_LAMBDA_MAIN(N), nullptr, \ GCODE_LAMBDA_MAIN(N), nullptr, \
PSTR(MAIN_MENU_ITEM_##N##_DESC "?") \ F(MAIN_MENU_ITEM_##N##_DESC "?") \
); \ ); \
}) })
#define CUSTOM_ITEM_MAIN(N) do{ \ #define CUSTOM_ITEM_MAIN(N) do{ \
@ -247,10 +247,10 @@ void menu_main() {
if (card_detected) { if (card_detected) {
if (!card_open) { if (!card_open) {
#if PIN_EXISTS(SD_DETECT) #if PIN_EXISTS(SD_DETECT)
GCODES_ITEM(MSG_CHANGE_MEDIA, PSTR("M21")); // M21 Change Media GCODES_ITEM(MSG_CHANGE_MEDIA, F("M21")); // M21 Change Media
#else // - or - #else // - or -
ACTION_ITEM(MSG_RELEASE_MEDIA, []{ // M22 Release Media ACTION_ITEM(MSG_RELEASE_MEDIA, []{ // M22 Release Media
queue.inject(PSTR("M22")); queue.inject(F("M22"));
#if ENABLED(TFT_COLOR_UI) #if ENABLED(TFT_COLOR_UI)
// Menu display issue on item removal with multi language selection menu // Menu display issue on item removal with multi language selection menu
if (encoderTopLine > 0) encoderTopLine--; if (encoderTopLine > 0) encoderTopLine--;
@ -258,14 +258,14 @@ void menu_main() {
#endif #endif
}); });
#endif #endif
SUBMENU(MSG_MEDIA_MENU, MEDIA_MENU_GATEWAY); // Media Menu (or Password First) SUBMENU(MSG_MEDIA_MENU, MEDIA_MENU_GATEWAY); // Media Menu (or Password First)
} }
} }
else { else {
#if PIN_EXISTS(SD_DETECT) #if PIN_EXISTS(SD_DETECT)
ACTION_ITEM(MSG_NO_MEDIA, nullptr); // "No Media" ACTION_ITEM(MSG_NO_MEDIA, nullptr); // "No Media"
#else #else
GCODES_ITEM(MSG_ATTACH_MEDIA, PSTR("M21")); // M21 Attach Media GCODES_ITEM(MSG_ATTACH_MEDIA, F("M21")); // M21 Attach Media
#endif #endif
} }
}; };
@ -279,9 +279,9 @@ void menu_main() {
#if MACHINE_CAN_STOP #if MACHINE_CAN_STOP
SUBMENU(MSG_STOP_PRINT, []{ SUBMENU(MSG_STOP_PRINT, []{
MenuItem_confirm::select_screen( MenuItem_confirm::select_screen(
GET_TEXT(MSG_BUTTON_STOP), GET_TEXT(MSG_BACK), GET_TEXT_F(MSG_BUTTON_STOP), GET_TEXT_F(MSG_BACK),
ui.abort_print, nullptr, ui.abort_print, nullptr,
GET_TEXT(MSG_STOP_PRINT), (const char *)nullptr, PSTR("?") GET_TEXT_F(MSG_STOP_PRINT), (const char *)nullptr, F("?")
); );
}); });
#endif #endif
@ -342,7 +342,7 @@ void menu_main() {
#if ENABLED(CUSTOM_MENU_MAIN) #if ENABLED(CUSTOM_MENU_MAIN)
if (TERN1(CUSTOM_MENU_MAIN_ONLY_IDLE, !busy)) { if (TERN1(CUSTOM_MENU_MAIN_ONLY_IDLE, !busy)) {
#ifdef CUSTOM_MENU_MAIN_TITLE #ifdef CUSTOM_MENU_MAIN_TITLE
SUBMENU_P(PSTR(CUSTOM_MENU_MAIN_TITLE), custom_menus_main); SUBMENU_F(F(CUSTOM_MENU_MAIN_TITLE), custom_menus_main);
#else #else
SUBMENU(MSG_CUSTOM_COMMANDS, custom_menus_main); SUBMENU(MSG_CUSTOM_COMMANDS, custom_menus_main);
#endif #endif
@ -353,7 +353,7 @@ void menu_main() {
#if E_STEPPERS == 1 && DISABLED(FILAMENT_LOAD_UNLOAD_GCODES) #if E_STEPPERS == 1 && DISABLED(FILAMENT_LOAD_UNLOAD_GCODES)
YESNO_ITEM(MSG_FILAMENTCHANGE, YESNO_ITEM(MSG_FILAMENTCHANGE,
menu_change_filament, nullptr, menu_change_filament, nullptr,
GET_TEXT(MSG_FILAMENTCHANGE), (const char *)nullptr, PSTR("?") GET_TEXT_F(MSG_FILAMENTCHANGE), (const char *)nullptr, F("?")
); );
#else #else
SUBMENU(MSG_FILAMENTCHANGE, menu_change_filament); SUBMENU(MSG_FILAMENTCHANGE, menu_change_filament);
@ -377,13 +377,13 @@ void menu_main() {
CONFIRM_ITEM(MSG_SWITCH_PS_OFF, CONFIRM_ITEM(MSG_SWITCH_PS_OFF,
MSG_YES, MSG_NO, MSG_YES, MSG_NO,
ui.poweroff, nullptr, ui.poweroff, nullptr,
GET_TEXT(MSG_SWITCH_PS_OFF), (const char *)nullptr, PSTR("?") GET_TEXT_F(MSG_SWITCH_PS_OFF), (const char *)nullptr, F("?")
); );
#else #else
ACTION_ITEM(MSG_SWITCH_PS_OFF, ui.poweroff); ACTION_ITEM(MSG_SWITCH_PS_OFF, ui.poweroff);
#endif #endif
else else
GCODES_ITEM(MSG_SWITCH_PS_ON, PSTR("M80")); GCODES_ITEM(MSG_SWITCH_PS_ON, F("M80"));
#endif #endif
#if ENABLED(SDSUPPORT) && DISABLED(MEDIA_MENU_AT_TOP) #if ENABLED(SDSUPPORT) && DISABLED(MEDIA_MENU_AT_TOP)
@ -398,24 +398,24 @@ void menu_main() {
ui.return_to_status(); ui.return_to_status();
}; };
#if SERVICE_INTERVAL_1 > 0 #if SERVICE_INTERVAL_1 > 0
CONFIRM_ITEM_P(PSTR(SERVICE_NAME_1), CONFIRM_ITEM_F(F(SERVICE_NAME_1),
MSG_BUTTON_RESET, MSG_BUTTON_CANCEL, MSG_BUTTON_RESET, MSG_BUTTON_CANCEL,
[]{ _service_reset(1); }, nullptr, []{ _service_reset(1); }, nullptr,
GET_TEXT(MSG_SERVICE_RESET), F(SERVICE_NAME_1), PSTR("?") GET_TEXT_F(MSG_SERVICE_RESET), F(SERVICE_NAME_1), F("?")
); );
#endif #endif
#if SERVICE_INTERVAL_2 > 0 #if SERVICE_INTERVAL_2 > 0
CONFIRM_ITEM_P(PSTR(SERVICE_NAME_2), CONFIRM_ITEM_F(F(SERVICE_NAME_2),
MSG_BUTTON_RESET, MSG_BUTTON_CANCEL, MSG_BUTTON_RESET, MSG_BUTTON_CANCEL,
[]{ _service_reset(2); }, nullptr, []{ _service_reset(2); }, nullptr,
GET_TEXT(MSG_SERVICE_RESET), F(SERVICE_NAME_2), PSTR("?") GET_TEXT_F(MSG_SERVICE_RESET), F(SERVICE_NAME_2), F("?")
); );
#endif #endif
#if SERVICE_INTERVAL_3 > 0 #if SERVICE_INTERVAL_3 > 0
CONFIRM_ITEM_P(PSTR(SERVICE_NAME_3), CONFIRM_ITEM_F(F(SERVICE_NAME_3),
MSG_BUTTON_RESET, MSG_BUTTON_CANCEL, MSG_BUTTON_RESET, MSG_BUTTON_CANCEL,
[]{ _service_reset(3); }, nullptr, []{ _service_reset(3); }, nullptr,
GET_TEXT(MSG_SERVICE_RESET), F(SERVICE_NAME_3), PSTR("?") GET_TEXT_F(MSG_SERVICE_RESET), F(SERVICE_NAME_3), F("?")
); );
#endif #endif
#endif #endif
@ -451,9 +451,9 @@ void menu_main() {
#if ENABLED(HOST_SHUTDOWN_MENU_ITEM) && defined(SHUTDOWN_ACTION) #if ENABLED(HOST_SHUTDOWN_MENU_ITEM) && defined(SHUTDOWN_ACTION)
SUBMENU(MSG_HOST_SHUTDOWN, []{ SUBMENU(MSG_HOST_SHUTDOWN, []{
MenuItem_confirm::select_screen( MenuItem_confirm::select_screen(
GET_TEXT(MSG_BUTTON_PROCEED), GET_TEXT(MSG_BUTTON_CANCEL), GET_TEXT_F(MSG_BUTTON_PROCEED), GET_TEXT_F(MSG_BUTTON_CANCEL),
[]{ ui.return_to_status(); hostui.shutdown(); }, nullptr, []{ ui.return_to_status(); hostui.shutdown(); }, nullptr,
GET_TEXT(MSG_HOST_SHUTDOWN), (const char *)nullptr, PSTR("?") GET_TEXT_F(MSG_HOST_SHUTDOWN), (const char *)nullptr, F("?")
); );
}); });
#endif #endif

26
Marlin/src/lcd/menu/menu_media.cpp
View file

@ -61,10 +61,10 @@ inline void sdcard_start_selected_file() {
class MenuItem_sdfile : public MenuItem_sdbase { class MenuItem_sdfile : public MenuItem_sdbase {
public: public:
static inline void draw(const bool sel, const uint8_t row, PGM_P const pstr, CardReader &theCard) { static inline void draw(const bool sel, const uint8_t row, FSTR_P const fstr, CardReader &theCard) {
MenuItem_sdbase::draw(sel, row, pstr, theCard, false); MenuItem_sdbase::draw(sel, row, fstr, theCard, false);
} }
static void action(PGM_P const pstr, CardReader &) { static void action(FSTR_P const fstr, CardReader &) {
#if ENABLED(SD_REPRINT_LAST_SELECTED_FILE) #if ENABLED(SD_REPRINT_LAST_SELECTED_FILE)
// Save menu state for the selected file // Save menu state for the selected file
sd_encoder_position = ui.encoderPosition; sd_encoder_position = ui.encoderPosition;
@ -72,30 +72,30 @@ class MenuItem_sdfile : public MenuItem_sdbase {
sd_items = screen_items; sd_items = screen_items;
#endif #endif
#if ENABLED(SD_MENU_CONFIRM_START) #if ENABLED(SD_MENU_CONFIRM_START)
MenuItem_submenu::action(pstr, []{ MenuItem_submenu::action(fstr, []{
char * const longest = card.longest_filename(); char * const longest = card.longest_filename();
char buffer[strlen(longest) + 2]; char buffer[strlen(longest) + 2];
buffer[0] = ' '; buffer[0] = ' ';
strcpy(buffer + 1, longest); strcpy(buffer + 1, longest);
MenuItem_confirm::select_screen( MenuItem_confirm::select_screen(
GET_TEXT(MSG_BUTTON_PRINT), GET_TEXT(MSG_BUTTON_CANCEL), GET_TEXT_F(MSG_BUTTON_PRINT), GET_TEXT_F(MSG_BUTTON_CANCEL),
sdcard_start_selected_file, nullptr, sdcard_start_selected_file, nullptr,
GET_TEXT(MSG_START_PRINT), buffer, PSTR("?") GET_TEXT_F(MSG_START_PRINT), buffer, F("?")
); );
}); });
#else #else
sdcard_start_selected_file(); sdcard_start_selected_file();
UNUSED(pstr); UNUSED(fstr);
#endif #endif
} }
}; };
class MenuItem_sdfolder : public MenuItem_sdbase { class MenuItem_sdfolder : public MenuItem_sdbase {
public: public:
static inline void draw(const bool sel, const uint8_t row, PGM_P const pstr, CardReader &theCard) { static inline void draw(const bool sel, const uint8_t row, FSTR_P const fstr, CardReader &theCard) {
MenuItem_sdbase::draw(sel, row, pstr, theCard, true); MenuItem_sdbase::draw(sel, row, fstr, theCard, true);
} }
static void action(PGM_P const, CardReader &theCard) { static void action(FSTR_P const, CardReader &theCard) {
card.cd(theCard.filename); card.cd(theCard.filename);
encoderTopLine = 0; encoderTopLine = 0;
ui.encoderPosition = 2 * (ENCODER_STEPS_PER_MENU_ITEM); ui.encoderPosition = 2 * (ENCODER_STEPS_PER_MENU_ITEM);
@ -119,7 +119,7 @@ void menu_media_filelist() {
#if ENABLED(MULTI_VOLUME) #if ENABLED(MULTI_VOLUME)
ACTION_ITEM(MSG_BACK, []{ ui.goto_screen(menu_media); }); ACTION_ITEM(MSG_BACK, []{ ui.goto_screen(menu_media); });
#else #else
BACK_ITEM_P(TERN1(BROWSE_MEDIA_ON_INSERT, screen_history_depth) ? GET_TEXT(MSG_MAIN) : GET_TEXT(MSG_BACK)); BACK_ITEM_F(TERN1(BROWSE_MEDIA_ON_INSERT, screen_history_depth) ? GET_TEXT_F(MSG_MAIN) : GET_TEXT_F(MSG_BACK));
#endif #endif
if (card.flag.workDirIsRoot) { if (card.flag.workDirIsRoot) {
#if !PIN_EXISTS(SD_DETECT) #if !PIN_EXISTS(SD_DETECT)
@ -127,7 +127,7 @@ void menu_media_filelist() {
#endif #endif
} }
else if (card.isMounted()) else if (card.isMounted())
ACTION_ITEM_P(PSTR(LCD_STR_FOLDER " .."), lcd_sd_updir); ACTION_ITEM_F(F(LCD_STR_FOLDER " .."), lcd_sd_updir);
if (ui.should_draw()) for (uint16_t i = 0; i < fileCnt; i++) { if (ui.should_draw()) for (uint16_t i = 0; i < fileCnt; i++) {
if (_menuLineNr == _thisItemNr) { if (_menuLineNr == _thisItemNr) {
@ -146,7 +146,7 @@ void menu_media_filelist() {
#if ENABLED(MULTI_VOLUME) #if ENABLED(MULTI_VOLUME)
void menu_media_select() { void menu_media_select() {
START_MENU(); START_MENU();
BACK_ITEM_P(TERN1(BROWSE_MEDIA_ON_INSERT, screen_history_depth) ? GET_TEXT(MSG_MAIN) : GET_TEXT(MSG_BACK)); BACK_ITEM_F(TERN1(BROWSE_MEDIA_ON_INSERT, screen_history_depth) ? GET_TEXT_F(MSG_MAIN) : GET_TEXT_F(MSG_BACK));
#if ENABLED(VOLUME_SD_ONBOARD) #if ENABLED(VOLUME_SD_ONBOARD)
ACTION_ITEM(MSG_SD_CARD, []{ card.changeMedia(&card.media_driver_sdcard); card.mount(); ui.goto_screen(menu_media_filelist); }); ACTION_ITEM(MSG_SD_CARD, []{ card.changeMedia(&card.media_driver_sdcard); card.mount(); ui.goto_screen(menu_media_filelist); });
#endif #endif

10
Marlin/src/lcd/menu/menu_mixer.cpp
View file

@ -89,15 +89,15 @@
char tmp[18]; char tmp[18];
PGM_P const slabel = GET_TEXT(MSG_START_Z); FSTR_P const slabel = GET_TEXT_F(MSG_START_Z);
SUBMENU_P(slabel, []{ _lcd_mixer_gradient_z_edit(false); }); SUBMENU_F(slabel, []{ _lcd_mixer_gradient_z_edit(false); });
MENU_ITEM_ADDON_START_RJ(11); 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); sprintf_P(tmp, PSTR("%4d.%d mm"), int(mixer.gradient.start_z), int(mixer.gradient.start_z * 10) % 10);
lcd_put_u8str(tmp); lcd_put_u8str(tmp);
MENU_ITEM_ADDON_END(); MENU_ITEM_ADDON_END();
PGM_P const elabel = GET_TEXT(MSG_END_Z); FSTR_P const elabel = GET_TEXT_F(MSG_END_Z);
SUBMENU_P(elabel, []{ _lcd_mixer_gradient_z_edit(true); }); SUBMENU_F(elabel, []{ _lcd_mixer_gradient_z_edit(true); });
MENU_ITEM_ADDON_START_RJ(11); 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); sprintf_P(tmp, PSTR("%4d.%d mm"), int(mixer.gradient.end_z), int(mixer.gradient.end_z * 10) % 10);
lcd_put_u8str(tmp); lcd_put_u8str(tmp);
@ -257,7 +257,7 @@ void menu_mixer() {
ui.return_to_status(); ui.return_to_status();
}, },
nullptr, nullptr,
GET_TEXT(MSG_RESET_VTOOLS), (const char *)nullptr, PSTR("?") GET_TEXT_F(MSG_RESET_VTOOLS), (const char *)nullptr, F("?")
); );
#if ENABLED(GRADIENT_MIX) #if ENABLED(GRADIENT_MIX)

88
Marlin/src/lcd/menu/menu_motion.cpp
View file

@ -57,7 +57,7 @@
// "Motion" > "Move Axis" submenu // "Motion" > "Move Axis" submenu
// //
static void _lcd_move_xyz(PGM_P const name, const AxisEnum axis) { static void _lcd_move_xyz(FSTR_P const name, const AxisEnum axis) {
if (ui.use_click()) return ui.goto_previous_screen_no_defer(); if (ui.use_click()) return ui.goto_previous_screen_no_defer();
if (ui.encoderPosition && !ui.manual_move.processing) { if (ui.encoderPosition && !ui.manual_move.processing) {
// Get motion limit from software endstops, if any // Get motion limit from software endstops, if any
@ -90,21 +90,21 @@ static void _lcd_move_xyz(PGM_P const name, const AxisEnum axis) {
MenuEditItemBase::draw_edit_screen(name, ui.manual_move.menu_scale >= 0.1f ? (LARGE_AREA_TEST ? ftostr51sign(pos) : ftostr41sign(pos)) : ftostr63(pos)); MenuEditItemBase::draw_edit_screen(name, ui.manual_move.menu_scale >= 0.1f ? (LARGE_AREA_TEST ? ftostr51sign(pos) : ftostr41sign(pos)) : ftostr63(pos));
} }
} }
void lcd_move_x() { _lcd_move_xyz(GET_TEXT(MSG_MOVE_X), X_AXIS); } void lcd_move_x() { _lcd_move_xyz(GET_TEXT_F(MSG_MOVE_X), X_AXIS); }
#if HAS_Y_AXIS #if HAS_Y_AXIS
void lcd_move_y() { _lcd_move_xyz(GET_TEXT(MSG_MOVE_Y), Y_AXIS); } void lcd_move_y() { _lcd_move_xyz(GET_TEXT_F(MSG_MOVE_Y), Y_AXIS); }
#endif #endif
#if HAS_Z_AXIS #if HAS_Z_AXIS
void lcd_move_z() { _lcd_move_xyz(GET_TEXT(MSG_MOVE_Z), Z_AXIS); } void lcd_move_z() { _lcd_move_xyz(GET_TEXT_F(MSG_MOVE_Z), Z_AXIS); }
#endif #endif
#if HAS_I_AXIS #if HAS_I_AXIS
void lcd_move_i() { _lcd_move_xyz(GET_TEXT(MSG_MOVE_I), I_AXIS); } void lcd_move_i() { _lcd_move_xyz(GET_TEXT_F(MSG_MOVE_I), I_AXIS); }
#endif #endif
#if HAS_J_AXIS #if HAS_J_AXIS
void lcd_move_j() { _lcd_move_xyz(GET_TEXT(MSG_MOVE_J), J_AXIS); } void lcd_move_j() { _lcd_move_xyz(GET_TEXT_F(MSG_MOVE_J), J_AXIS); }
#endif #endif
#if HAS_K_AXIS #if HAS_K_AXIS
void lcd_move_k() { _lcd_move_xyz(GET_TEXT(MSG_MOVE_K), K_AXIS); } void lcd_move_k() { _lcd_move_xyz(GET_TEXT_F(MSG_MOVE_K), K_AXIS); }
#endif #endif
#if E_MANUAL #if E_MANUAL
@ -123,7 +123,7 @@ void lcd_move_x() { _lcd_move_xyz(GET_TEXT(MSG_MOVE_X), X_AXIS); }
if (ui.should_draw()) { if (ui.should_draw()) {
TERN_(MULTI_E_MANUAL, MenuItemBase::init(eindex)); TERN_(MULTI_E_MANUAL, MenuItemBase::init(eindex));
MenuEditItemBase::draw_edit_screen( MenuEditItemBase::draw_edit_screen(
GET_TEXT(TERN(MULTI_E_MANUAL, MSG_MOVE_EN, MSG_MOVE_E)), GET_TEXT_F(TERN(MULTI_E_MANUAL, MSG_MOVE_EN, MSG_MOVE_E)),
ftostr41sign(current_position.e ftostr41sign(current_position.e
PLUS_TERN0(IS_KINEMATIC, ui.manual_move.offset) PLUS_TERN0(IS_KINEMATIC, ui.manual_move.offset)
MINUS_TERN0(MANUAL_E_MOVES_RELATIVE, manual_move_e_origin) MINUS_TERN0(MANUAL_E_MOVES_RELATIVE, manual_move_e_origin)
@ -195,12 +195,12 @@ void _menu_move_distance(const AxisEnum axis, const screenFunc_t func, const int
char tmp[strlen_P(label) + 10 + 1], numstr[10]; char tmp[strlen_P(label) + 10 + 1], numstr[10];
sprintf_P(tmp, label, dtostrf(FINE_MANUAL_MOVE, 1, digs, numstr)); sprintf_P(tmp, label, dtostrf(FINE_MANUAL_MOVE, 1, digs, numstr));
#if DISABLED(HAS_GRAPHICAL_TFT) #if DISABLED(HAS_GRAPHICAL_TFT)
SUBMENU_P(NUL_STR, []{ _goto_manual_move(float(FINE_MANUAL_MOVE)); }); SUBMENU_F(FPSTR(NUL_STR), []{ _goto_manual_move(float(FINE_MANUAL_MOVE)); });
MENU_ITEM_ADDON_START(0 + ENABLED(HAS_MARLINUI_HD44780)); MENU_ITEM_ADDON_START(0 + ENABLED(HAS_MARLINUI_HD44780));
lcd_put_u8str(tmp); lcd_put_u8str(tmp);
MENU_ITEM_ADDON_END(); MENU_ITEM_ADDON_END();
#else #else
SUBMENU_P(tmp, []{ _goto_manual_move(float(FINE_MANUAL_MOVE)); }); SUBMENU_F(FPSTR(tmp), []{ _goto_manual_move(float(FINE_MANUAL_MOVE)); });
#endif #endif
} }
} }
@ -219,9 +219,9 @@ void _menu_move_distance(const AxisEnum axis, const screenFunc_t func, const int
if (too_cold) { if (too_cold) {
ui.goto_screen([]{ ui.goto_screen([]{
MenuItem_confirm::select_screen( MenuItem_confirm::select_screen(
GET_TEXT(MSG_BUTTON_PROCEED), GET_TEXT(MSG_BACK), GET_TEXT_F(MSG_BUTTON_PROCEED), GET_TEXT_F(MSG_BACK),
_goto_menu_move_distance_e, nullptr, _goto_menu_move_distance_e, nullptr,
GET_TEXT(MSG_HOTEND_TOO_COLD), (const char *)nullptr, PSTR("!") GET_TEXT_F(MSG_HOTEND_TOO_COLD), (const char *)nullptr, F("!")
); );
}); });
return; return;
@ -266,41 +266,41 @@ void menu_move() {
#endif #endif
} }
else else
GCODES_ITEM(MSG_AUTO_HOME, G28_STR); GCODES_ITEM(MSG_AUTO_HOME, FPSTR(G28_STR));
#if ANY(SWITCHING_EXTRUDER, SWITCHING_NOZZLE, MAGNETIC_SWITCHING_TOOLHEAD) #if ANY(SWITCHING_EXTRUDER, SWITCHING_NOZZLE, MAGNETIC_SWITCHING_TOOLHEAD)
#if EXTRUDERS >= 4 #if EXTRUDERS >= 4
switch (active_extruder) { switch (active_extruder) {
case 0: GCODES_ITEM_N(1, MSG_SELECT_E, PSTR("T1")); break; case 0: GCODES_ITEM_N(1, MSG_SELECT_E, F("T1")); break;
case 1: GCODES_ITEM_N(0, MSG_SELECT_E, PSTR("T0")); break; case 1: GCODES_ITEM_N(0, MSG_SELECT_E, F("T0")); break;
case 2: GCODES_ITEM_N(3, MSG_SELECT_E, PSTR("T3")); break; case 2: GCODES_ITEM_N(3, MSG_SELECT_E, F("T3")); break;
case 3: GCODES_ITEM_N(2, MSG_SELECT_E, PSTR("T2")); break; case 3: GCODES_ITEM_N(2, MSG_SELECT_E, F("T2")); break;
#if EXTRUDERS == 6 #if EXTRUDERS == 6
case 4: GCODES_ITEM_N(5, MSG_SELECT_E, PSTR("T5")); break; case 4: GCODES_ITEM_N(5, MSG_SELECT_E, F("T5")); break;
case 5: GCODES_ITEM_N(4, MSG_SELECT_E, PSTR("T4")); break; case 5: GCODES_ITEM_N(4, MSG_SELECT_E, F("T4")); break;
#endif #endif
} }
#elif EXTRUDERS == 3 #elif EXTRUDERS == 3
if (active_extruder < 2) { if (active_extruder < 2) {
if (active_extruder) if (active_extruder)
GCODES_ITEM_N(0, MSG_SELECT_E, PSTR("T0")); GCODES_ITEM_N(0, MSG_SELECT_E, F("T0"));
else else
GCODES_ITEM_N(1, MSG_SELECT_E, PSTR("T1")); GCODES_ITEM_N(1, MSG_SELECT_E, F("T1"));
} }
#else #else
if (active_extruder) if (active_extruder)
GCODES_ITEM_N(0, MSG_SELECT_E, PSTR("T0")); GCODES_ITEM_N(0, MSG_SELECT_E, F("T0"));
else else
GCODES_ITEM_N(1, MSG_SELECT_E, PSTR("T1")); GCODES_ITEM_N(1, MSG_SELECT_E, F("T1"));
#endif #endif
#elif ENABLED(DUAL_X_CARRIAGE) #elif ENABLED(DUAL_X_CARRIAGE)
if (active_extruder) if (active_extruder)
GCODES_ITEM_N(0, MSG_SELECT_E, PSTR("T0")); GCODES_ITEM_N(0, MSG_SELECT_E, F("T0"));
else else
GCODES_ITEM_N(1, MSG_SELECT_E, PSTR("T1")); GCODES_ITEM_N(1, MSG_SELECT_E, F("T1"));
#endif #endif
@ -338,22 +338,22 @@ void menu_move() {
START_MENU(); START_MENU();
BACK_ITEM(MSG_MOTION); BACK_ITEM(MSG_MOTION);
GCODES_ITEM(MSG_AUTO_HOME, G28_STR); GCODES_ITEM(MSG_AUTO_HOME, FPSTR(G28_STR));
GCODES_ITEM_N(X_AXIS, MSG_AUTO_HOME_A, PSTR("G28X")); GCODES_ITEM_N(X_AXIS, MSG_AUTO_HOME_A, F("G28X"));
#if HAS_Y_AXIS #if HAS_Y_AXIS
GCODES_ITEM_N(Y_AXIS, MSG_AUTO_HOME_A, PSTR("G28Y")); GCODES_ITEM_N(Y_AXIS, MSG_AUTO_HOME_A, F("G28Y"));
#endif #endif
#if HAS_Z_AXIS #if HAS_Z_AXIS
GCODES_ITEM_N(Z_AXIS, MSG_AUTO_HOME_A, PSTR("G28Z")); GCODES_ITEM_N(Z_AXIS, MSG_AUTO_HOME_A, F("G28Z"));
#endif #endif
#if HAS_I_AXIS #if HAS_I_AXIS
GCODES_ITEM_N(I_AXIS, MSG_AUTO_HOME_A, PSTR("G28" STR_I)); GCODES_ITEM_N(I_AXIS, MSG_AUTO_HOME_A, F("G28" STR_I));
#endif #endif
#if HAS_J_AXIS #if HAS_J_AXIS
GCODES_ITEM_N(J_AXIS, MSG_AUTO_HOME_A, PSTR("G28" STR_J)); GCODES_ITEM_N(J_AXIS, MSG_AUTO_HOME_A, F("G28" STR_J));
#endif #endif
#if HAS_K_AXIS #if HAS_K_AXIS
GCODES_ITEM_N(K_AXIS, MSG_AUTO_HOME_A, PSTR("G28" STR_K)); GCODES_ITEM_N(K_AXIS, MSG_AUTO_HOME_A, F("G28" STR_K));
#endif #endif
END_MENU(); END_MENU();
@ -390,23 +390,23 @@ void menu_motion() {
#if ENABLED(INDIVIDUAL_AXIS_HOMING_SUBMENU) #if ENABLED(INDIVIDUAL_AXIS_HOMING_SUBMENU)
SUBMENU(MSG_HOMING, menu_home); SUBMENU(MSG_HOMING, menu_home);
#else #else
GCODES_ITEM(MSG_AUTO_HOME, G28_STR); GCODES_ITEM(MSG_AUTO_HOME, FPSTR(G28_STR));
#if ENABLED(INDIVIDUAL_AXIS_HOMING_MENU) #if ENABLED(INDIVIDUAL_AXIS_HOMING_MENU)
GCODES_ITEM_N(X_AXIS, MSG_AUTO_HOME_A, PSTR("G28X")); GCODES_ITEM_N(X_AXIS, MSG_AUTO_HOME_A, F("G28X"));
#if HAS_Y_AXIS #if HAS_Y_AXIS
GCODES_ITEM_N(Y_AXIS, MSG_AUTO_HOME_A, PSTR("G28Y")); GCODES_ITEM_N(Y_AXIS, MSG_AUTO_HOME_A, F("G28Y"));
#endif #endif
#if HAS_Z_AXIS #if HAS_Z_AXIS
GCODES_ITEM_N(Z_AXIS, MSG_AUTO_HOME_A, PSTR("G28Z")); GCODES_ITEM_N(Z_AXIS, MSG_AUTO_HOME_A, F("G28Z"));
#endif #endif
#if HAS_I_AXIS #if HAS_I_AXIS
GCODES_ITEM_N(I_AXIS, MSG_AUTO_HOME_A, PSTR("G28" STR_I)); GCODES_ITEM_N(I_AXIS, MSG_AUTO_HOME_A, F("G28" STR_I));
#endif #endif
#if HAS_J_AXIS #if HAS_J_AXIS
GCODES_ITEM_N(J_AXIS, MSG_AUTO_HOME_A, PSTR("G28" STR_J)); GCODES_ITEM_N(J_AXIS, MSG_AUTO_HOME_A, F("G28" STR_J));
#endif #endif
#if HAS_K_AXIS #if HAS_K_AXIS
GCODES_ITEM_N(K_AXIS, MSG_AUTO_HOME_A, PSTR("G28" STR_K)); GCODES_ITEM_N(K_AXIS, MSG_AUTO_HOME_A, F("G28" STR_K));
#endif #endif
#endif #endif
#endif #endif
@ -415,14 +415,14 @@ void menu_motion() {
// Auto-calibration // Auto-calibration
// //
#if ENABLED(CALIBRATION_GCODE) #if ENABLED(CALIBRATION_GCODE)
GCODES_ITEM(MSG_AUTO_CALIBRATE, PSTR("G425")); GCODES_ITEM(MSG_AUTO_CALIBRATE, F("G425"));
#endif #endif
// //
// Auto Z-Align // Auto Z-Align
// //
#if EITHER(Z_STEPPER_AUTO_ALIGN, MECHANICAL_GANTRY_CALIBRATION) #if EITHER(Z_STEPPER_AUTO_ALIGN, MECHANICAL_GANTRY_CALIBRATION)
GCODES_ITEM(MSG_AUTO_Z_ALIGN, PSTR("G34")); GCODES_ITEM(MSG_AUTO_Z_ALIGN, F("G34"));
#endif #endif
// //
@ -447,7 +447,7 @@ void menu_motion() {
#elif HAS_LEVELING && DISABLED(SLIM_LCD_MENUS) #elif HAS_LEVELING && DISABLED(SLIM_LCD_MENUS)
#if DISABLED(PROBE_MANUALLY) #if DISABLED(PROBE_MANUALLY)
GCODES_ITEM(MSG_LEVEL_BED, PSTR("G29N")); GCODES_ITEM(MSG_LEVEL_BED, F("G29N"));
#endif #endif
if (all_axes_homed() && leveling_is_valid()) { if (all_axes_homed() && leveling_is_valid()) {
@ -467,13 +467,13 @@ void menu_motion() {
#endif #endif
#if ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST) #if ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)
GCODES_ITEM(MSG_M48_TEST, PSTR("G28O\nM48 P10")); GCODES_ITEM(MSG_M48_TEST, F("G28O\nM48 P10"));
#endif #endif
// //
// Disable Steppers // Disable Steppers
// //
GCODES_ITEM(MSG_DISABLE_STEPPERS, PSTR("M84")); GCODES_ITEM(MSG_DISABLE_STEPPERS, F("M84"));
END_MENU(); END_MENU();
} }

12
Marlin/src/lcd/menu/menu_password.cpp
View file

@ -49,18 +49,18 @@ void Password::menu_password_entry() {
START_MENU(); START_MENU();
// "Login" or "New Code" // "Login" or "New Code"
STATIC_ITEM_P(authenticating ? GET_TEXT(MSG_LOGIN_REQUIRED) : GET_TEXT(MSG_EDIT_PASSWORD), SS_CENTER|SS_INVERT); STATIC_ITEM_F(authenticating ? GET_TEXT_F(MSG_LOGIN_REQUIRED) : GET_TEXT_F(MSG_EDIT_PASSWORD), SS_CENTER|SS_INVERT);
STATIC_ITEM_P(NUL_STR, SS_CENTER, string); STATIC_ITEM_F(FPSTR(NUL_STR), SS_CENTER, string);
#if HAS_MARLINUI_U8GLIB #if HAS_MARLINUI_U8GLIB
STATIC_ITEM_P(NUL_STR, SS_CENTER, ""); STATIC_ITEM_F(FPSTR(NUL_STR), SS_CENTER, "");
#endif #endif
// Make the digit edit item look like a sub-menu // Make the digit edit item look like a sub-menu
PGM_P const label = GET_TEXT(MSG_ENTER_DIGIT); FSTR_P const label = GET_TEXT_F(MSG_ENTER_DIGIT);
EDIT_ITEM_P(uint8, label, &editable.uint8, 0, 9, digit_entered); EDIT_ITEM_F(uint8, label, &editable.uint8, 0, 9, digit_entered);
MENU_ITEM_ADDON_START(utf8_strlen_P(label) + 1); MENU_ITEM_ADDON_START(utf8_strlen(label) + 1);
lcd_put_wchar(' '); lcd_put_wchar(' ');
lcd_put_wchar('1' + digit_no); lcd_put_wchar('1' + digit_no);
SETCURSOR_X(LCD_WIDTH - 2); SETCURSOR_X(LCD_WIDTH - 2);

10
Marlin/src/lcd/menu/menu_probe_offset.cpp
View file

@ -62,7 +62,7 @@ void probe_offset_wizard_menu() {
if (LCD_HEIGHT >= 4) if (LCD_HEIGHT >= 4)
STATIC_ITEM(MSG_MOVE_NOZZLE_TO_BED, SS_CENTER|SS_INVERT); 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_F(F("Z"), SS_CENTER, ftostr42_52(current_position.z));
STATIC_ITEM(MSG_ZPROBE_ZOFFSET, SS_LEFT, ftostr42_52(calculated_z_offset)); STATIC_ITEM(MSG_ZPROBE_ZOFFSET, SS_LEFT, ftostr42_52(calculated_z_offset));
SUBMENU(MSG_MOVE_1MM, []{ _goto_manual_move_z( 1); }); SUBMENU(MSG_MOVE_1MM, []{ _goto_manual_move_z( 1); });
@ -75,12 +75,12 @@ void probe_offset_wizard_menu() {
!UNEAR_ZERO((FINE_MANUAL_MOVE) * 100 - int((FINE_MANUAL_MOVE) * 100)) ? 3 : 2; !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)); sprintf_P(tmp, GET_TEXT(MSG_MOVE_N_MM), dtostrf(FINE_MANUAL_MOVE, 1, digs, numstr));
#if DISABLED(HAS_GRAPHICAL_TFT) #if DISABLED(HAS_GRAPHICAL_TFT)
SUBMENU_P(NUL_STR, []{ _goto_manual_move_z(float(FINE_MANUAL_MOVE)); }); SUBMENU_F(FPSTR(NUL_STR), []{ _goto_manual_move_z(float(FINE_MANUAL_MOVE)); });
MENU_ITEM_ADDON_START(0 + ENABLED(HAS_MARLINUI_HD44780)); MENU_ITEM_ADDON_START(0 + ENABLED(HAS_MARLINUI_HD44780));
lcd_put_u8str(tmp); lcd_put_u8str(tmp);
MENU_ITEM_ADDON_END(); MENU_ITEM_ADDON_END();
#else #else
SUBMENU_P(tmp, []{ _goto_manual_move_z(float(FINE_MANUAL_MOVE)); }); SUBMENU_F(tmp, []{ _goto_manual_move_z(float(FINE_MANUAL_MOVE)); });
#endif #endif
} }
@ -107,7 +107,7 @@ void probe_offset_wizard_menu() {
void prepare_for_probe_offset_wizard() { void prepare_for_probe_offset_wizard() {
#if defined(PROBE_OFFSET_WIZARD_XY_POS) || !HOMING_Z_WITH_PROBE #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.should_draw()) MenuItem_static::draw(1, GET_TEXT_F(MSG_PROBE_WIZARD_PROBING));
if (ui.wait_for_move) return; if (ui.wait_for_move) return;
@ -133,7 +133,7 @@ void prepare_for_probe_offset_wizard() {
ui.wait_for_move = true; ui.wait_for_move = true;
current_position += probe.offset_xy; current_position += probe.offset_xy;
line_to_current_position(MMM_TO_MMS(XY_PROBE_FEEDRATE)); line_to_current_position(MMM_TO_MMS(XY_PROBE_FEEDRATE));
ui.synchronize(GET_TEXT(MSG_PROBE_WIZARD_MOVING)); ui.synchronize(GET_TEXT_F(MSG_PROBE_WIZARD_MOVING));
ui.wait_for_move = false; ui.wait_for_move = false;
SET_SOFT_ENDSTOP_LOOSE(true); // Disable soft endstops for free Z movement SET_SOFT_ENDSTOP_LOOSE(true); // Disable soft endstops for free Z movement

2
Marlin/src/lcd/menu/menu_spindle_laser.cpp
View file

@ -64,7 +64,7 @@
#if ENABLED(SPINDLE_CHANGE_DIR) #if ENABLED(SPINDLE_CHANGE_DIR)
if (!is_enabled) { if (!is_enabled) {
editable.state = is_rev; editable.state = is_rev;
ACTION_ITEM_P(is_rev ? GET_TEXT(MSG_CUTTER(REVERSE)) : GET_TEXT(MSG_CUTTER(FORWARD)), []{ cutter.set_reverse(!editable.state); }); ACTION_ITEM_F(is_rev ? GET_TEXT_F(MSG_CUTTER(REVERSE)) : GET_TEXT_F(MSG_CUTTER(FORWARD)), []{ cutter.set_reverse(!editable.state); });
} }
#endif #endif

8
Marlin/src/lcd/menu/menu_tmc.cpp
View file

@ -32,7 +32,7 @@
#include "../../module/stepper/indirection.h" #include "../../module/stepper/indirection.h"
#include "../../feature/tmc_util.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(); }) #define TMC_EDIT_STORED_I_RMS(ST,STR) EDIT_ITEM_F(uint16_4, F(STR), &stepper##ST.val_mA, 100, 3000, []{ stepper##ST.refresh_stepper_current(); })
void menu_tmc_current() { void menu_tmc_current() {
START_MENU(); START_MENU();
@ -90,7 +90,7 @@ void menu_tmc_current() {
#if ENABLED(HYBRID_THRESHOLD) #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(); }); #define TMC_EDIT_STORED_HYBRID_THRS(ST, STR) EDIT_ITEM_F(uint8, F(STR), &stepper##ST.stored.hybrid_thrs, 0, 255, []{ stepper##ST.refresh_hybrid_thrs(); });
void menu_tmc_hybrid_thrs() { void menu_tmc_hybrid_thrs() {
START_MENU(); START_MENU();
@ -118,7 +118,7 @@ void menu_tmc_current() {
#if ENABLED(SENSORLESS_HOMING) #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(); }); #define TMC_EDIT_STORED_SGT(ST) EDIT_ITEM_F(int4, F(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() { void menu_tmc_homing_thrs() {
START_MENU(); START_MENU();
@ -141,7 +141,7 @@ void menu_tmc_current() {
#if HAS_STEALTHCHOP #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(); }) #define TMC_EDIT_STEP_MODE(ST, STR) EDIT_ITEM_F(bool, F(STR), &stepper##ST.stored.stealthChop_enabled, []{ stepper##ST.refresh_stepping_mode(); })
void menu_tmc_step_mode() { void menu_tmc_step_mode() {
START_MENU(); START_MENU();

2
Marlin/src/lcd/menu/menu_tramming.cpp
View file

@ -83,7 +83,7 @@ static void tramming_wizard_menu() {
// Draw a menu item for each tramming point // Draw a menu item for each tramming point
for (tram_index = 0; tram_index < G35_PROBE_COUNT; tram_index++) for (tram_index = 0; tram_index < G35_PROBE_COUNT; tram_index++)
SUBMENU_P((char*)pgm_read_ptr(&tramming_point_name[tram_index]), _menu_single_probe); SUBMENU_F(FPSTR(pgm_read_ptr(&tramming_point_name[tram_index])), _menu_single_probe);
ACTION_ITEM(MSG_BUTTON_DONE, []{ ACTION_ITEM(MSG_BUTTON_DONE, []{
probe.stow(); // Stow before exiting Tramming Wizard probe.stow(); // Stow before exiting Tramming Wizard

10
Marlin/src/lcd/menu/menu_tune.cpp
View file

@ -50,7 +50,7 @@
#include "../dogm/marlinui_DOGM.h" #include "../dogm/marlinui_DOGM.h"
#endif #endif
void _lcd_babystep(const AxisEnum axis, PGM_P const msg) { void _lcd_babystep(const AxisEnum axis, FSTR_P const fmsg) {
if (ui.use_click()) return ui.goto_previous_screen_no_defer(); if (ui.use_click()) return ui.goto_previous_screen_no_defer();
if (ui.encoderPosition) { if (ui.encoderPosition) {
const int16_t steps = int16_t(ui.encoderPosition) * ( const int16_t steps = int16_t(ui.encoderPosition) * (
@ -66,7 +66,7 @@
} }
if (ui.should_draw()) { if (ui.should_draw()) {
const float mps = planner.mm_per_step[axis]; const float mps = planner.mm_per_step[axis];
MenuEditItemBase::draw_edit_screen(msg, BABYSTEP_TO_STR(mps * babystep.accum)); MenuEditItemBase::draw_edit_screen(fmsg, BABYSTEP_TO_STR(mps * babystep.accum));
#if ENABLED(BABYSTEP_DISPLAY_TOTAL) #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)); const bool in_view = TERN1(HAS_MARLINUI_U8GLIB, PAGE_CONTAINS(LCD_PIXEL_HEIGHT - MENU_FONT_HEIGHT, LCD_PIXEL_HEIGHT - 1));
if (in_view) { if (in_view) {
@ -94,12 +94,12 @@
} }
#if ENABLED(BABYSTEP_XY) #if ENABLED(BABYSTEP_XY)
void _lcd_babystep_x() { _lcd_babystep(X_AXIS, GET_TEXT(MSG_BABYSTEP_X)); } void _lcd_babystep_x() { _lcd_babystep(X_AXIS, GET_TEXT_F(MSG_BABYSTEP_X)); }
void _lcd_babystep_y() { _lcd_babystep(Y_AXIS, GET_TEXT(MSG_BABYSTEP_Y)); } void _lcd_babystep_y() { _lcd_babystep(Y_AXIS, GET_TEXT_F(MSG_BABYSTEP_Y)); }
#endif #endif
#if DISABLED(BABYSTEP_ZPROBE_OFFSET) #if DISABLED(BABYSTEP_ZPROBE_OFFSET)
void _lcd_babystep_z() { _lcd_babystep(Z_AXIS, GET_TEXT(MSG_BABYSTEP_Z)); } void _lcd_babystep_z() { _lcd_babystep(Z_AXIS, GET_TEXT_F(MSG_BABYSTEP_Z)); }
void lcd_babystep_z() { _lcd_babystep_go(_lcd_babystep_z); } void lcd_babystep_z() { _lcd_babystep_go(_lcd_babystep_z); }
#endif #endif

58
Marlin/src/lcd/menu/menu_ubl.cpp
View file

@ -67,7 +67,7 @@ inline float rounded_mesh_value() {
* - Draw the graphical overlay, if enabled. * - Draw the graphical overlay, if enabled.
* - Update the 'refresh' state according to the display type * - Update the 'refresh' state according to the display type
*/ */
void _lcd_mesh_fine_tune(PGM_P const msg) { void _lcd_mesh_fine_tune(FSTR_P const fmsg) {
constexpr float mesh_edit_step = 1.0f / 200.0f; constexpr float mesh_edit_step = 1.0f / 200.0f;
ui.defer_status_screen(); ui.defer_status_screen();
if (bedlevel.encoder_diff) { if (bedlevel.encoder_diff) {
@ -82,7 +82,7 @@ void _lcd_mesh_fine_tune(PGM_P const msg) {
if (ui.should_draw()) { if (ui.should_draw()) {
const float rounded_f = rounded_mesh_value(); const float rounded_f = rounded_mesh_value();
MenuEditItemBase::draw_edit_screen(msg, ftostr43sign(rounded_f)); MenuEditItemBase::draw_edit_screen(fmsg, ftostr43sign(rounded_f));
TERN_(MESH_EDIT_GFX_OVERLAY, ui.zoffset_overlay(rounded_f)); TERN_(MESH_EDIT_GFX_OVERLAY, ui.zoffset_overlay(rounded_f));
TERN_(HAS_GRAPHICAL_TFT, ui.refresh(LCDVIEW_NONE)); TERN_(HAS_GRAPHICAL_TFT, ui.refresh(LCDVIEW_NONE));
} }
@ -95,7 +95,7 @@ void _lcd_mesh_fine_tune(PGM_P const msg) {
void MarlinUI::ubl_mesh_edit_start(const_float_t initial) { void MarlinUI::ubl_mesh_edit_start(const_float_t initial) {
TERN_(HAS_GRAPHICAL_TFT, clear_lcd()); TERN_(HAS_GRAPHICAL_TFT, clear_lcd());
mesh_edit_accumulator = initial; mesh_edit_accumulator = initial;
goto_screen([]{ _lcd_mesh_fine_tune(GET_TEXT(MSG_MESH_EDIT_Z)); }); goto_screen([]{ _lcd_mesh_fine_tune(GET_TEXT_F(MSG_MESH_EDIT_Z)); });
} }
// //
@ -176,8 +176,8 @@ void _menu_ubl_height_adjust() {
void _lcd_ubl_edit_mesh() { void _lcd_ubl_edit_mesh() {
START_MENU(); START_MENU();
BACK_ITEM(MSG_UBL_TOOLS); BACK_ITEM(MSG_UBL_TOOLS);
GCODES_ITEM(MSG_UBL_FINE_TUNE_ALL, PSTR("G29P4RT")); GCODES_ITEM(MSG_UBL_FINE_TUNE_ALL, F("G29P4RT"));
GCODES_ITEM(MSG_UBL_FINE_TUNE_CLOSEST, PSTR("G29P4T")); GCODES_ITEM(MSG_UBL_FINE_TUNE_CLOSEST, F("G29P4T"));
SUBMENU(MSG_UBL_MESH_HEIGHT_ADJUST, _menu_ubl_height_adjust); SUBMENU(MSG_UBL_MESH_HEIGHT_ADJUST, _menu_ubl_height_adjust);
ACTION_ITEM(MSG_INFO_SCREEN, ui.return_to_status); ACTION_ITEM(MSG_INFO_SCREEN, ui.return_to_status);
END_MENU(); END_MENU();
@ -211,10 +211,10 @@ void _lcd_ubl_edit_mesh() {
#if HAS_PREHEAT #if HAS_PREHEAT
#if HAS_HEATED_BED #if HAS_HEATED_BED
#define VALIDATE_MESH_GCODE_ITEM(M) \ #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))); GCODES_ITEM_N_S(M, ui.get_preheat_label(M), MSG_UBL_VALIDATE_MESH_M, F("G28\nG26CPI" STRINGIFY(M)));
#else #else
#define VALIDATE_MESH_GCODE_ITEM(M) \ #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))); GCODES_ITEM_N_S(M, ui.get_preheat_label(M), MSG_UBL_VALIDATE_MESH_M, F("G28\nG26CPB0I" STRINGIFY(M)));
#endif #endif
REPEAT(PREHEAT_COUNT, VALIDATE_MESH_GCODE_ITEM) REPEAT(PREHEAT_COUNT, VALIDATE_MESH_GCODE_ITEM)
#endif #endif
@ -255,7 +255,7 @@ void _lcd_ubl_grid_level() {
void _lcd_ubl_mesh_leveling() { void _lcd_ubl_mesh_leveling() {
START_MENU(); START_MENU();
BACK_ITEM(MSG_UBL_TOOLS); BACK_ITEM(MSG_UBL_TOOLS);
GCODES_ITEM(MSG_UBL_3POINT_MESH_LEVELING, PSTR("G29J0")); GCODES_ITEM(MSG_UBL_3POINT_MESH_LEVELING, F("G29J0"));
SUBMENU(MSG_UBL_GRID_MESH_LEVELING, _lcd_ubl_grid_level); SUBMENU(MSG_UBL_GRID_MESH_LEVELING, _lcd_ubl_grid_level);
ACTION_ITEM(MSG_INFO_SCREEN, ui.return_to_status); ACTION_ITEM(MSG_INFO_SCREEN, ui.return_to_status);
END_MENU(); END_MENU();
@ -284,8 +284,8 @@ void _menu_ubl_fillin() {
START_MENU(); START_MENU();
BACK_ITEM(MSG_UBL_BUILD_MESH_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); 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_SMART_FILLIN, F("G29P3T0"));
GCODES_ITEM(MSG_UBL_MANUAL_FILLIN, PSTR("G29P2BT0")); GCODES_ITEM(MSG_UBL_MANUAL_FILLIN, F("G29P2BT0"));
ACTION_ITEM(MSG_INFO_SCREEN, ui.return_to_status); ACTION_ITEM(MSG_INFO_SCREEN, ui.return_to_status);
END_MENU(); END_MENU();
} }
@ -318,7 +318,7 @@ void _lcd_ubl_build_mesh() {
#define PREHEAT_BED_GCODE(M) "" #define PREHEAT_BED_GCODE(M) ""
#endif #endif
#define BUILD_MESH_GCODE_ITEM(M) GCODES_ITEM_S(ui.get_preheat_label(M), MSG_UBL_BUILD_MESH_M, \ #define BUILD_MESH_GCODE_ITEM(M) GCODES_ITEM_S(ui.get_preheat_label(M), MSG_UBL_BUILD_MESH_M, \
PSTR( \ F( \
"G28\n" \ "G28\n" \
PREHEAT_BED_GCODE(M) \ PREHEAT_BED_GCODE(M) \
"M109I" STRINGIFY(M) "\n" \ "M109I" STRINGIFY(M) "\n" \
@ -342,11 +342,11 @@ void _lcd_ubl_build_mesh() {
#endif // HAS_PREHEAT #endif // HAS_PREHEAT
SUBMENU(MSG_UBL_BUILD_CUSTOM_MESH, _lcd_ubl_custom_mesh); SUBMENU(MSG_UBL_BUILD_CUSTOM_MESH, _lcd_ubl_custom_mesh);
GCODES_ITEM(MSG_UBL_BUILD_COLD_MESH, PSTR("G29NP1")); GCODES_ITEM(MSG_UBL_BUILD_COLD_MESH, F("G29NP1"));
SUBMENU(MSG_UBL_FILLIN_MESH, _menu_ubl_fillin); SUBMENU(MSG_UBL_FILLIN_MESH, _menu_ubl_fillin);
GCODES_ITEM(MSG_UBL_CONTINUE_MESH, PSTR("G29P1C")); GCODES_ITEM(MSG_UBL_CONTINUE_MESH, F("G29P1C"));
ACTION_ITEM(MSG_UBL_INVALIDATE_ALL, _lcd_ubl_invalidate); ACTION_ITEM(MSG_UBL_INVALIDATE_ALL, _lcd_ubl_invalidate);
GCODES_ITEM(MSG_UBL_INVALIDATE_CLOSEST, PSTR("G29I")); GCODES_ITEM(MSG_UBL_INVALIDATE_CLOSEST, F("G29I"));
ACTION_ITEM(MSG_INFO_SCREEN, ui.return_to_status); ACTION_ITEM(MSG_INFO_SCREEN, ui.return_to_status);
END_MENU(); END_MENU();
} }
@ -354,14 +354,14 @@ void _lcd_ubl_build_mesh() {
/** /**
* UBL Load / Save Mesh Commands * UBL Load / Save Mesh Commands
*/ */
inline void _lcd_ubl_load_save_cmd(const char loadsave, PGM_P const msg) { inline void _lcd_ubl_load_save_cmd(const char loadsave, FSTR_P const fmsg) {
char ubl_lcd_gcode[40]; char ubl_lcd_gcode[40];
sprintf_P(ubl_lcd_gcode, PSTR("G29%c%i\nM117 "), loadsave, ubl_storage_slot); 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); sprintf_P(&ubl_lcd_gcode[strlen(ubl_lcd_gcode)], FTOP(fmsg), ubl_storage_slot);
gcode.process_subcommands_now(ubl_lcd_gcode); 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_load_mesh_cmd() { _lcd_ubl_load_save_cmd('L', GET_TEXT_F(MSG_MESH_LOADED)); }
void _lcd_ubl_save_mesh_cmd() { _lcd_ubl_load_save_cmd('S', GET_TEXT(MSG_MESH_SAVED)); } void _lcd_ubl_save_mesh_cmd() { _lcd_ubl_load_save_cmd('S', GET_TEXT_F(MSG_MESH_SAVED)); }
/** /**
* UBL Mesh Storage submenu * UBL Mesh Storage submenu
@ -531,9 +531,9 @@ void _ubl_goto_map_screen() {
void _lcd_ubl_output_map() { void _lcd_ubl_output_map() {
START_MENU(); START_MENU();
BACK_ITEM(MSG_UBL_LEVEL_BED); BACK_ITEM(MSG_UBL_LEVEL_BED);
GCODES_ITEM(MSG_UBL_OUTPUT_MAP_HOST, PSTR("G29T0")); GCODES_ITEM(MSG_UBL_OUTPUT_MAP_HOST, F("G29T0"));
GCODES_ITEM(MSG_UBL_OUTPUT_MAP_CSV, PSTR("G29T1")); GCODES_ITEM(MSG_UBL_OUTPUT_MAP_CSV, F("G29T1"));
GCODES_ITEM(MSG_UBL_OUTPUT_MAP_BACKUP, PSTR("G29S-1")); GCODES_ITEM(MSG_UBL_OUTPUT_MAP_BACKUP, F("G29S-1"));
END_MENU(); END_MENU();
} }
@ -550,7 +550,7 @@ void _menu_ubl_tools() {
START_MENU(); START_MENU();
BACK_ITEM(MSG_UBL_LEVEL_BED); BACK_ITEM(MSG_UBL_LEVEL_BED);
SUBMENU(MSG_UBL_BUILD_MESH_MENU, _lcd_ubl_build_mesh); SUBMENU(MSG_UBL_BUILD_MESH_MENU, _lcd_ubl_build_mesh);
GCODES_ITEM(MSG_UBL_MANUAL_MESH, PSTR("G29I999\nG29P2BT0")); GCODES_ITEM(MSG_UBL_MANUAL_MESH, F("G29I999\nG29P2BT0"));
#if ENABLED(G26_MESH_VALIDATION) #if ENABLED(G26_MESH_VALIDATION)
SUBMENU(MSG_UBL_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh); SUBMENU(MSG_UBL_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
#endif #endif
@ -576,12 +576,12 @@ void _menu_ubl_tools() {
void _lcd_ubl_step_by_step() { void _lcd_ubl_step_by_step() {
START_MENU(); START_MENU();
BACK_ITEM(MSG_UBL_LEVEL_BED); BACK_ITEM(MSG_UBL_LEVEL_BED);
GCODES_ITEM(MSG_UBL_1_BUILD_COLD_MESH, PSTR("G29NP1")); GCODES_ITEM(MSG_UBL_1_BUILD_COLD_MESH, F("G29NP1"));
GCODES_ITEM(MSG_UBL_2_SMART_FILLIN, PSTR("G29P3T0")); GCODES_ITEM(MSG_UBL_2_SMART_FILLIN, F("G29P3T0"));
SUBMENU(MSG_UBL_3_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh); SUBMENU(MSG_UBL_3_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
GCODES_ITEM(MSG_UBL_4_FINE_TUNE_ALL, PSTR("G29P4RT")); GCODES_ITEM(MSG_UBL_4_FINE_TUNE_ALL, F("G29P4RT"));
SUBMENU(MSG_UBL_5_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh); SUBMENU(MSG_UBL_5_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
GCODES_ITEM(MSG_UBL_6_FINE_TUNE_ALL, PSTR("G29P4RT")); GCODES_ITEM(MSG_UBL_6_FINE_TUNE_ALL, F("G29P4RT"));
ACTION_ITEM(MSG_UBL_7_SAVE_MESH, _lcd_ubl_save_mesh_cmd); ACTION_ITEM(MSG_UBL_7_SAVE_MESH, _lcd_ubl_save_mesh_cmd);
END_MENU(); END_MENU();
} }
@ -650,9 +650,9 @@ void _lcd_ubl_level_bed() {
START_MENU(); START_MENU();
BACK_ITEM(MSG_MOTION); BACK_ITEM(MSG_MOTION);
if (planner.leveling_active) if (planner.leveling_active)
GCODES_ITEM(MSG_UBL_DEACTIVATE_MESH, PSTR("G29D")); GCODES_ITEM(MSG_UBL_DEACTIVATE_MESH, F("G29D"));
else else
GCODES_ITEM(MSG_UBL_ACTIVATE_MESH, PSTR("G29A")); GCODES_ITEM(MSG_UBL_ACTIVATE_MESH, F("G29A"));
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
editable.decimal = planner.z_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); }); EDIT_ITEM_FAST(float3, MSG_Z_FADE_HEIGHT, &editable.decimal, 0, 100, []{ set_z_fade_height(editable.decimal); });
@ -667,7 +667,7 @@ void _lcd_ubl_level_bed() {
SUBMENU(MSG_UBL_STORAGE_MESH_MENU, _lcd_ubl_storage_mesh); SUBMENU(MSG_UBL_STORAGE_MESH_MENU, _lcd_ubl_storage_mesh);
SUBMENU(MSG_UBL_OUTPUT_MAP, _lcd_ubl_output_map); SUBMENU(MSG_UBL_OUTPUT_MAP, _lcd_ubl_output_map);
SUBMENU(MSG_UBL_TOOLS, _menu_ubl_tools); SUBMENU(MSG_UBL_TOOLS, _menu_ubl_tools);
GCODES_ITEM(MSG_UBL_INFO_UBL, PSTR("G29W")); GCODES_ITEM(MSG_UBL_INFO_UBL, F("G29W"));
END_MENU(); END_MENU();
} }

18
Marlin/src/lcd/menu/menu_x_twist.cpp
View file

@ -51,7 +51,7 @@ void xatc_wizard_done() {
ui.goto_screen(menu_advanced_settings); ui.goto_screen(menu_advanced_settings);
} }
if (ui.should_draw()) if (ui.should_draw())
MenuItem_static::draw(LCD_HEIGHT >= 4, GET_TEXT(MSG_XATC_DONE)); MenuItem_static::draw(LCD_HEIGHT >= 4, GET_TEXT_F(MSG_XATC_DONE));
ui.refresh(LCDVIEW_CALL_REDRAW_NEXT); ui.refresh(LCDVIEW_CALL_REDRAW_NEXT);
} }
@ -62,14 +62,14 @@ void xatc_wizard_goto_next_point();
// //
void xatc_wizard_update_z_offset() { void xatc_wizard_update_z_offset() {
MenuItem_confirm::select_screen( MenuItem_confirm::select_screen(
GET_TEXT(MSG_YES), GET_TEXT(MSG_NO) GET_TEXT_F(MSG_YES), GET_TEXT_F(MSG_NO)
, []{ , []{
probe.offset.z = z_offset; probe.offset.z = z_offset;
ui.goto_screen(xatc_wizard_done); ui.goto_screen(xatc_wizard_done);
} }
, xatc_wizard_done , xatc_wizard_done
, GET_TEXT(MSG_XATC_UPDATE_Z_OFFSET) , GET_TEXT_F(MSG_XATC_UPDATE_Z_OFFSET)
, ftostr42_52(z_offset), PSTR("?") , ftostr42_52(z_offset), F("?")
); );
} }
@ -93,7 +93,7 @@ void xatc_wizard_menu() {
if (LCD_HEIGHT >= 4) if (LCD_HEIGHT >= 4)
STATIC_ITEM(MSG_MOVE_NOZZLE_TO_BED, SS_CENTER|SS_INVERT); 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_F(F("Z="), SS_CENTER, ftostr42_52(current_position.z));
STATIC_ITEM(MSG_ZPROBE_ZOFFSET, SS_LEFT, ftostr42_52(calculated_z_offset)); STATIC_ITEM(MSG_ZPROBE_ZOFFSET, SS_LEFT, ftostr42_52(calculated_z_offset));
SUBMENU(MSG_MOVE_1MM, []{ _goto_manual_move_z( 1); }); SUBMENU(MSG_MOVE_1MM, []{ _goto_manual_move_z( 1); });
@ -106,12 +106,12 @@ void xatc_wizard_menu() {
!UNEAR_ZERO((FINE_MANUAL_MOVE) * 100 - int((FINE_MANUAL_MOVE) * 100)) ? 3 : 2; !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)); sprintf_P(tmp, GET_TEXT(MSG_MOVE_N_MM), dtostrf(FINE_MANUAL_MOVE, 1, digs, numstr));
#if DISABLED(HAS_GRAPHICAL_TFT) #if DISABLED(HAS_GRAPHICAL_TFT)
SUBMENU_P(NUL_STR, []{ _goto_manual_move_z(float(FINE_MANUAL_MOVE)); }); SUBMENU_F(FPSTR(NUL_STR), []{ _goto_manual_move_z(float(FINE_MANUAL_MOVE)); });
MENU_ITEM_ADDON_START(0 + ENABLED(HAS_MARLINUI_HD44780)); MENU_ITEM_ADDON_START(0 + ENABLED(HAS_MARLINUI_HD44780));
lcd_put_u8str(tmp); lcd_put_u8str(tmp);
MENU_ITEM_ADDON_END(); MENU_ITEM_ADDON_END();
#else #else
SUBMENU_P(tmp, []{ _goto_manual_move_z(float(FINE_MANUAL_MOVE)); }); SUBMENU_F(FPSTR(tmp), []{ _goto_manual_move_z(float(FINE_MANUAL_MOVE)); });
#endif #endif
} }
@ -127,7 +127,7 @@ void xatc_wizard_moving() {
if (ui.should_draw()) { if (ui.should_draw()) {
char msg[10]; char msg[10];
sprintf_P(msg, PSTR("%i / %u"), manual_probe_index + 1, XATC_MAX_POINTS); sprintf_P(msg, PSTR("%i / %u"), manual_probe_index + 1, XATC_MAX_POINTS);
MenuEditItemBase::draw_edit_screen(GET_TEXT(MSG_LEVEL_BED_NEXT_POINT), msg); MenuEditItemBase::draw_edit_screen(GET_TEXT_F(MSG_LEVEL_BED_NEXT_POINT), msg);
} }
ui.refresh(LCDVIEW_CALL_NO_REDRAW); ui.refresh(LCDVIEW_CALL_NO_REDRAW);
if (!ui.wait_for_move) ui.goto_screen(xatc_wizard_menu); if (!ui.wait_for_move) ui.goto_screen(xatc_wizard_menu);
@ -180,7 +180,7 @@ void xatc_wizard_goto_next_point() {
// //
void xatc_wizard_homing_done() { void xatc_wizard_homing_done() {
if (ui.should_draw()) { if (ui.should_draw()) {
MenuItem_static::draw(1, GET_TEXT(MSG_LEVEL_BED_WAITING)); MenuItem_static::draw(1, GET_TEXT_F(MSG_LEVEL_BED_WAITING));
// Color UI needs a control to detect a touch // Color UI needs a control to detect a touch
#if BOTH(TOUCH_SCREEN, HAS_GRAPHICAL_TFT) #if BOTH(TOUCH_SCREEN, HAS_GRAPHICAL_TFT)

8
Marlin/src/lcd/tft/tft_string.cpp
View file

@ -89,13 +89,13 @@ uint8_t read_byte(uint8_t *byte) { return *byte; }
/** /**
* Add a string, applying substitutions for the following characters: * Add a string, applying substitutions for the following characters:
* *
* $ displays an inserted C-string given by the itemString parameter * $ displays an inserted C-string given by the inStr parameter
* = displays '0'....'10' for indexes 0 - 10 * = displays '0'....'10' for indexes 0 - 10
* ~ displays '1'....'11' for indexes 0 - 10 * ~ displays '1'....'11' for indexes 0 - 10
* * displays 'E1'...'E11' for indexes 0 - 10 (By default. Uses LCD_FIRST_TOOL) * * displays 'E1'...'E11' for indexes 0 - 10 (By default. Uses LCD_FIRST_TOOL)
* @ displays an axis name such as XYZUVW, or E for an extruder * @ displays an axis name such as XYZUVW, or E for an extruder
*/ */
void TFT_String::add(uint8_t *string, int8_t index, uint8_t *itemString/*=nullptr*/) { void TFT_String::add(uint8_t *string, int8_t index, uint8_t *inStr/*=nullptr*/) {
wchar_t wchar; wchar_t wchar;
while (*string) { while (*string) {
@ -113,8 +113,8 @@ void TFT_String::add(uint8_t *string, int8_t index, uint8_t *itemString/*=nullpt
else else
add(index == -2 ? GET_TEXT(MSG_CHAMBER) : GET_TEXT(MSG_BED)); add(index == -2 ? GET_TEXT(MSG_CHAMBER) : GET_TEXT(MSG_BED));
} }
else if (ch == '$' && itemString) else if (ch == '$' && inStr)
add(itemString); add(inStr);
else if (ch == '@') else if (ch == '@')
add_character(axis_codes[index]); add_character(axis_codes[index]);
else else

12
Marlin/src/lcd/tft/tft_string.h
View file

@ -86,13 +86,19 @@ class TFT_String {
static void set(); static void set();
static void add(uint8_t character) { add_character(character); eol(); } static void add(uint8_t character) { add_character(character); eol(); }
static void add(uint8_t *string, uint8_t max_len=MAX_STRING_LENGTH); static void add(uint8_t *string, uint8_t max_len=MAX_STRING_LENGTH);
static void add(uint8_t *string, int8_t index, uint8_t *itemString=nullptr); static void add(uint8_t *string, int8_t index, uint8_t *inStr=nullptr);
static void set(uint8_t *string) { set(); add(string); }; static void set(uint8_t *string) { set(); add(string); };
static void set(uint8_t *string, int8_t index, const char *itemString=nullptr) { set(); add(string, index, (uint8_t *)itemString); }; static void set(uint8_t *string, int8_t index, const char *inStr=nullptr) { set(); add(string, index, (uint8_t *)inStr); };
static void set(const char *string) { set((uint8_t *)string); } static void set(const char *string) { set((uint8_t *)string); }
static void set(const char *string, int8_t index, const char *itemString=nullptr) { set((uint8_t *)string, index, itemString); } static void set(const char *string, int8_t index, const char *inStr=nullptr) { set((uint8_t *)string, index, inStr); }
static void add(const char *string) { add((uint8_t *)string); } static void add(const char *string) { add((uint8_t *)string); }
static void add(FSTR_P const string, uint8_t max_len=MAX_STRING_LENGTH) { add((uint8_t *)FTOP(string), max_len); }
static void add(FSTR_P const string, int8_t index, uint8_t *inStr=nullptr) { add((uint8_t *)FTOP(string), index, inStr); }
static void set(FSTR_P const string) { set((uint8_t *)FTOP(string)); }
static void set(FSTR_P const string, int8_t index, const char *inStr=nullptr) { set((uint8_t *)FTOP(string), index, inStr); }
static void add(FSTR_P const string) { add((uint8_t *)FTOP(string)); }
static void trim(uint8_t character=0x20); static void trim(uint8_t character=0x20);
static void rtrim(uint8_t character=0x20); static void rtrim(uint8_t character=0x20);
static void ltrim(uint8_t character=0x20); static void ltrim(uint8_t character=0x20);

18
Marlin/src/lcd/tft/touch.cpp
View file

@ -189,26 +189,26 @@ void Touch::touch(touch_control_t *control) {
#if HAS_HOTEND #if HAS_HOTEND
if (heater >= 0) { // HotEnd if (heater >= 0) { // HotEnd
#if HOTENDS == 1 #if HOTENDS == 1
MenuItem_int3::action((const char *)GET_TEXT_F(MSG_NOZZLE), &thermalManager.temp_hotend[0].target, 0, thermalManager.hotend_max_target(0), []{ thermalManager.start_watching_hotend(0); }); MenuItem_int3::action(GET_TEXT_F(MSG_NOZZLE), &thermalManager.temp_hotend[0].target, 0, thermalManager.hotend_max_target(0), []{ thermalManager.start_watching_hotend(0); });
#else #else
MenuItemBase::itemIndex = heater; MenuItemBase::itemIndex = heater;
MenuItem_int3::action((const char *)GET_TEXT_F(MSG_NOZZLE_N), &thermalManager.temp_hotend[heater].target, 0, thermalManager.hotend_max_target(heater), []{ thermalManager.start_watching_hotend(MenuItemBase::itemIndex); }); MenuItem_int3::action(GET_TEXT_F(MSG_NOZZLE_N), &thermalManager.temp_hotend[heater].target, 0, thermalManager.hotend_max_target(heater), []{ thermalManager.start_watching_hotend(MenuItemBase::itemIndex); });
#endif #endif
} }
#endif #endif
#if HAS_HEATED_BED #if HAS_HEATED_BED
else if (heater == H_BED) { else if (heater == H_BED) {
MenuItem_int3::action((const char *)GET_TEXT_F(MSG_BED), &thermalManager.temp_bed.target, 0, BED_MAX_TARGET, thermalManager.start_watching_bed); MenuItem_int3::action(GET_TEXT_F(MSG_BED), &thermalManager.temp_bed.target, 0, BED_MAX_TARGET, thermalManager.start_watching_bed);
} }
#endif #endif
#if HAS_HEATED_CHAMBER #if HAS_HEATED_CHAMBER
else if (heater == H_CHAMBER) { else if (heater == H_CHAMBER) {
MenuItem_int3::action((const char *)GET_TEXT_F(MSG_CHAMBER), &thermalManager.temp_chamber.target, 0, CHAMBER_MAX_TARGET, thermalManager.start_watching_chamber); MenuItem_int3::action(GET_TEXT_F(MSG_CHAMBER), &thermalManager.temp_chamber.target, 0, CHAMBER_MAX_TARGET, thermalManager.start_watching_chamber);
} }
#endif #endif
#if HAS_COOLER #if HAS_COOLER
else if (heater == H_COOLER) { else if (heater == H_COOLER) {
MenuItem_int3::action((const char *)GET_TEXT_F(MSG_COOLER), &thermalManager.temp_cooler.target, 0, COOLER_MAX_TARGET, thermalManager.start_watching_cooler); MenuItem_int3::action(GET_TEXT_F(MSG_COOLER), &thermalManager.temp_cooler.target, 0, COOLER_MAX_TARGET, thermalManager.start_watching_cooler);
} }
#endif #endif
@ -218,19 +218,19 @@ void Touch::touch(touch_control_t *control) {
static uint8_t fan, fan_speed; static uint8_t fan, fan_speed;
fan = 0; fan = 0;
fan_speed = thermalManager.fan_speed[fan]; fan_speed = thermalManager.fan_speed[fan];
MenuItem_percent::action((const char *)GET_TEXT_F(MSG_FIRST_FAN_SPEED), &fan_speed, 0, 255, []{ thermalManager.set_fan_speed(fan, fan_speed); }); MenuItem_percent::action(GET_TEXT_F(MSG_FIRST_FAN_SPEED), &fan_speed, 0, 255, []{ thermalManager.set_fan_speed(fan, fan_speed); });
break; break;
case FEEDRATE: case FEEDRATE:
ui.clear_lcd(); ui.clear_lcd();
MenuItem_int3::action((const char *)GET_TEXT_F(MSG_SPEED), &feedrate_percentage, 10, 999); MenuItem_int3::action(GET_TEXT_F(MSG_SPEED), &feedrate_percentage, 10, 999);
break; break;
case FLOWRATE: case FLOWRATE:
ui.clear_lcd(); ui.clear_lcd();
MenuItemBase::itemIndex = control->data; MenuItemBase::itemIndex = control->data;
#if EXTRUDERS == 1 #if EXTRUDERS == 1
MenuItem_int3::action((const char *)GET_TEXT_F(MSG_FLOW), &planner.flow_percentage[MenuItemBase::itemIndex], 10, 999, []{ planner.refresh_e_factor(MenuItemBase::itemIndex); }); MenuItem_int3::action(GET_TEXT_F(MSG_FLOW), &planner.flow_percentage[MenuItemBase::itemIndex], 10, 999, []{ planner.refresh_e_factor(MenuItemBase::itemIndex); });
#else #else
MenuItem_int3::action((const char *)GET_TEXT_F(MSG_FLOW_N), &planner.flow_percentage[MenuItemBase::itemIndex], 10, 999, []{ planner.refresh_e_factor(MenuItemBase::itemIndex); }); MenuItem_int3::action(GET_TEXT_F(MSG_FLOW_N), &planner.flow_percentage[MenuItemBase::itemIndex], 10, 999, []{ planner.refresh_e_factor(MenuItemBase::itemIndex); });
#endif #endif
break; break;

22
Marlin/src/lcd/tft/ui_1024x600.cpp
View file

@ -105,12 +105,12 @@ void MarlinUI::draw_kill_screen() {
line++; line++;
menu_line(line++, COLOR_KILL_SCREEN_BG); menu_line(line++, COLOR_KILL_SCREEN_BG);
tft_string.set(GET_TEXT(MSG_HALTED)); tft_string.set(GET_TEXT_F(MSG_HALTED));
tft_string.trim(); tft_string.trim();
tft.add_text(tft_string.center(TFT_WIDTH), 0, COLOR_MENU_TEXT, tft_string); tft.add_text(tft_string.center(TFT_WIDTH), 0, COLOR_MENU_TEXT, tft_string);
menu_line(line++, COLOR_KILL_SCREEN_BG); menu_line(line++, COLOR_KILL_SCREEN_BG);
tft_string.set(GET_TEXT(MSG_PLEASE_RESET)); tft_string.set(GET_TEXT_F(MSG_PLEASE_RESET));
tft_string.trim(); tft_string.trim();
tft.add_text(tft_string.center(TFT_WIDTH), 0, COLOR_MENU_TEXT, tft_string); tft.add_text(tft_string.center(TFT_WIDTH), 0, COLOR_MENU_TEXT, tft_string);
@ -352,14 +352,14 @@ void MarlinUI::draw_status_screen() {
} }
// Low-level draw_edit_screen can be used to draw an edit screen from anyplace // Low-level draw_edit_screen can be used to draw an edit screen from anyplace
void MenuEditItemBase::draw_edit_screen(PGM_P const pstr, const char * const value/*=nullptr*/) { void MenuEditItemBase::draw_edit_screen(FSTR_P const fstr, const char * const value/*=nullptr*/) {
ui.encoder_direction_normal(); ui.encoder_direction_normal();
TERN_(TOUCH_SCREEN, touch.clear()); TERN_(TOUCH_SCREEN, touch.clear());
uint16_t line = 1; uint16_t line = 1;
menu_line(line++); menu_line(line++);
tft_string.set(pstr, itemIndex, itemString); tft_string.set(FTOP(fstr), itemIndex, FTOP(itemString));
tft_string.trim(); tft_string.trim();
tft.add_text(tft_string.center(TFT_WIDTH), MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string); tft.add_text(tft_string.center(TFT_WIDTH), MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string);
@ -421,7 +421,7 @@ void TFT::draw_edit_screen_buttons() {
} }
// The Select Screen presents a prompt and two "buttons" // The Select Screen presents a prompt and two "buttons"
void MenuItem_confirm::draw_select_screen(PGM_P const yes, PGM_P const no, const bool yesno, PGM_P const pref, const char * const string/*=nullptr*/, PGM_P const suff/*=nullptr*/) { void MenuItem_confirm::draw_select_screen(FSTR_P const yes, FSTR_P const no, const bool yesno, FSTR_P const pref, const char * const string/*=nullptr*/, FSTR_P const suff/*=nullptr*/) {
uint16_t line = 1; uint16_t line = 1;
if (!string) line++; if (!string) line++;
@ -473,7 +473,7 @@ void MenuItem_confirm::draw_select_screen(PGM_P const yes, PGM_P const no, const
#endif #endif
menu_line(row); menu_line(row);
tft_string.set(GET_TEXT(MSG_FILAMENT_CHANGE_NOZZLE)); tft_string.set(GET_TEXT_F(MSG_FILAMENT_CHANGE_NOZZLE));
tft_string.add('E'); tft_string.add('E');
tft_string.add((char)('1' + extruder)); tft_string.add((char)('1' + extruder));
tft_string.add(' '); tft_string.add(' ');
@ -693,18 +693,18 @@ static void moveAxis(const AxisEnum axis, const int8_t direction) {
drawAxisValue(axis); drawAxisValue(axis);
} }
else { else {
drawMessage(GET_TEXT(MSG_LCD_SOFT_ENDSTOPS)); drawMessage(GET_TEXT_F(MSG_LCD_SOFT_ENDSTOPS));
} }
#elif HAS_BED_PROBE #elif HAS_BED_PROBE
// only change probe.offset.z // only change probe.offset.z
probe.offset.z += diff; probe.offset.z += diff;
if (direction < 0 && current_position[axis] < Z_PROBE_OFFSET_RANGE_MIN) { if (direction < 0 && current_position[axis] < Z_PROBE_OFFSET_RANGE_MIN) {
current_position[axis] = Z_PROBE_OFFSET_RANGE_MIN; current_position[axis] = Z_PROBE_OFFSET_RANGE_MIN;
drawMessage(GET_TEXT(MSG_LCD_SOFT_ENDSTOPS)); drawMessage(GET_TEXT_F(MSG_LCD_SOFT_ENDSTOPS));
} }
else if (direction > 0 && current_position[axis] > Z_PROBE_OFFSET_RANGE_MAX) { else if (direction > 0 && current_position[axis] > Z_PROBE_OFFSET_RANGE_MAX) {
current_position[axis] = Z_PROBE_OFFSET_RANGE_MAX; current_position[axis] = Z_PROBE_OFFSET_RANGE_MAX;
drawMessage(GET_TEXT(MSG_LCD_SOFT_ENDSTOPS)); drawMessage(GET_TEXT_F(MSG_LCD_SOFT_ENDSTOPS));
} }
else { else {
drawMessage(""); // clear the error drawMessage(""); // clear the error
@ -733,7 +733,7 @@ static void moveAxis(const AxisEnum axis, const int8_t direction) {
#if IS_KINEMATIC #if IS_KINEMATIC
UNUSED(limited); UNUSED(limited);
#else #else
PGM_P const msg = limited ? GET_TEXT(MSG_LCD_SOFT_ENDSTOPS) : NUL_STR; FSTR_P const msg = limited ? GET_TEXT_F(MSG_LCD_SOFT_ENDSTOPS) : FPSTR(NUL_STR);
drawMessage(msg); drawMessage(msg);
#endif #endif
@ -766,7 +766,7 @@ static void z_minus() { moveAxis(Z_AXIS, -1); }
static void do_home() { static void do_home() {
quick_feedback(); quick_feedback();
drawMessage(GET_TEXT(MSG_LEVEL_BED_HOMING)); drawMessage(GET_TEXT_F(MSG_LEVEL_BED_HOMING));
queue.inject_P(G28_STR); queue.inject_P(G28_STR);
// Disable touch until home is done // Disable touch until home is done
TERN_(TOUCH_SCREEN, touch.disable()); TERN_(TOUCH_SCREEN, touch.disable());

14
Marlin/src/lcd/tft/ui_320x240.cpp
View file

@ -347,14 +347,14 @@ void MarlinUI::draw_status_screen() {
} }
// Low-level draw_edit_screen can be used to draw an edit screen from anyplace // Low-level draw_edit_screen can be used to draw an edit screen from anyplace
void MenuEditItemBase::draw_edit_screen(PGM_P const pstr, const char * const value/*=nullptr*/) { void MenuEditItemBase::draw_edit_screen(FSTR_P const fstr, const char * const value/*=nullptr*/) {
ui.encoder_direction_normal(); ui.encoder_direction_normal();
TERN_(TOUCH_SCREEN, touch.clear()); TERN_(TOUCH_SCREEN, touch.clear());
uint16_t line = 1; uint16_t line = 1;
menu_line(line++); menu_line(line++);
tft_string.set(pstr, itemIndex, itemString); tft_string.set(FTOP(fstr), itemIndex, FTOP(itemString));
tft_string.trim(); tft_string.trim();
tft.add_text(tft_string.center(TFT_WIDTH), MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string); tft.add_text(tft_string.center(TFT_WIDTH), MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string);
@ -416,7 +416,7 @@ void TFT::draw_edit_screen_buttons() {
} }
// The Select Screen presents a prompt and two "buttons" // The Select Screen presents a prompt and two "buttons"
void MenuItem_confirm::draw_select_screen(PGM_P const yes, PGM_P const no, const bool yesno, PGM_P const pref, const char * const string/*=nullptr*/, PGM_P const suff/*=nullptr*/) { void MenuItem_confirm::draw_select_screen(FSTR_P const yes, FSTR_P const no, const bool yesno, FSTR_P const pref, const char * const string/*=nullptr*/, FSTR_P const suff/*=nullptr*/) {
uint16_t line = 1; uint16_t line = 1;
if (!string) line++; if (!string) line++;
@ -621,7 +621,7 @@ static void drawCurESelection() {
tft.add_text(tft_string.width(), 0, E_BTN_COLOR, ui8tostr3rj(motionAxisState.e_selection)); tft.add_text(tft_string.width(), 0, E_BTN_COLOR, ui8tostr3rj(motionAxisState.e_selection));
} }
static void drawMessage(const char *msg) { static void drawMessage(PGM_P const msg) {
tft.canvas(X_MARGIN, TFT_HEIGHT - Y_MARGIN - 29, (TFT_WIDTH / 2) - (BTN_WIDTH / 2) - X_MARGIN, 20); tft.canvas(X_MARGIN, TFT_HEIGHT - Y_MARGIN - 29, (TFT_WIDTH / 2) - (BTN_WIDTH / 2) - X_MARGIN, 20);
tft.set_background(COLOR_BACKGROUND); tft.set_background(COLOR_BACKGROUND);
tft.add_text(0, 0, COLOR_YELLOW, msg); tft.add_text(0, 0, COLOR_YELLOW, msg);
@ -652,7 +652,7 @@ static void moveAxis(const AxisEnum axis, const int8_t direction) {
#if ENABLED(PREVENT_COLD_EXTRUSION) #if ENABLED(PREVENT_COLD_EXTRUSION)
if (axis == E_AXIS && thermalManager.tooColdToExtrude(motionAxisState.e_selection)) { if (axis == E_AXIS && thermalManager.tooColdToExtrude(motionAxisState.e_selection)) {
drawMessage("Too cold"); drawMessage(PSTR("Too cold"));
return; return;
} }
#endif #endif
@ -675,7 +675,7 @@ static void moveAxis(const AxisEnum axis, const int8_t direction) {
probe.offset.z = new_offs; probe.offset.z = new_offs;
else else
TERN(BABYSTEP_HOTEND_Z_OFFSET, hotend_offset[active_extruder].z = new_offs, NOOP); TERN(BABYSTEP_HOTEND_Z_OFFSET, hotend_offset[active_extruder].z = new_offs, NOOP);
drawMessage(""); // clear the error drawMessage(NUL_STR); // clear the error
drawAxisValue(axis); drawAxisValue(axis);
} }
else { else {
@ -693,7 +693,7 @@ static void moveAxis(const AxisEnum axis, const int8_t direction) {
drawMessage(GET_TEXT(MSG_LCD_SOFT_ENDSTOPS)); drawMessage(GET_TEXT(MSG_LCD_SOFT_ENDSTOPS));
} }
else { else {
drawMessage(""); // clear the error drawMessage(NUL_STR); // clear the error
} }
drawAxisValue(axis); drawAxisValue(axis);
#endif #endif

14
Marlin/src/lcd/tft/ui_480x320.cpp
View file

@ -352,14 +352,14 @@ void MarlinUI::draw_status_screen() {
} }
// Low-level draw_edit_screen can be used to draw an edit screen from anyplace // Low-level draw_edit_screen can be used to draw an edit screen from anyplace
void MenuEditItemBase::draw_edit_screen(PGM_P const pstr, const char * const value/*=nullptr*/) { void MenuEditItemBase::draw_edit_screen(FSTR_P const fstr, const char * const value/*=nullptr*/) {
ui.encoder_direction_normal(); ui.encoder_direction_normal();
TERN_(TOUCH_SCREEN, touch.clear()); TERN_(TOUCH_SCREEN, touch.clear());
uint16_t line = 1; uint16_t line = 1;
menu_line(line++); menu_line(line++);
tft_string.set(pstr, itemIndex, itemString); tft_string.set(FTOP(fstr), itemIndex, FTOP(itemString));
tft_string.trim(); tft_string.trim();
tft.add_text(tft_string.center(TFT_WIDTH), MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string); tft.add_text(tft_string.center(TFT_WIDTH), MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string);
@ -421,7 +421,7 @@ void TFT::draw_edit_screen_buttons() {
} }
// The Select Screen presents a prompt and two "buttons" // The Select Screen presents a prompt and two "buttons"
void MenuItem_confirm::draw_select_screen(PGM_P const yes, PGM_P const no, const bool yesno, PGM_P const pref, const char * const string/*=nullptr*/, PGM_P const suff/*=nullptr*/) { void MenuItem_confirm::draw_select_screen(FSTR_P const yes, FSTR_P const no, const bool yesno, FSTR_P const pref, const char * const string/*=nullptr*/, FSTR_P const suff/*=nullptr*/) {
uint16_t line = 1; uint16_t line = 1;
if (!string) line++; if (!string) line++;
@ -622,7 +622,7 @@ static void drawCurESelection() {
tft.add_text(tft_string.width(), 0, E_BTN_COLOR, ui8tostr3rj(motionAxisState.e_selection)); tft.add_text(tft_string.width(), 0, E_BTN_COLOR, ui8tostr3rj(motionAxisState.e_selection));
} }
static void drawMessage(const char *msg) { static void drawMessage(PGM_P const msg) {
tft.canvas(X_MARGIN, TFT_HEIGHT - Y_MARGIN - 34, TFT_HEIGHT / 2, 34); tft.canvas(X_MARGIN, TFT_HEIGHT - Y_MARGIN - 34, TFT_HEIGHT / 2, 34);
tft.set_background(COLOR_BACKGROUND); tft.set_background(COLOR_BACKGROUND);
tft.add_text(0, 0, COLOR_YELLOW, msg); tft.add_text(0, 0, COLOR_YELLOW, msg);
@ -653,7 +653,7 @@ static void moveAxis(const AxisEnum axis, const int8_t direction) {
#if ENABLED(PREVENT_COLD_EXTRUSION) #if ENABLED(PREVENT_COLD_EXTRUSION)
if (axis == E_AXIS && thermalManager.tooColdToExtrude(motionAxisState.e_selection)) { if (axis == E_AXIS && thermalManager.tooColdToExtrude(motionAxisState.e_selection)) {
drawMessage("Too cold"); drawMessage(PSTR("Too cold"));
return; return;
} }
#endif #endif
@ -676,7 +676,7 @@ static void moveAxis(const AxisEnum axis, const int8_t direction) {
probe.offset.z = new_offs; probe.offset.z = new_offs;
else else
TERN(BABYSTEP_HOTEND_Z_OFFSET, hotend_offset[active_extruder].z = new_offs, NOOP); TERN(BABYSTEP_HOTEND_Z_OFFSET, hotend_offset[active_extruder].z = new_offs, NOOP);
drawMessage(""); // clear the error drawMessage(NUL_STR); // clear the error
drawAxisValue(axis); drawAxisValue(axis);
} }
else { else {
@ -694,7 +694,7 @@ static void moveAxis(const AxisEnum axis, const int8_t direction) {
drawMessage(GET_TEXT(MSG_LCD_SOFT_ENDSTOPS)); drawMessage(GET_TEXT(MSG_LCD_SOFT_ENDSTOPS));
} }
else { else {
drawMessage(""); // clear the error drawMessage(NUL_STR); // clear the error
} }
drawAxisValue(axis); drawAxisValue(axis);
#endif #endif

16
Marlin/src/lcd/tft/ui_common.cpp
View file

@ -130,10 +130,10 @@ void lcd_put_int(const int i) {
// //
// Draw a generic menu item with pre_char (if selected) and post_char // Draw a generic menu item with pre_char (if selected) and post_char
void MenuItemBase::_draw(const bool sel, const uint8_t row, PGM_P const pstr, const char pre_char, const char post_char) { void MenuItemBase::_draw(const bool sel, const uint8_t row, FSTR_P const fstr, const char pre_char, const char post_char) {
menu_item(row, sel); menu_item(row, sel);
uint8_t *string = (uint8_t *)pstr; uint8_t *string = (uint8_t *)FTOP(fstr);
MarlinImage image = noImage; MarlinImage image = noImage;
switch (*string) { switch (*string) {
case 0x01: image = imgRefresh; break; // LCD_STR_REFRESH case 0x01: image = imgRefresh; break; // LCD_STR_REFRESH
@ -147,15 +147,15 @@ void MenuItemBase::_draw(const bool sel, const uint8_t row, PGM_P const pstr, co
tft.add_image(MENU_ITEM_ICON_X, MENU_ITEM_ICON_Y, image, COLOR_MENU_TEXT, sel ? COLOR_SELECTION_BG : COLOR_BACKGROUND); tft.add_image(MENU_ITEM_ICON_X, MENU_ITEM_ICON_Y, image, COLOR_MENU_TEXT, sel ? COLOR_SELECTION_BG : COLOR_BACKGROUND);
} }
tft_string.set(string, itemIndex, itemString); tft_string.set(string, itemIndex, FTOP(itemString));
tft.add_text(offset, MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string); tft.add_text(offset, MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string);
} }
// Draw a menu item with a (potentially) editable value // Draw a menu item with a (potentially) editable value
void MenuEditItemBase::draw(const bool sel, const uint8_t row, PGM_P const pstr, const char * const data, const bool pgm) { void MenuEditItemBase::draw(const bool sel, const uint8_t row, FSTR_P const fstr, const char * const data, const bool pgm) {
menu_item(row, sel); menu_item(row, sel);
tft_string.set(pstr, itemIndex, itemString); tft_string.set(FTOP(fstr), itemIndex, FTOP(itemString));
tft.add_text(MENU_TEXT_X_OFFSET, MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string); tft.add_text(MENU_TEXT_X_OFFSET, MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string);
if (data) { if (data) {
tft_string.set(data); tft_string.set(data);
@ -164,16 +164,16 @@ void MenuEditItemBase::draw(const bool sel, const uint8_t row, PGM_P const pstr,
} }
// Draw a static item with no left-right margin required. Centered by default. // Draw a static item with no left-right margin required. Centered by default.
void MenuItem_static::draw(const uint8_t row, PGM_P const pstr, const uint8_t style/*=SS_DEFAULT*/, const char * const vstr/*=nullptr*/) { void MenuItem_static::draw(const uint8_t row, FSTR_P const fstr, const uint8_t style/*=SS_DEFAULT*/, const char * const vstr/*=nullptr*/) {
menu_item(row); menu_item(row);
tft_string.set(pstr, itemIndex, itemString); tft_string.set(FTOP(fstr), itemIndex, FTOP(itemString));
if (vstr) tft_string.add(vstr); if (vstr) tft_string.add(vstr);
tft.add_text(tft_string.center(TFT_WIDTH), MENU_TEXT_Y_OFFSET, COLOR_YELLOW, tft_string); tft.add_text(tft_string.center(TFT_WIDTH), MENU_TEXT_Y_OFFSET, COLOR_YELLOW, tft_string);
} }
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
void MenuItem_sdbase::draw(const bool sel, const uint8_t row, PGM_P const, CardReader &theCard, const bool isDir) { void MenuItem_sdbase::draw(const bool sel, const uint8_t row, FSTR_P const, CardReader &theCard, const bool isDir) {
menu_item(row, sel); menu_item(row, sel);
if (isDir) tft.add_image(MENU_ITEM_ICON_X, MENU_ITEM_ICON_Y, imgDirectory, COLOR_MENU_TEXT, sel ? COLOR_SELECTION_BG : COLOR_BACKGROUND); if (isDir) tft.add_image(MENU_ITEM_ICON_X, MENU_ITEM_ICON_Y, imgDirectory, COLOR_MENU_TEXT, sel ? COLOR_SELECTION_BG : COLOR_BACKGROUND);
constexpr uint8_t maxlen = (MENU_ITEM_HEIGHT) - (MENU_TEXT_Y_OFFSET) + 1; constexpr uint8_t maxlen = (MENU_ITEM_HEIGHT) - (MENU_TEXT_Y_OFFSET) + 1;