🩹 Remove poison wchar_t macro

Marlin/src/feature/power_monitor.cpp

     void PowerMonitor::draw_current() {
       const float amps = getAmps();
       lcd_put_u8str(amps < 100 ? ftostr31ns(amps) : ui16tostr4rj((uint16_t)amps));
-      lcd_put_wchar('A');
+      lcd_put_lchar('A');
     }
   #endif
 
     void PowerMonitor::draw_voltage() {
       const float volts = getVolts();
       lcd_put_u8str(volts < 100 ? ftostr31ns(volts) : ui16tostr4rj((uint16_t)volts));
-      lcd_put_wchar('V');
+      lcd_put_lchar('V');
     }
   #endif
 
     void PowerMonitor::draw_power() {
       const float power = getPower();
       lcd_put_u8str(power < 100 ? ftostr31ns(power) : ui16tostr4rj((uint16_t)power));
-      lcd_put_wchar('W');
+      lcd_put_lchar('W');
     }
   #endif
 

Marlin/src/lcd/HD44780/lcdprint_hd44780.cpp

 int lcd_glyph_height() { return 1; }
 
 typedef struct _hd44780_charmap_t {
-  wchar_t uchar; // the unicode char
+  lchar_t uchar; // the unicode char
   uint8_t idx;   // the glyph of the char in the ROM
   uint8_t idx2;  // the char used to be combined with the idx to simulate a single char
 } hd44780_charmap_t;
 
 // return < 0 on error
 // return the advanced cols
-int lcd_put_wchar_max(const wchar_t c, const pixel_len_t max_length) {
+int lcd_put_lchar_max(const lchar_t &c, const pixel_len_t max_length) {
 
   // find the HD44780 internal ROM first
   int ret;
   pixel_len_t ret = 0;
   const uint8_t *p = (uint8_t *)utf8_str;
   while (ret < max_length) {
-    wchar_t ch = 0;
-    p = get_utf8_value_cb(p, cb_read_byte, &ch);
+    lchar_t ch;
+    p = get_utf8_value_cb(p, cb_read_byte, ch);
     if (!ch) break;
-    ret += lcd_put_wchar_max(ch, max_length - ret);
+    ret += lcd_put_lchar_max(ch, max_length - ret);
   }
   return (int)ret;
 }

Marlin/src/lcd/HD44780/marlinui_HD44780.cpp

   void lcd_erase_line(const lcd_uint_t line) {
     lcd_moveto(0, line);
     for (uint8_t i = LCD_WIDTH + 1; --i;)
-      lcd_put_wchar(' ');
+      lcd_put_lchar(' ');
   }
 
   // Scroll the PSTR 'text' in a 'len' wide field for 'time' milliseconds at position col,line
     uint8_t slen = utf8_strlen(ftxt);
     if (slen < len) {
       lcd_put_u8str_max(col, line, ftxt, len);
-      for (; slen < len; ++slen) lcd_put_wchar(' ');
+      for (; slen < len; ++slen) lcd_put_lchar(' ');
       safe_delay(time);
     }
     else {
         lcd_put_u8str_max_P(col, line, p, len);
 
         // Fill with spaces
-        for (uint8_t ix = slen - i; ix < len; ++ix) lcd_put_wchar(' ');
+        for (uint8_t ix = slen - i; ix < len; ++ix) lcd_put_lchar(' ');
 
         // Delay
         safe_delay(dly);
 
   static void logo_lines(FSTR_P const extra) {
     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_lchar(indent, 0, '\x00'); lcd_put_u8str(F( "------" ));  lcd_put_lchar('\x01');
     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_lchar(indent, 2, '\x02'); lcd_put_u8str(F( "------" ));  lcd_put_lchar('\x03');
   }
 
   void MarlinUI::show_bootscreen() {
 // Homed and known, display constantly.
 //
 FORCE_INLINE void _draw_axis_value(const AxisEnum axis, const char *value, const bool blink) {
-  lcd_put_wchar('X' + uint8_t(axis));
+  lcd_put_lchar('X' + uint8_t(axis));
   if (blink)
     lcd_put_u8str(value);
   else if (axis_should_home(axis))
-    while (const char c = *value++) lcd_put_wchar(c <= '.' ? c : '?');
+    while (const char c = *value++) lcd_put_lchar(c <= '.' ? c : '?');
   else if (NONE(HOME_AFTER_DEACTIVATE, DISABLE_REDUCED_ACCURACY_WARNING) && !axis_is_trusted(axis))
     lcd_put_u8str(axis == Z_AXIS ? F("       ") : F("    "));
   else
     const celsius_t t1 = thermalManager.wholeDegHotend(heater_id), t2 = thermalManager.degTargetHotend(heater_id);
   #endif
 
-  if (prefix >= 0) lcd_put_wchar(prefix);
+  if (prefix >= 0) lcd_put_lchar(prefix);
 
   lcd_put_u8str(t1 < 0 ? "err" : i16tostr3rj(t1));
-  lcd_put_wchar('/');
+  lcd_put_lchar('/');
 
   #if !HEATER_IDLE_HANDLER
     UNUSED(blink);
   #else
     if (!blink && thermalManager.heater_idle[thermalManager.idle_index_for_id(heater_id)].timed_out) {
-      lcd_put_wchar(' ');
-      if (t2 >= 10) lcd_put_wchar(' ');
-      if (t2 >= 100) lcd_put_wchar(' ');
+      lcd_put_lchar(' ');
+      if (t2 >= 10) lcd_put_lchar(' ');
+      if (t2 >= 100) lcd_put_lchar(' ');
     }
     else
   #endif
       lcd_put_u8str(i16tostr3left(t2));
 
   if (prefix >= 0) {
-    lcd_put_wchar(LCD_STR_DEGREE[0]);
-    lcd_put_wchar(' ');
-    if (t2 < 10) lcd_put_wchar(' ');
+    lcd_put_lchar(LCD_STR_DEGREE[0]);
+    lcd_put_lchar(' ');
+    if (t2 < 10) lcd_put_lchar(' ');
   }
 }
 
 FORCE_INLINE void _draw_cooler_status(const char prefix, const bool blink) {
   const celsius_t t2 = thermalManager.degTargetCooler();
 
-  if (prefix >= 0) lcd_put_wchar(prefix);
+  if (prefix >= 0) lcd_put_lchar(prefix);
 
   lcd_put_u8str(i16tostr3rj(thermalManager.wholeDegCooler()));
-  lcd_put_wchar('/');
+  lcd_put_lchar('/');
 
   #if !HEATER_IDLE_HANDLER
     UNUSED(blink);
   #else
     if (!blink && thermalManager.heater_idle[thermalManager.idle_index_for_id(heater_id)].timed_out) {
-      lcd_put_wchar(' ');
-      if (t2 >= 10) lcd_put_wchar(' ');
-      if (t2 >= 100) lcd_put_wchar(' ');
+      lcd_put_lchar(' ');
+      if (t2 >= 10) lcd_put_lchar(' ');
+      if (t2 >= 100) lcd_put_lchar(' ');
     }
     else
   #endif
       lcd_put_u8str(i16tostr3left(t2));
 
   if (prefix >= 0) {
-    lcd_put_wchar(LCD_STR_DEGREE[0]);
-    lcd_put_wchar(' ');
-    if (t2 < 10) lcd_put_wchar(' ');
+    lcd_put_lchar(LCD_STR_DEGREE[0]);
+    lcd_put_lchar(' ');
+    if (t2 < 10) lcd_put_lchar(' ');
   }
 }
 #endif
   FORCE_INLINE void _draw_flowmeter_status() {
     lcd_put_u8str("~");
     lcd_put_u8str(ftostr11ns(cooler.flowrate));
-    lcd_put_wchar('L');
+    lcd_put_lchar('L');
   }
 #endif
 
     }
     else {
       lcd_put_u8str(ftostr12ns(ammeter.current));
-      lcd_put_wchar('A');
+      lcd_put_lchar('A');
     }
   }
 #endif
       lcd_put_u8str(ui8tostr3rj(progress));
     else
       lcd_put_u8str(F("---"));
-    lcd_put_wchar('%');
+    lcd_put_lchar('%');
   }
 
 #endif
       lcd_put_u8str(ftostr12ns(filwidth.measured_mm));
       lcd_put_u8str(F(" V"));
       lcd_put_u8str(i16tostr3rj(planner.volumetric_percent(parser.volumetric_enabled)));
-      lcd_put_wchar('%');
+      lcd_put_lchar('%');
       return;
     }
 
       lcd_put_u8str(status_message);
 
       // Fill the rest with spaces
-      while (slen < LCD_WIDTH) { lcd_put_wchar(' '); ++slen; }
+      while (slen < LCD_WIDTH) { lcd_put_lchar(' '); ++slen; }
     }
     else {
       // String is larger than the available space in screen.
       // If the remaining string doesn't completely fill the screen
       if (rlen < LCD_WIDTH) {
         uint8_t chars = LCD_WIDTH - rlen;     // Amount of space left in characters
-        lcd_put_wchar(' ');                   // Always at 1+ spaces left, draw a space
+        lcd_put_lchar(' ');                   // Always at 1+ spaces left, draw a space
         if (--chars) {                        // Draw a second space if there's room
-          lcd_put_wchar(' ');
+          lcd_put_lchar(' ');
           if (--chars) {                      // Draw a third space if there's room
-            lcd_put_wchar(' ');
+            lcd_put_lchar(' ');
             if (--chars)
               lcd_put_u8str_max(status_message, chars); // Print a second copy of the message
           }
 
     // Fill the rest with spaces if there are missing spaces
     while (slen < LCD_WIDTH) {
-      lcd_put_wchar(' ');
+      lcd_put_lchar(' ');
       ++slen;
     }
   #endif
         duration_t remaining = (progress > 0) ? ((elapsed * 25600 / progress) >> 8) - elapsed : 0;
       #endif
       timepos -= remaining.toDigital(buffer);
-      lcd_put_wchar(timepos, 2, 'R');
+      lcd_put_lchar(timepos, 2, 'R');
     }
   #else
     constexpr bool show_remain = false;
   if (!show_remain) {
     duration_t elapsed = print_job_timer.duration();
     timepos -= elapsed.toDigital(buffer);
-    lcd_put_wchar(timepos, 2, LCD_STR_CLOCK[0]);
+    lcd_put_lchar(timepos, 2, LCD_STR_CLOCK[0]);
   }
   lcd_put_u8str(buffer);
   return timepos;
             else {
               const xy_pos_t lpos = current_position.asLogical();
               _draw_axis_value(X_AXIS, ftostr4sign(lpos.x), blink);
-              lcd_put_wchar(' ');
+              lcd_put_lchar(' ');
               _draw_axis_value(Y_AXIS, ftostr4sign(lpos.y), blink);
             }
 
       _draw_axis_value(Z_AXIS, ftostr52sp(LOGICAL_Z_POSITION(current_position.z)), blink);
 
       #if HAS_LEVELING && !HAS_HEATED_BED
-        lcd_put_wchar(planner.leveling_active || blink ? '_' : ' ');
+        lcd_put_lchar(planner.leveling_active || blink ? '_' : ' ');
       #endif
 
     #endif // LCD_HEIGHT > 2
 
     #if LCD_HEIGHT > 3
 
-      lcd_put_wchar(0, 2, LCD_STR_FEEDRATE[0]);
+      lcd_put_lchar(0, 2, LCD_STR_FEEDRATE[0]);
       lcd_put_u8str(i16tostr3rj(feedrate_percentage));
-      lcd_put_wchar('%');
+      lcd_put_lchar('%');
 
       const uint8_t timepos = draw_elapsed_or_remaining_time(LCD_WIDTH - 1, blink);
 
                 per = planner.flow_percentage[0];
               #endif
             }
-          lcd_put_wchar(c);
+          lcd_put_lchar(c);
           lcd_put_u8str(i16tostr3rj(per));
-          lcd_put_wchar('%');
+          lcd_put_lchar('%');
         #endif
       #endif
 
     _draw_axis_value(Z_AXIS, ftostr52sp(LOGICAL_Z_POSITION(current_position.z)), blink);
 
     #if HAS_LEVELING && (HAS_MULTI_HOTEND || !HAS_HEATED_BED)
-      lcd_put_wchar(LCD_WIDTH - 1, 0, planner.leveling_active || blink ? '_' : ' ');
+      lcd_put_lchar(LCD_WIDTH - 1, 0, planner.leveling_active || blink ? '_' : ' ');
     #endif
 
     // ========== Line 2 ==========
       _draw_bed_status(blink);
     #endif
 
-    lcd_put_wchar(LCD_WIDTH - 9, 1, LCD_STR_FEEDRATE[0]);
+    lcd_put_lchar(LCD_WIDTH - 9, 1, LCD_STR_FEEDRATE[0]);
     lcd_put_u8str(i16tostr3rj(feedrate_percentage));
-    lcd_put_wchar('%');
+    lcd_put_lchar('%');
 
     // ========== Line 3 ==========
 
                  vlen = vstr ? utf8_strlen(vstr) : 0;
     if (style & SS_CENTER) {
       int8_t pad = (LCD_WIDTH - plen - vlen) / 2;
-      while (--pad >= 0) { lcd_put_wchar(' '); n--; }
+      while (--pad >= 0) { lcd_put_lchar(' '); n--; }
     }
     if (plen) n = lcd_put_u8str(fstr, itemIndex, itemStringC, itemStringF, n);
     if (vlen) n -= lcd_put_u8str_max(vstr, n);
-    for (; n > 0; --n) lcd_put_wchar(' ');
+    for (; n > 0; --n) lcd_put_lchar(' ');
   }
 
   // Draw a generic menu item with pre_char (if selected) and post_char
   void MenuItemBase::_draw(const bool sel, const uint8_t row, FSTR_P const ftpl, const char pre_char, const char post_char) {
-    lcd_put_wchar(0, row, sel ? pre_char : ' ');
+    lcd_put_lchar(0, row, sel ? pre_char : ' ');
     uint8_t n = lcd_put_u8str(ftpl, itemIndex, itemStringC, itemStringF, LCD_WIDTH - 2);
-    for (; n; --n) lcd_put_wchar(' ');
-    lcd_put_wchar(post_char);
+    for (; n; --n) lcd_put_lchar(' ');
+    lcd_put_lchar(post_char);
   }
 
   // Draw a menu item with a (potentially) editable value
   void MenuEditItemBase::draw(const bool sel, const uint8_t row, FSTR_P const ftpl, const char * const inStr, const bool pgm) {
     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_lchar(0, row, sel ? LCD_STR_ARROW_RIGHT[0] : ' ');
     uint8_t n = lcd_put_u8str(ftpl, itemIndex, itemStringC, itemStringF, LCD_WIDTH - 2 - vlen);
     if (vlen) {
-      lcd_put_wchar(':');
-      for (; n; --n) lcd_put_wchar(' ');
+      lcd_put_lchar(':');
+      for (; n; --n) lcd_put_lchar(' ');
       if (pgm) lcd_put_u8str_P(inStr); else lcd_put_u8str(inStr);
     }
   }
     ui.encoder_direction_normal();
     uint8_t n = lcd_put_u8str(0, 1, ftpl, itemIndex, itemStringC, itemStringF, LCD_WIDTH - 1);
     if (value) {
-      lcd_put_wchar(':'); n--;
+      lcd_put_lchar(':'); n--;
       const uint8_t len = utf8_strlen(value) + 1;   // Plus one for a leading space
       const lcd_uint_t valrow = n < len ? 2 : 1;    // Value on the next row if it won't fit
-      lcd_put_wchar(LCD_WIDTH - len, valrow, ' ');  // Right-justified, padded, leading space
+      lcd_put_lchar(LCD_WIDTH - len, valrow, ' ');  // Right-justified, padded, leading space
       lcd_put_u8str(value);
     }
   }
     ui.draw_select_screen_prompt(pref, string, suff);
     if (no) {
       SETCURSOR(0, LCD_HEIGHT - 1);
-      lcd_put_wchar(yesno ? ' ' : '['); lcd_put_u8str(no); lcd_put_wchar(yesno ? ' ' : ']');
+      lcd_put_lchar(yesno ? ' ' : '['); lcd_put_u8str(no); lcd_put_lchar(yesno ? ' ' : ']');
     }
     if (yes) {
       SETCURSOR_RJ(utf8_strlen(yes) + 2, LCD_HEIGHT - 1);
-      lcd_put_wchar(yesno ? '[' : ' '); lcd_put_u8str(yes); lcd_put_wchar(yesno ? ']' : ' ');
+      lcd_put_lchar(yesno ? '[' : ' '); lcd_put_u8str(yes); lcd_put_lchar(yesno ? ']' : ' ');
     }
   }
 
   #if ENABLED(SDSUPPORT)
 
     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_lchar(0, row, sel ? LCD_STR_ARROW_RIGHT[0] : ' ');
       constexpr uint8_t maxlen = LCD_WIDTH - 2;
       uint8_t n = maxlen - lcd_put_u8str_max(ui.scrolled_filename(theCard, maxlen, row, sel), maxlen);
-      for (; n; --n) lcd_put_wchar(' ');
-      lcd_put_wchar(isDir ? LCD_STR_FOLDER[0] : ' ');
+      for (; n; --n) lcd_put_lchar(' ');
+      lcd_put_lchar(isDir ? LCD_STR_FOLDER[0] : ' ');
     }
 
   #endif
     void prep_and_put_map_char(custom_char &chrdata, const coordinate &ul, const coordinate &lr, const coordinate &brc, const uint8_t cl, const char c, const lcd_uint_t x, const lcd_uint_t y) {
       add_edges_to_custom_char(chrdata, ul, lr, brc, cl);
       lcd.createChar(c, (uint8_t*)&chrdata);
-      lcd_put_wchar(x, y, c);
+      lcd_put_lchar(x, y, c);
     }
 
     void MarlinUI::ubl_plot(const uint8_t x_plot, const uint8_t y_plot) {
         #define _LCD_W_POS 8
         #define _PLOT_X 0
         #define _MAP_X 1
-        #define _LABEL(X,Y,C) lcd_put_wchar(X, Y, C)
+        #define _LABEL(X,Y,C) lcd_put_lchar(X, Y, C)
         #define _XLABEL(X,Y) _LABEL('X',X,Y)
         #define _YLABEL(X,Y) _LABEL('Y',X,Y)
         #define _ZLABEL(X,Y) _LABEL('Z',X,Y)
         n_cols = right_edge / (HD44780_CHAR_WIDTH) + 1;
 
         for (i = 0; i < n_cols; i++) {
-          lcd_put_wchar(i, 0, CHAR_LINE_TOP);                               // Box Top line
-          lcd_put_wchar(i, n_rows - 1, CHAR_LINE_BOT);                      // Box Bottom line
+          lcd_put_lchar(i, 0, CHAR_LINE_TOP);                               // Box Top line
+          lcd_put_lchar(i, n_rows - 1, CHAR_LINE_BOT);                      // Box Bottom line
         }
 
         for (j = 0; j < n_rows; j++) {
-          lcd_put_wchar(0, j, CHAR_EDGE_L);                                 // Box Left edge
-          lcd_put_wchar(n_cols - 1, j, CHAR_EDGE_R);                        // Box Right edge
+          lcd_put_lchar(0, j, CHAR_EDGE_L);                                 // Box Left edge
+          lcd_put_lchar(n_cols - 1, j, CHAR_EDGE_R);                        // Box Right edge
         }
 
         /**
         k = pixels_per_y_mesh_pnt * (GRID_MAX_POINTS_Y) + 2;
         l = (HD44780_CHAR_HEIGHT) * n_rows;
         if (l > k && l - k >= (HD44780_CHAR_HEIGHT) / 2) {
-          lcd_put_wchar(0, n_rows - 1, ' ');                                // Box Left edge
-          lcd_put_wchar(n_cols - 1, n_rows - 1, ' ');                       // Box Right edge
+          lcd_put_lchar(0, n_rows - 1, ' ');                                // Box Left edge
+          lcd_put_lchar(n_cols - 1, n_rows - 1, ' ');                       // Box Right edge
         }
 
         clear_custom_char(&new_char);
       /**
        * Print plot position
        */
-      lcd_put_wchar(_LCD_W_POS, 0, '(');
+      lcd_put_lchar(_LCD_W_POS, 0, '(');
       lcd_put_u8str(ui8tostr3rj(x_plot));
-      lcd_put_wchar(',');
+      lcd_put_lchar(',');
       lcd_put_u8str(ui8tostr3rj(y_plot));
-      lcd_put_wchar(')');
+      lcd_put_lchar(')');
 
       #if LCD_HEIGHT <= 3   // 16x2 or 20x2 display
 

Marlin/src/lcd/TFTGLCD/lcdprint_TFTGLCD.cpp

 int lcd_glyph_height() { return 1; }
 
 typedef struct _TFTGLCD_charmap_t {
-  wchar_t uchar; // the unicode char
+  lchar_t uchar; // the unicode char
   uint8_t idx;   // the glyph of the char in the ROM
   uint8_t idx2;  // the char used to be combined with the idx to simulate a single char
 } TFTGLCD_charmap_t;
 
 // return < 0 on error
 // return the advanced cols
-int lcd_put_wchar_max(const wchar_t c, const pixel_len_t max_length) {
+int lcd_put_lchar_max(const lchar_t &c, const pixel_len_t max_length) {
 
   // find the HD44780 internal ROM first
   int ret;
   pixel_len_t ret = 0;
   const uint8_t *p = (uint8_t *)utf8_str;
   while (ret < max_length) {
-    wchar_t ch = 0;
-    p = get_utf8_value_cb(p, cb_read_byte, &ch);
+    lchar_t ch;
+    p = get_utf8_value_cb(p, cb_read_byte, ch);
     if (!ch) break;
-    ret += lcd_put_wchar_max(ch, max_length - ret);
+    ret += lcd_put_lchar_max(ch, max_length - ret);
   }
   return (int)ret;
 }

Marlin/src/lcd/TFTGLCD/marlinui_TFTGLCD.cpp

       UNUSED(blink);
     #else
       if (!blink && thermalManager.heater_idle[thermalManager.idle_index_for_id(heater_id)].timed_out) {
-        lcd_put_wchar(' ');
-        if (t2 >= 10) lcd_put_wchar(' ');
-        if (t2 >= 100) lcd_put_wchar(' ');
+        lcd_put_lchar(' ');
+        if (t2 >= 10) lcd_put_lchar(' ');
+        if (t2 >= 100) lcd_put_lchar(' ');
       }
       else
     #endif
         lcd_put_u8str(i16tostr3left(t2));
 
-    lcd_put_wchar(' ');
-    if (t2 < 10) lcd_put_wchar(' ');
+    lcd_put_lchar(' ');
+    if (t2 < 10) lcd_put_lchar(' ');
 
     if (t2) picBits |= ICON_TEMP1;
     else    picBits &= ~ICON_TEMP1;
 
   FORCE_INLINE void _draw_flowmeter_status() {
     lcd_moveto(5, 5); lcd_put_u8str(F("FLOW"));
-    lcd_moveto(7, 6); lcd_put_wchar('L');
+    lcd_moveto(7, 6); lcd_put_lchar('L');
     lcd_moveto(6, 7); lcd_put_u8str(ftostr11ns(cooler.flowrate));
 
     if (cooler.flowrate)  picBits |= ICON_FAN;
     {
       lcd_put_u8str("mA");
       lcd_moveto(10, 7);
-      lcd_put_wchar(' '); lcd_put_u8str(ui16tostr3rj(uint16_t(ammeter.current * 1000 + 0.5f)));
+      lcd_put_lchar(' '); lcd_put_u8str(ui16tostr3rj(uint16_t(ammeter.current * 1000 + 0.5f)));
     }
     else {
       lcd_put_u8str(" A");
     #if CUTTER_UNIT_IS(RPM)
       lcd_moveto(16, 6);  lcd_put_u8str(F("RPM"));
       lcd_moveto(15, 7);  lcd_put_u8str(ftostr31ns(float(cutter.unitPower) / 1000));
-      lcd_put_wchar('K');
+      lcd_put_lchar('K');
     #elif CUTTER_UNIT_IS(PERCENT)
-      lcd_moveto(17, 6);  lcd_put_wchar('%');
+      lcd_moveto(17, 6);  lcd_put_lchar('%');
       lcd_moveto(18, 7);  lcd_put_u8str(cutter_power2str(cutter.unitPower));
     #else
       lcd_moveto(17, 7);  lcd_put_u8str(cutter_power2str(cutter.unitPower));

Marlin/src/lcd/dogm/lcdprint_u8g.cpp

 
 // return < 0 on error
 // return the advanced pixels
-int lcd_put_wchar_max(const wchar_t c, const pixel_len_t max_length) {
+int lcd_put_lchar_max(const lchar_t &c, const pixel_len_t max_length) {
   if (c < 256) {
     u8g.print((char)c);
     return u8g_GetFontBBXWidth(u8g.getU8g());

Marlin/src/lcd/dogm/marlinui_DOGM.cpp

 
       if (!PAGE_CONTAINS(y1 + 1, y2 + 2)) return;
 
-      lcd_put_wchar(LCD_PIXEL_WIDTH - 11 * (MENU_FONT_WIDTH), y2, 'E');
-      lcd_put_wchar((char)('1' + extruder));
-      lcd_put_wchar(' ');
+      lcd_put_lchar(LCD_PIXEL_WIDTH - 11 * (MENU_FONT_WIDTH), y2, 'E');
+      lcd_put_lchar((char)('1' + extruder));
+      lcd_put_lchar(' ');
       lcd_put_u8str(i16tostr3rj(thermalManager.wholeDegHotend(extruder)));
-      lcd_put_wchar('/');
+      lcd_put_lchar('/');
 
       if (get_blink() || !thermalManager.heater_idle[extruder].timed_out)
         lcd_put_u8str(i16tostr3rj(thermalManager.degTargetHotend(extruder)));
                 vlen = vstr ? utf8_strlen(vstr) : 0;
       if (style & SS_CENTER) {
         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_lchar(' ');
       }
 
       if (plen) n = lcd_put_u8str(ftpl, itemIndex, itemStringC, itemStringF, n / (MENU_FONT_WIDTH)) * (MENU_FONT_WIDTH);
       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_lchar(' ');
     }
   }
 
   void MenuItemBase::_draw(const bool sel, const uint8_t row, FSTR_P const ftpl, const char, const char post_char) {
     if (mark_as_selected(row, sel)) {
       pixel_len_t n = lcd_put_u8str(ftpl, itemIndex, itemStringC, itemStringF, LCD_WIDTH - 1) * (MENU_FONT_WIDTH);
-      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(' ');
+      while (n > MENU_FONT_WIDTH) n -= lcd_put_lchar(' ');
+      lcd_put_lchar(LCD_PIXEL_WIDTH - (MENU_FONT_WIDTH), row_y2, post_char);
+      lcd_put_lchar(' ');
     }
   }
 
 
       pixel_len_t n = lcd_put_u8str(ftpl, itemIndex, itemStringC, itemStringF, LCD_WIDTH - 2 - vallen * prop) * (MENU_FONT_WIDTH);
       if (vallen) {
-        lcd_put_wchar(':');
-        while (n > MENU_FONT_WIDTH) n -= lcd_put_wchar(' ');
+        lcd_put_lchar(':');
+        while (n > MENU_FONT_WIDTH) n -= lcd_put_lchar(' ');
         lcd_moveto(LCD_PIXEL_WIDTH - _MAX((MENU_FONT_WIDTH) * vallen, pixelwidth + 2), row_y2);
         if (pgm) lcd_put_u8str_P(inStr); else lcd_put_u8str(inStr);
       }
 
     // If a value is included, print a colon, then print the value right-justified
     if (value) {
-      lcd_put_wchar(':');
+      lcd_put_lchar(':');
       if (extra_row) {
         // Assume that value is numeric (with no descender)
         baseline += EDIT_FONT_ASCENT + 2;
         onpage = PAGE_CONTAINS(baseline - (EDIT_FONT_ASCENT - 1), baseline);
       }
       if (onpage) {
-        lcd_put_wchar(((lcd_chr_fit - 1) - (vallen * prop + 1)) * one_chr_width, baseline, ' '); // Right-justified, padded, add a leading space
+        lcd_put_lchar(((lcd_chr_fit - 1) - (vallen * prop + 1)) * one_chr_width, baseline, ' '); // Right-justified, padded, add a leading space
         lcd_put_u8str(value);
       }
     }
     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)) {
         const uint8_t maxlen = LCD_WIDTH - isDir;
-        if (isDir) lcd_put_wchar(LCD_STR_FOLDER[0]);
+        if (isDir) lcd_put_lchar(LCD_STR_FOLDER[0]);
         const pixel_len_t pixw = maxlen * (MENU_FONT_WIDTH);
         pixel_len_t n = pixw - lcd_put_u8str_max(ui.scrolled_filename(theCard, maxlen, row, sel), pixw);
-        while (n > MENU_FONT_WIDTH) n -= lcd_put_wchar(' ');
+        while (n > MENU_FONT_WIDTH) n -= lcd_put_lchar(' ');
       }
     }
 
 
       // Print plot position
       if (PAGE_CONTAINS(LCD_PIXEL_HEIGHT - (INFO_FONT_HEIGHT - 1), LCD_PIXEL_HEIGHT)) {
-        lcd_put_wchar(5, LCD_PIXEL_HEIGHT, '(');
+        lcd_put_lchar(5, LCD_PIXEL_HEIGHT, '(');
         u8g.print(x_plot);
-        lcd_put_wchar(',');
+        lcd_put_lchar(',');
         u8g.print(y_plot);
-        lcd_put_wchar(')');
+        lcd_put_lchar(')');
 
         // Show the location value
         lcd_put_u8str_P(74, LCD_PIXEL_HEIGHT, Z_LBL);

Marlin/src/lcd/dogm/status_screen_DOGM.cpp

     const char *str = i16tostr3rj(temp);
     const uint8_t len = str[0] != ' ' ? 3 : str[1] != ' ' ? 2 : 1;
     lcd_put_u8str(tx - len * (INFO_FONT_WIDTH) / 2 + 1, ty, &str[3-len]);
-    lcd_put_wchar(LCD_STR_DEGREE[0]);
+    lcd_put_lchar(LCD_STR_DEGREE[0]);
   }
 }
 
   const bool is_inch = parser.using_inch_units();
   const AxisEnum a = TERN(LCD_SHOW_E_TOTAL, axis == E_AXIS ? X_AXIS : axis, axis);
   const uint8_t offs = a * (is_inch ? XYZ_SPACING_IN : XYZ_SPACING);
-  lcd_put_wchar((is_inch ? X_LABEL_POS_IN : X_LABEL_POS) + offs, XYZ_BASELINE, AXIS_CHAR(axis));
+  lcd_put_lchar((is_inch ? X_LABEL_POS_IN : X_LABEL_POS) + offs, XYZ_BASELINE, AXIS_CHAR(axis));
   lcd_moveto((is_inch ? X_VALUE_POS_IN : X_VALUE_POS) + offs, XYZ_BASELINE);
 
   if (blink)
     lcd_put_u8str(value);
   else if (axis_should_home(axis))
-    while (const char c = *value++) lcd_put_wchar(c <= '.' ? c : '?');
+    while (const char c = *value++) lcd_put_lchar(c <= '.' ? c : '?');
   else if (NONE(HOME_AFTER_DEACTIVATE, DISABLE_REDUCED_ACCURACY_WARNING) && !axis_is_trusted(axis))
     lcd_put_u8str(axis == Z_AXIS ? F("       ") : F("    "));
   else
           lcd_put_u8str(STATUS_CUTTER_TEXT_X, STATUS_CUTTER_TEXT_Y, cutter_power2str(cutter.unitPower));
         #elif CUTTER_UNIT_IS(RPM)
           lcd_put_u8str(STATUS_CUTTER_TEXT_X - 2, STATUS_CUTTER_TEXT_Y, ftostr61rj(float(cutter.unitPower) / 1000));
-          lcd_put_wchar('K');
+          lcd_put_lchar('K');
         #else
           lcd_put_u8str(STATUS_CUTTER_TEXT_X, STATUS_CUTTER_TEXT_Y, cutter_power2str(cutter.unitPower));
         #endif
             }
           #endif
           lcd_put_u8str(STATUS_FAN_TEXT_X, STATUS_FAN_TEXT_Y, i16tostr3rj(thermalManager.pwmToPercent(spd)));
-          lcd_put_wchar(c);
+          lcd_put_lchar(c);
         }
       }
     #endif
         if (progress_state == 0) {
           if (progress_string[0]) {
             lcd_put_u8str(progress_x_pos, EXTRAS_BASELINE, progress_string);
-            lcd_put_wchar('%');
+            lcd_put_lchar('%');
           }
         }
         else if (progress_state == 2 && estimation_string[0]) {
         #if ENABLED(SHOW_SD_PERCENT)
           if (progress_string[0]) {
             lcd_put_u8str(55, EXTRAS_BASELINE, progress_string); // Percent complete
-            lcd_put_wchar('%');
+            lcd_put_lchar('%');
           }
         #endif
 
 
         #if ENABLED(SHOW_REMAINING_TIME)
           if (blink && estimation_string[0]) {
-            lcd_put_wchar(estimation_x_pos, EXTRAS_BASELINE, 'R');
+            lcd_put_lchar(estimation_x_pos, EXTRAS_BASELINE, 'R');
             lcd_put_u8str(estimation_string);
           }
           else
 
   if (PAGE_CONTAINS(EXTRAS_2_BASELINE - INFO_FONT_ASCENT, EXTRAS_2_BASELINE - 1)) {
     set_font(FONT_MENU);
-    lcd_put_wchar(3, EXTRAS_2_BASELINE, LCD_STR_FEEDRATE[0]);
+    lcd_put_lchar(3, EXTRAS_2_BASELINE, LCD_STR_FEEDRATE[0]);
 
     set_font(FONT_STATUSMENU);
     lcd_put_u8str(12, EXTRAS_2_BASELINE, i16tostr3rj(feedrate_percentage));
-    lcd_put_wchar('%');
+    lcd_put_lchar('%');
 
     //
     // Filament sensor display if SD is disabled
     #if ENABLED(FILAMENT_LCD_DISPLAY) && DISABLED(SDSUPPORT)
       lcd_put_u8str(56, EXTRAS_2_BASELINE, wstring);
       lcd_put_u8str(102, EXTRAS_2_BASELINE, mstring);
-      lcd_put_wchar('%');
+      lcd_put_lchar('%');
       set_font(FONT_MENU);
-      lcd_put_wchar(47, EXTRAS_2_BASELINE, LCD_STR_FILAM_DIA[0]); // lcd_put_u8str(F(LCD_STR_FILAM_DIA));
-      lcd_put_wchar(93, EXTRAS_2_BASELINE, LCD_STR_FILAM_MUL[0]);
+      lcd_put_lchar(47, EXTRAS_2_BASELINE, LCD_STR_FILAM_DIA[0]); // lcd_put_u8str(F(LCD_STR_FILAM_DIA));
+      lcd_put_lchar(93, EXTRAS_2_BASELINE, LCD_STR_FILAM_MUL[0]);
     #endif
   }
 
       // Alternate Status message and Filament display
       if (ELAPSED(millis(), next_filament_display)) {
         lcd_put_u8str(F(LCD_STR_FILAM_DIA));
-        lcd_put_wchar(':');
+        lcd_put_lchar(':');
         lcd_put_u8str(wstring);
         lcd_put_u8str(F("  " LCD_STR_FILAM_MUL));
-        lcd_put_wchar(':');
+        lcd_put_lchar(':');
         lcd_put_u8str(mstring);
-        lcd_put_wchar('%');
+        lcd_put_lchar('%');
         return;
       }
     #endif
     if (slen <= lcd_width) {
       // The string fits within the line. Print with no scrolling
       lcd_put_u8str(status_message);
-      while (slen < lcd_width) { lcd_put_wchar(' '); ++slen; }
+      while (slen < lcd_width) { lcd_put_lchar(' '); ++slen; }
     }
     else {
       // String is longer than the available space
       // If the remaining string doesn't completely fill the screen
       if (rlen < lcd_width) {
         uint8_t chars = lcd_width - rlen;       // Amount of space left in characters
-        lcd_put_wchar(' ');                     // Always at 1+ spaces left, draw a space
+        lcd_put_lchar(' ');                     // Always at 1+ spaces left, draw a space
         if (--chars) {                          // Draw a second space if there's room
-          lcd_put_wchar(' ');
+          lcd_put_lchar(' ');
           if (--chars) {                        // Draw a third space if there's room
-            lcd_put_wchar(' ');
+            lcd_put_lchar(' ');
             if (--chars) {                      // Print a second copy of the message
               lcd_put_u8str_max(status_message, pixel_width - (rlen + 2) * (MENU_FONT_WIDTH));
-              lcd_put_wchar(' ');
+              lcd_put_lchar(' ');
             }
           }
         }
     lcd_put_u8str_max(status_message, pixel_width);
 
     // Fill the rest with spaces
-    for (; slen < lcd_width; ++slen) lcd_put_wchar(' ');
+    for (; slen < lcd_width; ++slen) lcd_put_lchar(' ');
 
   #endif // !STATUS_MESSAGE_SCROLLING
 

Marlin/src/lcd/dogm/u8g_fontutf8.cpp

   return 0;
 }
 
-static const font_t* fontgroup_find(font_group_t * root, wchar_t val) {
-  uxg_fontinfo_t vcmp = {(uint16_t)(val / 128), (uint8_t)(val % 128 + 128), (uint8_t)(val % 128 + 128), 0, 0};
-  size_t idx = 0;
+static const font_t* fontgroup_find(font_group_t * root, const lchar_t &val) {
+  if (val <= 0xFF) return nullptr;
 
-  if (val < 256) return nullptr;
+  uxg_fontinfo_t vcmp = { uint16_t(val >> 7), uint8_t((val & 0x7F) + 0x80), uint8_t((val & 0x7F) + 0x80), 0, 0 };
+  size_t idx = 0;
 
   if (pf_bsearch_r((void*)root->m_fntifo, root->m_fntinfo_num, pf_bsearch_cb_comp_fntifo_pgm, (void*)&vcmp, &idx) < 0)
     return nullptr;
   return vcmp.fntdata;
 }
 
-static void fontgroup_drawwchar(font_group_t *group, const font_t *fnt_default, wchar_t val, void * userdata, fontgroup_cb_draw_t cb_draw_ram) {
+static void fontgroup_drawwchar(font_group_t *group, const font_t *fnt_default, const lchar_t &val, void * userdata, fontgroup_cb_draw_t cb_draw_ram) {
   uint8_t buf[2] = {0, 0};
   const font_t * fntpqm = (font_t*)fontgroup_find(group, val);
   if (!fntpqm) {
 static void fontgroup_drawstring(font_group_t *group, const font_t *fnt_default, const char *utf8_msg, read_byte_cb_t cb_read_byte, void * userdata, fontgroup_cb_draw_t cb_draw_ram) {
   const uint8_t *p = (uint8_t*)utf8_msg;
   for (;;) {
-    wchar_t val = 0;
-    p = get_utf8_value_cb(p, cb_read_byte, &val);
-    if (!val) break;
-    fontgroup_drawwchar(group, fnt_default, val, userdata, cb_draw_ram);
+    lchar_t ch;
+    p = get_utf8_value_cb(p, cb_read_byte, ch);
+    if (!ch) break;
+    fontgroup_drawwchar(group, fnt_default, ch, userdata, cb_draw_ram);
   }
 }
 
 }
 
 /**
- * @brief Draw a wchar_t at the specified position
+ * @brief Draw a lchar_t at the specified position
  *
  * @param pu8g : U8G pointer
  * @param x : position x axis
  * @param y : position y axis
- * @param ch : the wchar_t
+ * @param ch : the lchar_t
  * @param max_width : the pixel width of the string allowed
  *
  * @return number of pixels advanced
  *
  * Draw a UTF-8 string at the specified position
  */
-unsigned int uxg_DrawWchar(u8g_t *pu8g, unsigned int x, unsigned int y, wchar_t ch, pixel_len_t max_width) {
+unsigned int uxg_DrawWchar(u8g_t *pu8g, unsigned int x, unsigned int y, const lchar_t &ch, pixel_len_t max_width) {
   struct _uxg_drawu8_data_t data;
   font_group_t *group = &g_fontgroup_root;
   const font_t *fnt_default = uxg_GetFont(pu8g);

Marlin/src/lcd/dogm/u8g_fontutf8.h

 
 int uxg_SetUtf8Fonts(const uxg_fontinfo_t * fntinfo, int number); // fntinfo is type of PROGMEM
 
-unsigned int uxg_DrawWchar(u8g_t *pu8g, unsigned int x, unsigned int y, wchar_t ch, const pixel_len_t max_length);
+unsigned int uxg_DrawWchar(u8g_t *pu8g, unsigned int x, unsigned int y, const lchar_t &ch, const pixel_len_t max_length);
 
 unsigned int uxg_DrawUtf8Str(u8g_t *pu8g, unsigned int x, unsigned int y, const char *utf8_msg, const pixel_len_t max_length);
 unsigned int uxg_DrawUtf8StrP(u8g_t *pu8g, unsigned int x, unsigned int y, PGM_P utf8_msg, const pixel_len_t max_length);

Marlin/src/lcd/e3v2/marlinui/dwin_string.cpp

  *   @ displays an axis name such as XYZUVW, or E for an extruder
  */
 void DWIN_String::add(const char *tpl, const int8_t index, const char *cstr/*=nullptr*/, FSTR_P const fstr/*=nullptr*/) {
-  wchar_t wchar;
+  lchar_t ch;
 
   while (*tpl) {
-    tpl = get_utf8_value_cb(tpl, read_byte, &wchar);
-    if (wchar > 255) wchar |= 0x0080;
-    const uint8_t ch = uint8_t(wchar & 0x00FF);
+    tpl = get_utf8_value_cb(tpl, read_byte, ch);
+    if (ch > 255) ch |= 0x0080;
+    const uint8_t ch = uint8_t(ch & 0x00FF);
 
     if (ch == '=' || ch == '~' || ch == '*') {
       if (index >= 0) {
 }
 
 void DWIN_String::add(const char *cstr, uint8_t max_len/*=MAX_STRING_LENGTH*/) {
-  wchar_t wchar;
+  lchar_t ch;
   while (*cstr && max_len) {
-    cstr = get_utf8_value_cb(cstr, read_byte, &wchar);
+    cstr = get_utf8_value_cb(cstr, read_byte, ch);
     /*
-    if (wchar > 255) wchar |= 0x0080;
-    uint8_t ch = uint8_t(wchar & 0x00FF);
+    if (ch > 255) ch |= 0x0080;
+    uint8_t ch = uint8_t(ch & 0x00FF);
     add_character(ch);
     */
-    add(wchar);
+    add(ch);
     max_len--;
   }
   eol();
 }
 
-void DWIN_String::add(const wchar_t character) {
+void DWIN_String::add(const lchar_t &ch) {
   int ret;
   size_t idx = 0;
   dwin_charmap_t pinval;
   dwin_charmap_t *copy_address = nullptr;
-  pinval.uchar = character;
+  pinval.uchar = ch;
   pinval.idx = -1;
 
-  // For 8-bit ASCII just print the single character
+  // For 8-bit ASCII just print the single ch
   char str[] = { '?', 0 };
-  if (character < 255) {
-    str[0] = (char)character;
+  if (ch < 255) {
+    str[0] = (char)ch;
   }
   else {
     copy_address = nullptr;

Marlin/src/lcd/e3v2/marlinui/dwin_string.h

 #include <stdint.h>
 
 typedef struct _dwin_charmap_t {
-  wchar_t uchar; // the unicode char
+  lchar_t uchar; // the unicode char
   uint8_t idx;   // the glyph of the char in the ROM
   uint8_t idx2;  // the char used to be combined with the idx to simulate a single char
 } dwin_charmap_t;
     /**
      * @brief Append a UTF-8 character
      *
-     * @param character The UTF-8 character
+     * @param ch The UTF-8 character
      */
-    static void add(wchar_t character);
-    static void set(wchar_t character) { set(); add(character); }
+    static void add(const lchar_t &ch);
+    static void set(const lchar_t &ch) { set(); add(ch); }
 
     /**
      * @brief Append / Set C-string

Marlin/src/lcd/e3v2/marlinui/lcdprint_dwin.cpp

 
 // return < 0 on error
 // return the advanced cols
-int lcd_put_wchar_max(const wchar_t c, const pixel_len_t max_length) {
+int lcd_put_lchar_max(const lchar_t &c, const pixel_len_t max_length) {
   dwin_string.set(c);
   dwin_string.truncate(max_length);
   // Draw the char(s) at the cursor and advance the cursor
   const uint8_t *p = (uint8_t *)utf8_str;
   dwin_string.set();
   while (dwin_string.length < max_length) {
-    wchar_t ch = 0;
-    p = get_utf8_value_cb(p, cb_read_byte, &ch);
+    lchar_t ch;
+    p = get_utf8_value_cb(p, cb_read_byte, ch);
     if (!ch) break;
     dwin_string.add(ch);
   }

Marlin/src/lcd/e3v2/marlinui/ui_common.cpp

         lcd_put_u8str(status_message);
 
         // Fill the rest with spaces
-        while (slen < max_status_chars) { lcd_put_wchar(' '); ++slen; }
+        while (slen < max_status_chars) { lcd_put_lchar(' '); ++slen; }
       }
     }
     else {
 
       // If the string doesn't completely fill the line...
       if (rlen < max_status_chars) {
-        lcd_put_wchar('.');                   // Always at 1+ spaces left, draw a dot
+        lcd_put_lchar('.');                   // Always at 1+ spaces left, draw a dot
         uint8_t chars = max_status_chars - rlen;  // Amount of space left in characters
         if (--chars) {                        // Draw a second dot if there's space
-          lcd_put_wchar('.');
+          lcd_put_lchar('.');
           if (--chars)
             lcd_put_u8str_max(status_message, chars); // Print a second copy of the message
         }
       lcd_put_u8str_max(status_message, max_status_chars);
 
       // Fill the rest with spaces if there are missing spaces
-      while (slen < max_status_chars) { lcd_put_wchar(' '); ++slen; }
+      while (slen < max_status_chars) { lcd_put_lchar(' '); ++slen; }
     }
 
   #endif

Marlin/src/lcd/fontutils.h

 #pragma once
 
 #include <stdlib.h>
-#include <stddef.h> // wchar_t
 #include <stdint.h> // uint32_t
 
 #include "../HAL/shared/Marduino.h"
 #include "../core/macros.h"
 
+#define MAX_UTF8_CHAR_SIZE 4
+
 // read a byte from ROM or RAM
 typedef uint8_t (*read_byte_cb_t)(const uint8_t * str);
 
 uint8_t read_byte_ram(const uint8_t *str);
 uint8_t read_byte_rom(const uint8_t *str);
 
-// there's overflow of the wchar_t due to the 2-byte size in Arduino
-// sizeof(wchar_t)=2; sizeof(size_t)=2; sizeof(uint32_t)=4;
-// sizeof(int)=2; sizeof(long)=4; sizeof(unsigned)=2;
-//#undef wchar_t
-#define wchar_t uint32_t
-//typedef uint32_t wchar_t;
+// An extra long character type because wchar_t is only 2 bytes
+typedef uint32_t lchar_t;
 
 typedef uint16_t pixel_len_t;
 #define PIXEL_LEN_NOLIMIT ((pixel_len_t)(-1))
 
 /* Perform binary search */
-typedef int (* pf_bsearch_cb_comp_t)(void *userdata, size_t idx, void * data_pin); /*"data_list[idx] - *data_pin"*/
+typedef int (* pf_bsearch_cb_comp_t)(void *userdata, size_t idx, void * data_pin);
 int pf_bsearch_r(void *userdata, size_t num_data, pf_bsearch_cb_comp_t cb_comp, void *data_pinpoint, size_t *ret_idx);
 
 /* Get the character, decoding multibyte UTF8 characters and returning a pointer to the start of the next UTF8 character */
-const uint8_t* get_utf8_value_cb(const uint8_t *pstart, read_byte_cb_t cb_read_byte, wchar_t *pval);
+const uint8_t* get_utf8_value_cb(const uint8_t *pstart, read_byte_cb_t cb_read_byte, lchar_t &pval);
 
-inline const char* get_utf8_value_cb(const char *pstart, read_byte_cb_t cb_read_byte, wchar_t *pval) {
+inline const char* get_utf8_value_cb(const char *pstart, read_byte_cb_t cb_read_byte, lchar_t &pval) {
   return (const char *)get_utf8_value_cb((const uint8_t *)pstart, cb_read_byte, pval);
 }
 

Marlin/src/lcd/lcdprint.cpp

   const uint8_t *p = (uint8_t*)ptpl;
   int8_t n = maxlen;
   while (n > 0) {
-    wchar_t ch;
-    p = get_utf8_value_cb(p, read_byte_rom, &ch);
+    lchar_t ch;
+    p = get_utf8_value_cb(p, read_byte_rom, ch);
     if (!ch) break;
     if (ch == '=' || ch == '~' || ch == '*') {
       if (ind >= 0) {
-        if (ch == '*') { lcd_put_wchar('E'); n--; }
+        if (ch == '*') { lcd_put_lchar('E'); n--; }
         if (n) {
           int8_t inum = ind + ((ch == '=') ? 0 : LCD_FIRST_TOOL);
           if (inum >= 10) {
-            lcd_put_wchar('0' + (inum / 10)); n--;
+            lcd_put_lchar('0' + (inum / 10)); n--;
             inum %= 10;
           }
-          if (n) { lcd_put_wchar('0' + inum); n--; }
+          if (n) { lcd_put_lchar('0' + inum); n--; }
         }
       }
       else {
       n -= lcd_put_u8str_max(cstr, n * (MENU_FONT_WIDTH)) / (MENU_FONT_WIDTH);
     }
     else if (ch == '@') {
-      lcd_put_wchar(AXIS_CHAR(ind));
+      lcd_put_lchar(AXIS_CHAR(ind));
       n--;
     }
     else {
-      lcd_put_wchar(ch);
+      lcd_put_lchar(ch);
       n -= ch > 255 ? prop : 1;
     }
   }
   int n = 0;
 
   do {
-    wchar_t ch;
-    p = get_utf8_value_cb(p, read_byte_rom, &ch);
+    lchar_t ch;
+    p = get_utf8_value_cb(p, read_byte_rom, ch);
     if (!ch) break;
     n += (ch > 255) ? prop : 1;
   } while (1);

Marlin/src/lcd/lcdprint.h

  *
  * @return the output width (in pixels on GLCD)
  */
-int lcd_put_wchar_max(const wchar_t c, const pixel_len_t max_length);
+int lcd_put_lchar_max(const lchar_t &c, const pixel_len_t max_length);
 
 /**
  * @brief Draw a SRAM UTF-8 string
 /**
  * @brief Draw a UTF-8 character with no width limit
  *
- * @param c The wchar to draw
+ * @param c The lchar to draw
  * @return the output width (in pixels on GLCD)
  */
-inline int lcd_put_wchar(const wchar_t c) { return lcd_put_wchar_max(c, PIXEL_LEN_NOLIMIT); }
+inline int lcd_put_lchar(const lchar_t &c) { return lcd_put_lchar_max(c, PIXEL_LEN_NOLIMIT); }
 /**
  * @param col
  * @param row
  */
-inline int lcd_put_wchar(const lcd_uint_t col, const lcd_uint_t row, const wchar_t c) {
+inline int lcd_put_lchar(const lcd_uint_t col, const lcd_uint_t row, const lchar_t &c) {
   lcd_moveto(col, row);
-  return lcd_put_wchar(c);
+  return lcd_put_lchar(c);
 }
 
 /**

Marlin/src/lcd/marlinui.cpp

         };
 
         const uint8_t *p = (uint8_t*)string;
-        wchar_t ch;
+        lchar_t ch;
         if (wordwrap) {
           const uint8_t *wrd = nullptr;
           uint8_t c = 0;
           // find the end of the part
           for (;;) {
             if (!wrd) wrd = p;            // Get word start /before/ advancing
-            p = get_utf8_value_cb(p, cb_read_byte, &ch);
+            p = get_utf8_value_cb(p, cb_read_byte, ch);
             const bool eol = !ch;         // zero ends the string
             // End or a break between phrases?
             if (eol || ch == ' ' || ch == '-' || ch == '+' || ch == '.') {
               col += c;                   // advance col to new position
               while (c) {                 // character countdown
                 --c;                      // count down to zero
-                wrd = get_utf8_value_cb(wrd, cb_read_byte, &ch); // get characters again
-                lcd_put_wchar(ch);        // character to the LCD
+                wrd = get_utf8_value_cb(wrd, cb_read_byte, ch); // get characters again
+                lcd_put_lchar(ch);        // character to the LCD
               }
               if (eol) break;             // all done!
               wrd = nullptr;              // set up for next word
         }
         else {
           for (;;) {
-            p = get_utf8_value_cb(p, cb_read_byte, &ch);
+            p = get_utf8_value_cb(p, cb_read_byte, ch);
             if (!ch) break;
-            lcd_put_wchar(ch);
+            lcd_put_lchar(ch);
             col++;
             if (col >= LCD_WIDTH) _newline();
           }

Marlin/src/lcd/menu/menu_bed_corners.cpp

       lcd_put_u8str(GET_TEXT_F(MSG_BED_TRAMMING_GOOD_POINTS));
       IF_ENABLED(TFT_COLOR_UI, lcd_moveto(12, cy));
       lcd_put_u8str(GOOD_POINTS_TO_STR(good_points));
-      lcd_put_wchar('/');
+      lcd_put_lchar('/');
       lcd_put_u8str(GOOD_POINTS_TO_STR(nr_edge_points));
     }
 

Marlin/src/lcd/menu/menu_configuration.cpp

     LIMIT(bar_percent, 0, 100);
     ui.encoderPosition = 0;
     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_lchar('%');
     lcd_moveto(0, LCD_HEIGHT - 1); ui.draw_progress_bar(bar_percent);
   }
 

Marlin/src/lcd/menu/menu_password.cpp

   FSTR_P const label = GET_TEXT_F(MSG_ENTER_DIGIT);
   EDIT_ITEM_F(uint8, label, &editable.uint8, 0, 9, digit_entered);
   MENU_ITEM_ADDON_START(utf8_strlen(label) + 1);
-    lcd_put_wchar(' ');
-    lcd_put_wchar('1' + digit_no);
+    lcd_put_lchar(' ');
+    lcd_put_lchar('1' + digit_no);
     SETCURSOR_X(LCD_WIDTH - 2);
-    lcd_put_wchar('>');
+    lcd_put_lchar('>');
   MENU_ITEM_ADDON_END();
 
   ACTION_ITEM(MSG_START_OVER, start_over);

Marlin/src/lcd/menu/menu_tune.cpp

           #if ENABLED(TFT_COLOR_UI)
             lcd_moveto(4, 3);
             lcd_put_u8str(GET_TEXT_F(MSG_BABYSTEP_TOTAL));
-            lcd_put_wchar(':');
+            lcd_put_lchar(':');
             lcd_moveto(10, 3);
           #else
             lcd_moveto(0, TERN(HAS_MARLINUI_U8GLIB, LCD_PIXEL_HEIGHT - MENU_FONT_DESCENT, LCD_HEIGHT - 1));
             lcd_put_u8str(GET_TEXT_F(MSG_BABYSTEP_TOTAL));
-            lcd_put_wchar(':');
+            lcd_put_lchar(':');
           #endif
           lcd_put_u8str(BABYSTEP_TO_STR(mps * babystep.axis_total[BS_TOTAL_IND(axis)]));
         }

Marlin/src/lcd/tft/tft_string.cpp

  *   @ displays an axis name such as XYZUVW, or E for an extruder
  */
 void TFT_String::add(const char *tpl, const int8_t index, const char *cstr/*=nullptr*/, FSTR_P const fstr/*=nullptr*/) {
-  wchar_t wchar;
+  lchar_t ch;
 
   while (*tpl) {
-    tpl = get_utf8_value_cb(tpl, read_byte_ram, &wchar);
-    if (wchar > 255) wchar |= 0x0080;
-    const uint8_t ch = uint8_t(wchar & 0x00FF);
+    tpl = get_utf8_value_cb(tpl, read_byte_ram, ch);
+    if (ch > 255) ch |= 0x0080;
+    const uint8_t ch = uint8_t(ch & 0x00FF);
 
     if (ch == '=' || ch == '~' || ch == '*') {
       if (index >= 0) {
 }
 
 void TFT_String::add(const char *cstr, uint8_t max_len/*=MAX_STRING_LENGTH*/) {
-  wchar_t wchar;
+  lchar_t ch;
   while (*cstr && max_len) {
-    cstr = get_utf8_value_cb(cstr, read_byte_ram, &wchar);
-    if (wchar > 255) wchar |= 0x0080;
-    const uint8_t ch = uint8_t(wchar & 0x00FF);
+    cstr = get_utf8_value_cb(cstr, read_byte_ram, ch);
+    if (ch > 255) ch |= 0x0080;
+    const uint8_t ch = uint8_t(ch & 0x00FF);
     add_character(ch);
     max_len--;
   }

Marlin/src/lcd/tft/tft_string.h

      * @param character The ASCII character
      */
     static void add(const char character) { add_character(character); eol(); }
-    static void set(wchar_t character) { set(); add(character); }
+    static void set(const lchar_t &character) { set(); add(character); }
 
     /**
      * @brief Append / Set C-string

Marlin/src/lcd/tft/ui_common.cpp

   lcd_gotopixel(int(col) * (TFT_COL_WIDTH), int(row) * MENU_LINE_HEIGHT);
 }
 
-int lcd_put_wchar_max(const wchar_t c, const pixel_len_t max_length) {
+int lcd_put_lchar_max(const lchar_t &c, const pixel_len_t max_length) {
   if (max_length < 1) return 0;
   tft_string.set(c);
   tft.add_text(MENU_TEXT_X_OFFSET, MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string);