← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/irssi/intrepid-updates

« back to all changes in this revision

Viewing changes to src/fe-common/core/chat-completion.c

  • Committer: Bazaar Package Importer
  • Author(s): David Pashley
  • Date: 2005-12-10 21:25:51 UTC
  • Revision ID: james.westby@ubuntu.com-20051210212551-5qwm108g7inyu2f2
Tags: upstream-0.8.10
Import upstream version 0.8.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
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 "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) g_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
                                g_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
                                g_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 *linestart)
 
583
{
 
584
        CHANNEL_REC *channel;
 
585
        GList *tmplist;
 
586
        GSList *tmp;
 
587
        const char *nicksuffix;
 
588
 
 
589
        nicksuffix = *linestart != '\0' ? NULL : completion_char;
 
590
 
 
591
        channel = CHANNEL(window->active);
 
592
 
 
593
        /* first the active channel */
 
594
        if (channel != NULL) {
 
595
                tmplist = completion_channel_nicks(channel, word, nicksuffix);
 
596
                *list = completion_joinlist(*list, tmplist);
 
597
        }
 
598
 
 
599
        if (nicksuffix != NULL) {
 
600
                /* completing nick at the start of line - probably answering
 
601
                   to some other nick, don't even try to complete from
 
602
                   non-active channels */
 
603
                return;
 
604
        }
 
605
 
 
606
        /* then the rest */
 
607
        for (tmp = window->items; tmp != NULL; tmp = tmp->next) {
 
608
                channel = CHANNEL(tmp->data);
 
609
                if (channel != NULL && tmp->data != window->active) {
 
610
                        tmplist = completion_channel_nicks(channel, word,
 
611
                                                           nicksuffix);
 
612
                        *list = completion_joinlist(*list, tmplist);
 
613
                }
 
614
        }
 
615
}
 
616
 
 
617
static void sig_complete_word(GList **list, WINDOW_REC *window,
 
618
                              const char *word, const char *linestart,
 
619
                              int *want_space)
 
620
{
 
621
        SERVER_REC *server;
 
622
        CHANNEL_REC *channel;
 
623
        QUERY_REC *query;
 
624
        char *prefix;
 
625
 
 
626
        g_return_if_fail(list != NULL);
 
627
        g_return_if_fail(window != NULL);
 
628
        g_return_if_fail(word != NULL);
 
629
        g_return_if_fail(linestart != NULL);
 
630
 
 
631
        server = window->active_server;
 
632
        if (server == NULL && servers != NULL)
 
633
                server = servers->data;
 
634
 
 
635
        if (server != NULL && server_ischannel(server, word)) {
 
636
                /* probably completing a channel name */
 
637
                *list = completion_get_channels(window->active_server, word);
 
638
                return;
 
639
        }
 
640
 
 
641
        server = window->active_server;
 
642
        if (server == NULL || !server->connected)
 
643
                return;
 
644
 
 
645
        if (*linestart == '\0' && *word == '\0') {
 
646
                /* pressed TAB at the start of line - add /MSG */
 
647
                prefix = g_strdup_printf("%cmsg", *cmdchars);
 
648
                *list = completion_msg(server, NULL, "", prefix);
 
649
                if (*list == NULL)
 
650
                        *list = g_list_append(*list, g_strdup(prefix));
 
651
                g_free(prefix);
 
652
 
 
653
                signal_stop();
 
654
                return;
 
655
        }
 
656
 
 
657
        channel = CHANNEL(window->active);
 
658
        query = QUERY(window->active);
 
659
        if (channel == NULL && query != NULL &&
 
660
            g_strncasecmp(word, query->name, strlen(word)) == 0) {
 
661
                /* completion in query */
 
662
                *list = g_list_append(*list, g_strdup(query->name));
 
663
        } else if (channel != NULL) {
 
664
                /* nick completion .. we could also be completing a nick
 
665
                   after /MSG from nicks in channel */
 
666
                complete_window_nicks(list, window, word, linestart);
 
667
        } else if (window->level & MSGLEVEL_MSGS) {
 
668
                /* msgs window, complete /MSG nicks */
 
669
                *list = g_list_concat(completion_msg(server, NULL, word, NULL), *list);
 
670
        }
 
671
 
 
672
        if (*list != NULL) signal_stop();
 
673
}
 
674
 
 
675
static SERVER_REC *line_get_server(const char *line)
 
676
{
 
677
        SERVER_REC *server;
 
678
        char *tag, *ptr;
 
679
 
 
680
        g_return_val_if_fail(line != NULL, NULL);
 
681
        if (*line != '-') return NULL;
 
682
 
 
683
        /* -option found - should be server tag */
 
684
        tag = g_strdup(line+1);
 
685
        ptr = strchr(tag, ' ');
 
686
        if (ptr != NULL) *ptr = '\0';
 
687
 
 
688
        server = server_find_tag(tag);
 
689
 
 
690
        g_free(tag);
 
691
        return server;
 
692
}
 
693
 
 
694
static void sig_complete_msg(GList **list, WINDOW_REC *window,
 
695
                             const char *word, const char *line,
 
696
                             int *want_space)
 
697
{
 
698
        SERVER_REC *server, *msgserver;
 
699
 
 
700
        g_return_if_fail(list != NULL);
 
701
        g_return_if_fail(word != NULL);
 
702
        g_return_if_fail(line != NULL);
 
703
 
 
704
        server = window->active_server;
 
705
        if (server == NULL || !server->connected)
 
706
                return;
 
707
 
 
708
        msgserver = line_get_server(line);
 
709
        *list = completion_msg(server, msgserver, word, NULL);
 
710
        if (*list != NULL) signal_stop();
 
711
}
 
712
 
 
713
static void sig_erase_complete_msg(WINDOW_REC *window, const char *word,
 
714
                                   const char *line)
 
715
{
 
716
        SERVER_REC *server;
 
717
        MODULE_SERVER_REC *mserver;
 
718
        GSList *tmp;
 
719
 
 
720
        server = line_get_server(line);
 
721
        if (server == NULL){
 
722
                server = window->active_server;
 
723
                if (server == NULL)
 
724
                        return;
 
725
        }
 
726
 
 
727
        if (*word == '\0')
 
728
                return;
 
729
 
 
730
        /* check from global list */
 
731
        completion_last_message_remove(word);
 
732
 
 
733
        /* check from server specific list */
 
734
        if (server != NULL) {
 
735
                mserver = MODULE_DATA(server);
 
736
                for (tmp = mserver->lastmsgs; tmp != NULL; tmp = tmp->next) {
 
737
                        LAST_MSG_REC *rec = tmp->data;
 
738
 
 
739
                        if (g_strcasecmp(rec->nick, word) == 0) {
 
740
                                last_msg_destroy(&mserver->lastmsgs, rec);
 
741
                                break;
 
742
                        }
 
743
                }
 
744
 
 
745
        }
 
746
}
 
747
 
 
748
GList *completion_get_chatnets(const char *word)
 
749
{
 
750
        GList *list;
 
751
        GSList *tmp;
 
752
        int len;
 
753
 
 
754
        g_return_val_if_fail(word != NULL, NULL);
 
755
 
 
756
        len = strlen(word);
 
757
        list = NULL;
 
758
 
 
759
        for (tmp = chatnets; tmp != NULL; tmp = tmp->next) {
 
760
                CHATNET_REC *rec = tmp->data;
 
761
 
 
762
                if (g_strncasecmp(rec->name, word, len) == 0)
 
763
                        list = g_list_append(list, g_strdup(rec->name));
 
764
        }
 
765
 
 
766
        return list;
 
767
}
 
768
 
 
769
GList *completion_get_servers(const char *word)
 
770
{
 
771
        GList *list;
 
772
        GSList *tmp;
 
773
        int len;
 
774
 
 
775
        g_return_val_if_fail(word != NULL, NULL);
 
776
 
 
777
        len = strlen(word);
 
778
        list = NULL;
 
779
 
 
780
        for (tmp = setupservers; tmp != NULL; tmp = tmp->next) {
 
781
                SERVER_SETUP_REC *rec = tmp->data;
 
782
 
 
783
                if (g_strncasecmp(rec->address, word, len) == 0) 
 
784
                        list = g_list_append(list, g_strdup(rec->address));
 
785
        }
 
786
 
 
787
        return list;
 
788
}
 
789
 
 
790
GList *completion_get_targets(const char *word)
 
791
{
 
792
        CONFIG_NODE *node;
 
793
        GList *list;
 
794
        GSList *tmp;
 
795
        int len;
 
796
 
 
797
        g_return_val_if_fail(word != NULL, NULL);
 
798
 
 
799
        len = strlen(word);
 
800
        list = NULL;
 
801
 
 
802
        /* get the list of all conversion targets */
 
803
        node = iconfig_node_traverse("conversions", FALSE);
 
804
        tmp = node == NULL ? NULL : config_node_first(node->value);
 
805
        for (; tmp != NULL; tmp = config_node_next(tmp)) {
 
806
                node = tmp->data;
 
807
 
 
808
                if (node->type != NODE_TYPE_KEY)
 
809
                        continue;
 
810
 
 
811
                if (len != 0 && g_strncasecmp(node->key, word, len) != 0)
 
812
                        continue;
 
813
 
 
814
                list = g_list_append(list, g_strdup(node->key));
 
815
        }
 
816
        
 
817
        return list;
 
818
}
 
819
 
 
820
static void sig_complete_connect(GList **list, WINDOW_REC *window,
 
821
                                 const char *word, const char *line, 
 
822
                                 int *want_space)
 
823
{
 
824
        g_return_if_fail(list != NULL);
 
825
        g_return_if_fail(word != NULL);
 
826
 
 
827
        *list = completion_get_chatnets(word);
 
828
        *list = g_list_concat(*list, completion_get_servers(word));
 
829
        if (*list != NULL) signal_stop();
 
830
}
 
831
 
 
832
static void sig_complete_tag(GList **list, WINDOW_REC *window,
 
833
                             const char *word, const char *line,
 
834
                             int *want_space)
 
835
{
 
836
        g_return_if_fail(list != NULL);
 
837
        g_return_if_fail(word != NULL);
 
838
 
 
839
        *list = completion_get_servertags(word);
 
840
        if (*list != NULL) signal_stop();
 
841
}
 
842
 
 
843
static void sig_complete_topic(GList **list, WINDOW_REC *window,
 
844
                               const char *word, const char *line,
 
845
                               int *want_space)
 
846
{
 
847
        const char *topic;
 
848
 
 
849
        g_return_if_fail(list != NULL);
 
850
        g_return_if_fail(word != NULL);
 
851
 
 
852
        if (*word == '\0' && IS_CHANNEL(window->active)) {
 
853
                topic = CHANNEL(window->active)->topic;
 
854
                if (topic != NULL) {
 
855
                        *list = g_list_append(NULL, g_strdup(topic));
 
856
                        signal_stop();
 
857
                }
 
858
        }
 
859
}
 
860
 
 
861
static void sig_complete_away(GList **list, WINDOW_REC *window,
 
862
                               const char *word, const char *line,
 
863
                               int *want_space)
 
864
{
 
865
        const char *reason;
 
866
 
 
867
        g_return_if_fail(list != NULL);
 
868
        g_return_if_fail(word != NULL);
 
869
 
 
870
        *want_space = FALSE;
 
871
 
 
872
        if (*word == '\0' && window->active_server != NULL) {
 
873
                reason = SERVER(window->active_server)->away_reason;
 
874
                if (reason != NULL) {
 
875
                        *list = g_list_append(NULL, g_strdup(reason));
 
876
                        signal_stop();
 
877
                }
 
878
        }
 
879
}
 
880
 
 
881
static void sig_complete_unalias(GList **list, WINDOW_REC *window,
 
882
                                const char *word, const char *line,
 
883
                                int *want_space)
 
884
{
 
885
        g_return_if_fail(list != NULL);
 
886
        g_return_if_fail(word != NULL);
 
887
 
 
888
        *list = completion_get_aliases(word);
 
889
        if (*list != NULL) signal_stop();
 
890
}
 
891
 
 
892
static void sig_complete_alias(GList **list, WINDOW_REC *window,
 
893
                                const char *word, const char *line,
 
894
                                int *want_space)
 
895
{
 
896
        const char *definition;
 
897
        
 
898
        g_return_if_fail(list != NULL);
 
899
        g_return_if_fail(word != NULL);
 
900
        g_return_if_fail(line != NULL);
 
901
 
 
902
        if (*line != '\0') {
 
903
                if ((definition = alias_find(line)) != NULL) {
 
904
                        *list = g_list_append(NULL, g_strdup(definition));
 
905
                        signal_stop();
 
906
                }
 
907
        } else {        
 
908
                *list = completion_get_aliases(word);
 
909
                if (*list != NULL) signal_stop();
 
910
        }
 
911
}
 
912
 
 
913
static void sig_complete_channel(GList **list, WINDOW_REC *window,
 
914
                                 const char *word, const char *line,
 
915
                                 int *want_space)
 
916
{
 
917
        g_return_if_fail(list != NULL);
 
918
        g_return_if_fail(word != NULL);
 
919
 
 
920
        *list = completion_get_channels(NULL, word);
 
921
        if (*list != NULL) signal_stop();
 
922
}
 
923
 
 
924
static void sig_complete_server(GList **list, WINDOW_REC *window,
 
925
                                const char *word, const char *line,
 
926
                                int *want_space)
 
927
{
 
928
        g_return_if_fail(list != NULL);
 
929
        g_return_if_fail(word != NULL);
 
930
 
 
931
        *list = completion_get_servers(word);
 
932
        if (*list != NULL) signal_stop();
 
933
}
 
934
 
 
935
static void sig_complete_target(GList **list, WINDOW_REC *window,
 
936
                                const char *word, const char *line,
 
937
                                int *want_space)
 
938
{
 
939
        const char *definition;
 
940
        
 
941
        g_return_if_fail(list != NULL);
 
942
        g_return_if_fail(word != NULL);
 
943
        g_return_if_fail(line != NULL);
 
944
 
 
945
        if (*line != '\0') {
 
946
                if ((definition = iconfig_get_str("conversions", line ,NULL)) != NULL) {
 
947
                        *list = g_list_append(NULL, g_strdup(definition));
 
948
                        signal_stop();
 
949
                }
 
950
        } else {        
 
951
                *list = completion_get_targets(word);
 
952
                if (*list != NULL) signal_stop();
 
953
        }
 
954
}
 
955
 
 
956
/* expand \n, \t and \\ */
 
957
static char *expand_escapes(const char *line, SERVER_REC *server,
 
958
                            WI_ITEM_REC *item)
 
959
{
 
960
        char *ptr, *ret;
 
961
        int chr;
 
962
 
 
963
        ret = ptr = g_malloc(strlen(line)+1);
 
964
        for (; *line != '\0'; line++) {
 
965
                if (*line != '\\') {
 
966
                        *ptr++ = *line;
 
967
                        continue;
 
968
                }
 
969
 
 
970
                line++;
 
971
                if (*line == '\0') {
 
972
                        *ptr++ = '\\';
 
973
                        break;
 
974
                }
 
975
 
 
976
                chr = expand_escape(&line);
 
977
                if (chr == '\r' || chr == '\n') {
 
978
                        /* newline .. we need to send another "send text"
 
979
                           event to handle it (or actually the text before
 
980
                           the newline..) */
 
981
                        if (ret != ptr) {
 
982
                                *ptr = '\0';
 
983
                                signal_emit("send text", 3, ret, server, item);
 
984
                                ptr = ret;
 
985
                        }
 
986
                } else if (chr != -1) {
 
987
                        /* escaping went ok */
 
988
                        *ptr++ = chr;
 
989
                } else {
 
990
                        /* unknown escape, add it as-is */
 
991
                        *ptr++ = '\\';
 
992
                        *ptr++ = *line;
 
993
                }
 
994
        }
 
995
 
 
996
        *ptr = '\0';
 
997
        return ret;
 
998
}
 
999
 
 
1000
static char *auto_complete(CHANNEL_REC *channel, const char *line)
 
1001
{
 
1002
        GList *comp;
 
1003
        const char *p;
 
1004
        char *nick, *ret;
 
1005
 
 
1006
        p = strstr(line, completion_char);
 
1007
        if (p == NULL)
 
1008
                return NULL;
 
1009
 
 
1010
        nick = g_strndup(line, (int) (p-line));
 
1011
 
 
1012
        ret = NULL;
 
1013
        if (nicklist_find(channel, nick) == NULL) {
 
1014
                /* not an exact match, use the first possible completion */
 
1015
                comp = completion_channel_nicks(channel, nick, NULL);
 
1016
                if (comp != NULL) {
 
1017
                        ret = g_strconcat(comp->data, p, NULL);
 
1018
                        g_list_foreach(comp, (GFunc) g_free, NULL);
 
1019
                        g_list_free(comp);
 
1020
                }
 
1021
        }
 
1022
 
 
1023
        g_free(nick);
 
1024
 
 
1025
        return ret;
 
1026
}
 
1027
 
 
1028
static void event_text(const char *data, SERVER_REC *server, WI_ITEM_REC *item)
 
1029
{
 
1030
        char *line, *str, *target;
 
1031
 
 
1032
        g_return_if_fail(data != NULL);
 
1033
 
 
1034
        if (item == NULL)
 
1035
                return;
 
1036
 
 
1037
        if (*data == '\0') {
 
1038
                /* empty line, forget it. */
 
1039
                signal_stop();
 
1040
                return;
 
1041
        }
 
1042
 
 
1043
        line = settings_get_bool("expand_escapes") ?
 
1044
                expand_escapes(data, server, item) : g_strdup(data);
 
1045
 
 
1046
        /* check for automatic nick completion */
 
1047
        if (completion_auto && IS_CHANNEL(item)) {
 
1048
                str = auto_complete(CHANNEL(item), line);
 
1049
                if (str != NULL) {
 
1050
                        g_free(line);
 
1051
                        line = str;
 
1052
                }
 
1053
        }
 
1054
 
 
1055
        /* the nick is quoted in case it contains '-' character. also
 
1056
           spaces should work too now :) The nick is also escaped in case
 
1057
           it contains '\' characters */
 
1058
        target = escape_string(window_item_get_target(item));
 
1059
        str = g_strdup_printf(IS_CHANNEL(item) ? "-channel \"%s\" %s" :
 
1060
                              IS_QUERY(item) ? "-nick \"%s\" %s" : "%s %s",
 
1061
                              target, line);
 
1062
        g_free(target);
 
1063
 
 
1064
        signal_emit("command msg", 3, str, server, item);
 
1065
 
 
1066
        g_free(str);
 
1067
        g_free(line);
 
1068
 
 
1069
        signal_stop();
 
1070
}
 
1071
 
 
1072
static void sig_server_disconnected(SERVER_REC *server)
 
1073
{
 
1074
        MODULE_SERVER_REC *mserver;
 
1075
 
 
1076
        g_return_if_fail(server != NULL);
 
1077
 
 
1078
        mserver = MODULE_DATA(server);
 
1079
        while (mserver->lastmsgs)
 
1080
                last_msg_destroy(&mserver->lastmsgs, mserver->lastmsgs->data);
 
1081
}
 
1082
 
 
1083
static void sig_channel_destroyed(CHANNEL_REC *channel)
 
1084
{
 
1085
        MODULE_CHANNEL_REC *mchannel;
 
1086
 
 
1087
        g_return_if_fail(channel != NULL);
 
1088
 
 
1089
        mchannel = MODULE_DATA(channel);
 
1090
        while (mchannel->lastmsgs != NULL) {
 
1091
                last_msg_destroy(&mchannel->lastmsgs,
 
1092
                                 mchannel->lastmsgs->data);
 
1093
        }
 
1094
}
 
1095
 
 
1096
static void read_settings(void)
 
1097
{
 
1098
        keep_privates_count = settings_get_int("completion_keep_privates");
 
1099
        keep_publics_count = settings_get_int("completion_keep_publics");
 
1100
        completion_lowercase = settings_get_bool("completion_nicks_lowercase");
 
1101
        completion_char = settings_get_str("completion_char");
 
1102
        cmdchars = settings_get_str("cmdchars");
 
1103
        completion_auto = settings_get_bool("completion_auto");
 
1104
        completion_strict = settings_get_bool("completion_strict");
 
1105
 
 
1106
        if (*completion_char == '\0') {
 
1107
                /* this would break.. */
 
1108
                completion_auto = FALSE;
 
1109
        }
 
1110
}
 
1111
 
 
1112
void chat_completion_init(void)
 
1113
{
 
1114
        settings_add_str("completion", "completion_char", ":");
 
1115
        settings_add_bool("completion", "completion_auto", FALSE);
 
1116
        settings_add_int("completion", "completion_keep_publics", 50);
 
1117
        settings_add_int("completion", "completion_keep_privates", 10);
 
1118
        settings_add_bool("completion", "completion_nicks_lowercase", FALSE);
 
1119
        settings_add_bool("completion", "completion_strict", FALSE);
 
1120
 
 
1121
        settings_add_bool("lookandfeel", "expand_escapes", FALSE);
 
1122
 
 
1123
        read_settings();
 
1124
        signal_add("complete word", (SIGNAL_FUNC) sig_complete_word);
 
1125
        signal_add("complete command msg", (SIGNAL_FUNC) sig_complete_msg);
 
1126
        signal_add("complete command query", (SIGNAL_FUNC) sig_complete_msg);
 
1127
        signal_add("complete command action", (SIGNAL_FUNC) sig_complete_msg);
 
1128
        signal_add("complete erase command msg", (SIGNAL_FUNC) sig_erase_complete_msg);
 
1129
        signal_add("complete erase command query", (SIGNAL_FUNC) sig_erase_complete_msg);
 
1130
        signal_add("complete erase command action", (SIGNAL_FUNC) sig_erase_complete_msg);
 
1131
        signal_add("complete command connect", (SIGNAL_FUNC) sig_complete_connect);
 
1132
        signal_add("complete command server", (SIGNAL_FUNC) sig_complete_connect);
 
1133
        signal_add("complete command disconnect", (SIGNAL_FUNC) sig_complete_tag);
 
1134
        signal_add("complete command reconnect", (SIGNAL_FUNC) sig_complete_tag);
 
1135
        signal_add("complete command topic", (SIGNAL_FUNC) sig_complete_topic);
 
1136
        signal_add("complete command away", (SIGNAL_FUNC) sig_complete_away);
 
1137
        signal_add("complete command unalias", (SIGNAL_FUNC) sig_complete_unalias);
 
1138
        signal_add("complete command alias", (SIGNAL_FUNC) sig_complete_alias);
 
1139
        signal_add("complete command window item move", (SIGNAL_FUNC) sig_complete_channel);
 
1140
        signal_add("complete command server add", (SIGNAL_FUNC) sig_complete_server);
 
1141
        signal_add("complete command server remove", (SIGNAL_FUNC) sig_complete_server);
 
1142
        signal_add("complete command recode remove", (SIGNAL_FUNC) sig_complete_target);
 
1143
        signal_add("message public", (SIGNAL_FUNC) sig_message_public);
 
1144
        signal_add("message join", (SIGNAL_FUNC) sig_message_join);
 
1145
        signal_add("message private", (SIGNAL_FUNC) sig_message_private);
 
1146
        signal_add("message own_public", (SIGNAL_FUNC) sig_message_own_public);
 
1147
        signal_add("message own_private", (SIGNAL_FUNC) sig_message_own_private);
 
1148
        signal_add("nicklist remove", (SIGNAL_FUNC) sig_nick_removed);
 
1149
        signal_add("nicklist changed", (SIGNAL_FUNC) sig_nick_changed);
 
1150
        signal_add("send text", (SIGNAL_FUNC) event_text);
 
1151
        signal_add("server disconnected", (SIGNAL_FUNC) sig_server_disconnected);
 
1152
        signal_add("channel destroyed", (SIGNAL_FUNC) sig_channel_destroyed);
 
1153
        signal_add("setup changed", (SIGNAL_FUNC) read_settings);
 
1154
}
 
1155
 
 
1156
void chat_completion_deinit(void)
 
1157
{
 
1158
        while (global_lastmsgs != NULL)
 
1159
                last_msg_destroy(&global_lastmsgs, global_lastmsgs->data);
 
1160
 
 
1161
        signal_remove("complete word", (SIGNAL_FUNC) sig_complete_word);
 
1162
        signal_remove("complete command msg", (SIGNAL_FUNC) sig_complete_msg);
 
1163
        signal_remove("complete command query", (SIGNAL_FUNC) sig_complete_msg);
 
1164
        signal_remove("complete command action", (SIGNAL_FUNC) sig_complete_msg);
 
1165
        signal_remove("complete erase command msg", (SIGNAL_FUNC) sig_erase_complete_msg);
 
1166
        signal_remove("complete erase command query", (SIGNAL_FUNC) sig_erase_complete_msg);
 
1167
        signal_remove("complete erase command action", (SIGNAL_FUNC) sig_erase_complete_msg);
 
1168
        signal_remove("complete command connect", (SIGNAL_FUNC) sig_complete_connect);
 
1169
        signal_remove("complete command server", (SIGNAL_FUNC) sig_complete_connect);
 
1170
        signal_remove("complete command disconnect", (SIGNAL_FUNC) sig_complete_tag);
 
1171
        signal_remove("complete command reconnect", (SIGNAL_FUNC) sig_complete_tag);
 
1172
        signal_remove("complete command topic", (SIGNAL_FUNC) sig_complete_topic);
 
1173
        signal_remove("complete command away", (SIGNAL_FUNC) sig_complete_away);
 
1174
        signal_remove("complete command unalias", (SIGNAL_FUNC) sig_complete_unalias);
 
1175
        signal_remove("complete command alias", (SIGNAL_FUNC) sig_complete_alias);
 
1176
        signal_remove("complete command window item move", (SIGNAL_FUNC) sig_complete_channel);
 
1177
        signal_remove("complete command server add", (SIGNAL_FUNC) sig_complete_server);
 
1178
        signal_remove("complete command server remove", (SIGNAL_FUNC) sig_complete_server);
 
1179
        signal_remove("complete command recode remove", (SIGNAL_FUNC) sig_complete_target);
 
1180
        signal_remove("message public", (SIGNAL_FUNC) sig_message_public);
 
1181
        signal_remove("message join", (SIGNAL_FUNC) sig_message_join);
 
1182
        signal_remove("message private", (SIGNAL_FUNC) sig_message_private);
 
1183
        signal_remove("message own_public", (SIGNAL_FUNC) sig_message_own_public);
 
1184
        signal_remove("message own_private", (SIGNAL_FUNC) sig_message_own_private);
 
1185
        signal_remove("nicklist remove", (SIGNAL_FUNC) sig_nick_removed);
 
1186
        signal_remove("nicklist changed", (SIGNAL_FUNC) sig_nick_changed);
 
1187
        signal_remove("send text", (SIGNAL_FUNC) event_text);
 
1188
        signal_remove("server disconnected", (SIGNAL_FUNC) sig_server_disconnected);
 
1189
        signal_remove("channel destroyed", (SIGNAL_FUNC) sig_channel_destroyed);
 
1190
        signal_remove("setup changed", (SIGNAL_FUNC) read_settings);
 
1191
}