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