apps/irssi/src/fe-common/core/chat-completion.c

   1 /*
   2  chat-completion.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 "signals.h"
  23 #include "commands.h"
  24 #include "misc.h"
  25 #include "levels.h"
  26 #include "lib-config/iconfig.h"
  27 #include "settings.h"
  28
  29 #include "chatnets.h"
  30 #include "servers.h"
  31 #include "servers-setup.h"
  32 #include "channels.h"
  33 #include "channels-setup.h"
  34 #include "queries.h"
  35 #include "nicklist.h"
  36
  37 #include "completion.h"
  38 #include "chat-completion.h"
  39 #include "window-items.h"
  40
  41 static int keep_privates_count, keep_publics_count;
  42 static int completion_lowercase;
  43 static const char *completion_char, *cmdchars;
  44 static GSList *global_lastmsgs;
  45 static int completion_auto, completion_strict;
  46
  47 #define SERVER_LAST_MSG_ADD(server, nick) \
  48         last_msg_add(&((MODULE_SERVER_REC *) MODULE_DATA(server))->lastmsgs, \
  49                      nick, TRUE, keep_privates_count)
  50
  51 #define CHANNEL_LAST_MSG_ADD(channel, nick, own) \
  52         last_msg_add(&((MODULE_CHANNEL_REC *) MODULE_DATA(channel))->lastmsgs, \
  53                      nick, own, keep_publics_count)
  54
  55 static LAST_MSG_REC *last_msg_find(GSList *list, const char *nick)
  56 {
  57         while (list != NULL) {
  58                 LAST_MSG_REC *rec = list->data;
  59
  60                 if (g_strcasecmp(rec->nick, nick) == 0)
  61                         return rec;
  62                 list = list->next;
  63         }
  64
  65         return NULL;
  66 }
  67
  68 static void last_msg_dec_owns(GSList *list)
  69 {
  70         LAST_MSG_REC *rec;
  71
  72         while (list != NULL) {
  73                 rec = list->data;
  74                 if (rec->own) rec->own--;
  75
  76                 list = list->next;
  77         }
  78 }
  79
  80 static void last_msg_destroy(GSList **list, LAST_MSG_REC *rec)
  81 {
  82         *list = g_slist_remove(*list, rec);
  83
  84         g_free(rec->nick);
  85         g_free(rec);
  86 }
  87
  88 static void last_msg_add(GSList **list, const char *nick, int own, int max)
  89 {
  90         LAST_MSG_REC *rec;
  91
  92         if (max <= 0)
  93                 return;
  94
  95         rec = last_msg_find(*list, nick);
  96         if (rec != NULL) {
  97                 /* msg already exists, update it */
  98                 *list = g_slist_remove(*list, rec);
  99                 if (own)
 100                         rec->own = max;
 101                 else if (rec->own)
 102                         rec->own--;
 103         } else {
 104                 rec = g_new(LAST_MSG_REC, 1);
 105                 rec->nick = g_strdup(nick);
 106
 107                 while ((int)g_slist_length(*list) >= max) {
 108                         last_msg_destroy(list, g_slist_last(*list)->data);
 109                 }
 110
 111                 rec->own = own ? max : 0;
 112         }
 113         rec->time = time(NULL);
 114
 115         last_msg_dec_owns(*list);
 116
 117         *list = g_slist_prepend(*list, rec);
 118 }
 119
 120 void completion_last_message_add(const char *nick)
 121 {
 122         g_return_if_fail(nick != NULL);
 123
 124         last_msg_add(&global_lastmsgs, nick, TRUE, keep_privates_count);
 125 }
 126
 127 void completion_last_message_remove(const char *nick)
 128 {
 129         LAST_MSG_REC *rec;
 130
 131         g_return_if_fail(nick != NULL);
 132
 133         rec = last_msg_find(global_lastmsgs, nick);
 134         if (rec != NULL) last_msg_destroy(&global_lastmsgs, rec);
 135 }
 136
 137 void completion_last_message_rename(const char *oldnick, const char *newnick)
 138 {
 139         LAST_MSG_REC *rec;
 140
 141         g_return_if_fail(oldnick != NULL);
 142         g_return_if_fail(newnick != NULL);
 143
 144         rec = last_msg_find(global_lastmsgs, oldnick);
 145         if (rec != NULL) {
 146                 g_free(rec->nick);
 147                 rec->nick = g_strdup(newnick);
 148         }
 149 }
 150
 151 static void sig_message_public(SERVER_REC *server, const char *msg,
 152                                const char *nick, const char *address,
 153                                const char *target)
 154 {
 155         CHANNEL_REC *channel;
 156         int own;
 157
 158         channel = channel_find(server, target);
 159         if (channel != NULL) {
 160                 own = nick_match_msg(channel, msg, server->nick);
 161                 CHANNEL_LAST_MSG_ADD(channel, nick, own);
 162         }
 163 }
 164
 165 static void sig_message_join(SERVER_REC *server, const char *channel,
 166                              const char *nick, const char *address)
 167 {
 168         CHANNEL_REC *chanrec;
 169
 170         chanrec = channel_find(server, channel);
 171         if (chanrec != NULL)
 172                 CHANNEL_LAST_MSG_ADD(chanrec, nick, FALSE);
 173 }
 174
 175 static void sig_message_private(SERVER_REC *server, const char *msg,
 176                                 const char *nick, const char *address)
 177 {
 178         g_return_if_fail(server != NULL);
 179         g_return_if_fail(nick != NULL);
 180
 181         SERVER_LAST_MSG_ADD(server, nick);
 182 }
 183
 184 static void sig_message_own_public(SERVER_REC *server, const char *msg,
 185                                    const char *target, const char *origtarget)
 186 {
 187         CHANNEL_REC *channel;
 188         NICK_REC *nick;
 189         char *p, *msgnick;
 190
 191         g_return_if_fail(server != NULL);
 192         g_return_if_fail(msg != NULL);
 193         if (target == NULL) return;
 194
 195         channel = channel_find(server, target);
 196         if (channel == NULL)
 197                 return;
 198
 199         /* channel msg - if first word in line is nick,
 200            add it to lastmsgs */
 201         p = strchr(msg, ' ');
 202         if (p != NULL && p != msg) {
 203                 msgnick = g_strndup(msg, (int) (p-msg));
 204                 nick = nicklist_find(channel, msgnick);
 205                 if (nick == NULL && msgnick[1] != '\0') {
 206                         /* probably ':' or ',' or some other
 207                            char after nick, try without it */
 208                         msgnick[strlen(msgnick)-1] = '\0';
 209                         nick = nicklist_find(channel, msgnick);
 210                 }
 211                 g_free(msgnick);
 212                 if (nick != NULL && nick != channel->ownnick)
 213                         CHANNEL_LAST_MSG_ADD(channel, nick->nick, TRUE);
 214         }
 215 }
 216
 217 static void sig_message_own_private(SERVER_REC *server, const char *msg,
 218                                     const char *target, const char *origtarget)
 219 {
 220         g_return_if_fail(server != NULL);
 221
 222         if (target != NULL && query_find(server, target) == NULL)
 223                 SERVER_LAST_MSG_ADD(server, target);
 224 }
 225
 226 static void sig_nick_removed(CHANNEL_REC *channel, NICK_REC *nick)
 227 {
 228         MODULE_CHANNEL_REC *mchannel;
 229         LAST_MSG_REC *rec;
 230
 231         mchannel = MODULE_DATA(channel);
 232         rec = last_msg_find(mchannel->lastmsgs, nick->nick);
 233         if (rec != NULL) last_msg_destroy(&mchannel->lastmsgs, rec);
 234 }
 235
 236 static void sig_nick_changed(CHANNEL_REC *channel, NICK_REC *nick,
 237                              const char *oldnick)
 238 {
 239         MODULE_CHANNEL_REC *mchannel;
 240         LAST_MSG_REC *rec;
 241
 242         mchannel = MODULE_DATA(channel);
 243         rec = last_msg_find(mchannel->lastmsgs, oldnick);
 244         if (rec != NULL) {
 245                 g_free(rec->nick);
 246                 rec->nick = g_strdup(nick->nick);
 247         }
 248 }
 249
 250 static int last_msg_cmp(LAST_MSG_REC *m1, LAST_MSG_REC *m2)
 251 {
 252         return m1->time < m2->time ? 1 : -1;
 253 }
 254
 255 /* Complete /MSG from specified server, or from
 256    global_lastmsgs if server is NULL */
 257 static void completion_msg_server(GSList **list, SERVER_REC *server,
 258                                   const char *nick, const char *prefix)
 259 {
 260         LAST_MSG_REC *msg;
 261         GSList *tmp;
 262         int len;
 263
 264         g_return_if_fail(nick != NULL);
 265
 266         len = strlen(nick);
 267         tmp = server == NULL ? global_lastmsgs :
 268                 ((MODULE_SERVER_REC *) MODULE_DATA(server))->lastmsgs;
 269         for (; tmp != NULL; tmp = tmp->next) {
 270                 LAST_MSG_REC *rec = tmp->data;
 271
 272                 if (len != 0 && g_strncasecmp(rec->nick, nick, len) != 0)
 273                         continue;
 274
 275                 msg = g_new(LAST_MSG_REC, 1);
 276                 msg->time = rec->time;
 277                 msg->nick = prefix == NULL || *prefix == '\0' ?
 278                         g_strdup(rec->nick) :
 279                         g_strconcat(prefix, " ", rec->nick, NULL);
 280                 *list = g_slist_insert_sorted(*list, msg,
 281                                               (GCompareFunc) last_msg_cmp);
 282         }
 283 }
 284
 285 /* convert list of LAST_MSG_REC's to list of char* nicks. */
 286 static GList *convert_msglist(GSList *msglist)
 287 {
 288         GList *list;
 289
 290         list = NULL;
 291         while (msglist != NULL) {
 292                 LAST_MSG_REC *rec = msglist->data;
 293
 294                 list = g_list_append(list, rec->nick);
 295                 msglist = g_slist_remove(msglist, rec);
 296                 g_free(rec);
 297         }
 298
 299         return list;
 300 }
 301
 302 /* Complete /MSG - if `find_server' is NULL, complete nicks from all servers */
 303 GList *completion_msg(SERVER_REC *win_server,
 304                              SERVER_REC *find_server,
 305                              const char *nick, const char *prefix)
 306 {
 307         GSList *tmp, *list;
 308         char *newprefix;
 309
 310         g_return_val_if_fail(nick != NULL, NULL);
 311         if (servers == NULL) return NULL;
 312
 313         list = NULL;
 314         if (find_server != NULL) {
 315                 completion_msg_server(&list, find_server, nick, prefix);
 316                 return convert_msglist(list);
 317         }
 318
 319         completion_msg_server(&list, NULL, nick, prefix);
 320         for (tmp = servers; tmp != NULL; tmp = tmp->next) {
 321                 SERVER_REC *rec = tmp->data;
 322
 323                 if (servers->next == NULL && rec == win_server)
 324                         newprefix = g_strdup(prefix);
 325                 else {
 326                         newprefix = prefix == NULL ?
 327                                 g_strdup_printf("-%s", rec->tag) :
 328                                 g_strdup_printf("%s -%s", prefix, rec->tag);
 329                 }
 330
 331                 completion_msg_server(&list, rec, nick, newprefix);
 332                 g_free_not_null(newprefix);
 333         }
 334
 335         return convert_msglist(list);
 336 }
 337
 338 static void complete_from_nicklist(GList **outlist, CHANNEL_REC *channel,
 339                                    const char *nick, const char *suffix)
 340 {
 341         MODULE_CHANNEL_REC *mchannel;
 342         GSList *tmp;
 343         GList *ownlist;
 344         char *str;
 345         int len;
 346
 347         /* go through the last x nicks who have said something in the channel.
 348            nicks of all the "own messages" are placed before others */
 349         ownlist = NULL;
 350         len = strlen(nick);
 351         mchannel = MODULE_DATA(channel);
 352         for (tmp = mchannel->lastmsgs; tmp != NULL; tmp = tmp->next) {
 353                 LAST_MSG_REC *rec = tmp->data;
 354
 355                 if (g_strncasecmp(rec->nick, nick, len) == 0 &&
 356                     glist_find_icase_string(*outlist, rec->nick) == NULL) {
 357                         str = g_strconcat(rec->nick, suffix, NULL);
 358                         if (completion_lowercase) ascii_strdown(str);
 359                         if (rec->own)
 360                                 ownlist = g_list_append(ownlist, str);
 361                         else
 362                                 *outlist = g_list_append(*outlist, str);
 363                 }
 364         }
 365
 366         *outlist = g_list_concat(ownlist, *outlist);
 367 }
 368
 369 static GList *completion_nicks_nonstrict(CHANNEL_REC *channel,
 370                                          const char *nick,
 371                                          const char *suffix)
 372 {
 373         GSList *nicks, *tmp;
 374         GList *list;
 375         char *tnick, *str, *in, *out;
 376         int len, str_len, tmplen;
 377
 378         g_return_val_if_fail(channel != NULL, NULL);
 379
 380         list = NULL;
 381
 382         /* get all nicks from current channel, strip non alnum chars,
 383            compare again and add to completion list on matching */
 384         len = strlen(nick);
 385         nicks = nicklist_getnicks(channel);
 386
 387         str_len = 80; str = g_malloc(str_len+1);
 388         for (tmp = nicks; tmp != NULL; tmp = tmp->next) {
 389                 NICK_REC *rec = tmp->data;
 390
 391                 tmplen = strlen(rec->nick);
 392                 if (tmplen > str_len) {
 393                         str_len = tmplen*2;
 394                         str = g_realloc(str, str_len+1);
 395                 }
 396
 397                 /* remove non alnum chars from nick */
 398                 in = rec->nick; out = str;
 399                 while (*in != '\0') {
 400                         if (i_isalnum(*in))
 401                                 *out++ = *in;
 402                         in++;
 403                 }
 404                 *out = '\0';
 405
 406                 /* add to list if 'cleaned' nick matches */
 407                 if (g_strncasecmp(str, nick, len) == 0) {
 408                         tnick = g_strconcat(rec->nick, suffix, NULL);
 409                         if (completion_lowercase)
 410                                 ascii_strdown(tnick);
 411
 412                         if (glist_find_icase_string(list, tnick) == NULL)
 413                                 list = g_list_append(list, tnick);
 414                         else
 415                                 g_free(tnick);
 416                 }
 417
 418         }
 419         g_free(str);
 420         g_slist_free(nicks);
 421
 422         return list;
 423 }
 424
 425 static GList *completion_channel_nicks(CHANNEL_REC *channel, const char *nick,
 426                                        const char *suffix)
 427 {
 428         GSList *nicks, *tmp;
 429         GList *list;
 430         char *str;
 431         int len;
 432
 433         g_return_val_if_fail(channel != NULL, NULL);
 434         g_return_val_if_fail(nick != NULL, NULL);
 435         if (*nick == '\0') return NULL;
 436
 437         if (suffix != NULL && *suffix == '\0')
 438                 suffix = NULL;
 439
 440         /* put first the nicks who have recently said something */
 441         list = NULL;
 442         complete_from_nicklist(&list, channel, nick, suffix);
 443
 444         /* and add the rest of the nicks too */
 445         len = strlen(nick);
 446         nicks = nicklist_getnicks(channel);
 447         for (tmp = nicks; tmp != NULL; tmp = tmp->next) {
 448                 NICK_REC *rec = tmp->data;
 449
 450                 if (g_strncasecmp(rec->nick, nick, len) == 0 &&
 451                     rec != channel->ownnick) {
 452                         str = g_strconcat(rec->nick, suffix, NULL);
 453                         if (completion_lowercase)
 454                                 ascii_strdown(str);
 455                         if (glist_find_icase_string(list, str) == NULL)
 456                                 list = g_list_append(list, str);
 457                         else
 458                                 g_free(str);
 459                 }
 460         }
 461         g_slist_free(nicks);
 462
 463         /* remove non alphanum chars from nick and search again in case
 464            list is still NULL ("foo<tab>" would match "_foo_" f.e.) */
 465         if (!completion_strict)
 466                 list = g_list_concat(list, completion_nicks_nonstrict(channel, nick, suffix));
 467         return list;
 468 }
 469
 470 /* append all strings in list2 to list1 that already aren't there and
 471    free list2 */
 472 static GList *completion_joinlist(GList *list1, GList *list2)
 473 {
 474         GList *old;
 475
 476         old = list2;
 477         while (list2 != NULL) {
 478                 if (!glist_find_icase_string(list1, list2->data))
 479                         list1 = g_list_append(list1, list2->data);
 480                 else
 481                         g_free(list2->data);
 482
 483                 list2 = list2->next;
 484         }
 485
 486         g_list_free(old);
 487         return list1;
 488 }
 489
 490 GList *completion_get_servertags(const char *word)
 491 {
 492         GList *list;
 493         GSList *tmp;
 494         int len;
 495
 496         g_return_val_if_fail(word != NULL, NULL);
 497
 498         len = strlen(word);
 499         list = NULL;
 500
 501         for (tmp = servers; tmp != NULL; tmp = tmp->next) {
 502                 SERVER_REC *rec = tmp->data;
 503
 504                 if (g_strncasecmp(rec->tag, word, len) == 0) {
 505                         if (rec == active_win->active_server)
 506                                 list = g_list_prepend(list, g_strdup(rec->tag));
 507                         else
 508                                 list = g_list_append(list, g_strdup(rec->tag));
 509                 }
 510
 511         }
 512
 513         return list;
 514 }
 515
 516 GList *completion_get_channels(SERVER_REC *server, const char *word)
 517 {
 518         GList *list;
 519         GSList *tmp;
 520         int len;
 521
 522         g_return_val_if_fail(word != NULL, NULL);
 523
 524         len = strlen(word);
 525         list = NULL;
 526
 527         /* first get the joined channels */
 528         tmp = server == NULL ? NULL : server->channels;
 529         for (; tmp != NULL; tmp = tmp->next) {
 530                 CHANNEL_REC *rec = tmp->data;
 531
 532                 if (g_strncasecmp(rec->visible_name, word, len) == 0)
 533                         list = g_list_append(list, g_strdup(rec->visible_name));
 534                 else if (g_strncasecmp(rec->name, word, len) == 0)
 535                         list = g_list_append(list, g_strdup(rec->name));
 536         }
 537
 538         /* get channels from setup */
 539         for (tmp = setupchannels; tmp != NULL; tmp = tmp->next) {
 540                 CHANNEL_SETUP_REC *rec = tmp->data;
 541
 542                 if (g_strncasecmp(rec->name, word, len) == 0 &&
 543                     glist_find_icase_string(list, rec->name) == NULL)
 544                         list = g_list_append(list, g_strdup(rec->name));
 545
 546         }
 547
 548         return list;
 549 }
 550
 551 GList *completion_get_aliases(const char *word)
 552 {
 553         CONFIG_NODE *node;
 554         GList *list;
 555         GSList *tmp;
 556         int len;
 557
 558         g_return_val_if_fail(word != NULL, NULL);
 559
 560         len = strlen(word);
 561         list = NULL;
 562
 563         /* get the list of all aliases */
 564         node = iconfig_node_traverse("aliases", FALSE);
 565         tmp = node == NULL ? NULL : config_node_first(node->value);
 566         for (; tmp != NULL; tmp = config_node_next(tmp)) {
 567                 node = tmp->data;
 568
 569                 if (node->type != NODE_TYPE_KEY)
 570                         continue;
 571
 572                 if (len != 0 && g_strncasecmp(node->key, word, len) != 0)
 573                         continue;
 574
 575                 list = g_list_append(list, g_strdup(node->key));
 576         }
 577
 578         return list;
 579 }
 580
 581 static void complete_window_nicks(GList **list, WINDOW_REC *window,
 582                                   const char *word, const char *nicksuffix)
 583 {
 584         CHANNEL_REC *channel;
 585         GList *tmplist;
 586         GSList *tmp;
 587
 588         channel = CHANNEL(window->active);
 589
 590         /* first the active channel */
 591         if (channel != NULL) {
 592                 tmplist = completion_channel_nicks(channel, word, nicksuffix);
 593                 *list = completion_joinlist(*list, tmplist);
 594         }
 595
 596         if (nicksuffix != NULL) {
 597                 /* completing nick at the start of line - probably answering
 598                    to some other nick, don't even try to complete from
 599                    non-active channels */
 600                 return;
 601         }
 602
 603         /* then the rest */
 604         for (tmp = window->items; tmp != NULL; tmp = tmp->next) {
 605                 channel = CHANNEL(tmp->data);
 606                 if (channel != NULL && tmp->data != window->active) {
 607                         tmplist = completion_channel_nicks(channel, word,
 608                                                            nicksuffix);
 609                         *list = completion_joinlist(*list, tmplist);
 610                 }
 611         }
 612 }
 613
 614 static void sig_complete_word(GList **list, WINDOW_REC *window,
 615                               const char *word, const char *linestart,
 616                               int *want_space)
 617 {
 618         SERVER_REC *server;
 619         CHANNEL_REC *channel;
 620         QUERY_REC *query;
 621         char *prefix;
 622
 623         g_return_if_fail(list != NULL);
 624         g_return_if_fail(window != NULL);
 625         g_return_if_fail(word != NULL);
 626         g_return_if_fail(linestart != NULL);
 627
 628         server = window->active_server;
 629         if (server == NULL && servers != NULL)
 630                 server = servers->data;
 631
 632         if (server != NULL && server_ischannel(server, word)) {
 633                 /* probably completing a channel name */
 634                 *list = completion_get_channels(window->active_server, word);
 635                 if (*list != NULL) signal_stop();
 636                 return;
 637         }
 638
 639         server = window->active_server;
 640         if (server == NULL || !server->connected)
 641                 return;
 642
 643         if (*linestart == '\0' && *word == '\0') {
 644                 /* pressed TAB at the start of line - add /MSG */
 645                 prefix = g_strdup_printf("%cmsg", *cmdchars);
 646                 *list = completion_msg(server, NULL, "", prefix);
 647                 if (*list == NULL)
 648                         *list = g_list_append(*list, g_strdup(prefix));
 649                 g_free(prefix);
 650
 651                 signal_stop();
 652                 return;
 653         }
 654
 655         channel = CHANNEL(window->active);
 656         query = QUERY(window->active);
 657         if (channel == NULL && query != NULL &&
 658             g_strncasecmp(word, query->name, strlen(word)) == 0) {
 659                 /* completion in query */
 660                 *list = g_list_append(*list, g_strdup(query->name));
 661         } else if (channel != NULL) {
 662                 /* nick completion .. we could also be completing a nick
 663                    after /MSG from nicks in channel */
 664                 const char *suffix = *linestart != '\0' ? NULL : completion_char;
 665                 complete_window_nicks(list, window, word, suffix);
 666         } else if (window->level & MSGLEVEL_MSGS) {
 667                 /* msgs window, complete /MSG nicks */
 668                 *list = g_list_concat(completion_msg(server, NULL, word, NULL), *list);
 669         }
 670
 671         if (*list != NULL) signal_stop();
 672 }
 673
 674 static SERVER_REC *line_get_server(const char *line)
 675 {
 676         SERVER_REC *server;
 677         char *tag, *ptr;
 678
 679         g_return_val_if_fail(line != NULL, NULL);
 680         if (*line != '-') return NULL;
 681
 682         /* -option found - should be server tag */
 683         tag = g_strdup(line+1);
 684         ptr = strchr(tag, ' ');
 685         if (ptr != NULL) *ptr = '\0';
 686
 687         server = server_find_tag(tag);
 688
 689         g_free(tag);
 690         return server;
 691 }
 692
 693 static void sig_complete_msg(GList **list, WINDOW_REC *window,
 694                              const char *word, const char *line,
 695                              int *want_space)
 696 {
 697         SERVER_REC *server, *msgserver;
 698
 699         g_return_if_fail(list != NULL);
 700         g_return_if_fail(word != NULL);
 701         g_return_if_fail(line != NULL);
 702
 703         server = window->active_server;
 704         if (server == NULL || !server->connected)
 705                 return;
 706
 707         msgserver = line_get_server(line);
 708         *list = completion_msg(server, msgserver, word, NULL);
 709         if (CHANNEL(window->active) != NULL)
 710                 complete_window_nicks(list, window, word, NULL);
 711         if (*list != NULL) signal_stop();
 712 }
 713
 714 static void sig_erase_complete_msg(WINDOW_REC *window, const char *word,
 715                                    const char *line)
 716 {
 717         SERVER_REC *server;
 718         MODULE_SERVER_REC *mserver;
 719         GSList *tmp;
 720
 721         server = line_get_server(line);
 722         if (server == NULL){
 723                 server = window->active_server;
 724                 if (server == NULL)
 725                         return;
 726         }
 727
 728         if (*word == '\0')
 729                 return;
 730
 731         /* check from global list */
 732         completion_last_message_remove(word);
 733
 734         /* check from server specific list */
 735         if (server != NULL) {
 736                 mserver = MODULE_DATA(server);
 737                 for (tmp = mserver->lastmsgs; tmp != NULL; tmp = tmp->next) {
 738                         LAST_MSG_REC *rec = tmp->data;
 739
 740                         if (g_strcasecmp(rec->nick, word) == 0) {
 741                                 last_msg_destroy(&mserver->lastmsgs, rec);
 742                                 break;
 743                         }
 744                 }
 745
 746         }
 747 }
 748
 749 GList *completion_get_chatnets(const char *word)
 750 {
 751         GList *list;
 752         GSList *tmp;
 753         int len;
 754
 755         g_return_val_if_fail(word != NULL, NULL);
 756
 757         len = strlen(word);
 758         list = NULL;
 759
 760         for (tmp = chatnets; tmp != NULL; tmp = tmp->next) {
 761                 CHATNET_REC *rec = tmp->data;
 762
 763                 if (g_strncasecmp(rec->name, word, len) == 0)
 764                         list = g_list_append(list, g_strdup(rec->name));
 765         }
 766
 767         return list;
 768 }
 769
 770 GList *completion_get_servers(const char *word)
 771 {
 772         GList *list;
 773         GSList *tmp;
 774         int len;
 775
 776         g_return_val_if_fail(word != NULL, NULL);
 777
 778         len = strlen(word);
 779         list = NULL;
 780
 781         for (tmp = setupservers; tmp != NULL; tmp = tmp->next) {
 782                 SERVER_SETUP_REC *rec = tmp->data;
 783
 784                 if (g_strncasecmp(rec->address, word, len) == 0)
 785                         list = g_list_append(list, g_strdup(rec->address));
 786         }
 787
 788         return list;
 789 }
 790
 791 GList *completion_get_targets(const char *word)
 792 {
 793         CONFIG_NODE *node;
 794         GList *list;
 795         GSList *tmp;
 796         int len;
 797
 798         g_return_val_if_fail(word != NULL, NULL);
 799
 800         len = strlen(word);
 801         list = NULL;
 802
 803         /* get the list of all conversion targets */
 804         node = iconfig_node_traverse("conversions", FALSE);
 805         tmp = node == NULL ? NULL : config_node_first(node->value);
 806         for (; tmp != NULL; tmp = config_node_next(tmp)) {
 807                 node = tmp->data;
 808
 809                 if (node->type != NODE_TYPE_KEY)
 810                         continue;
 811
 812                 if (len != 0 && g_strncasecmp(node->key, word, len) != 0)
 813                         continue;
 814
 815                 list = g_list_append(list, g_strdup(node->key));
 816         }
 817
 818         return list;
 819 }
 820
 821 static void sig_complete_connect(GList **list, WINDOW_REC *window,
 822                                  const char *word, const char *line,
 823                                  int *want_space)
 824 {
 825         g_return_if_fail(list != NULL);
 826         g_return_if_fail(word != NULL);
 827
 828         *list = completion_get_chatnets(word);
 829         *list = g_list_concat(*list, completion_get_servers(word));
 830         if (*list != NULL) signal_stop();
 831 }
 832
 833 static void sig_complete_tag(GList **list, WINDOW_REC *window,
 834                              const char *word, const char *line,
 835                              int *want_space)
 836 {
 837         g_return_if_fail(list != NULL);
 838         g_return_if_fail(word != NULL);
 839
 840         *list = completion_get_servertags(word);
 841         if (*list != NULL) signal_stop();
 842 }
 843
 844 static void sig_complete_topic(GList **list, WINDOW_REC *window,
 845                                const char *word, const char *line,
 846                                int *want_space)
 847 {
 848         const char *topic;
 849
 850         g_return_if_fail(list != NULL);
 851         g_return_if_fail(word != NULL);
 852
 853         if (*word == '\0' && IS_CHANNEL(window->active)) {
 854                 topic = CHANNEL(window->active)->topic;
 855                 if (topic != NULL) {
 856                         *list = g_list_append(NULL, g_strdup(topic));
 857                         signal_stop();
 858                 }
 859         }
 860 }
 861
 862 static void sig_complete_away(GList **list, WINDOW_REC *window,
 863                                const char *word, const char *line,
 864                                int *want_space)
 865 {
 866         const char *reason;
 867
 868         g_return_if_fail(list != NULL);
 869         g_return_if_fail(word != NULL);
 870
 871         *want_space = FALSE;
 872
 873         if (*word == '\0' && window->active_server != NULL) {
 874                 reason = SERVER(window->active_server)->away_reason;
 875                 if (reason != NULL) {
 876                         *list = g_list_append(NULL, g_strdup(reason));
 877                         signal_stop();
 878                 }
 879         }
 880 }
 881
 882 static void sig_complete_unalias(GList **list, WINDOW_REC *window,
 883                                 const char *word, const char *line,
 884                                 int *want_space)
 885 {
 886         g_return_if_fail(list != NULL);
 887         g_return_if_fail(word != NULL);
 888
 889         *list = completion_get_aliases(word);
 890         if (*list != NULL) signal_stop();
 891 }
 892
 893 static void sig_complete_alias(GList **list, WINDOW_REC *window,
 894                                 const char *word, const char *line,
 895                                 int *want_space)
 896 {
 897         const char *definition;
 898
 899         g_return_if_fail(list != NULL);
 900         g_return_if_fail(word != NULL);
 901         g_return_if_fail(line != NULL);
 902
 903         if (*line != '\0') {
 904                 if ((definition = alias_find(line)) != NULL) {
 905                         *list = g_list_append(NULL, g_strdup(definition));
 906                         signal_stop();
 907                 }
 908         } else {
 909                 *list = completion_get_aliases(word);
 910                 if (*list != NULL) signal_stop();
 911         }
 912 }
 913
 914 static void sig_complete_window(GList **list, WINDOW_REC *window,
 915                                 const char *word, const char *linestart,
 916                                 int *want_space)
 917 {
 918         WINDOW_REC *win;
 919         WI_ITEM_REC *item;
 920         GSList *tmp;
 921         int len;
 922
 923         g_return_if_fail(list != NULL);
 924         g_return_if_fail(word != NULL);
 925
 926         len = strlen(word);
 927
 928         for (tmp = windows; tmp != NULL; tmp = tmp->next) {
 929                 win = tmp->data;
 930                 item = win->active;
 931
 932                 if (win->name != NULL && g_strncasecmp(win->name, word, len) == 0)
 933                         *list = g_list_append(*list, g_strdup(win->name));
 934                 if (item != NULL && g_strncasecmp(item->visible_name, word, len) == 0)
 935                         *list = g_list_append(*list, g_strdup(item->visible_name));
 936         }
 937
 938         if (*list != NULL) signal_stop();
 939 }
 940
 941 static void sig_complete_channel(GList **list, WINDOW_REC *window,
 942                                  const char *word, const char *line,
 943                                  int *want_space)
 944 {
 945         g_return_if_fail(list != NULL);
 946         g_return_if_fail(word != NULL);
 947
 948         *list = completion_get_channels(NULL, word);
 949         if (*list != NULL) signal_stop();
 950 }
 951
 952 static void sig_complete_server(GList **list, WINDOW_REC *window,
 953                                 const char *word, const char *line,
 954                                 int *want_space)
 955 {
 956         g_return_if_fail(list != NULL);
 957         g_return_if_fail(word != NULL);
 958
 959         *list = completion_get_servers(word);
 960         if (*list != NULL) signal_stop();
 961 }
 962
 963 static void sig_complete_target(GList **list, WINDOW_REC *window,
 964                                 const char *word, const char *line,
 965                                 int *want_space)
 966 {
 967         const char *definition;
 968
 969         g_return_if_fail(list != NULL);
 970         g_return_if_fail(word != NULL);
 971         g_return_if_fail(line != NULL);
 972
 973         if (*line != '\0') {
 974                 if ((definition = iconfig_get_str("conversions", line ,NULL)) != NULL) {
 975                         *list = g_list_append(NULL, g_strdup(definition));
 976                         signal_stop();
 977                 }
 978         } else {
 979                 *list = completion_get_targets(word);
 980                 if (*list != NULL) signal_stop();
 981         }
 982 }
 983
 984 /* expand \n, \t and \\ */
 985 static char *expand_escapes(const char *line, SERVER_REC *server,
 986                             WI_ITEM_REC *item)
 987 {
 988         char *ptr, *ret;
 989         int chr;
 990
 991         ret = ptr = g_malloc(strlen(line)+1);
 992         for (; *line != '\0'; line++) {
 993                 if (*line != '\\') {
 994                         *ptr++ = *line;
 995                         continue;
 996                 }
 997
 998                 line++;
 999                 if (*line == '\0') {
1000                         *ptr++ = '\\';
1001                         break;
1002                 }
1003
1004                 chr = expand_escape(&line);
1005                 if (chr == '\r' || chr == '\n') {
1006                         /* newline .. we need to send another "send text"
1007                            event to handle it (or actually the text before
1008                            the newline..) */
1009                         if (ret != ptr) {
1010                                 *ptr = '\0';
1011                                 signal_emit("send text", 3, ret, server, item);
1012                                 ptr = ret;
1013                         }
1014                 } else if (chr != -1) {
1015                         /* escaping went ok */
1016                         *ptr++ = chr;
1017                 } else {
1018                         /* unknown escape, add it as-is */
1019                         *ptr++ = '\\';
1020                         *ptr++ = *line;
1021                 }
1022         }
1023
1024         *ptr = '\0';
1025         return ret;
1026 }
1027
1028 static char *auto_complete(CHANNEL_REC *channel, const char *line)
1029 {
1030         GList *comp;
1031         const char *p;
1032         char *nick, *ret;
1033
1034         p = strstr(line, completion_char);
1035         if (p == NULL)
1036                 return NULL;
1037
1038         nick = g_strndup(line, (int) (p-line));
1039
1040         ret = NULL;
1041         if (nicklist_find(channel, nick) == NULL) {
1042                 /* not an exact match, use the first possible completion */
1043                 comp = completion_channel_nicks(channel, nick, NULL);
1044                 if (comp != NULL) {
1045                         ret = g_strconcat(comp->data, p, NULL);
1046                         g_list_foreach(comp, (GFunc) g_free, NULL);
1047                         g_list_free(comp);
1048                 }
1049         }
1050
1051         g_free(nick);
1052
1053         return ret;
1054 }
1055
1056 static void event_text(const char *data, SERVER_REC *server, WI_ITEM_REC *item)
1057 {
1058         char *line, *str, *target;
1059
1060         g_return_if_fail(data != NULL);
1061
1062         if (item == NULL)
1063                 return;
1064
1065         if (*data == '\0') {
1066                 /* empty line, forget it. */
1067                 signal_stop();
1068                 return;
1069         }
1070
1071         line = settings_get_bool("expand_escapes") ?
1072                 expand_escapes(data, server, item) : g_strdup(data);
1073
1074         /* check for automatic nick completion */
1075         if (completion_auto && IS_CHANNEL(item)) {
1076                 str = auto_complete(CHANNEL(item), line);
1077                 if (str != NULL) {
1078                         g_free(line);
1079                         line = str;
1080                 }
1081         }
1082
1083         /* the nick is quoted in case it contains '-' character. also
1084            spaces should work too now :) The nick is also escaped in case
1085            it contains '\' characters */
1086         target = escape_string(window_item_get_target(item));
1087         str = g_strdup_printf(IS_CHANNEL(item) ? "-channel \"%s\" %s" :
1088                               IS_QUERY(item) ? "-nick \"%s\" %s" : "%s %s",
1089                               target, line);
1090         g_free(target);
1091
1092         signal_emit("command msg", 3, str, server, item);
1093
1094         g_free(str);
1095         g_free(line);
1096
1097         signal_stop();
1098 }
1099
1100 static void sig_server_disconnected(SERVER_REC *server)
1101 {
1102         MODULE_SERVER_REC *mserver;
1103
1104         g_return_if_fail(server != NULL);
1105
1106         mserver = MODULE_DATA(server);
1107         while (mserver->lastmsgs)
1108                 last_msg_destroy(&mserver->lastmsgs, mserver->lastmsgs->data);
1109 }
1110
1111 static void sig_channel_destroyed(CHANNEL_REC *channel)
1112 {
1113         MODULE_CHANNEL_REC *mchannel;
1114
1115         g_return_if_fail(channel != NULL);
1116
1117         mchannel = MODULE_DATA(channel);
1118         while (mchannel->lastmsgs != NULL) {
1119                 last_msg_destroy(&mchannel->lastmsgs,
1120                                  mchannel->lastmsgs->data);
1121         }
1122 }
1123
1124 static void read_settings(void)
1125 {
1126         keep_privates_count = settings_get_int("completion_keep_privates");
1127         keep_publics_count = settings_get_int("completion_keep_publics");
1128         completion_lowercase = settings_get_bool("completion_nicks_lowercase");
1129         completion_char = settings_get_str("completion_char");
1130         cmdchars = settings_get_str("cmdchars");
1131         completion_auto = settings_get_bool("completion_auto");
1132         completion_strict = settings_get_bool("completion_strict");
1133
1134         if (*completion_char == '\0') {
1135                 /* this would break.. */
1136                 completion_auto = FALSE;
1137         }
1138 }
1139
1140 void chat_completion_init(void)
1141 {
1142         settings_add_str("completion", "completion_char", ":");
1143         settings_add_bool("completion", "completion_auto", FALSE);
1144         settings_add_int("completion", "completion_keep_publics", 50);
1145         settings_add_int("completion", "completion_keep_privates", 10);
1146         settings_add_bool("completion", "completion_nicks_lowercase", FALSE);
1147         settings_add_bool("completion", "completion_strict", FALSE);
1148
1149         settings_add_bool("lookandfeel", "expand_escapes", FALSE);
1150
1151         read_settings();
1152         signal_add("complete word", (SIGNAL_FUNC) sig_complete_word);
1153         signal_add("complete command msg", (SIGNAL_FUNC) sig_complete_msg);
1154         signal_add("complete command query", (SIGNAL_FUNC) sig_complete_msg);
1155         signal_add("complete command action", (SIGNAL_FUNC) sig_complete_msg);
1156         signal_add("complete erase command msg", (SIGNAL_FUNC) sig_erase_complete_msg);
1157         signal_add("complete erase command query", (SIGNAL_FUNC) sig_erase_complete_msg);
1158         signal_add("complete erase command action", (SIGNAL_FUNC) sig_erase_complete_msg);
1159         signal_add("complete command connect", (SIGNAL_FUNC) sig_complete_connect);
1160         signal_add("complete command server", (SIGNAL_FUNC) sig_complete_connect);
1161         signal_add("complete command disconnect", (SIGNAL_FUNC) sig_complete_tag);
1162         signal_add("complete command reconnect", (SIGNAL_FUNC) sig_complete_tag);
1163         signal_add("complete command window server", (SIGNAL_FUNC) sig_complete_tag);
1164         signal_add("complete command topic", (SIGNAL_FUNC) sig_complete_topic);
1165         signal_add("complete command away", (SIGNAL_FUNC) sig_complete_away);
1166         signal_add("complete command unalias", (SIGNAL_FUNC) sig_complete_unalias);
1167         signal_add("complete command alias", (SIGNAL_FUNC) sig_complete_alias);
1168         signal_add("complete command window goto", (SIGNAL_FUNC) sig_complete_window);
1169         signal_add("complete command window item move", (SIGNAL_FUNC) sig_complete_channel);
1170         signal_add("complete command server add", (SIGNAL_FUNC) sig_complete_server);
1171         signal_add("complete command server remove", (SIGNAL_FUNC) sig_complete_server);
1172         signal_add("complete command recode remove", (SIGNAL_FUNC) sig_complete_target);
1173         signal_add("message public", (SIGNAL_FUNC) sig_message_public);
1174         signal_add("message join", (SIGNAL_FUNC) sig_message_join);
1175         signal_add("message private", (SIGNAL_FUNC) sig_message_private);
1176         signal_add("message own_public", (SIGNAL_FUNC) sig_message_own_public);
1177         signal_add("message own_private", (SIGNAL_FUNC) sig_message_own_private);
1178         signal_add("nicklist remove", (SIGNAL_FUNC) sig_nick_removed);
1179         signal_add("nicklist changed", (SIGNAL_FUNC) sig_nick_changed);
1180         signal_add("send text", (SIGNAL_FUNC) event_text);
1181         signal_add("server disconnected", (SIGNAL_FUNC) sig_server_disconnected);
1182         signal_add("channel destroyed", (SIGNAL_FUNC) sig_channel_destroyed);
1183         signal_add("setup changed", (SIGNAL_FUNC) read_settings);
1184 }
1185
1186 void chat_completion_deinit(void)
1187 {
1188         while (global_lastmsgs != NULL)
1189                 last_msg_destroy(&global_lastmsgs, global_lastmsgs->data);
1190
1191         signal_remove("complete word", (SIGNAL_FUNC) sig_complete_word);
1192         signal_remove("complete command msg", (SIGNAL_FUNC) sig_complete_msg);
1193         signal_remove("complete command query", (SIGNAL_FUNC) sig_complete_msg);
1194         signal_remove("complete command action", (SIGNAL_FUNC) sig_complete_msg);
1195         signal_remove("complete erase command msg", (SIGNAL_FUNC) sig_erase_complete_msg);
1196         signal_remove("complete erase command query", (SIGNAL_FUNC) sig_erase_complete_msg);
1197         signal_remove("complete erase command action", (SIGNAL_FUNC) sig_erase_complete_msg);
1198         signal_remove("complete command connect", (SIGNAL_FUNC) sig_complete_connect);
1199         signal_remove("complete command server", (SIGNAL_FUNC) sig_complete_connect);
1200         signal_remove("complete command disconnect", (SIGNAL_FUNC) sig_complete_tag);
1201         signal_remove("complete command reconnect", (SIGNAL_FUNC) sig_complete_tag);
1202         signal_remove("complete command window server", (SIGNAL_FUNC) sig_complete_tag);
1203         signal_remove("complete command topic", (SIGNAL_FUNC) sig_complete_topic);
1204         signal_remove("complete command away", (SIGNAL_FUNC) sig_complete_away);
1205         signal_remove("complete command unalias", (SIGNAL_FUNC) sig_complete_unalias);
1206         signal_remove("complete command alias", (SIGNAL_FUNC) sig_complete_alias);
1207         signal_remove("complete command window goto", (SIGNAL_FUNC) sig_complete_window);
1208         signal_remove("complete command window item move", (SIGNAL_FUNC) sig_complete_channel);
1209         signal_remove("complete command server add", (SIGNAL_FUNC) sig_complete_server);
1210         signal_remove("complete command server remove", (SIGNAL_FUNC) sig_complete_server);
1211         signal_remove("complete command recode remove", (SIGNAL_FUNC) sig_complete_target);
1212         signal_remove("message public", (SIGNAL_FUNC) sig_message_public);
1213         signal_remove("message join", (SIGNAL_FUNC) sig_message_join);
1214         signal_remove("message private", (SIGNAL_FUNC) sig_message_private);
1215         signal_remove("message own_public", (SIGNAL_FUNC) sig_message_own_public);
1216         signal_remove("message own_private", (SIGNAL_FUNC) sig_message_own_private);
1217         signal_remove("nicklist remove", (SIGNAL_FUNC) sig_nick_removed);
1218         signal_remove("nicklist changed", (SIGNAL_FUNC) sig_nick_changed);
1219         signal_remove("send text", (SIGNAL_FUNC) event_text);
1220         signal_remove("server disconnected", (SIGNAL_FUNC) sig_server_disconnected);
1221         signal_remove("channel destroyed", (SIGNAL_FUNC) sig_channel_destroyed);
1222         signal_remove("setup changed", (SIGNAL_FUNC) read_settings);
1223 }