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