apps/irssi/src/fe-common/core/fe-recode.c

   1 /*
   2  fe-recode.c : irssi
   3
   4     Copyright (C) 1999-2000 Timo Sirainen
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License along
  17     with this program; if not, write to the Free Software Foundation, Inc.,
  18     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21 #include "module.h"
  22 #include "modules.h"
  23 #include "module-formats.h"
  24 #include "commands.h"
  25 #include "levels.h"
  26 #include "lib-config/iconfig.h"
  27 #include "settings.h"
  28 #include "printtext.h"
  29 #include "formats.h"
  30 #include "recode.h"
  31
  32 static char *recode_fallback = NULL;
  33 static char *recode_out_default = NULL;
  34 static char *term_charset = NULL;
  35
  36 static const char *fe_recode_get_target (WI_ITEM_REC *witem)
  37 {
  38         if (witem && (witem->type == module_get_uniq_id_str("WINDOW ITEM TYPE", "QUERY")
  39             || witem->type == module_get_uniq_id_str("WINDOW ITEM TYPE", "CHANNEL")))
  40                 return window_item_get_target(witem);
  41
  42         printformat(NULL, NULL, MSGLEVEL_CLIENTERROR, TXT_NOT_CHANNEL_OR_QUERY);
  43         return NULL;
  44 }
  45
  46 static int fe_recode_compare_func (CONFIG_NODE *node1, CONFIG_NODE *node2)
  47 {
  48         return strcmp(node1->key, node2->key);
  49 }
  50
  51 /* SYNTAX: RECODE */
  52 static void fe_recode_cmd (const char *data, SERVER_REC *server, WI_ITEM_REC *witem)
  53 {
  54         if (*data)
  55                 command_runsub("recode", data, server, witem);
  56         else {
  57                 CONFIG_NODE *conversions;
  58                 GSList *tmp;
  59                 GSList *sorted = NULL;
  60
  61                 conversions = iconfig_node_traverse("conversions", FALSE);
  62
  63                 for (tmp = conversions ? config_node_first(conversions->value) : NULL;
  64                      tmp != NULL;
  65                      tmp = config_node_next(tmp)) {
  66                         CONFIG_NODE *node = tmp->data;
  67
  68                         if (node->type == NODE_TYPE_KEY)
  69                                 sorted = g_slist_insert_sorted(sorted, node, (GCompareFunc) fe_recode_compare_func);
  70                 }
  71
  72                 printformat(NULL, NULL, MSGLEVEL_CLIENTCRAP, TXT_RECODE_HEADER);
  73                 for (tmp = sorted; tmp != NULL; tmp = tmp->next) {
  74                         CONFIG_NODE *node = tmp->data;
  75                         printformat(NULL, NULL, MSGLEVEL_CLIENTCRAP, TXT_RECODE_LINE, node->key, node->value);
  76                 }
  77
  78                 g_slist_free(sorted);
  79         }
  80 }
  81
  82 /* SYNTAX: RECODE ADD [[<tag>/]<target>] <charset> */
  83 static void fe_recode_add_cmd (const char *data, SERVER_REC *server, WI_ITEM_REC *witem)
  84 {
  85         const char *first;
  86         const char *second;
  87         const char *target;
  88         const char *charset;
  89         void *free_arg;
  90
  91         if (! cmd_get_params(data, &free_arg, 2, &first, &second))
  92                 return;
  93
  94         if (! *first)
  95                 cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
  96
  97         if (*second) {
  98                 target = first;
  99                 charset = second;
 100         } else {
 101                 target = fe_recode_get_target(witem);
 102                 charset = first;
 103                 if (! target)
 104                         goto end;
 105         }
 106         if (is_valid_charset(charset)) {
 107                 iconfig_set_str("conversions", target, charset);
 108                 printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE, TXT_CONVERSION_ADDED, target, charset);
 109         } else
 110                 signal_emit("error command", 2, GINT_TO_POINTER(CMDERR_INVALID_CHARSET), charset);
 111  end:
 112         cmd_params_free(free_arg);
 113 }
 114
 115 /* SYNTAX: RECODE REMOVE [<target>] */
 116 static void fe_recode_remove_cmd (const char *data, SERVER_REC *server, WI_ITEM_REC *witem)
 117 {
 118         const char *target;
 119         void *free_arg;
 120
 121         if (! cmd_get_params(data, &free_arg, 1, &target))
 122                 return;
 123
 124         if (! *target) {
 125                 target = fe_recode_get_target(witem);
 126                 if (! target)
 127                         goto end;
 128         }
 129
 130         if (iconfig_get_str("conversions", target, NULL) == NULL)
 131                 printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE, TXT_CONVERSION_NOT_FOUND, target);
 132         else {
 133                 iconfig_set_str("conversions", target, NULL);
 134                 printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE, TXT_CONVERSION_REMOVED, target);
 135         }
 136
 137  end:
 138         cmd_params_free(free_arg);
 139 }
 140
 141 static void read_settings(void)
 142 {
 143         /* preserve the valid values */
 144         char *old_term_charset = g_strdup(term_charset);
 145         char *old_recode_fallback = g_strdup(recode_fallback);
 146         char *old_recode_out_default = g_strdup(recode_out_default);
 147
 148         if (settings_get_bool("recode_transliterate")) {
 149                 /* check if transliterations are supported in this system */
 150                 if (!is_valid_charset("ASCII")) {
 151                         printformat(NULL, NULL, MSGLEVEL_CLIENTERROR,
 152                                     TXT_CONVERSION_NO_TRANSLITS);
 153                         settings_set_bool("recode_transliterate", FALSE);
 154                 }
 155         }
 156
 157         if (recode_fallback)
 158                 g_free(recode_fallback);
 159         recode_fallback = g_strdup(settings_get_str("recode_fallback"));
 160         if (!is_valid_charset(recode_fallback)) {
 161                 signal_emit("error command", 2, GINT_TO_POINTER(CMDERR_INVALID_CHARSET), recode_fallback);
 162                 g_free(recode_fallback);
 163                 recode_fallback = is_valid_charset(old_recode_fallback) ? g_strdup(old_recode_fallback) : NULL;
 164                 settings_set_str("recode_fallback", recode_fallback);
 165         }
 166
 167         if (term_charset)
 168                 g_free(term_charset);
 169         term_charset = g_strdup(settings_get_str("term_charset"));
 170         if (!is_valid_charset(term_charset)) {
 171                 g_free(term_charset);
 172                 term_charset = is_valid_charset(old_term_charset) ? g_strdup(old_term_charset) : NULL;
 173                 settings_set_str("term_charset", term_charset);
 174         }
 175         recode_update_charset();
 176
 177         if (recode_out_default)
 178                 g_free(recode_out_default);
 179         recode_out_default = g_strdup(settings_get_str("recode_out_default_charset"));
 180         if (recode_out_default != NULL && *recode_out_default != '\0' &&
 181             !is_valid_charset(recode_out_default)) {
 182                 signal_emit("error command", 2, GINT_TO_POINTER(CMDERR_INVALID_CHARSET), recode_out_default);
 183                 g_free(recode_out_default);
 184                 recode_out_default = is_valid_charset(old_recode_out_default) ? g_strdup(old_recode_out_default) : NULL;
 185                 settings_set_str("recode_out_default_charset", recode_out_default);
 186         }
 187
 188         g_free(old_term_charset);
 189         g_free(old_recode_fallback);
 190         g_free(old_recode_out_default);
 191 }
 192
 193 void fe_recode_init (void)
 194 {
 195         command_bind("recode", NULL, (SIGNAL_FUNC) fe_recode_cmd);
 196         command_bind("recode add", NULL, (SIGNAL_FUNC) fe_recode_add_cmd);
 197         command_bind("recode remove", NULL, (SIGNAL_FUNC) fe_recode_remove_cmd);
 198         signal_add_first("setup changed", (SIGNAL_FUNC) read_settings);
 199         read_settings();
 200 }
 201
 202 void fe_recode_deinit (void)
 203 {
 204         command_unbind("recode", (SIGNAL_FUNC) fe_recode_cmd);
 205         command_unbind("recode add", (SIGNAL_FUNC) fe_recode_add_cmd);
 206         command_unbind("recode remove", (SIGNAL_FUNC) fe_recode_remove_cmd);
 207         signal_remove("setup changed", (SIGNAL_FUNC) read_settings);
 208 }