LULZBOT_TOUCH_UI fixes. Fix some warnings. (#15276)

Marlin/src/core/macros.h

 // Macros for bit masks
 #undef _BV
 #define _BV(n) (1<<(n))
-#define TEST(n,b) !!((n)&_BV(b))
+#define TEST(n,b) (!!((n)&_BV(b)))
 #define SET_BIT_TO(N,B,TF) do{ if (TF) SBI(N,B); else CBI(N,B); }while(0)
 
 #ifndef SBI

Marlin/src/feature/pause.cpp

 
   #if HAS_BUZZER
     filament_change_beep(max_beep_count, true);
+  #else
+    UNUSED(max_beep_count);
   #endif
 
   // Start the heater idle timers

Marlin/src/lcd/dogm/status_screen_lite_ST7920.cpp

     begin_data();
     write_number(percentage, 3);
     write_byte('%');
+  #else
+    UNUSED(percentage);
   #endif
 }
 

Marlin/src/lcd/extensible_ui/lib/lulzbot/ftdi_eve_lib/extended/command_processor.h

   uint32_t rgb;
 } btn_colors;
 
+// Disable TOUCH_UI_FIT_TEXT on a case-by-case basis
+namespace FTDI {
+  constexpr uint16_t OPT_NOFIT = OPT_NOTICKS;
+}
+
 /**************************** Enhanced Command Processor **************************/
 
 /* The CommandProcessor class wraps the CommandFifo with several features to make
     int8_t apply_fit_text(int16_t w, int16_t h, T text) {
       using namespace FTDI;
       int8_t font = _font;
-      for (;;) {
+      for (;font >= 26;) {
         #ifdef TOUCH_UI_USE_UTF8
           const int16_t width  = get_utf8_text_width(text, font_size_t::from_romfont(font));
           const int16_t height = font_size_t::from_romfont(font).get_height();
           const int16_t width  = fm.get_text_width(text);
           const int16_t height = fm.height;
         #endif
-        if ((width < w && height < h) || font == 26) break;
+        if (width < w && height < h) break;
         font--;
       }
       return font;
     }
 
     template<typename T>
+    uint16_t text_width(T text) {
+      using namespace FTDI;
+      #ifdef TOUCH_UI_USE_UTF8
+        return get_utf8_text_width(text, font_size_t::from_romfont(_font));
+      #else
+        CLCD::FontMetrics fm(_font);
+        return fm.get_text_width(text);
+      #endif
+    }
+
+    template<typename T>
     CommandProcessor& text(int16_t x, int16_t y, int16_t w, int16_t h, T text, uint16_t options = FTDI::OPT_CENTER) {
       using namespace FTDI;
       apply_text_alignment(x, y, w, h, options);
       #ifdef TOUCH_UI_FIT_TEXT
-        const int8_t font = apply_fit_text(w, h, text);
+        const int8_t font = (options & OPT_NOFIT) ? _font : apply_fit_text(w, h, text);
       #else
         const int8_t font = _font;
       #endif
       bool styleModified = false;
       if (_btn_style_callback) styleModified = _btn_style_callback(*this, _tag, _style, options, false);
       #ifdef TOUCH_UI_FIT_TEXT
-        const int8_t font = apply_fit_text(w, h, text);
+        const int8_t font = (options & OPT_NOFIT) ? _font : apply_fit_text(w, h, text);
       #else
         const int8_t font = _font;
       #endif
       #ifdef TOUCH_UI_USE_UTF8
         apply_text_alignment(x, y, w, h, OPT_CENTER);
         CLCD::CommandFifo::str(F(""));
+        if (!(options & FTDI::OPT_FLAT)) {
+          // Reproduce the black "shadow" the FTDI adds to the button label
+          CLCD::CommandFifo::cmd(SAVE_CONTEXT());
+          CLCD::CommandFifo::cmd(COLOR_RGB(0x00000));
+          draw_utf8_text(*this, x-1, y-1, text, font_size_t::from_romfont(font), OPT_CENTER);
+          CLCD::CommandFifo::cmd(RESTORE_CONTEXT());
+        }
+        // Draw the button label
         draw_utf8_text(*this, x, y, text, font_size_t::from_romfont(font), OPT_CENTER);
       #else
         CLCD::CommandFifo::str(text);

Marlin/src/lcd/extensible_ui/lib/lulzbot/ftdi_eve_lib/extended/unicode/unicode.cpp

   uint16_t FTDI::get_utf8_text_width(progmem_str pstr, font_size_t fs) {
     char str[strlen_P((const char*)pstr) + 1];
     strcpy_P(str, (const char*)pstr);
-    return get_utf8_text_width((const char*) pstr, fs);
+    return get_utf8_text_width(str, fs);
   }
 
    /**

Marlin/src/lcd/extensible_ui/lib/lulzbot/screens/base_screen.cpp

 void BaseScreen::onEntry() {
   CommandProcessor cmd;
   cmd.set_button_style_callback(buttonStyleCallback);
+  reset_menu_timeout();
   UIScreen::onEntry();
 }
 
 
 void BaseScreen::onIdle() {
   #ifdef LCD_TIMEOUT_TO_STATUS
-    const uint32_t elapsed = millis() - last_interaction;
-    if (elapsed > uint32_t(LCD_TIMEOUT_TO_STATUS)) {
+    if ((millis() - last_interaction) > LCD_TIMEOUT_TO_STATUS) {
       reset_menu_timeout();
+      #ifdef UI_FRAMEWORK_DEBUG
+        SERIAL_ECHO_MSG("Returning to status due to menu timeout");
+      #endif
       GOTO_SCREEN(StatusScreen);
     }
   #endif

Marlin/src/lcd/extensible_ui/lib/lulzbot/screens/bio_advanced_settings.cpp

       #else
        .enabled(0)
       #endif
-      .tag(4) .button( BTN_POS(1,3), BTN_SIZE(1,1), GET_TEXTF(BUMP_SENSE))
+      .tag(4) .button( BTN_POS(1,3), BTN_SIZE(1,1), GET_TEXTF(HOME_SENSE))
       .tag(5) .button( BTN_POS(1,4), BTN_SIZE(1,1), GET_TEXTF(ENDSTOPS))
       #if HOTENDS > 1
       .enabled(1)
       #else
       .enabled(0)
       #endif
-      .tag(6) .button( BTN_POS(1,5), BTN_SIZE(1,1), GET_TEXTF(NOZZLE_OFFSETS))
+      .tag(6) .button( BTN_POS(1,5), BTN_SIZE(1,1), GET_TEXTF(TOOL_OFFSETS))
 
 
       .tag(7) .button( BTN_POS(2,1), BTN_SIZE(1,1), GET_TEXTF(STEPS_PER_MM))
-      .tag(8) .button( BTN_POS(2,2), BTN_SIZE(1,1), GET_TEXTF(MAX_VELOCITY))
-      .tag(9) .button( BTN_POS(2,3), BTN_SIZE(1,1), GET_TEXTF(MAX_ACCELERATION))
+      .tag(8) .button( BTN_POS(2,2), BTN_SIZE(1,1), GET_TEXTF(VELOCITY))
+      .tag(9) .button( BTN_POS(2,3), BTN_SIZE(1,1), GET_TEXTF(ACCELERATION))
       #if ENABLED(JUNCTION_DEVIATION)
         .tag(10) .button( BTN_POS(2,4), BTN_SIZE(1,1), GET_TEXTF(JUNCTION_DEVIATION))
       #else
-        .tag(10) .button( BTN_POS(2,4), BTN_SIZE(1,1), GET_TEXTF(MAX_JERK))
+        .tag(10) .button( BTN_POS(2,4), BTN_SIZE(1,1), GET_TEXTF(JERK))
       #endif
       #if ENABLED(BACKLASH_GCODE)
       .enabled(1)
       #endif
       .tag(12) .button( BTN_POS(1,6), BTN_SIZE(2,1), GET_TEXTF(LINEAR_ADVANCE))
       .tag(13) .button( BTN_POS(1,7), BTN_SIZE(2,1), GET_TEXTF(INTERFACE_SETTINGS))
-      .tag(14) .button( BTN_POS(1,8), BTN_SIZE(2,1), GET_TEXTF(RESTORE_FAILSAFE))
+      .tag(14) .button( BTN_POS(1,8), BTN_SIZE(2,1), GET_TEXTF(RESTORE_DEFAULTS))
       .colors(action_btn)
       .tag(1). button( BTN_POS(1,9), BTN_SIZE(2,1), GET_TEXTF(BACK));
     #undef GRID_COLS

Marlin/src/lcd/extensible_ui/lib/lulzbot/screens/bio_printing_dialog_box.cpp

 }
 
 void BioPrintingDialogBox::setStatusMessage(progmem_str message) {
-  char buff[strlen_P((const char * const)message)+1];
-  strcpy_P(buff, (const char * const) message);
+  char buff[strlen_P((const char*)message)+1];
+  strcpy_P(buff, (const char*) message);
   setStatusMessage(buff);
 }
 

Marlin/src/lcd/extensible_ui/lib/lulzbot/screens/bio_status_screen.cpp

        .icon (x + 2, y + 2, h, v, Bed_Heat_Icon_Info, icon_scale * 2)
        .cmd(COLOR_RGB(bg_text_enabled))
        .icon (x, y, h, v, Bed_Heat_Icon_Info, icon_scale * 2);
+
+    #ifdef TOUCH_UI_USE_UTF8
+      load_utf8_bitmaps(cmd); // Restore font bitmap handles
+    #endif
   }
 
   if (what & FOREGROUND) {
        .cmd(COLOR_RGB(bg_text_enabled));
 
     if (!isHeaterIdle(BED) && getTargetTemp_celsius(BED) > 0) {
-      sprintf_P(bed_str, F("%3d%S"), ROUND(getTargetTemp_celsius(BED), GET_TEXT(UNITS_C)));
+      sprintf_P(bed_str, PSTR("%3d%S"), ROUND(getTargetTemp_celsius(BED)), GET_TEXT(UNITS_C));
       ui.bounds(POLY(target_temp), x, y, h, v);
       cmd.text(x, y, h, v, bed_str);
     }
 
-    sprintf_P(bed_str, F("%3d%S"), ROUND(getActualTemp_celsius(BED)), GET_TEXT(UNITS_C));
+    sprintf_P(bed_str, PSTR("%3d%S"), ROUND(getActualTemp_celsius(BED)), GET_TEXT(UNITS_C));
     ui.bounds(POLY(actual_temp), x, y, h, v);
     cmd.text(x, y, h, v, bed_str);
   }
     ui.button_stroke(stroke_rgb, 28);
     ui.button_shadow(shadow_rgb, shadow_depth);
 
-    if (!jog_xy) {
-      ui.button(12, POLY(padlock));
-    }
-
-    if (!e_homed) {
-      ui.button(13, POLY(home_e));
-    }
-
-    if (!z_homed) {
-      ui.button(14, POLY(home_z));
-    }
+    if (!jog_xy)  ui.button(12, POLY(padlock));
+    if (!e_homed) ui.button(13, POLY(home_e));
+    if (!z_homed) ui.button(14, POLY(home_z));
   }
 }
 
         isPrintingFromMedia() ?
           GET_TEXTF(PRINTING) :
         #ifdef LULZBOT_MANUAL_USB_STARTUP
-        (Sd2Card::ready() ? GET_TEXTF(MEDIA) : GET_TEXTF(ENABLE_MEDIA))
+          (Sd2Card::ready() ? GET_TEXTF(MEDIA) : GET_TEXTF(ENABLE_MEDIA))
         #else
-        GET_TEXTF(MEDIA)
+          GET_TEXTF(MEDIA)
         #endif
       );
 
-  cmd.colors(!has_media ? action_btn : normal_btn).tag(10).button(BTN_POS(2,9), BTN_SIZE(1,1), F("Menu"));
+  cmd.colors(!has_media ? action_btn : normal_btn).tag(10).button(BTN_POS(2,9), BTN_SIZE(1,1), GET_TEXTF(MENU));
 }
 
-void StatusScreen::onStartup() {
+void StatusScreen::loadBitmaps() {
   // Load the bitmaps for the status screen
   constexpr uint32_t base = ftdi_memory_map::RAM_G;
   CLCD::mem_write_pgm(base + Bed_Heat_Icon_Info.RAMG_offset, Bed_Heat_Icon, sizeof(Bed_Heat_Icon));
+
+  // Load fonts for internationalization
+  #ifdef TOUCH_UI_USE_UTF8
+    load_utf8_data(base + UTF8_FONT_OFFSET);
+  #endif
 }
 
 void StatusScreen::onRedraw(draw_mode_t what) {

Marlin/src/lcd/extensible_ui/lib/lulzbot/screens/dialog_box_base_class.cpp

   }
 }
 
+void DialogBoxBaseClass::onIdle() {
+  reset_menu_timeout();
+}
+
 #endif // LULZBOT_TOUCH_UI

Marlin/src/lcd/extensible_ui/lib/lulzbot/screens/endstop_state_screen.cpp

   #if HAS_SOFTWARE_ENDSTOPS
     #undef EDGE_R
     #define EDGE_R 30
-    cmd.font(font_small)
+    cmd.cmd(COLOR_RGB(bg_text_enabled))
+       .font(font_small)
        .text         (BTN_POS(1,5), BTN_SIZE(3,1), GET_TEXTF(SOFT_ENDSTOPS), OPT_RIGHTX | OPT_CENTERY)
        .colors(ui_toggle)
        .tag(2).toggle2(BTN_POS(4,5), BTN_SIZE(3,1), GET_TEXTF(NO), GET_TEXTF(YES), getSoftEndstopState());

Marlin/src/lcd/extensible_ui/lib/lulzbot/screens/files_screen.cpp

       cmd.cmd(MACRO(0));
     }
   #endif
-  cmd.text  (BTN_POS(1,header_h+line), BTN_SIZE(6,1), filename, OPT_CENTERY);
+  cmd.text  (BTN_POS(1,header_h+line), BTN_SIZE(6,1), filename, OPT_CENTERY
+    #if ENABLED(SCROLL_LONG_FILENAMES)
+      | OPT_NOFIT
+    #endif
+  );
   if (is_dir) {
     cmd.text(BTN_POS(1,header_h+line), BTN_SIZE(6,1), F("> "),  OPT_CENTERY | OPT_RIGHTX);
   }
           if (FTDI::ftdi_chip >= 810) {
             const char *longFilename = getSelectedLongFilename();
             if (longFilename[0]) {
-              CLCD::FontMetrics fm(font_medium);
-              uint16_t text_width = fm.get_text_width(longFilename);
+              CommandProcessor cmd;
+              uint16_t text_width = cmd.font(font_medium).text_width(longFilename);
               screen_data.FilesScreen.scroll_pos = 0;
               if (text_width > display_width)
                 screen_data.FilesScreen.scroll_max = text_width - display_width + MARGIN_L + MARGIN_R;

Marlin/src/lcd/extensible_ui/lib/lulzbot/screens/screens.h

     static void onRedraw(draw_mode_t) {};
   public:
     static bool onTouchEnd(uint8_t tag);
+    static void onIdle();
 };
 
 class AlertDialogBox : public DialogBoxBaseClass, public CachedScreen<ALERT_BOX_CACHE,ALERT_BOX_DL_SIZE> {
       static void draw_fine_motion(draw_mode_t what);
       static void draw_buttons(draw_mode_t what);
     public:
+      static void loadBitmaps();
       static void unlockMotors();
 
       static void setStatusMessage(const char *);
       static void setStatusMessage(progmem_str);
 
-      static void onStartup();
       static void onRedraw(draw_mode_t);
 
       static bool onTouchStart(uint8_t tag);

Marlin/src/lcd/extensible_ui/lib/lulzbot/screens/spinner_dialog_box.cpp

 }
 
 void SpinnerDialogBox::onIdle() {
+  reset_menu_timeout();
   if (screen_data.SpinnerDialogBox.auto_hide && !commandsInQueue()) {
     screen_data.SpinnerDialogBox.auto_hide = false;
     hide();

Marlin/src/lcd/extensible_ui/lib/lulzbot/screens/status_screen.cpp

        .cmd(BITMAP_LAYOUT(Fan_Icon_Info))
        .cmd(BITMAP_SIZE  (Fan_Icon_Info))
        .icon  (BTN_POS(5,2), BTN_SIZE(1,1), Fan_Icon_Info, icon_scale);
+
+    #ifdef TOUCH_UI_USE_UTF8
+      load_utf8_bitmaps(cmd); // Restore font bitmap handles
+    #endif
   }
 
   if (what & FOREGROUND) {
      .cmd(CLEAR(true,true,true));
 
   draw_temperature(BACKGROUND);
-  #ifdef TOUCH_UI_USE_UTF8
-    load_utf8_bitmaps(cmd);
-  #endif
   draw_progress(BACKGROUND);
   draw_axis_position(BACKGROUND);
   draw_status_message(BACKGROUND, message);

Marlin/src/lcd/extensible_ui/ui_api.cpp

   void enableHeater(const extruder_t extruder) {
     #if HOTENDS && HEATER_IDLE_HANDLER
       thermalManager.reset_heater_idle_timer(extruder - E0);
+    #else
+      UNUSED(extruder);
     #endif
   }
 
           #endif
           break;
       }
+    #else
+      UNUSED(heater);
     #endif
   }
 
     return false
       #if HOTENDS && HEATER_IDLE_HANDLER
         || thermalManager.hotend_idle[extruder - E0].timed_out
+      #else
+        ; UNUSED(extruder)
       #endif
     ;
   }
           #endif
       }
     #else
+      UNUSED(heater);
       return false;
     #endif
   }