apps/irssi/src/core/expandos.c

   1 /*
   2  expandos.c : irssi
   3
   4     Copyright (C) 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 "modules.h"
  23 #include "signals.h"
  24 #include "expandos.h"
  25 #include "settings.h"
  26 #include "commands.h"
  27 #include "misc.h"
  28 #include "irssi-version.h"
  29
  30 #include "servers.h"
  31 #include "channels.h"
  32 #include "queries.h"
  33 #include "window-item-def.h"
  34
  35 #ifdef HAVE_SYS_UTSNAME_H
  36 #  include <sys/utsname.h>
  37 #endif
  38
  39 #define MAX_EXPANDO_SIGNALS 10
  40
  41 typedef struct {
  42         EXPANDO_FUNC func;
  43
  44         int signals;
  45         int signal_ids[MAX_EXPANDO_SIGNALS];
  46         int signal_args[MAX_EXPANDO_SIGNALS];
  47 } EXPANDO_REC;
  48
  49 const char *current_expando = NULL;
  50
  51 static int timer_tag;
  52
  53 static EXPANDO_REC *char_expandos[255];
  54 static GHashTable *expandos;
  55 static time_t client_start_time;
  56 static char *last_sent_msg, *last_sent_msg_body;
  57 static char *last_privmsg_from, *last_public_from;
  58 static char *sysname, *sysrelease, *sysarch;
  59
  60 static const char *timestamp_format;
  61 static int timestamp_seconds;
  62 static time_t last_timestamp;
  63
  64 #define CHAR_EXPANDO(chr) \
  65         (char_expandos[(int) (unsigned char) chr])
  66
  67 /* Create expando - overrides any existing ones. */
  68 void expando_create(const char *key, EXPANDO_FUNC func, ...)
  69 {
  70         EXPANDO_REC *rec;
  71         const char *signal;
  72         va_list va;
  73
  74         g_return_if_fail(key != NULL || *key == '\0');
  75         g_return_if_fail(func != NULL);
  76
  77         if (key[1] != '\0')
  78                 rec = g_hash_table_lookup(expandos, key);
  79         else {
  80                 /* single character expando */
  81                 rec = CHAR_EXPANDO(*key);
  82         }
  83
  84         if (rec != NULL)
  85                 rec->signals = 0;
  86         else {
  87                 rec = g_new0(EXPANDO_REC, 1);
  88                 if (key[1] != '\0')
  89                         g_hash_table_insert(expandos, g_strdup(key), rec);
  90                 else
  91                         char_expandos[(int) (unsigned char) *key] = rec;
  92         }
  93
  94         rec->func = func;
  95
  96         va_start(va, func);
  97         while ((signal = (const char *) va_arg(va, const char *)) != NULL)
  98                expando_add_signal(key, signal, (int) va_arg(va, int));
  99         va_end(va);
 100 }
 101
 102 static EXPANDO_REC *expando_find(const char *key)
 103 {
 104         if (key[1] != '\0')
 105                 return g_hash_table_lookup(expandos, key);
 106         else
 107                 return CHAR_EXPANDO(*key);
 108 }
 109
 110 /* Add new signal to expando */
 111 void expando_add_signal(const char *key, const char *signal, ExpandoArg arg)
 112 {
 113         EXPANDO_REC *rec;
 114
 115         g_return_if_fail(key != NULL);
 116         g_return_if_fail(signal != NULL);
 117
 118         rec = expando_find(key);
 119         g_return_if_fail(rec != NULL);
 120
 121         if (arg == EXPANDO_NEVER) {
 122                 /* expando changes never */
 123                 rec->signals = -1;
 124         } else if (rec->signals < MAX_EXPANDO_SIGNALS) {
 125                 g_return_if_fail(rec->signals != -1);
 126
 127                 rec->signal_ids[rec->signals] = signal_get_uniq_id(signal);
 128                 rec->signal_args[rec->signals] = arg;
 129                 rec->signals++;
 130         }
 131 }
 132
 133 /* Destroy expando */
 134 void expando_destroy(const char *key, EXPANDO_FUNC func)
 135 {
 136         gpointer origkey;
 137         EXPANDO_REC *rec;
 138
 139         g_return_if_fail(key != NULL || *key == '\0');
 140         g_return_if_fail(func != NULL);
 141
 142         if (key[1] == '\0') {
 143                 /* single character expando */
 144                 rec = CHAR_EXPANDO(*key);
 145                 if (rec != NULL && rec->func == func) {
 146                         char_expandos[(int) (unsigned char) *key] = NULL;
 147                         g_free(rec);
 148                 }
 149         } else if (g_hash_table_lookup_extended(expandos, key, &origkey,
 150                                                 (gpointer *) &rec)) {
 151                 if (rec->func == func) {
 152                         g_hash_table_remove(expandos, key);
 153                         g_free(origkey);
 154                         g_free(rec);
 155                 }
 156         }
 157 }
 158
 159 void expando_bind(const char *key, int funccount, SIGNAL_FUNC *funcs)
 160 {
 161         SIGNAL_FUNC func;
 162         EXPANDO_REC *rec;
 163         int n, arg;
 164
 165         g_return_if_fail(key != NULL);
 166         g_return_if_fail(funccount >= 1);
 167         g_return_if_fail(funcs != NULL);
 168         g_return_if_fail(funcs[0] != NULL);
 169
 170         rec = expando_find(key);
 171         g_return_if_fail(rec != NULL);
 172
 173         if (rec->signals == 0) {
 174                 /* it's unknown when this expando changes..
 175                    check it once in a second */
 176                 signal_add("expando timer", funcs[EXPANDO_ARG_NONE]);
 177         }
 178
 179         for (n = 0; n < rec->signals; n++) {
 180                 arg = rec->signal_args[n];
 181                 func = arg < funccount ? funcs[arg] : NULL;
 182                 if (func == NULL) func = funcs[EXPANDO_ARG_NONE];
 183
 184                 signal_add_full_id(MODULE_NAME, SIGNAL_PRIORITY_DEFAULT,
 185                                    rec->signal_ids[n], func, NULL);
 186         }
 187 }
 188
 189 void expando_unbind(const char *key, int funccount, SIGNAL_FUNC *funcs)
 190 {
 191         SIGNAL_FUNC func;
 192         EXPANDO_REC *rec;
 193         int n, arg;
 194
 195         g_return_if_fail(key != NULL);
 196         g_return_if_fail(funccount >= 1);
 197         g_return_if_fail(funcs != NULL);
 198         g_return_if_fail(funcs[0] != NULL);
 199
 200         rec = expando_find(key);
 201         g_return_if_fail(rec != NULL);
 202
 203         if (rec->signals == 0) {
 204                 /* it's unknown when this expando changes..
 205                    check it once in a second */
 206                 signal_remove("expando timer", funcs[EXPANDO_ARG_NONE]);
 207         }
 208
 209         for (n = 0; n < rec->signals; n++) {
 210                 arg = rec->signal_args[n];
 211                 func = arg < funccount ? funcs[arg] : NULL;
 212                 if (func == NULL) func = funcs[EXPANDO_ARG_NONE];
 213
 214                 signal_remove_id(rec->signal_ids[n], func, NULL);
 215         }
 216 }
 217
 218 /* Returns [<signal id>, EXPANDO_ARG_xxx, <signal id>, ..., -1] */
 219 int *expando_get_signals(const char *key)
 220 {
 221         EXPANDO_REC *rec;
 222         int *signals;
 223         int n;
 224
 225         g_return_val_if_fail(key != NULL, NULL);
 226
 227         rec = expando_find(key);
 228         if (rec == NULL || rec->signals < 0)
 229                 return NULL;
 230
 231         if (rec->signals == 0) {
 232                 /* it's unknown when this expando changes..
 233                    check it once in a second */
 234                 signals = g_new(int, 3);
 235                 signals[0] = signal_get_uniq_id("expando timer");
 236                 signals[1] = EXPANDO_ARG_NONE;
 237                 signals[2] = -1;
 238                 return signals;
 239         }
 240
 241         signals = g_new(int, rec->signals*2+1);
 242         for (n = 0; n < rec->signals; n++) {
 243                 signals[n*2] = rec->signal_ids[n];
 244                 signals[n*2+1] = rec->signal_args[n];
 245         }
 246         signals[rec->signals*2] = -1;
 247         return signals;
 248 }
 249
 250 EXPANDO_FUNC expando_find_char(char chr)
 251 {
 252         return CHAR_EXPANDO(chr) == NULL ? NULL :
 253                 CHAR_EXPANDO(chr)->func;
 254 }
 255
 256 EXPANDO_FUNC expando_find_long(const char *key)
 257 {
 258         EXPANDO_REC *rec = g_hash_table_lookup(expandos, key);
 259         return rec == NULL ? NULL : rec->func;
 260 }
 261
 262 /* last person who sent you a MSG */
 263 static char *expando_lastmsg(SERVER_REC *server, void *item, int *free_ret)
 264 {
 265         return last_privmsg_from;
 266 }
 267
 268 /* last person to whom you sent a MSG */
 269 static char *expando_lastmymsg(SERVER_REC *server, void *item, int *free_ret)
 270 {
 271         return last_sent_msg;
 272 }
 273
 274 /* last person to send a public message to a channel you are on */
 275 static char *expando_lastpublic(SERVER_REC *server, void *item, int *free_ret)
 276 {
 277         return last_public_from;
 278 }
 279
 280 /* text of your AWAY message, if any */
 281 static char *expando_awaymsg(SERVER_REC *server, void *item, int *free_ret)
 282 {
 283         return server == NULL ? "" : server->away_reason;
 284 }
 285
 286 /* body of last MSG you sent */
 287 static char *expando_lastmymsg_body(SERVER_REC *server, void *item, int *free_ret)
 288 {
 289         return last_sent_msg_body;
 290 }
 291
 292 /* current channel */
 293 static char *expando_channel(SERVER_REC *server, void *item, int *free_ret)
 294 {
 295         return !IS_CHANNEL(item) ? NULL : CHANNEL(item)->name;
 296 }
 297
 298 /* time client was started, $time() format */
 299 static char *expando_clientstarted(SERVER_REC *server, void *item, int *free_ret)
 300 {
 301         *free_ret = TRUE;
 302         return g_strdup_printf("%ld", (long) client_start_time);
 303 }
 304
 305 /* channel you were last INVITEd to */
 306 static char *expando_last_invite(SERVER_REC *server, void *item, int *free_ret)
 307 {
 308         return server == NULL ? "" : server->last_invite;
 309 }
 310
 311 /* client version text string */
 312 static char *expando_version(SERVER_REC *server, void *item, int *free_ret)
 313 {
 314         return IRSSI_VERSION;
 315 }
 316
 317 /* current value of CMDCHARS */
 318 static char *expando_cmdchars(SERVER_REC *server, void *item, int *free_ret)
 319 {
 320         return (char *) settings_get_str("cmdchars");
 321 }
 322
 323 /* first CMDCHAR */
 324 static char *expando_cmdchar(SERVER_REC *server, void *item, int *free_ret)
 325 {
 326         char str[2] = { 0, 0 };
 327
 328         str[0] = *settings_get_str("cmdchars");
 329
 330         *free_ret = TRUE;
 331         return g_strdup(str);
 332 }
 333
 334 /* modes of current channel, if any */
 335 static char *expando_chanmode(SERVER_REC *server, void *item, int *free_ret)
 336 {
 337         return !IS_CHANNEL(item) ? NULL : CHANNEL(item)->mode;
 338 }
 339
 340 /* current nickname */
 341 static char *expando_nick(SERVER_REC *server, void *item, int *free_ret)
 342 {
 343         return server == NULL ? "" : server->nick;
 344 }
 345
 346 /* value of STATUS_OPER if you are an irc operator */
 347 static char *expando_statusoper(SERVER_REC *server, void *item, int *free_ret)
 348 {
 349         return server == NULL || !server->server_operator ? "" :
 350                 (char *) settings_get_str("STATUS_OPER");
 351 }
 352
 353 /* if you are a channel operator in $C, expands to a '@' */
 354 static char *expando_chanop(SERVER_REC *server, void *item, int *free_ret)
 355 {
 356         return IS_CHANNEL(item) && CHANNEL(item)->chanop ? "@" : "";
 357 }
 358
 359 /* nickname of whomever you are QUERYing */
 360 static char *expando_query(SERVER_REC *server, void *item, int *free_ret)
 361 {
 362         return !IS_QUERY(item) ? "" : QUERY(item)->name;
 363 }
 364
 365 /* version of current server */
 366 static char *expando_serverversion(SERVER_REC *server, void *item, int *free_ret)
 367 {
 368         return server == NULL ? "" : server->version;
 369 }
 370
 371 /* target of current input (channel or QUERY nickname) */
 372 static char *expando_target(SERVER_REC *server, void *item, int *free_ret)
 373 {
 374         return item == NULL ? "" :
 375                 (char *) window_item_get_target((WI_ITEM_REC *) item);
 376 }
 377
 378 /* client release date (in YYYYMMDD format) */
 379 static char *expando_releasedate(SERVER_REC *server, void *item, int *free_ret)
 380 {
 381         *free_ret = TRUE;
 382         return g_strdup_printf("%d", IRSSI_VERSION_DATE);
 383 }
 384
 385 /* client release time (in HHMM format) */
 386 static char *expando_releasetime(SERVER_REC *server, void *item, int *free_ret)
 387 {
 388         *free_ret = TRUE;
 389         return g_strdup_printf("%04d", IRSSI_VERSION_TIME);
 390 }
 391
 392 /* current working directory */
 393 static char *expando_workdir(SERVER_REC *server, void *item, int *free_ret)
 394 {
 395         *free_ret = TRUE;
 396         return g_get_current_dir();
 397 }
 398
 399 /* value of REALNAME */
 400 static char *expando_realname(SERVER_REC *server, void *item, int *free_ret)
 401 {
 402         return server == NULL ? "" : server->connrec->realname;
 403 }
 404
 405 /* time of day (hh:mm) */
 406 static char *expando_time(SERVER_REC *server, void *item, int *free_ret)
 407 {
 408         time_t now;
 409         struct tm *tm;
 410         char str[256];
 411
 412         now = time(NULL);
 413         tm = localtime(&now);
 414
 415         if (strftime(str, sizeof(str), timestamp_format, tm) == 0)
 416                 return "";
 417
 418         *free_ret = TRUE;
 419         return g_strdup(str);
 420 }
 421
 422 /* a literal '$' */
 423 static char *expando_dollar(SERVER_REC *server, void *item, int *free_ret)
 424 {
 425         return "$";
 426 }
 427
 428 /* system name */
 429 static char *expando_sysname(SERVER_REC *server, void *item, int *free_ret)
 430 {
 431         return sysname;
 432 }
 433
 434 /* system release */
 435 static char *expando_sysrelease(SERVER_REC *server, void *item, int *free_ret)
 436 {
 437         return sysrelease;
 438 }
 439
 440 /* system architecture */
 441 static char *expando_sysarch(SERVER_REC *server, void *item, int *free_ret)
 442 {
 443         return sysarch;
 444 }
 445
 446 /* Topic of active channel (or address of queried nick) */
 447 static char *expando_topic(SERVER_REC *server, void *item, int *free_ret)
 448 {
 449         if (IS_CHANNEL(item))
 450                 return CHANNEL(item)->topic;
 451         if (IS_QUERY(item)) {
 452                 QUERY_REC *query = QUERY(item);
 453
 454                 if (query->server_tag == NULL)
 455                         return "";
 456
 457                 *free_ret = TRUE;
 458                 return query->address == NULL ?
 459                         g_strdup_printf("(%s)", query->server_tag) :
 460                         g_strdup_printf("%s (%s)", query->address,
 461                                         query->server_tag);
 462         }
 463         return "";
 464 }
 465
 466 /* Server tag */
 467 static char *expando_servertag(SERVER_REC *server, void *item, int *free_ret)
 468 {
 469         return server == NULL ? "" : server->tag;
 470 }
 471
 472 /* Server chatnet */
 473 static char *expando_chatnet(SERVER_REC *server, void *item, int *free_ret)
 474 {
 475         return server == NULL ? "" : server->connrec->chatnet;
 476 }
 477
 478 /* visible_name of current window item */
 479 static char *expando_itemname(SERVER_REC *server, void *item, int *free_ret)
 480 {
 481         return item == NULL ? "" : ((WI_ITEM_REC *) item)->visible_name;
 482 }
 483
 484 static void sig_message_public(SERVER_REC *server, const char *msg,
 485                                const char *nick, const char *address,
 486                                const char *target)
 487 {
 488         g_free_not_null(last_public_from);
 489         last_public_from = g_strdup(nick);
 490 }
 491
 492 static void sig_message_private(SERVER_REC *server, const char *msg,
 493                                 const char *nick, const char *address)
 494 {
 495         g_free_not_null(last_privmsg_from);
 496         last_privmsg_from = g_strdup(nick);
 497 }
 498
 499 static void sig_message_own_private(SERVER_REC *server, const char *msg,
 500                                     const char *target, const char *origtarget)
 501 {
 502         g_return_if_fail(server != NULL);
 503         g_return_if_fail(msg != NULL);
 504
 505         if (target != NULL) {
 506                 if (target != last_sent_msg) {
 507                         g_free_not_null(last_sent_msg);
 508                         last_sent_msg = g_strdup(target);
 509                 }
 510                 g_free_not_null(last_sent_msg_body);
 511                 last_sent_msg_body = g_strdup(msg);
 512         }
 513 }
 514
 515 static int sig_timer(void)
 516 {
 517         time_t now;
 518         struct tm *tm;
 519         int last_min;
 520
 521         signal_emit("expando timer", 0);
 522
 523         /* check if $Z has changed */
 524         now = time(NULL);
 525         if (last_timestamp != now) {
 526                 if (!timestamp_seconds && last_timestamp != 0) {
 527                         /* assume it changes every minute */
 528                         tm = localtime(&last_timestamp);
 529                         last_min = tm->tm_min;
 530
 531                         tm = localtime(&now);
 532                         if (tm->tm_min == last_min)
 533                                 return 1;
 534                 }
 535
 536                 signal_emit("time changed", 0);
 537                 last_timestamp = now;
 538         }
 539
 540         return 1;
 541 }
 542
 543 static void read_settings(void)
 544 {
 545         timestamp_format = settings_get_str("timestamp_format");
 546         timestamp_seconds =
 547                 strstr(timestamp_format, "%r") != NULL ||
 548                 strstr(timestamp_format, "%s") != NULL ||
 549                 strstr(timestamp_format, "%S") != NULL ||
 550                 strstr(timestamp_format, "%X") != NULL ||
 551                 strstr(timestamp_format, "%T") != NULL;
 552
 553 }
 554
 555 void expandos_init(void)
 556 {
 557 #ifdef HAVE_SYS_UTSNAME_H
 558         struct utsname un;
 559 #endif
 560         settings_add_str("misc", "STATUS_OPER", "*");
 561         settings_add_str("lookandfeel", "timestamp_format", "%H:%M");
 562
 563         client_start_time = time(NULL);
 564         last_sent_msg = NULL; last_sent_msg_body = NULL;
 565         last_privmsg_from = NULL; last_public_from = NULL;
 566         last_timestamp = 0;
 567
 568         sysname = sysrelease = sysarch = NULL;
 569 #ifdef HAVE_SYS_UTSNAME_H
 570         if (uname(&un) >= 0) {
 571                 sysname = g_strdup(un.sysname);
 572                 sysrelease = g_strdup(un.release);
 573                 sysarch = g_strdup(un.machine);
 574         }
 575 #endif
 576
 577         memset(char_expandos, 0, sizeof(char_expandos));
 578         expandos = g_hash_table_new((GHashFunc) g_str_hash,
 579                                     (GCompareFunc) g_str_equal);
 580
 581         expando_create(",", expando_lastmsg,
 582                        "message private", EXPANDO_ARG_SERVER, NULL);
 583         expando_create(".", expando_lastmymsg,
 584                        "command msg", EXPANDO_ARG_NONE, NULL);
 585         expando_create(";", expando_lastpublic,
 586                        "message public", EXPANDO_ARG_SERVER, NULL);
 587         expando_create("A", expando_awaymsg,
 588                        "away mode changed", EXPANDO_ARG_NONE, NULL);
 589         expando_create("B", expando_lastmymsg_body,
 590                        "command msg", EXPANDO_ARG_NONE, NULL);
 591         expando_create("C", expando_channel,
 592                        "window changed", EXPANDO_ARG_NONE,
 593                        "window item changed", EXPANDO_ARG_WINDOW, NULL);
 594         expando_create("F", expando_clientstarted,
 595                        "", EXPANDO_NEVER, NULL);
 596         expando_create("I", expando_last_invite, NULL);
 597         expando_create("J", expando_version,
 598                        "", EXPANDO_NEVER, NULL);
 599         expando_create("K", expando_cmdchars,
 600                        "setup changed", EXPANDO_ARG_NONE, NULL);
 601         expando_create("k", expando_cmdchar,
 602                        "setup changed", EXPANDO_ARG_NONE, NULL);
 603         expando_create("M", expando_chanmode,
 604                        "window changed", EXPANDO_ARG_NONE,
 605                        "window item changed", EXPANDO_ARG_WINDOW,
 606                        "channel mode changed", EXPANDO_ARG_WINDOW_ITEM, NULL);
 607         expando_create("N", expando_nick,
 608                        "window changed", EXPANDO_ARG_NONE,
 609                        "window connect changed", EXPANDO_ARG_WINDOW,
 610                        "window server changed", EXPANDO_ARG_WINDOW,
 611                        "server nick changed", EXPANDO_ARG_SERVER, NULL);
 612         expando_create("O", expando_statusoper,
 613                        "setup changed", EXPANDO_ARG_NONE,
 614                        "window changed", EXPANDO_ARG_NONE,
 615                        "window server changed", EXPANDO_ARG_WINDOW,
 616                        "user mode changed", EXPANDO_ARG_WINDOW, NULL);
 617         expando_create("P", expando_chanop,
 618                        "window changed", EXPANDO_ARG_NONE,
 619                        "window item changed", EXPANDO_ARG_WINDOW,
 620                        "nick mode changed", EXPANDO_ARG_WINDOW_ITEM, NULL);
 621         expando_create("Q", expando_query,
 622                        "window changed", EXPANDO_ARG_NONE,
 623                        "window item changed", EXPANDO_ARG_WINDOW, NULL);
 624         expando_create("R", expando_serverversion,
 625                        "window changed", EXPANDO_ARG_NONE,
 626                        "window server changed", EXPANDO_ARG_WINDOW, NULL);
 627         expando_create("T", expando_target,
 628                        "window changed", EXPANDO_ARG_NONE,
 629                        "window item changed", EXPANDO_ARG_WINDOW, NULL);
 630         expando_create("V", expando_releasedate,
 631                        "", EXPANDO_NEVER, NULL);
 632         expando_create("versiontime", expando_releasetime,
 633                        "", EXPANDO_NEVER, NULL);
 634         expando_create("W", expando_workdir, NULL);
 635         expando_create("Y", expando_realname,
 636                        "window changed", EXPANDO_ARG_NONE,
 637                        "window connect changed", EXPANDO_ARG_WINDOW,
 638                        "window server changed", EXPANDO_ARG_WINDOW, NULL);
 639         expando_create("Z", expando_time,
 640                        "time changed", EXPANDO_ARG_NONE, NULL);
 641         expando_create("$", expando_dollar,
 642                        "", EXPANDO_NEVER, NULL);
 643
 644         expando_create("sysname", expando_sysname,
 645                        "", EXPANDO_NEVER, NULL);
 646         expando_create("sysrelease", expando_sysrelease,
 647                        "", EXPANDO_NEVER, NULL);
 648         expando_create("sysarch", expando_sysarch,
 649                        "", EXPANDO_NEVER, NULL);
 650         expando_create("topic", expando_topic,
 651                        "window changed", EXPANDO_ARG_NONE,
 652                        "window item changed", EXPANDO_ARG_WINDOW,
 653                        "channel topic changed", EXPANDO_ARG_WINDOW_ITEM,
 654                        "query address changed", EXPANDO_ARG_WINDOW_ITEM, NULL);
 655         expando_create("tag", expando_servertag,
 656                        "window changed", EXPANDO_ARG_NONE,
 657                        "window connect changed", EXPANDO_ARG_WINDOW,
 658                        "window server changed", EXPANDO_ARG_WINDOW, NULL);
 659         expando_create("chatnet", expando_chatnet,
 660                        "window changed", EXPANDO_ARG_NONE,
 661                        "window connect changed", EXPANDO_ARG_WINDOW,
 662                        "window server changed", EXPANDO_ARG_WINDOW, NULL);
 663         expando_create("itemname", expando_itemname,
 664                        "window changed", EXPANDO_ARG_NONE,
 665                        "window item changed", EXPANDO_ARG_WINDOW,
 666                        "window item name changed", EXPANDO_ARG_WINDOW_ITEM,
 667                        NULL);
 668
 669         read_settings();
 670
 671         timer_tag = g_timeout_add(500, (GSourceFunc) sig_timer, NULL);
 672         signal_add("message public", (SIGNAL_FUNC) sig_message_public);
 673         signal_add("message private", (SIGNAL_FUNC) sig_message_private);
 674         signal_add("message own_private", (SIGNAL_FUNC) sig_message_own_private);
 675         signal_add_first("setup changed", (SIGNAL_FUNC) read_settings);
 676 }
 677
 678 void expandos_deinit(void)
 679 {
 680         int n;
 681
 682         for (n = 0; n < sizeof(char_expandos)/sizeof(char_expandos[0]); n++)
 683                 g_free_not_null(char_expandos[n]);
 684
 685         expando_destroy("sysname", expando_sysname);
 686         expando_destroy("sysrelease", expando_sysrelease);
 687         expando_destroy("sysarch", expando_sysarch);
 688         expando_destroy("topic", expando_topic);
 689         expando_destroy("tag", expando_servertag);
 690         expando_destroy("chatnet", expando_chatnet);
 691
 692         g_hash_table_destroy(expandos);
 693
 694         g_free_not_null(last_sent_msg); g_free_not_null(last_sent_msg_body);
 695         g_free_not_null(last_privmsg_from); g_free_not_null(last_public_from);
 696         g_free_not_null(sysname); g_free_not_null(sysrelease);
 697         g_free_not_null(sysarch);
 698
 699         g_source_remove(timer_tag);
 700         signal_remove("message public", (SIGNAL_FUNC) sig_message_public);
 701         signal_remove("message private", (SIGNAL_FUNC) sig_message_private);
 702         signal_remove("message own_private", (SIGNAL_FUNC) sig_message_own_private);
 703         signal_remove("setup changed", (SIGNAL_FUNC) read_settings);
 704 }