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

   1 /*
   2  formats.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
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 #include "module.h"
  22 #include "module-formats.h"
  23 #include "signals.h"
  24 #include "special-vars.h"
  25 #include "settings.h"
  26
  27 #include "levels.h"
  28 #include "servers.h"
  29
  30 #include "fe-windows.h"
  31 #include "window-items.h"
  32 #include "formats.h"
  33 #include "themes.h"
  34 #include "translation.h"
  35
  36 static const char *format_backs = "04261537";
  37 static const char *format_fores = "kbgcrmyw";
  38 static const char *format_boldfores = "KBGCRMYW";
  39
  40 static int signal_gui_print_text;
  41 static int hide_text_style, hide_server_tags, hide_colors;
  42
  43 static int timestamp_level;
  44 static int timestamp_timeout;
  45
  46 int format_find_tag(const char *module, const char *tag)
  47 {
  48         FORMAT_REC *formats;
  49         int n;
  50
  51         formats = g_hash_table_lookup(default_formats, module);
  52         if (formats == NULL)
  53                 return -1;
  54
  55         for (n = 0; formats[n].def != NULL; n++) {
  56                 if (formats[n].tag != NULL &&
  57                     g_strcasecmp(formats[n].tag, tag) == 0)
  58                         return n;
  59         }
  60
  61         return -1;
  62 }
  63
  64 static void format_expand_code(const char **format, GString *out, int *flags)
  65 {
  66         int set;
  67
  68         if (flags == NULL) {
  69                 /* flags are being ignored - skip the code */
  70                 while (**format != ']')
  71                         (*format)++;
  72                 return;
  73         }
  74
  75         set = TRUE;
  76         (*format)++;
  77         while (**format != ']' && **format != '\0') {
  78                 if (**format == '+')
  79                         set = TRUE;
  80                 else if (**format == '-')
  81                         set = FALSE;
  82                 else switch (**format) {
  83                 case 'i':
  84                         /* indent function */
  85                         (*format)++;
  86                         if (**format == '=')
  87                                 (*format)++;
  88
  89                         g_string_append_c(out, 4);
  90                         g_string_append_c(out, FORMAT_STYLE_INDENT_FUNC);
  91                         while (**format != ']' && **format != '\0' &&
  92                                **format != ',') {
  93                                 g_string_append_c(out, **format);
  94                                 (*format)++;
  95                         }
  96                         g_string_append_c(out, ',');
  97                         (*format)--;
  98                         break;
  99                 case 's':
 100                 case 'S':
 101                         *flags |= !set ? PRINT_FLAG_UNSET_LINE_START :
 102                                 **format == 's' ? PRINT_FLAG_SET_LINE_START :
 103                                 PRINT_FLAG_SET_LINE_START_IRSSI;
 104                         break;
 105                 case 't':
 106                         *flags |= set ? PRINT_FLAG_SET_TIMESTAMP :
 107                                 PRINT_FLAG_UNSET_TIMESTAMP;
 108                         break;
 109                 case 'T':
 110                         *flags |= set ? PRINT_FLAG_SET_SERVERTAG :
 111                                 PRINT_FLAG_UNSET_SERVERTAG;
 112                         break;
 113                 }
 114
 115                 (*format)++;
 116         }
 117 }
 118
 119 int format_expand_styles(GString *out, const char **format, int *flags)
 120 {
 121         char *p, fmt;
 122
 123         fmt = **format;
 124         switch (fmt) {
 125         case '{':
 126         case '}':
 127         case '%':
 128                 /* escaped char */
 129                 g_string_append_c(out, fmt);
 130                 break;
 131         case 'U':
 132                 /* Underline on/off */
 133                 g_string_append_c(out, 4);
 134                 g_string_append_c(out, FORMAT_STYLE_UNDERLINE);
 135                 break;
 136         case '9':
 137         case '_':
 138                 /* bold on/off */
 139                 g_string_append_c(out, 4);
 140                 g_string_append_c(out, FORMAT_STYLE_BOLD);
 141                 break;
 142         case '8':
 143                 /* reverse */
 144                 g_string_append_c(out, 4);
 145                 g_string_append_c(out, FORMAT_STYLE_REVERSE);
 146                 break;
 147         case ':':
 148                 /* Newline */
 149                 g_string_append_c(out, '\n');
 150                 break;
 151         case '|':
 152                 /* Indent here */
 153                 g_string_append_c(out, 4);
 154                 g_string_append_c(out, FORMAT_STYLE_INDENT);
 155                 break;
 156         case 'F':
 157                 /* blink */
 158                 g_string_append_c(out, 4);
 159                 g_string_append_c(out, FORMAT_STYLE_BLINK);
 160                 break;
 161         case 'n':
 162         case 'N':
 163                 /* default color */
 164                 g_string_append_c(out, 4);
 165                 g_string_append_c(out, FORMAT_STYLE_DEFAULTS);
 166                 break;
 167         case '>':
 168                 /* clear to end of line */
 169                 g_string_append_c(out, 4);
 170                 g_string_append_c(out, FORMAT_STYLE_CLRTOEOL);
 171                 break;
 172         case '#':
 173                 g_string_append_c(out, 4);
 174                 g_string_append_c(out, FORMAT_STYLE_MONOSPACE);
 175                 break;
 176         case '[':
 177                 /* code */
 178                 format_expand_code(format, out, flags);
 179                 break;
 180         default:
 181                 /* check if it's a background color */
 182                 p = strchr(format_backs, fmt);
 183                 if (p != NULL) {
 184                         g_string_append_c(out, 4);
 185                         g_string_append_c(out, FORMAT_COLOR_NOCHANGE);
 186                         g_string_append_c(out, (char) ((int) (p-format_backs)+'0'));
 187                         break;
 188                 }
 189
 190                 /* check if it's a foreground color */
 191                 if (fmt == 'p') fmt = 'm';
 192                 p = strchr(format_fores, fmt);
 193                 if (p != NULL) {
 194                         g_string_append_c(out, 4);
 195                         g_string_append_c(out, (char) ((int) (p-format_fores)+'0'));
 196                         g_string_append_c(out, FORMAT_COLOR_NOCHANGE);
 197                         break;
 198                 }
 199
 200                 /* check if it's a bold foreground color */
 201                 if (fmt == 'P') fmt = 'M';
 202                 p = strchr(format_boldfores, fmt);
 203                 if (p != NULL) {
 204                         g_string_append_c(out, 4);
 205                         g_string_append_c(out, (char) (8+(int) (p-format_boldfores)+'0'));
 206                         g_string_append_c(out, FORMAT_COLOR_NOCHANGE);
 207                         break;
 208                 }
 209
 210                 return FALSE;
 211         }
 212
 213         return TRUE;
 214 }
 215
 216 void format_read_arglist(va_list va, FORMAT_REC *format,
 217                          char **arglist, int arglist_size,
 218                          char *buffer, int buffer_size)
 219 {
 220         int num, len, bufpos;
 221
 222         g_return_if_fail(format->params < arglist_size);
 223
 224         bufpos = 0;
 225         arglist[format->params] = NULL;
 226         for (num = 0; num < format->params; num++) {
 227                 switch (format->paramtypes[num]) {
 228                 case FORMAT_STRING:
 229                         arglist[num] = (char *) va_arg(va, char *);
 230                         if (arglist[num] == NULL)
 231                                 arglist[num] = "";
 232                         break;
 233                 case FORMAT_INT: {
 234                         int d = (int) va_arg(va, int);
 235
 236                         if (bufpos >= buffer_size) {
 237                                 arglist[num] = "";
 238                                 break;
 239                         }
 240
 241                         arglist[num] = buffer+bufpos;
 242                         len = g_snprintf(buffer+bufpos, buffer_size-bufpos,
 243                                          "%d", d);
 244                         bufpos += len+1;
 245                         break;
 246                 }
 247                 case FORMAT_LONG: {
 248                         long l = (long) va_arg(va, long);
 249
 250                         if (bufpos >= buffer_size) {
 251                                 arglist[num] = "";
 252                                 break;
 253                         }
 254
 255                         arglist[num] = buffer+bufpos;
 256                         len = g_snprintf(buffer+bufpos, buffer_size-bufpos,
 257                                          "%ld", l);
 258                         bufpos += len+1;
 259                         break;
 260                 }
 261                 case FORMAT_FLOAT: {
 262                         double f = (double) va_arg(va, double);
 263
 264                         if (bufpos >= buffer_size) {
 265                                 arglist[num] = "";
 266                                 break;
 267                         }
 268
 269                         arglist[num] = buffer+bufpos;
 270                         len = g_snprintf(buffer+bufpos, buffer_size-bufpos,
 271                                          "%0.2f", f);
 272                         bufpos += len+1;
 273                         break;
 274                 }
 275                 }
 276         }
 277 }
 278
 279 void format_create_dest(TEXT_DEST_REC *dest,
 280                         void *server, const char *target,
 281                         int level, WINDOW_REC *window)
 282 {
 283         format_create_dest_tag(dest, server, NULL, target, level, window);
 284 }
 285
 286 void format_create_dest_tag(TEXT_DEST_REC *dest, void *server,
 287                             const char *server_tag, const char *target,
 288                             int level, WINDOW_REC *window)
 289 {
 290         memset(dest, 0, sizeof(TEXT_DEST_REC));
 291
 292         dest->server = server;
 293         dest->server_tag = server != NULL ? SERVER(server)->tag : server_tag;
 294         dest->target = target;
 295         dest->level = level;
 296         dest->window = window != NULL ? window :
 297                 window_find_closest(server, target, level);
 298 }
 299
 300 /* Return length of text part in string (ie. without % codes) */
 301 int format_get_length(const char *str)
 302 {
 303         GString *tmp;
 304         int len;
 305
 306         g_return_val_if_fail(str != NULL, 0);
 307
 308         tmp = g_string_new(NULL);
 309         len = 0;
 310         while (*str != '\0') {
 311                 if (*str == '%' && str[1] != '\0') {
 312                         str++;
 313                         if (*str != '%' &&
 314                             format_expand_styles(tmp, &str, NULL)) {
 315                                 str++;
 316                                 continue;
 317                         }
 318
 319                         /* %% or unknown %code, written as-is */
 320                         if (*str != '%')
 321                                 len++;
 322                 }
 323
 324                 len++;
 325                 str++;
 326         }
 327
 328         g_string_free(tmp, TRUE);
 329         return len;
 330 }
 331
 332 /* Return how many characters in `str' must be skipped before `len'
 333    characters of text is skipped. Like strip_real_length(), except this
 334    handles %codes. */
 335 int format_real_length(const char *str, int len)
 336 {
 337         GString *tmp;
 338         const char *start;
 339
 340         g_return_val_if_fail(str != NULL, 0);
 341         g_return_val_if_fail(len >= 0, 0);
 342
 343         start = str;
 344         tmp = g_string_new(NULL);
 345         while (*str != '\0' && len > 0) {
 346                 if (*str == '%' && str[1] != '\0') {
 347                         str++;
 348                         if (*str != '%' &&
 349                             format_expand_styles(tmp, &str, NULL)) {
 350                                 str++;
 351                                 continue;
 352                         }
 353
 354                         /* %% or unknown %code, written as-is */
 355                         if (*str != '%') {
 356                                 if (--len == 0)
 357                                         break;
 358                         }
 359                 }
 360
 361                 len--;
 362                 str++;
 363         }
 364
 365         g_string_free(tmp, TRUE);
 366         return (int) (str-start);
 367 }
 368
 369 char *format_string_expand(const char *text, int *flags)
 370 {
 371         GString *out;
 372         char code, *ret;
 373
 374         g_return_val_if_fail(text != NULL, NULL);
 375
 376         out = g_string_new(NULL);
 377
 378         if (flags != NULL) *flags = 0;
 379         code = 0;
 380         while (*text != '\0') {
 381                 if (code == '%') {
 382                         /* color code */
 383                         if (!format_expand_styles(out, &text, flags)) {
 384                                 g_string_append_c(out, '%');
 385                                 g_string_append_c(out, '%');
 386                                 g_string_append_c(out, *text);
 387                         }
 388                         code = 0;
 389                 } else {
 390                         if (*text == '%')
 391                                 code = *text;
 392                         else
 393                                 g_string_append_c(out, *text);
 394                 }
 395
 396                 text++;
 397         }
 398
 399         ret = out->str;
 400         g_string_free(out, FALSE);
 401         return ret;
 402 }
 403
 404 static char *format_get_text_args(TEXT_DEST_REC *dest,
 405                                   const char *text, char **arglist)
 406 {
 407         GString *out;
 408         char code, *ret;
 409         int need_free;
 410
 411         out = g_string_new(NULL);
 412
 413         code = 0;
 414         while (*text != '\0') {
 415                 if (code == '%') {
 416                         /* color code */
 417                         if (!format_expand_styles(out, &text, &dest->flags)) {
 418                                 g_string_append_c(out, '%');
 419                                 g_string_append_c(out, '%');
 420                                 g_string_append_c(out, *text);
 421                         }
 422                         code = 0;
 423                 } else if (code == '$') {
 424                         /* argument */
 425                         char *ret;
 426
 427                         ret = parse_special((char **) &text, dest->server,
 428                                             dest->target == NULL ? NULL :
 429                                             window_item_find(dest->server, dest->target),
 430                                             arglist, &need_free, NULL, 0);
 431
 432                         if (ret != NULL) {
 433                                 /* string shouldn't end with \003 or it could
 434                                    mess up the next one or two characters */
 435                                 int diff;
 436                                 int len = strlen(ret);
 437                                 while (len > 0 && ret[len-1] == 3) len--;
 438                                 diff = strlen(ret)-len;
 439
 440                                 g_string_append(out, ret);
 441                                 if (diff > 0)
 442                                         g_string_truncate(out, out->len-diff);
 443                                 if (need_free) g_free(ret);
 444                         }
 445                         code = 0;
 446                 } else {
 447                         if (*text == '%' || *text == '$')
 448                                 code = *text;
 449                         else
 450                                 g_string_append_c(out, *text);
 451                 }
 452
 453                 text++;
 454         }
 455
 456         ret = out->str;
 457         g_string_free(out, FALSE);
 458         return ret;
 459 }
 460
 461 char *format_get_text_theme(THEME_REC *theme, const char *module,
 462                             TEXT_DEST_REC *dest, int formatnum, ...)
 463 {
 464         va_list va;
 465         char *str;
 466
 467         if (theme == NULL)
 468                 theme = window_get_theme(dest->window);
 469
 470         va_start(va, formatnum);
 471         str = format_get_text_theme_args(theme, module, dest, formatnum, va);
 472         va_end(va);
 473
 474         return str;
 475 }
 476
 477 char *format_get_text_theme_args(THEME_REC *theme, const char *module,
 478                                  TEXT_DEST_REC *dest, int formatnum,
 479                                  va_list va)
 480 {
 481         char *arglist[MAX_FORMAT_PARAMS];
 482         char buffer[DEFAULT_FORMAT_ARGLIST_SIZE];
 483         FORMAT_REC *formats;
 484
 485         formats = g_hash_table_lookup(default_formats, module);
 486         format_read_arglist(va, &formats[formatnum],
 487                             arglist, sizeof(arglist)/sizeof(char *),
 488                             buffer, sizeof(buffer));
 489
 490         return format_get_text_theme_charargs(theme, module, dest,
 491                                               formatnum, arglist);
 492 }
 493
 494 char *format_get_text_theme_charargs(THEME_REC *theme, const char *module,
 495                                      TEXT_DEST_REC *dest, int formatnum,
 496                                      char **args)
 497 {
 498         MODULE_THEME_REC *module_theme;
 499         char *text;
 500
 501         module_theme = g_hash_table_lookup(theme->modules, module);
 502         if (module_theme == NULL)
 503                 return NULL;
 504
 505         text = module_theme->expanded_formats[formatnum];
 506         return format_get_text_args(dest, text, args);
 507 }
 508
 509 char *format_get_text(const char *module, WINDOW_REC *window,
 510                       void *server, const char *target,
 511                       int formatnum, ...)
 512 {
 513         TEXT_DEST_REC dest;
 514         THEME_REC *theme;
 515         va_list va;
 516         char *str;
 517
 518         format_create_dest(&dest, server, target, 0, window);
 519         theme = window_get_theme(dest.window);
 520
 521         va_start(va, formatnum);
 522         str = format_get_text_theme_args(theme, module, &dest, formatnum, va);
 523         va_end(va);
 524
 525         return str;
 526 }
 527
 528 /* add `linestart' to start of each line in `text'. `text' may contain
 529    multiple lines separated with \n. */
 530 char *format_add_linestart(const char *text, const char *linestart)
 531 {
 532         GString *str;
 533         char *ret;
 534
 535         if (linestart == NULL)
 536                 return g_strdup(text);
 537
 538         if (strchr(text, '\n') == NULL)
 539                 return g_strconcat(linestart, text, NULL);
 540
 541         str = g_string_new(linestart);
 542         while (*text != '\0') {
 543                 g_string_append_c(str, *text);
 544                 if (*text == '\n')
 545                         g_string_append(str, linestart);
 546                 text++;
 547         }
 548
 549         ret = str->str;
 550         g_string_free(str, FALSE);
 551         return ret;
 552 }
 553
 554 char *format_add_lineend(const char *text, const char *linestart)
 555 {
 556         GString *str;
 557         char *ret;
 558
 559         if (linestart == NULL)
 560                 return g_strdup(text);
 561
 562         if (strchr(text, '\n') == NULL)
 563                 return g_strconcat(text, linestart, NULL);
 564
 565         str = g_string_new(NULL);
 566         while (*text != '\0') {
 567                 if (*text == '\n')
 568                         g_string_append(str, linestart);
 569                 g_string_append_c(str, *text);
 570                 text++;
 571         }
 572         g_string_append(str, linestart);
 573
 574         ret = str->str;
 575         g_string_free(str, FALSE);
 576         return ret;
 577 }
 578
 579 #define LINE_START_IRSSI_LEVEL \
 580         (MSGLEVEL_CLIENTERROR | MSGLEVEL_CLIENTNOTICE)
 581
 582 #define NOT_LINE_START_LEVEL \
 583         (MSGLEVEL_NEVER | MSGLEVEL_LASTLOG | MSGLEVEL_CLIENTCRAP | \
 584         MSGLEVEL_MSGS | MSGLEVEL_PUBLIC | MSGLEVEL_DCC | MSGLEVEL_DCCMSGS | \
 585         MSGLEVEL_ACTIONS | MSGLEVEL_NOTICES | MSGLEVEL_SNOTES | MSGLEVEL_CTCPS)
 586
 587 /* return the "-!- " text at the start of the line */
 588 char *format_get_level_tag(THEME_REC *theme, TEXT_DEST_REC *dest)
 589 {
 590         int format;
 591
 592         /* check for flags if we want to override defaults */
 593         if (dest->flags & PRINT_FLAG_UNSET_LINE_START)
 594                 return NULL;
 595
 596         if (dest->flags & PRINT_FLAG_SET_LINE_START)
 597                 format = TXT_LINE_START;
 598         else if (dest->flags & PRINT_FLAG_SET_LINE_START_IRSSI)
 599                 format = TXT_LINE_START_IRSSI;
 600         else {
 601                 /* use defaults */
 602                 if (dest->level & LINE_START_IRSSI_LEVEL)
 603                         format = TXT_LINE_START_IRSSI;
 604                 else if ((dest->level & NOT_LINE_START_LEVEL) == 0)
 605                         format = TXT_LINE_START;
 606                 else
 607                         return NULL;
 608         }
 609
 610         return format_get_text_theme(theme, MODULE_NAME, dest, format);
 611 }
 612
 613 static char *get_timestamp(THEME_REC *theme, TEXT_DEST_REC *dest, time_t t)
 614 {
 615         char *format, str[256];
 616         struct tm *tm;
 617         int diff;
 618
 619         if ((timestamp_level & dest->level) == 0)
 620                 return NULL;
 621
 622         /* check for flags if we want to override defaults */
 623         if (dest->flags & PRINT_FLAG_UNSET_TIMESTAMP)
 624                 return NULL;
 625
 626         if ((dest->flags & PRINT_FLAG_SET_TIMESTAMP) == 0 &&
 627             (dest->level & (MSGLEVEL_NEVER|MSGLEVEL_LASTLOG)) != 0)
 628                 return NULL;
 629
 630
 631         if (timestamp_timeout > 0) {
 632                 diff = t - dest->window->last_timestamp;
 633                 dest->window->last_timestamp = t;
 634                 if (diff < timestamp_timeout)
 635                         return NULL;
 636         }
 637
 638         tm = localtime(&t);
 639         format = format_get_text_theme(theme, MODULE_NAME, dest,
 640                                        TXT_TIMESTAMP);
 641         if (strftime(str, sizeof(str), format, tm) <= 0)
 642                 str[0] = '\0';
 643         g_free(format);
 644         return g_strdup(str);
 645 }
 646
 647 static char *get_server_tag(THEME_REC *theme, TEXT_DEST_REC *dest)
 648 {
 649         int count = 0;
 650
 651         if (dest->server_tag == NULL || hide_server_tags)
 652                 return NULL;
 653
 654         /* check for flags if we want to override defaults */
 655         if (dest->flags & PRINT_FLAG_UNSET_SERVERTAG)
 656                 return NULL;
 657
 658         if ((dest->flags & PRINT_FLAG_SET_SERVERTAG) == 0) {
 659                 if (dest->window->active != NULL &&
 660                     dest->window->active->server == dest->server)
 661                         return NULL;
 662
 663                 if (servers != NULL) {
 664                         count++;
 665                         if (servers->next != NULL)
 666                                 count++;
 667                 }
 668                 if (count < 2 && lookup_servers != NULL) {
 669                         count++;
 670                         if (lookup_servers->next != NULL)
 671                                 count++;
 672                 }
 673
 674                 if (count < 2)
 675                         return NULL;
 676         }
 677
 678         return format_get_text_theme(theme, MODULE_NAME, dest,
 679                                      TXT_SERVERTAG, dest->server_tag);
 680 }
 681
 682 char *format_get_line_start(THEME_REC *theme, TEXT_DEST_REC *dest, time_t t)
 683 {
 684         char *timestamp, *servertag;
 685         char *linestart;
 686
 687         timestamp = get_timestamp(theme, dest, t);
 688         servertag = get_server_tag(theme, dest);
 689
 690         if (timestamp == NULL && servertag == NULL)
 691                 return NULL;
 692
 693         linestart = g_strconcat(timestamp != NULL ? timestamp : "",
 694                                 servertag, NULL);
 695
 696         g_free_not_null(timestamp);
 697         g_free_not_null(servertag);
 698         return linestart;
 699 }
 700
 701 void format_newline(WINDOW_REC *window)
 702 {
 703         g_return_if_fail(window != NULL);
 704
 705         signal_emit_id(signal_gui_print_text, 6, window,
 706                        GINT_TO_POINTER(-1), GINT_TO_POINTER(-1),
 707                        GINT_TO_POINTER(GUI_PRINT_FLAG_NEWLINE),
 708                        "", NULL);
 709 }
 710
 711 /* parse ANSI color string */
 712 static const char *get_ansi_color(THEME_REC *theme, const char *str,
 713                                   int *fg_ret, int *bg_ret, int *flags_ret)
 714 {
 715         static char ansitab[8] = { 0, 4, 2, 6, 1, 5, 3, 7 };
 716         const char *start;
 717         int fg, bg, flags, num;
 718
 719         if (*str != '[')
 720                 return str;
 721         start = str++;
 722
 723         fg = fg_ret == NULL || *fg_ret < 0 ? theme->default_color : *fg_ret;
 724         bg = bg_ret == NULL || *bg_ret < 0 ? -1 : *bg_ret;
 725         flags = flags_ret == NULL ? 0 : *flags_ret;
 726
 727         num = 0;
 728         for (;; str++) {
 729                 if (*str == '\0') return start;
 730
 731                 if (i_isdigit(*str)) {
 732                         num = num*10 + (*str-'0');
 733                         continue;
 734                 }
 735
 736                 if (*str != ';' && *str != 'm')
 737                         return start;
 738
 739                 switch (num) {
 740                 case 0:
 741                         /* reset colors back to default */
 742                         fg = theme->default_color;
 743                         bg = -1;
 744                         flags &= ~GUI_PRINT_FLAG_INDENT;
 745                         break;
 746                 case 1:
 747                         /* hilight */
 748                         flags |= GUI_PRINT_FLAG_BOLD;
 749                         break;
 750                 case 5:
 751                         /* blink */
 752                         flags |= GUI_PRINT_FLAG_BLINK;
 753                         break;
 754                 case 7:
 755                         /* reverse */
 756                         flags |= GUI_PRINT_FLAG_REVERSE;
 757                         break;
 758                 default:
 759                         if (num >= 30 && num <= 37) {
 760                                 if (fg == -1) fg = 0;
 761                                 fg = (fg & 0xf8) | ansitab[num-30];
 762                         }
 763                         if (num >= 40 && num <= 47) {
 764                                 if (bg == -1) bg = 0;
 765                                 bg = (bg & 0xf8) | ansitab[num-40];
 766                         }
 767                         break;
 768                 }
 769                 num = 0;
 770
 771                 if (*str == 'm') {
 772                         if (fg_ret != NULL) *fg_ret = fg;
 773                         if (bg_ret != NULL) *bg_ret = bg;
 774                         if (flags_ret != NULL) *flags_ret = flags;
 775
 776                         str++;
 777                         break;
 778                 }
 779         }
 780
 781         return str;
 782 }
 783
 784 /* parse MIRC color string */
 785 static void get_mirc_color(const char **str, int *fg_ret, int *bg_ret)
 786 {
 787         int fg, bg;
 788
 789         fg = fg_ret == NULL ? -1 : *fg_ret;
 790         bg = bg_ret == NULL ? -1 : *bg_ret;
 791
 792         if (!i_isdigit(**str) && **str != ',') {
 793                 fg = -1;
 794                 bg = -1;
 795         } else {
 796                 /* foreground color */
 797                 if (**str != ',') {
 798                         fg = **str-'0';
 799                         (*str)++;
 800                         if (i_isdigit(**str)) {
 801                                 fg = fg*10 + (**str-'0');
 802                                 (*str)++;
 803                         }
 804                 }
 805                 if (**str == ',') {
 806                         /* background color */
 807                         (*str)++;
 808                         if (!i_isdigit(**str))
 809                                 bg = -1;
 810                         else {
 811                                 bg = **str-'0';
 812                                 (*str)++;
 813                                 if (i_isdigit(**str)) {
 814                                         bg = bg*10 + (**str-'0');
 815                                         (*str)++;
 816                                 }
 817                         }
 818                 }
 819         }
 820
 821         if (fg_ret) *fg_ret = fg;
 822         if (bg_ret) *bg_ret = bg;
 823 }
 824
 825 #define IS_COLOR_CODE(c) \
 826         ((c) == 2 || (c) == 3 || (c) == 4 || (c) == 6 || (c) == 7 || \
 827         (c) == 15 || (c) == 22 || (c) == 27 || (c) == 31)
 828
 829 /* Return how many characters in `str' must be skipped before `len'
 830    characters of text is skipped. */
 831 int strip_real_length(const char *str, int len,
 832                       int *last_color_pos, int *last_color_len)
 833 {
 834         const char *start = str;
 835
 836         if (last_color_pos != NULL)
 837                 *last_color_pos = -1;
 838         if (last_color_len != NULL)
 839                 *last_color_len = -1;
 840
 841         while (*str != '\0') {
 842                 if (*str == 3) {
 843                         const char *mircstart = str;
 844
 845                         if (last_color_pos != NULL)
 846                                 *last_color_pos = (int) (str-start);
 847                         str++;
 848                         get_mirc_color(&str, NULL, NULL);
 849                         if (last_color_len != NULL)
 850                                 *last_color_len = (int) (str-mircstart);
 851
 852                 } else if (*str == 4 && str[1] != '\0') {
 853                         if (str[1] < FORMAT_STYLE_SPECIAL && str[2] != '\0') {
 854                                 if (last_color_pos != NULL)
 855                                         *last_color_pos = (int) (str-start);
 856                                 if (last_color_len != NULL)
 857                                         *last_color_len = 3;
 858                                 str++;
 859                         } else if (str[1] == FORMAT_STYLE_DEFAULTS) {
 860                                 if (last_color_pos != NULL)
 861                                         *last_color_pos = (int) (str-start);
 862                                 if (last_color_len != NULL)
 863                                         *last_color_len = 2;
 864                         }
 865                         str += 2;
 866                 } else {
 867                         if (!IS_COLOR_CODE(*str)) {
 868                                 if (len-- == 0)
 869                                         break;
 870                         }
 871                         str++;
 872                 }
 873         }
 874
 875         return (int) (str-start);
 876 }
 877
 878 char *strip_codes(const char *input)
 879 {
 880         const char *p;
 881         char *str, *out;
 882
 883         out = str = g_strdup(input);
 884         for (p = input; *p != '\0'; p++) {
 885                 if (*p == 3) {
 886                         p++;
 887
 888                         /* mirc color */
 889                         get_mirc_color(&p, NULL, NULL);
 890                         p--;
 891                         continue;
 892                 }
 893
 894                 if (*p == 4 && p[1] != '\0') {
 895                         if (p[1] >= FORMAT_STYLE_SPECIAL) {
 896                                 p++;
 897                                 continue;
 898                         }
 899
 900                         /* irssi color */
 901                         if (p[2] != '\0') {
 902                                 p += 2;
 903                                 continue;
 904                         }
 905                 }
 906
 907                 if (*p == 27 && p[1] != '\0') {
 908                         p++;
 909                         p = get_ansi_color(current_theme, p, NULL, NULL, NULL);
 910                 }
 911
 912                 if (!IS_COLOR_CODE(*p))
 913                         *out++ = *p;
 914         }
 915
 916         *out = '\0';
 917         return str;
 918 }
 919
 920 /* send a fully parsed text string for GUI to print */
 921 void format_send_to_gui(TEXT_DEST_REC *dest, const char *text)
 922 {
 923         THEME_REC *theme;
 924         char *dup, *str, *ptr, type;
 925         int fgcolor, bgcolor;
 926         int flags;
 927
 928         theme = dest->window != NULL && dest->window->theme != NULL ?
 929                 dest->window->theme : current_theme;
 930
 931         dup = str = g_strdup(text);
 932
 933         flags = 0; fgcolor = theme->default_color; bgcolor = -1;
 934         while (*str != '\0') {
 935                 type = '\0';
 936                 for (ptr = str; *ptr != '\0'; ptr++) {
 937                         if (IS_COLOR_CODE(*ptr) || *ptr == '\n') {
 938                                 type = *ptr;
 939                                 *ptr++ = '\0';
 940                                 break;
 941                         }
 942
 943                         *ptr = (char) translation_in[(int) (unsigned char) *ptr];
 944                 }
 945
 946                 if (type == 7) {
 947                         /* bell */
 948                         if (settings_get_bool("bell_beeps"))
 949                                 signal_emit("beep", 0);
 950                 } else if (type == 4 && *ptr == FORMAT_STYLE_CLRTOEOL) {
 951                         /* clear to end of line */
 952                         flags |= GUI_PRINT_FLAG_CLRTOEOL;
 953                 }
 954
 955                 if (*str != '\0' || (flags & GUI_PRINT_FLAG_CLRTOEOL)) {
 956                         /* send the text to gui handler */
 957                         signal_emit_id(signal_gui_print_text, 6, dest->window,
 958                                        GINT_TO_POINTER(fgcolor),
 959                                        GINT_TO_POINTER(bgcolor),
 960                                        GINT_TO_POINTER(flags), str,
 961                                        dest);
 962                         flags &= ~(GUI_PRINT_FLAG_INDENT|GUI_PRINT_FLAG_CLRTOEOL);
 963                 }
 964
 965                 if (type == '\n')
 966                         format_newline(dest->window);
 967
 968                 if (*ptr == '\0')
 969                         break;
 970
 971                 switch (type)
 972                 {
 973                 case 2:
 974                         /* bold */
 975                         if (!hide_text_style)
 976                                 flags ^= GUI_PRINT_FLAG_BOLD;
 977                         break;
 978                 case 3:
 979                         /* MIRC color */
 980                         get_mirc_color((const char **) &ptr,
 981                                         hide_colors ? NULL : &fgcolor,
 982                                         hide_colors ? NULL : &bgcolor);
 983                         if (!hide_colors)
 984                                 flags |= GUI_PRINT_FLAG_MIRC_COLOR;
 985                         break;
 986                 case 4:
 987                         /* user specific colors */
 988                         flags &= ~GUI_PRINT_FLAG_MIRC_COLOR;
 989                         switch (*ptr) {
 990                         case FORMAT_STYLE_BLINK:
 991                                 flags ^= GUI_PRINT_FLAG_BLINK;
 992                                 break;
 993                         case FORMAT_STYLE_UNDERLINE:
 994                                 flags ^= GUI_PRINT_FLAG_UNDERLINE;
 995                                 break;
 996                         case FORMAT_STYLE_BOLD:
 997                                 flags ^= GUI_PRINT_FLAG_BOLD;
 998                                 break;
 999                         case FORMAT_STYLE_REVERSE:
1000                                 flags ^= GUI_PRINT_FLAG_REVERSE;
1001                                 break;
1002                         case FORMAT_STYLE_MONOSPACE:
1003                                 flags ^= GUI_PRINT_FLAG_MONOSPACE;
1004                                 break;
1005                         case FORMAT_STYLE_INDENT:
1006                                 flags |= GUI_PRINT_FLAG_INDENT;
1007                                 break;
1008                         case FORMAT_STYLE_INDENT_FUNC: {
1009                                 const char *start = ptr;
1010                                 while (*ptr != ',' && *ptr != '\0')
1011                                         ptr++;
1012                                 if (*ptr != '\0') *ptr++ = '\0';
1013                                 ptr--;
1014                                 signal_emit_id(signal_gui_print_text, 6,
1015                                                dest->window, NULL, NULL,
1016                                                GINT_TO_POINTER(GUI_PRINT_FLAG_INDENT_FUNC),
1017                                                str, start, dest);
1018                                 break;
1019                         }
1020                         case FORMAT_STYLE_DEFAULTS:
1021                                 fgcolor = theme->default_color;
1022                                 bgcolor = -1;
1023                                 flags &= GUI_PRINT_FLAG_INDENT|GUI_PRINT_FLAG_MONOSPACE;
1024                                 break;
1025                         case FORMAT_STYLE_CLRTOEOL:
1026                                 break;
1027                         default:
1028                                 if (*ptr != FORMAT_COLOR_NOCHANGE) {
1029                                         fgcolor = (unsigned char) *ptr-'0';
1030                                         if (fgcolor <= 7)
1031                                                 flags &= ~GUI_PRINT_FLAG_BOLD;
1032                                         else {
1033                                                 /* bold */
1034                                                 if (fgcolor != 8) fgcolor -= 8;
1035                                                 flags |= GUI_PRINT_FLAG_BOLD;
1036                                         }
1037                                 }
1038                                 if (ptr[1] == '\0')
1039                                         break;
1040
1041                                 ptr++;
1042                                 if (*ptr != FORMAT_COLOR_NOCHANGE) {
1043                                         bgcolor = *ptr-'0';
1044                                         if (bgcolor <= 7)
1045                                                 flags &= ~GUI_PRINT_FLAG_BLINK;
1046                                         else {
1047                                                 /* blink */
1048                                                 bgcolor -= 8;
1049                                                 flags |= GUI_PRINT_FLAG_BLINK;
1050                                         }
1051                                 }
1052                         }
1053                         ptr++;
1054                         break;
1055                 case 6:
1056                         /* blink */
1057                         if (!hide_text_style)
1058                                 flags ^= GUI_PRINT_FLAG_BLINK;
1059                         break;
1060                 case 15:
1061                         /* remove all styling */
1062                         fgcolor = theme->default_color;
1063                         bgcolor = -1;
1064                         flags &= GUI_PRINT_FLAG_INDENT|GUI_PRINT_FLAG_MONOSPACE;
1065                         break;
1066                 case 22:
1067                         /* reverse */
1068                         if (!hide_text_style)
1069                                 flags ^= GUI_PRINT_FLAG_REVERSE;
1070                         break;
1071                 case 31:
1072                         /* underline */
1073                         if (!hide_text_style)
1074                                 flags ^= GUI_PRINT_FLAG_UNDERLINE;
1075                         break;
1076                 case 27:
1077                         /* ansi color code */
1078                         ptr = (char *)
1079                                 get_ansi_color(theme, ptr,
1080                                                hide_colors ? NULL : &fgcolor,
1081                                                hide_colors ? NULL : &bgcolor,
1082                                                hide_colors ? NULL : &flags);
1083                         break;
1084                 }
1085
1086                 str = ptr;
1087         }
1088
1089         g_free(dup);
1090 }
1091
1092 static void read_settings(void)
1093 {
1094         timestamp_level = settings_get_bool("timestamps") ? MSGLEVEL_ALL : 0;
1095         if (timestamp_level > 0) {
1096                 timestamp_level =
1097                         level2bits(settings_get_str("timestamp_level"));
1098         }
1099         timestamp_timeout = settings_get_int("timestamp_timeout");
1100
1101         hide_server_tags = settings_get_bool("hide_server_tags");
1102         hide_text_style = settings_get_bool("hide_text_style");
1103         hide_colors = hide_text_style || settings_get_bool("hide_colors");
1104 }
1105
1106 void formats_init(void)
1107 {
1108         signal_gui_print_text = signal_get_uniq_id("gui print text");
1109
1110         read_settings();
1111         signal_add("setup changed", (SIGNAL_FUNC) read_settings);
1112 }
1113
1114 void formats_deinit(void)
1115 {
1116         signal_remove("setup changed", (SIGNAL_FUNC) read_settings);
1117 }