src/charset.c

   1 /* ncmpc (Ncurses MPD Client)
   2  * (c) 2004-2009 The Music Player Daemon Project
   3  * Project homepage: http://musicpd.org
   4
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "charset.h"
  21
  22 #include <assert.h>
  23 #include <string.h>
  24 #include <glib.h>
  25
  26 #ifdef ENABLE_LOCALE
  27 static bool noconvert = true;
  28 static const char *charset;
  29
  30 const char *
  31 charset_init(void)
  32 {
  33         noconvert = g_get_charset(&charset);
  34         return charset;
  35 }
  36 #endif
  37
  38 #ifdef ENABLE_WIDE
  39 static inline unsigned
  40 unicode_char_width(gunichar ch)
  41 {
  42 #if !GLIB_CHECK_VERSION(2,14,0)
  43         if (g_unichar_iszerowidth(ch))
  44                 return 0;
  45 #endif
  46
  47         if (g_unichar_iswide(ch))
  48                 return 2;
  49
  50         return 1;
  51 }
  52 #endif /* ENABLE_WIDE */
  53
  54 unsigned
  55 utf8_width(const char *str)
  56 {
  57         assert(str != NULL);
  58
  59 #if defined(ENABLE_MULTIBYTE) && !defined(ENABLE_WIDE)
  60         return g_utf8_strlen(str, -1);
  61 #else
  62 #ifdef ENABLE_WIDE
  63         if (g_utf8_validate(str, -1, NULL)) {
  64                 size_t len = g_utf8_strlen(str, -1);
  65                 unsigned width = 0;
  66                 gunichar c;
  67
  68                 while (len--) {
  69                         c = g_utf8_get_char(str);
  70                         width += unicode_char_width(c);
  71                         str += g_unichar_to_utf8(c, NULL);
  72                 }
  73
  74                 return width;
  75         } else
  76 #endif
  77                 return strlen(str);
  78 #endif
  79 }
  80
  81 unsigned
  82 locale_width(const char *p)
  83 {
  84 #if defined(ENABLE_LOCALE) && defined(ENABLE_MULTIBYTE)
  85         char *utf8;
  86         unsigned width;
  87
  88         if (noconvert)
  89                 return utf8_width(p);
  90
  91         utf8 = locale_to_utf8(p);
  92         width = utf8_width(utf8);
  93         g_free(utf8);
  94
  95         return width;
  96 #else
  97         return strlen(p);
  98 #endif
  99 }
 100
 101 static inline unsigned
 102 ascii_cut_width(char *p, unsigned max_width)
 103 {
 104         size_t length = strlen(p);
 105         if (length <= (size_t)max_width)
 106                 return (unsigned)length;
 107
 108         p[max_width] = 0;
 109         return max_width;
 110 }
 111
 112 static inline unsigned
 113 narrow_cut_width(char *p, unsigned max_width)
 114 {
 115         size_t length = g_utf8_strlen(p, -1);
 116         if (length <= (size_t)max_width)
 117                 return (unsigned)length;
 118
 119         *g_utf8_offset_to_pointer(p, max_width) = 0;
 120         return max_width;
 121 }
 122
 123 static inline unsigned
 124 wide_cut_width(char *p, unsigned max_width)
 125 {
 126         size_t length = g_utf8_strlen(p, -1);
 127         unsigned width = 0, prev_width;
 128         gunichar c;
 129
 130         while (length-- > 0) {
 131                 c = g_utf8_get_char(p);
 132                 prev_width = width;
 133                 width += g_unichar_iswide(c) ? 2 : 1;
 134                 if (width > max_width) {
 135                         /* too wide - cut the rest off */
 136                         *p = 0;
 137                         return prev_width;
 138                 }
 139
 140                 p += g_unichar_to_utf8(c, NULL);
 141         }
 142
 143         return width;
 144 }
 145
 146 unsigned
 147 utf8_cut_width(char *p, unsigned max_width)
 148 {
 149         assert(p != NULL);
 150
 151 #ifdef ENABLE_WIDE
 152         if (!g_utf8_validate(p, -1, NULL))
 153                 return ascii_cut_width(p, max_width);
 154
 155         return wide_cut_width(p, max_width);
 156 #elif defined(ENABLE_MULTIBYTE) && !defined(ENABLE_WIDE)
 157         return narrow_cut_width(p, max_width);
 158 #else
 159         return ascii_cut_width(p, max_width);
 160 #endif
 161 }
 162
 163 char *
 164 utf8_to_locale(const char *utf8str)
 165 {
 166 #ifdef ENABLE_LOCALE
 167         gchar *str;
 168
 169         assert(utf8str != NULL);
 170
 171         if (noconvert)
 172                 return g_strdup(utf8str);
 173
 174         str = g_convert_with_fallback(utf8str, -1,
 175                                       charset, "utf-8",
 176                                       NULL, NULL, NULL, NULL);
 177         if (str == NULL)
 178                 return g_strdup(utf8str);
 179
 180         return str;
 181 #else
 182         return g_strdup(utf8str);
 183 #endif
 184 }
 185
 186 char *
 187 locale_to_utf8(const char *localestr)
 188 {
 189 #ifdef ENABLE_LOCALE
 190         gchar *str;
 191
 192         assert(localestr != NULL);
 193
 194         if (noconvert)
 195                 return g_strdup(localestr);
 196
 197         str = g_convert_with_fallback(localestr, -1,
 198                                       "utf-8", charset,
 199                                       NULL, NULL, NULL, NULL);
 200         if (str == NULL)
 201                 return g_strdup(localestr);
 202
 203         return str;
 204 #else
 205         return g_strdup(localestr);
 206 #endif
 207 }
 208
 209 char *
 210 replace_utf8_to_locale(char *src)
 211 {
 212 #ifdef ENABLE_LOCALE
 213         assert(src != NULL);
 214
 215         if (noconvert)
 216                 return src;
 217
 218         return utf8_to_locale(src);
 219 #else
 220         return src;
 221 #endif
 222 }
 223
 224
 225 char *
 226 replace_locale_to_utf8(char *src)
 227 {
 228 #ifdef ENABLE_LOCALE
 229         assert(src != NULL);
 230
 231         if (noconvert)
 232                 return src;
 233
 234         return locale_to_utf8(src);
 235 #else
 236         return src;
 237 #endif
 238 }