Unicode character support in screen tab names

Author: Explorer09

Action.c

@@ -408,13 +408,14 @@ Htop_Reaction Action_setScreenTab(State* st, int x) {
          return 0;
       }
       const char* tab = settings->screens[i]->heading;
-      int len = strlen(tab);
-      if (x < s + len + 2) {
+      const char* ptr = tab;
+      int width = String_mbswidth(&ptr, SIZE_MAX, INT_MAX);
+      if (x < s + width + 2) {
          settings->ssIndex = i;
          setActiveScreen(settings, st, i);
          return HTOP_UPDATE_PANELHDR | HTOP_REFRESH | HTOP_REDRAW_BAR;
       }
-      s += len + 2 + SCREEN_TAB_COLUMN_GAP;
+      s += width + 2 + SCREEN_TAB_COLUMN_GAP;
    }
    return 0;
 }

ScreenManager.c

@@ -166,11 +166,11 @@ static inline bool drawTab(const int* y, int* x, int l, const char* name, bool c
    (*x)++;
    if (*x >= l)
       return false;
-   int nameLen = strlen(name);
-   int n = MINIMUM(l - *x, nameLen);
+   const char* ptr = name;
+   int nameWidth = String_mbswidth(&ptr, SIZE_MAX, l - *x);
    attrset(CRT_colors[cur ? SCREENS_CUR_TEXT : SCREENS_OTH_TEXT]);
-   mvaddnstr(*y, *x, name, n);
-   *x += n;
+   mvaddnstr(*y, *x, name, (int)(ptr - name));
+   *x += nameWidth;
    if (*x >= l)
       return false;
    attrset(CRT_colors[cur ? SCREENS_CUR_BORDER : SCREENS_OTH_BORDER]);

XUtils.c

@@ -10,8 +10,10 @@ in the source distribution for its full text.
 #include "XUtils.h"
 
 #include <assert.h>
+#include <ctype.h> // IWYU pragma: keep
 #include <errno.h>
 #include <fcntl.h>
+#include <limits.h> // IWYU pragma: keep
 #include <math.h>
 #include <stdarg.h>
 #include <stdint.h>
@@ -224,6 +226,185 @@ size_t String_safeStrncpy(char* restrict dest, const char* restrict src, size_t
    return i;
 }
 
+#ifdef HAVE_LIBNCURSESW
+static void String_encodeWChar(WCharEncoderState* ps, wchar_t wc) {
+   char tempBuf[MB_LEN_MAX];
+
+   char* dest = ps->buf ? (char*)ps->buf + ps->pos : tempBuf;
+   size_t len = wcrtomb(dest, wc, &ps->mbState);
+   assert(len != (size_t)-1);
+   assert(len > 0);
+
+   ps->pos += len;
+}
+#else
+static void String_encodeWChar(WCharEncoderState* ps, int c) {
+   if (ps->buf) {
+      ((char*)ps->buf)[ps->pos] = (char)c;
+   }
+   ps->pos += 1;
+}
+#endif
+
+void EncodePrintableString(WCharEncoderState* ps, const char* src, size_t maxLen, EncodeWChar encodeWChar) {
+   assert(src || maxLen == 0);
+
+   size_t pos = 0;
+   bool wasReplaced = false;
+
+#ifdef HAVE_LIBNCURSESW
+   const wchar_t replacementChar = CRT_utf8 ? L'\xFFFD' : L'?';
+   wchar_t ch;
+
+   mbstate_t decState;
+   memset(&decState, 0, sizeof(decState));
+   mbstate_t newState;
+#else
+   const char replacementChar = '?';
+   char ch;
+#endif
+
+   do {
+      size_t len = 0;
+      bool shouldReplace = false;
+      ch = 0;
+
+      if (pos < maxLen) {
+         // Read the next character from the byte sequence
+#ifdef HAVE_LIBNCURSESW
+         memcpy(&newState, &decState, sizeof(newState));
+         len = mbrtowc(&ch, &src[pos], maxLen - pos, &newState);
+
+         switch (len) {
+
+         case (size_t)-2:
+            errno = EILSEQ;
+            shouldReplace = true;
+            len = maxLen - pos;
+            break;
+
+         case (size_t)-1:
+            shouldReplace = true;
+            len = 1;
+            break;
+
+         case 0:
+            assert(ch == 0);
+            len = 1;
+            // Fallthrough
+
+         default:
+            memcpy(&decState, &newState, sizeof(decState));
+         }
+#else
+         len = 1;
+         ch = src[pos];
+#endif
+      }
+
+      pos += len;
+
+      // Filter unprintable characters
+      if (!shouldReplace && ch != 0) {
+#ifdef HAVE_LIBNCURSESW
+         shouldReplace = !iswprint(ch);
+#else
+         shouldReplace = !isprint((unsigned char)ch);
+#endif
+      }
+
+      if (shouldReplace) {
+         ch = replacementChar;
+         if (wasReplaced) {
+            continue;
+         }
+      }
+      wasReplaced = shouldReplace;
+
+      encodeWChar(ps, ch);
+   } while (ch != 0);
+}
+
+char* String_makePrintable(const char* str, size_t maxLen) {
+   WCharEncoderState encState;
+
+   memset(&encState, 0, sizeof(encState));
+   EncodePrintableString(&encState, str, maxLen, String_encodeWChar);
+   size_t bufSize = encState.pos;
+   assert(bufSize > 0);
+
+   memset(&encState, 0, sizeof(encState));
+   char* buf = xMalloc(bufSize);
+   encState.buf = buf;
+   EncodePrintableString(&encState, str, maxLen, String_encodeWChar);
+   assert(encState.pos == bufSize);
+   encState.buf = NULL;
+
+   return buf;
+}
+
+#ifndef HAVE_STRNLEN
+static size_t strnlen(const char* str, size_t maxLen) {
+   size_t len;
+   for (len = 0; len < maxLen && str[len] != '\0'; len++) {}
+   return len;
+}
+#endif
+
+int String_mbswidth(const char** str, size_t maxLen, int maxWidth) {
+   assert(*str || maxLen == 0);
+
+   if (maxWidth < 0)
+      maxWidth = INT_MAX;
+
+   const char* start = *str;
+
+#ifdef HAVE_LIBNCURSESW
+   mbstate_t state;
+   memset(&state, 0, sizeof(state));
+
+   int totalWidth = 0;
+   for (size_t pos = 0; pos < maxLen; ) {
+      wchar_t wc;
+      size_t len = mbrtowc(&wc, &start[pos], maxLen - pos, &state);
+      if (len == 0 || len == (size_t)-2 || len == (size_t)-1) {
+         assert(len != (size_t)-1);
+         break;
+      }
+
+      pos += len;
+
+      assert(wc != L'\0');
+      int w = wcwidth(wc);
+      if (w < 0) {
+         assert(w >= 0);
+         break;
+      }
+
+      if (w > maxWidth - totalWidth)
+         break;
+
+      if (w > 0 || CRT_utf8) {
+         // (*str - start) will represent the length of the substring bounded
+         // by the width limit.
+
+         // In Unicode, combining characters are always placed after the base
+         // character. Some legacy 8-bit encodings instead place combining
+         // characters before the base character.
+         *str = &start[pos];
+      }
+      totalWidth += w;
+   }
+
+   return totalWidth;
+#else
+   maxLen = MINIMUM((unsigned int)maxWidth, maxLen);
+   size_t len = strnlen(*str, maxLen);
+   *str = start + len;
+   return (int)len;
+#endif
+}
+
 int xAsprintf(char** strp, const char* fmt, ...) {
    va_list vl;
    va_start(vl, fmt);

XUtils.h

@@ -23,8 +23,21 @@ in the source distribution for its full text.
 
 #include "Compat.h"
 #include "Macros.h"
+#include "ProvideCurses.h"
 
 
+typedef struct WCharEncoderState_ {
+   size_t pos;
+   void* buf;
+   mbstate_t mbState;
+} WCharEncoderState;
+
+#ifdef HAVE_LIBNCURSESW
+typedef ATTR_NONNULL void (*EncodeWChar)(WCharEncoderState* ps, wchar_t wc);
+#else
+typedef ATTR_NONNULL void (*EncodeWChar)(WCharEncoderState* ps, int c);
+#endif
+
 ATTR_NORETURN
 void fail(void);
 
@@ -102,6 +115,15 @@ static inline char* String_strchrnul(const char* s, int c) {
 ATTR_NONNULL ATTR_ACCESS3_W(1, 3) ATTR_ACCESS3_R(2, 3)
 size_t String_safeStrncpy(char* restrict dest, const char* restrict src, size_t size);
 
+ATTR_NONNULL_N(1, 4) ATTR_ACCESS2_W(1) ATTR_ACCESS3_R(2, 3)
+void EncodePrintableString(WCharEncoderState* ps, const char* src, size_t maxLen, EncodeWChar encodeWChar);
+
+ATTR_RETNONNULL ATTR_MALLOC ATTR_ACCESS3_R(1, 2)
+char* String_makePrintable(const char* str, size_t maxLen);
+
+ATTR_NONNULL ATTR_ACCESS2_RW(1)
+int String_mbswidth(const char** str, size_t maxLen, int maxWidth);
+
 ATTR_FORMAT(printf, 2, 3) ATTR_NONNULL_N(1, 2)
 int xAsprintf(char** strp, const char* fmt, ...);
 

configure.ac

@@ -372,6 +372,7 @@ AC_CHECK_FUNCS([ \
     sched_getscheduler \
     sched_setscheduler \
     strchrnul \
+    strnlen \
    ])
 
 if test "$my_htop_platform" = darwin; then