libpurple/pounce.c

   1 /**
   2  * @file pounce.c Buddy Pounce API
   3  * @ingroup core
   4  */
   5
   6 /* purple
   7  *
   8  * Purple is the legal property of its developers, whose names are too numerous
   9  * to list here.  Please refer to the COPYRIGHT file distributed with this
  10  * source distribution.
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  25  */
  26 #include "internal.h"
  27 #include "conversation.h"
  28 #include "debug.h"
  29 #include "pounce.h"
  30
  31 #include "debug.h"
  32 #include "pounce.h"
  33 #include "util.h"
  34
  35 typedef struct
  36 {
  37         GString *buffer;
  38
  39         PurplePounce *pounce;
  40         PurplePounceEvent events;
  41         PurplePounceOption options;
  42
  43         char *ui_name;
  44         char *pouncee;
  45         char *protocol_id;
  46         char *event_type;
  47         char *option_type;
  48         char *action_name;
  49         char *param_name;
  50         char *account_name;
  51
  52 } PounceParserData;
  53
  54 typedef struct
  55 {
  56         char *name;
  57
  58         gboolean enabled;
  59
  60         GHashTable *atts;
  61
  62 } PurplePounceActionData;
  63
  64 typedef struct
  65 {
  66         char *ui;
  67         PurplePounceCb cb;
  68         void (*new_pounce)(PurplePounce *);
  69         void (*free_pounce)(PurplePounce *);
  70
  71 } PurplePounceHandler;
  72
  73
  74 static GHashTable *pounce_handlers = NULL;
  75 static GList      *pounces = NULL;
  76 static guint       save_timer = 0;
  77 static gboolean    pounces_loaded = FALSE;
  78
  79
  80 /*********************************************************************
  81  * Private utility functions                                         *
  82  *********************************************************************/
  83
  84 static PurplePounceActionData *
  85 find_action_data(const PurplePounce *pounce, const char *name)
  86 {
  87         PurplePounceActionData *action;
  88
  89         g_return_val_if_fail(pounce != NULL, NULL);
  90         g_return_val_if_fail(name   != NULL, NULL);
  91
  92         action = g_hash_table_lookup(pounce->actions, name);
  93
  94         return action;
  95 }
  96
  97 static void
  98 free_action_data(gpointer data)
  99 {
 100         PurplePounceActionData *action_data = data;
 101
 102         g_free(action_data->name);
 103
 104         g_hash_table_destroy(action_data->atts);
 105
 106         g_free(action_data);
 107 }
 108
 109
 110 /*********************************************************************
 111  * Writing to disk                                                   *
 112  *********************************************************************/
 113
 114 static void
 115 action_parameter_to_xmlnode(gpointer key, gpointer value, gpointer user_data)
 116 {
 117         const char *name, *param_value;
 118         xmlnode *node, *child;
 119
 120         name        = (const char *)key;
 121         param_value = (const char *)value;
 122         node        = (xmlnode *)user_data;
 123
 124         child = xmlnode_new_child(node, "param");
 125         xmlnode_set_attrib(child, "name", name);
 126         xmlnode_insert_data(child, param_value, -1);
 127 }
 128
 129 static void
 130 action_parameter_list_to_xmlnode(gpointer key, gpointer value, gpointer user_data)
 131 {
 132         const char *action;
 133         PurplePounceActionData *action_data;
 134         xmlnode *node, *child;
 135
 136         action      = (const char *)key;
 137         action_data = (PurplePounceActionData *)value;
 138         node        = (xmlnode *)user_data;
 139
 140         if (!action_data->enabled)
 141                 return;
 142
 143         child = xmlnode_new_child(node, "action");
 144         xmlnode_set_attrib(child, "type", action);
 145
 146         g_hash_table_foreach(action_data->atts, action_parameter_to_xmlnode, child);
 147 }
 148
 149 static void
 150 add_event_to_xmlnode(xmlnode *node, const char *type)
 151 {
 152         xmlnode *child;
 153
 154         child = xmlnode_new_child(node, "event");
 155         xmlnode_set_attrib(child, "type", type);
 156 }
 157
 158 static void
 159 add_option_to_xmlnode(xmlnode *node, const char *type)
 160 {
 161         xmlnode *child;
 162
 163         child = xmlnode_new_child(node, "option");
 164         xmlnode_set_attrib(child, "type", type);
 165 }
 166
 167 static xmlnode *
 168 pounce_to_xmlnode(PurplePounce *pounce)
 169 {
 170         xmlnode *node, *child;
 171         PurpleAccount *pouncer;
 172         PurplePounceEvent events;
 173         PurplePounceOption options;
 174
 175         pouncer = purple_pounce_get_pouncer(pounce);
 176         events  = purple_pounce_get_events(pounce);
 177         options = purple_pounce_get_options(pounce);
 178
 179         node = xmlnode_new("pounce");
 180         xmlnode_set_attrib(node, "ui", pounce->ui_type);
 181
 182         child = xmlnode_new_child(node, "account");
 183         xmlnode_set_attrib(child, "protocol", pouncer->protocol_id);
 184         xmlnode_insert_data(child,
 185                         purple_normalize(pouncer, purple_account_get_username(pouncer)), -1);
 186
 187         child = xmlnode_new_child(node, "pouncee");
 188         xmlnode_insert_data(child, purple_pounce_get_pouncee(pounce), -1);
 189
 190         /* Write pounce options */
 191         child = xmlnode_new_child(node, "options");
 192         if (options & PURPLE_POUNCE_OPTION_AWAY)
 193                 add_option_to_xmlnode(child, "on-away");
 194
 195         /* Write pounce events */
 196         child = xmlnode_new_child(node, "events");
 197         if (events & PURPLE_POUNCE_SIGNON)
 198                 add_event_to_xmlnode(child, "sign-on");
 199         if (events & PURPLE_POUNCE_SIGNOFF)
 200                 add_event_to_xmlnode(child, "sign-off");
 201         if (events & PURPLE_POUNCE_AWAY)
 202                 add_event_to_xmlnode(child, "away");
 203         if (events & PURPLE_POUNCE_AWAY_RETURN)
 204                 add_event_to_xmlnode(child, "return-from-away");
 205         if (events & PURPLE_POUNCE_IDLE)
 206                 add_event_to_xmlnode(child, "idle");
 207         if (events & PURPLE_POUNCE_IDLE_RETURN)
 208                 add_event_to_xmlnode(child, "return-from-idle");
 209         if (events & PURPLE_POUNCE_TYPING)
 210                 add_event_to_xmlnode(child, "start-typing");
 211         if (events & PURPLE_POUNCE_TYPED)
 212                 add_event_to_xmlnode(child, "typed");
 213         if (events & PURPLE_POUNCE_TYPING_STOPPED)
 214                 add_event_to_xmlnode(child, "stop-typing");
 215         if (events & PURPLE_POUNCE_MESSAGE_RECEIVED)
 216                 add_event_to_xmlnode(child, "message-received");
 217
 218         /* Write pounce actions */
 219         child = xmlnode_new_child(node, "actions");
 220         g_hash_table_foreach(pounce->actions, action_parameter_list_to_xmlnode, child);
 221
 222         if (purple_pounce_get_save(pounce))
 223                 child = xmlnode_new_child(node, "save");
 224
 225         return node;
 226 }
 227
 228 static xmlnode *
 229 pounces_to_xmlnode(void)
 230 {
 231         xmlnode *node, *child;
 232         GList *cur;
 233
 234         node = xmlnode_new("pounces");
 235         xmlnode_set_attrib(node, "version", "1.0");
 236
 237         for (cur = purple_pounces_get_all(); cur != NULL; cur = cur->next)
 238         {
 239                 child = pounce_to_xmlnode(cur->data);
 240                 xmlnode_insert_child(node, child);
 241         }
 242
 243         return node;
 244 }
 245
 246 static void
 247 sync_pounces(void)
 248 {
 249         xmlnode *node;
 250         char *data;
 251
 252         if (!pounces_loaded)
 253         {
 254                 purple_debug_error("pounce", "Attempted to save buddy pounces before "
 255                                                  "they were read!\n");
 256                 return;
 257         }
 258
 259         node = pounces_to_xmlnode();
 260         data = xmlnode_to_formatted_str(node, NULL);
 261         purple_util_write_data_to_file("pounces.xml", data, -1);
 262         g_free(data);
 263         xmlnode_free(node);
 264 }
 265
 266 static gboolean
 267 save_cb(gpointer data)
 268 {
 269         sync_pounces();
 270         save_timer = 0;
 271         return FALSE;
 272 }
 273
 274 static void
 275 schedule_pounces_save(void)
 276 {
 277         if (save_timer == 0)
 278                 save_timer = purple_timeout_add_seconds(5, save_cb, NULL);
 279 }
 280
 281
 282 /*********************************************************************
 283  * Reading from disk                                                 *
 284  *********************************************************************/
 285
 286 static void
 287 free_parser_data(gpointer user_data)
 288 {
 289         PounceParserData *data = user_data;
 290
 291         if (data->buffer != NULL)
 292                 g_string_free(data->buffer, TRUE);
 293
 294         g_free(data->ui_name);
 295         g_free(data->pouncee);
 296         g_free(data->protocol_id);
 297         g_free(data->event_type);
 298         g_free(data->option_type);
 299         g_free(data->action_name);
 300         g_free(data->param_name);
 301         g_free(data->account_name);
 302
 303         g_free(data);
 304 }
 305
 306 static void
 307 start_element_handler(GMarkupParseContext *context,
 308                                           const gchar *element_name,
 309                                           const gchar **attribute_names,
 310                                           const gchar **attribute_values,
 311                                           gpointer user_data, GError **error)
 312 {
 313         PounceParserData *data = user_data;
 314         GHashTable *atts;
 315         int i;
 316
 317         atts = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
 318
 319         for (i = 0; attribute_names[i] != NULL; i++) {
 320                 g_hash_table_insert(atts, g_strdup(attribute_names[i]),
 321                                                         g_strdup(attribute_values[i]));
 322         }
 323
 324         if (data->buffer != NULL) {
 325                 g_string_free(data->buffer, TRUE);
 326                 data->buffer = NULL;
 327         }
 328
 329         if (purple_strequal(element_name, "pounce")) {
 330                 const char *ui = g_hash_table_lookup(atts, "ui");
 331
 332                 if (ui == NULL) {
 333                         purple_debug(PURPLE_DEBUG_ERROR, "pounce",
 334                                            "Unset 'ui' parameter for pounce!\n");
 335                 }
 336                 else
 337                         data->ui_name = g_strdup(ui);
 338
 339                 data->events = 0;
 340         }
 341         else if (purple_strequal(element_name, "account")) {
 342                 const char *protocol_id = g_hash_table_lookup(atts, "protocol");
 343
 344                 if (protocol_id == NULL) {
 345                         purple_debug(PURPLE_DEBUG_ERROR, "pounce",
 346                                            "Unset 'protocol' parameter for account!\n");
 347                 }
 348                 else
 349                         data->protocol_id = g_strdup(protocol_id);
 350         }
 351         else if (purple_strequal(element_name, "option")) {
 352                 const char *type = g_hash_table_lookup(atts, "type");
 353
 354                 if (type == NULL) {
 355                         purple_debug(PURPLE_DEBUG_ERROR, "pounce",
 356                                            "Unset 'type' parameter for option!\n");
 357                 }
 358                 else
 359                         data->option_type = g_strdup(type);
 360         }
 361         else if (purple_strequal(element_name, "event")) {
 362                 const char *type = g_hash_table_lookup(atts, "type");
 363
 364                 if (type == NULL) {
 365                         purple_debug(PURPLE_DEBUG_ERROR, "pounce",
 366                                            "Unset 'type' parameter for event!\n");
 367                 }
 368                 else
 369                         data->event_type = g_strdup(type);
 370         }
 371         else if (purple_strequal(element_name, "action")) {
 372                 const char *type = g_hash_table_lookup(atts, "type");
 373
 374                 if (type == NULL) {
 375                         purple_debug(PURPLE_DEBUG_ERROR, "pounce",
 376                                            "Unset 'type' parameter for action!\n");
 377                 }
 378                 else
 379                         data->action_name = g_strdup(type);
 380         }
 381         else if (purple_strequal(element_name, "param")) {
 382                 const char *param_name = g_hash_table_lookup(atts, "name");
 383
 384                 if (param_name == NULL) {
 385                         purple_debug(PURPLE_DEBUG_ERROR, "pounce",
 386                                            "Unset 'name' parameter for param!\n");
 387                 }
 388                 else
 389                         data->param_name = g_strdup(param_name);
 390         }
 391
 392         g_hash_table_destroy(atts);
 393 }
 394
 395 static void
 396 end_element_handler(GMarkupParseContext *context, const gchar *element_name,
 397                                         gpointer user_data,  GError **error)
 398 {
 399         PounceParserData *data = user_data;
 400         gchar *buffer = NULL;
 401
 402         if (data->buffer != NULL) {
 403                 buffer = g_string_free(data->buffer, FALSE);
 404                 data->buffer = NULL;
 405         }
 406
 407         if (purple_strequal(element_name, "account")) {
 408                 char *tmp;
 409                 g_free(data->account_name);
 410                 data->account_name = g_strdup(buffer);
 411                 tmp = data->protocol_id;
 412                 data->protocol_id = g_strdup(_purple_oscar_convert(buffer, tmp));
 413                 g_free(tmp);
 414         }
 415         else if (purple_strequal(element_name, "pouncee")) {
 416                 g_free(data->pouncee);
 417                 data->pouncee = g_strdup(buffer);
 418         }
 419         else if (purple_strequal(element_name, "option")) {
 420                 if (purple_strequal(data->option_type, "on-away"))
 421                         data->options |= PURPLE_POUNCE_OPTION_AWAY;
 422
 423                 g_free(data->option_type);
 424                 data->option_type = NULL;
 425         }
 426         else if (purple_strequal(element_name, "event")) {
 427                 if (purple_strequal(data->event_type, "sign-on"))
 428                         data->events |= PURPLE_POUNCE_SIGNON;
 429                 else if (purple_strequal(data->event_type, "sign-off"))
 430                         data->events |= PURPLE_POUNCE_SIGNOFF;
 431                 else if (purple_strequal(data->event_type, "away"))
 432                         data->events |= PURPLE_POUNCE_AWAY;
 433                 else if (purple_strequal(data->event_type, "return-from-away"))
 434                         data->events |= PURPLE_POUNCE_AWAY_RETURN;
 435                 else if (purple_strequal(data->event_type, "idle"))
 436                         data->events |= PURPLE_POUNCE_IDLE;
 437                 else if (purple_strequal(data->event_type, "return-from-idle"))
 438                         data->events |= PURPLE_POUNCE_IDLE_RETURN;
 439                 else if (purple_strequal(data->event_type, "start-typing"))
 440                         data->events |= PURPLE_POUNCE_TYPING;
 441                 else if (purple_strequal(data->event_type, "typed"))
 442                         data->events |= PURPLE_POUNCE_TYPED;
 443                 else if (purple_strequal(data->event_type, "stop-typing"))
 444                         data->events |= PURPLE_POUNCE_TYPING_STOPPED;
 445                 else if (purple_strequal(data->event_type, "message-received"))
 446                         data->events |= PURPLE_POUNCE_MESSAGE_RECEIVED;
 447
 448                 g_free(data->event_type);
 449                 data->event_type = NULL;
 450         }
 451         else if (purple_strequal(element_name, "action")) {
 452                 if (data->pounce != NULL) {
 453                         purple_pounce_action_register(data->pounce, data->action_name);
 454                         purple_pounce_action_set_enabled(data->pounce, data->action_name, TRUE);
 455                 }
 456
 457                 g_free(data->action_name);
 458                 data->action_name = NULL;
 459         }
 460         else if (purple_strequal(element_name, "param")) {
 461                 if (data->pounce != NULL) {
 462                         purple_pounce_action_set_attribute(data->pounce, data->action_name,
 463                                                                                          data->param_name, buffer);
 464                 }
 465
 466                 g_free(data->param_name);
 467                 data->param_name = NULL;
 468         }
 469         else if (purple_strequal(element_name, "events")) {
 470                 PurpleAccount *account;
 471
 472                 account = purple_accounts_find(data->account_name, data->protocol_id);
 473
 474                 g_free(data->account_name);
 475                 g_free(data->protocol_id);
 476
 477                 data->account_name = NULL;
 478                 data->protocol_id  = NULL;
 479
 480                 if (account == NULL) {
 481                         purple_debug(PURPLE_DEBUG_ERROR, "pounce",
 482                                            "Account for pounce not found!\n");
 483                         /*
 484                          * This pounce has effectively been removed, so make
 485                          * sure that we save the changes to pounces.xml
 486                          */
 487                         schedule_pounces_save();
 488                 }
 489                 else {
 490                         purple_debug(PURPLE_DEBUG_INFO, "pounce",
 491                                            "Creating pounce: %s, %s\n", data->ui_name,
 492                                            data->pouncee);
 493
 494                         data->pounce = purple_pounce_new(data->ui_name, account,
 495                                                                                    data->pouncee, data->events,
 496                                                                                    data->options);
 497                 }
 498
 499                 g_free(data->pouncee);
 500                 data->pouncee = NULL;
 501         }
 502         else if (purple_strequal(element_name, "save")) {
 503                 if (data->pounce != NULL)
 504                         purple_pounce_set_save(data->pounce, TRUE);
 505         }
 506         else if (purple_strequal(element_name, "pounce")) {
 507                 data->pounce  = NULL;
 508                 data->events  = 0;
 509                 data->options = 0;
 510
 511                 g_free(data->ui_name);
 512                 g_free(data->pouncee);
 513                 g_free(data->protocol_id);
 514                 g_free(data->event_type);
 515                 g_free(data->option_type);
 516                 g_free(data->action_name);
 517                 g_free(data->param_name);
 518                 g_free(data->account_name);
 519
 520                 data->ui_name      = NULL;
 521                 data->pounce       = NULL;
 522                 data->protocol_id  = NULL;
 523                 data->event_type   = NULL;
 524                 data->option_type  = NULL;
 525                 data->action_name  = NULL;
 526                 data->param_name   = NULL;
 527                 data->account_name = NULL;
 528         }
 529
 530         g_free(buffer);
 531 }
 532
 533 static void
 534 text_handler(GMarkupParseContext *context, const gchar *text,
 535                          gsize text_len, gpointer user_data, GError **error)
 536 {
 537         PounceParserData *data = user_data;
 538
 539         if (data->buffer == NULL)
 540                 data->buffer = g_string_new_len(text, text_len);
 541         else
 542                 g_string_append_len(data->buffer, text, text_len);
 543 }
 544
 545 static GMarkupParser pounces_parser =
 546 {
 547         start_element_handler,
 548         end_element_handler,
 549         text_handler,
 550         NULL,
 551         NULL
 552 };
 553
 554 gboolean
 555 purple_pounces_load(void)
 556 {
 557         gchar *filename = g_build_filename(purple_user_dir(), "pounces.xml", NULL);
 558         gchar *contents = NULL;
 559         gsize length;
 560         GMarkupParseContext *context;
 561         GError *error = NULL;
 562         PounceParserData *parser_data;
 563
 564         if (filename == NULL) {
 565                 pounces_loaded = TRUE;
 566                 return FALSE;
 567         }
 568
 569         if (!g_file_get_contents(filename, &contents, &length, &error)) {
 570                 purple_debug(PURPLE_DEBUG_ERROR, "pounce",
 571                                    "Error reading pounces: %s\n", error->message);
 572
 573                 g_free(filename);
 574                 g_error_free(error);
 575
 576                 pounces_loaded = TRUE;
 577                 return FALSE;
 578         }
 579
 580         parser_data = g_new0(PounceParserData, 1);
 581
 582         context = g_markup_parse_context_new(&pounces_parser, 0,
 583                                                                                  parser_data, free_parser_data);
 584
 585         if (!g_markup_parse_context_parse(context, contents, length, NULL)) {
 586                 g_markup_parse_context_free(context);
 587                 g_free(contents);
 588                 g_free(filename);
 589
 590                 pounces_loaded = TRUE;
 591
 592                 return FALSE;
 593         }
 594
 595         if (!g_markup_parse_context_end_parse(context, NULL)) {
 596                 purple_debug(PURPLE_DEBUG_ERROR, "pounce", "Error parsing %s\n",
 597                                    filename);
 598
 599                 g_markup_parse_context_free(context);
 600                 g_free(contents);
 601                 g_free(filename);
 602                 pounces_loaded = TRUE;
 603
 604                 return FALSE;
 605         }
 606
 607         g_markup_parse_context_free(context);
 608         g_free(contents);
 609         g_free(filename);
 610
 611         pounces_loaded = TRUE;
 612
 613         return TRUE;
 614 }
 615
 616
 617 PurplePounce *
 618 purple_pounce_new(const char *ui_type, PurpleAccount *pouncer,
 619                                 const char *pouncee, PurplePounceEvent event,
 620                                 PurplePounceOption option)
 621 {
 622         PurplePounce *pounce;
 623         PurplePounceHandler *handler;
 624
 625         g_return_val_if_fail(ui_type != NULL, NULL);
 626         g_return_val_if_fail(pouncer != NULL, NULL);
 627         g_return_val_if_fail(pouncee != NULL, NULL);
 628         g_return_val_if_fail(event   != 0,    NULL);
 629
 630         pounce = g_new0(PurplePounce, 1);
 631
 632         pounce->ui_type  = g_strdup(ui_type);
 633         pounce->pouncer  = pouncer;
 634         pounce->pouncee  = g_strdup(pouncee);
 635         pounce->events   = event;
 636         pounce->options  = option;
 637
 638         pounce->actions  = g_hash_table_new_full(g_str_hash, g_str_equal,
 639                                                                                          g_free, free_action_data);
 640
 641         handler = g_hash_table_lookup(pounce_handlers, pounce->ui_type);
 642
 643         if (handler != NULL && handler->new_pounce != NULL)
 644                 handler->new_pounce(pounce);
 645
 646         pounces = g_list_append(pounces, pounce);
 647
 648         schedule_pounces_save();
 649
 650         return pounce;
 651 }
 652
 653 void
 654 purple_pounce_destroy(PurplePounce *pounce)
 655 {
 656         PurplePounceHandler *handler;
 657
 658         g_return_if_fail(pounce != NULL);
 659
 660         handler = g_hash_table_lookup(pounce_handlers, pounce->ui_type);
 661
 662         pounces = g_list_remove(pounces, pounce);
 663
 664         g_free(pounce->ui_type);
 665         g_free(pounce->pouncee);
 666
 667         g_hash_table_destroy(pounce->actions);
 668
 669         if (handler != NULL && handler->free_pounce != NULL)
 670                 handler->free_pounce(pounce);
 671
 672         g_free(pounce);
 673
 674         schedule_pounces_save();
 675 }
 676
 677 void
 678 purple_pounce_destroy_all_by_account(PurpleAccount *account)
 679 {
 680         PurpleAccount *pouncer;
 681         PurplePounce *pounce;
 682         GList *l, *l_next;
 683
 684         g_return_if_fail(account != NULL);
 685
 686         for (l = purple_pounces_get_all(); l != NULL; l = l_next)
 687         {
 688                 pounce = (PurplePounce *)l->data;
 689                 l_next = l->next;
 690
 691                 pouncer = purple_pounce_get_pouncer(pounce);
 692                 if (pouncer == account)
 693                         purple_pounce_destroy(pounce);
 694         }
 695 }
 696
 697 void
 698 purple_pounce_set_events(PurplePounce *pounce, PurplePounceEvent events)
 699 {
 700         g_return_if_fail(pounce != NULL);
 701         g_return_if_fail(events != PURPLE_POUNCE_NONE);
 702
 703         pounce->events = events;
 704
 705         schedule_pounces_save();
 706 }
 707
 708 void
 709 purple_pounce_set_options(PurplePounce *pounce, PurplePounceOption options)
 710 {
 711         g_return_if_fail(pounce  != NULL);
 712
 713         pounce->options = options;
 714
 715         schedule_pounces_save();
 716 }
 717
 718 void
 719 purple_pounce_set_pouncer(PurplePounce *pounce, PurpleAccount *pouncer)
 720 {
 721         g_return_if_fail(pounce  != NULL);
 722         g_return_if_fail(pouncer != NULL);
 723
 724         pounce->pouncer = pouncer;
 725
 726         schedule_pounces_save();
 727 }
 728
 729 void
 730 purple_pounce_set_pouncee(PurplePounce *pounce, const char *pouncee)
 731 {
 732         g_return_if_fail(pounce  != NULL);
 733         g_return_if_fail(pouncee != NULL);
 734
 735         g_free(pounce->pouncee);
 736         pounce->pouncee = g_strdup(pouncee);
 737
 738         schedule_pounces_save();
 739 }
 740
 741 void
 742 purple_pounce_set_save(PurplePounce *pounce, gboolean save)
 743 {
 744         g_return_if_fail(pounce != NULL);
 745
 746         pounce->save = save;
 747
 748         schedule_pounces_save();
 749 }
 750
 751 void
 752 purple_pounce_action_register(PurplePounce *pounce, const char *name)
 753 {
 754         PurplePounceActionData *action_data;
 755
 756         g_return_if_fail(pounce != NULL);
 757         g_return_if_fail(name   != NULL);
 758
 759         if (g_hash_table_lookup(pounce->actions, name) != NULL)
 760                 return;
 761
 762         action_data = g_new0(PurplePounceActionData, 1);
 763
 764         action_data->name    = g_strdup(name);
 765         action_data->enabled = FALSE;
 766         action_data->atts    = g_hash_table_new_full(g_str_hash, g_str_equal,
 767                                                                                                  g_free, g_free);
 768
 769         g_hash_table_insert(pounce->actions, g_strdup(name), action_data);
 770
 771         schedule_pounces_save();
 772 }
 773
 774 void
 775 purple_pounce_action_set_enabled(PurplePounce *pounce, const char *action,
 776                                                            gboolean enabled)
 777 {
 778         PurplePounceActionData *action_data;
 779
 780         g_return_if_fail(pounce != NULL);
 781         g_return_if_fail(action != NULL);
 782
 783         action_data = find_action_data(pounce, action);
 784
 785         g_return_if_fail(action_data != NULL);
 786
 787         action_data->enabled = enabled;
 788
 789         schedule_pounces_save();
 790 }
 791
 792 void
 793 purple_pounce_action_set_attribute(PurplePounce *pounce, const char *action,
 794                                                                  const char *attr, const char *value)
 795 {
 796         PurplePounceActionData *action_data;
 797
 798         g_return_if_fail(pounce != NULL);
 799         g_return_if_fail(action != NULL);
 800         g_return_if_fail(attr   != NULL);
 801
 802         action_data = find_action_data(pounce, action);
 803
 804         g_return_if_fail(action_data != NULL);
 805
 806         if (value == NULL)
 807                 g_hash_table_remove(action_data->atts, attr);
 808         else
 809                 g_hash_table_insert(action_data->atts, g_strdup(attr),
 810                                                         g_strdup(value));
 811
 812         schedule_pounces_save();
 813 }
 814
 815 void
 816 purple_pounce_set_data(PurplePounce *pounce, void *data)
 817 {
 818         g_return_if_fail(pounce != NULL);
 819
 820         pounce->data = data;
 821
 822         schedule_pounces_save();
 823 }
 824
 825 PurplePounceEvent
 826 purple_pounce_get_events(const PurplePounce *pounce)
 827 {
 828         g_return_val_if_fail(pounce != NULL, PURPLE_POUNCE_NONE);
 829
 830         return pounce->events;
 831 }
 832
 833 PurplePounceOption
 834 purple_pounce_get_options(const PurplePounce *pounce)
 835 {
 836         g_return_val_if_fail(pounce != NULL, PURPLE_POUNCE_OPTION_NONE);
 837
 838         return pounce->options;
 839 }
 840
 841 PurpleAccount *
 842 purple_pounce_get_pouncer(const PurplePounce *pounce)
 843 {
 844         g_return_val_if_fail(pounce != NULL, NULL);
 845
 846         return pounce->pouncer;
 847 }
 848
 849 const char *
 850 purple_pounce_get_pouncee(const PurplePounce *pounce)
 851 {
 852         g_return_val_if_fail(pounce != NULL, NULL);
 853
 854         return pounce->pouncee;
 855 }
 856
 857 gboolean
 858 purple_pounce_get_save(const PurplePounce *pounce)
 859 {
 860         g_return_val_if_fail(pounce != NULL, FALSE);
 861
 862         return pounce->save;
 863 }
 864
 865 gboolean
 866 purple_pounce_action_is_enabled(const PurplePounce *pounce, const char *action)
 867 {
 868         PurplePounceActionData *action_data;
 869
 870         g_return_val_if_fail(pounce != NULL, FALSE);
 871         g_return_val_if_fail(action != NULL, FALSE);
 872
 873         action_data = find_action_data(pounce, action);
 874
 875         g_return_val_if_fail(action_data != NULL, FALSE);
 876
 877         return action_data->enabled;
 878 }
 879
 880 const char *
 881 purple_pounce_action_get_attribute(const PurplePounce *pounce,
 882                                                                  const char *action, const char *attr)
 883 {
 884         PurplePounceActionData *action_data;
 885
 886         g_return_val_if_fail(pounce != NULL, NULL);
 887         g_return_val_if_fail(action != NULL, NULL);
 888         g_return_val_if_fail(attr   != NULL, NULL);
 889
 890         action_data = find_action_data(pounce, action);
 891
 892         g_return_val_if_fail(action_data != NULL, NULL);
 893
 894         return g_hash_table_lookup(action_data->atts, attr);
 895 }
 896
 897 void *
 898 purple_pounce_get_data(const PurplePounce *pounce)
 899 {
 900         g_return_val_if_fail(pounce != NULL, NULL);
 901
 902         return pounce->data;
 903 }
 904
 905 void
 906 purple_pounce_execute(const PurpleAccount *pouncer, const char *pouncee,
 907                                         PurplePounceEvent events)
 908 {
 909         PurplePounce *pounce;
 910         PurplePounceHandler *handler;
 911         PurplePresence *presence;
 912         GList *l, *l_next;
 913         char *norm_pouncee;
 914
 915         g_return_if_fail(pouncer != NULL);
 916         g_return_if_fail(pouncee != NULL);
 917         g_return_if_fail(events  != PURPLE_POUNCE_NONE);
 918
 919         norm_pouncee = g_strdup(purple_normalize(pouncer, pouncee));
 920
 921         for (l = purple_pounces_get_all(); l != NULL; l = l_next)
 922         {
 923                 pounce = (PurplePounce *)l->data;
 924                 l_next = l->next;
 925
 926                 presence = purple_account_get_presence(pouncer);
 927
 928                 if ((purple_pounce_get_events(pounce) & events) &&
 929                         (purple_pounce_get_pouncer(pounce) == pouncer) &&
 930                         !purple_utf8_strcasecmp(purple_normalize(pouncer, purple_pounce_get_pouncee(pounce)),
 931                                                                   norm_pouncee) &&
 932                         (pounce->options == PURPLE_POUNCE_OPTION_NONE ||
 933                          (pounce->options & PURPLE_POUNCE_OPTION_AWAY &&
 934                           !purple_presence_is_available(presence))))
 935                 {
 936                         handler = g_hash_table_lookup(pounce_handlers, pounce->ui_type);
 937
 938                         if (handler != NULL && handler->cb != NULL)
 939                         {
 940                                 handler->cb(pounce, events, purple_pounce_get_data(pounce));
 941
 942                                 if (!purple_pounce_get_save(pounce))
 943                                         purple_pounce_destroy(pounce);
 944                         }
 945                 }
 946         }
 947
 948         g_free(norm_pouncee);
 949 }
 950
 951 PurplePounce *
 952 purple_find_pounce(const PurpleAccount *pouncer, const char *pouncee,
 953                                  PurplePounceEvent events)
 954 {
 955         PurplePounce *pounce = NULL;
 956         GList *l;
 957         char *norm_pouncee;
 958
 959         g_return_val_if_fail(pouncer != NULL, NULL);
 960         g_return_val_if_fail(pouncee != NULL, NULL);
 961         g_return_val_if_fail(events  != PURPLE_POUNCE_NONE, NULL);
 962
 963         norm_pouncee = g_strdup(purple_normalize(pouncer, pouncee));
 964
 965         for (l = purple_pounces_get_all(); l != NULL; l = l->next)
 966         {
 967                 pounce = (PurplePounce *)l->data;
 968
 969                 if ((purple_pounce_get_events(pounce) & events) &&
 970                         (purple_pounce_get_pouncer(pounce) == pouncer) &&
 971                         !purple_utf8_strcasecmp(purple_normalize(pouncer, purple_pounce_get_pouncee(pounce)),
 972                                                                   norm_pouncee))
 973                 {
 974                         break;
 975                 }
 976
 977                 pounce = NULL;
 978         }
 979
 980         g_free(norm_pouncee);
 981
 982         return pounce;
 983 }
 984
 985 void
 986 purple_pounces_register_handler(const char *ui, PurplePounceCb cb,
 987                                                           void (*new_pounce)(PurplePounce *pounce),
 988                                                           void (*free_pounce)(PurplePounce *pounce))
 989 {
 990         PurplePounceHandler *handler;
 991
 992         g_return_if_fail(ui != NULL);
 993         g_return_if_fail(cb != NULL);
 994
 995         handler = g_new0(PurplePounceHandler, 1);
 996
 997         handler->ui          = g_strdup(ui);
 998         handler->cb          = cb;
 999         handler->new_pounce  = new_pounce;
1000         handler->free_pounce = free_pounce;
1001
1002         g_hash_table_insert(pounce_handlers, g_strdup(ui), handler);
1003 }
1004
1005 void
1006 purple_pounces_unregister_handler(const char *ui)
1007 {
1008         g_return_if_fail(ui != NULL);
1009
1010         g_hash_table_remove(pounce_handlers, ui);
1011 }
1012
1013 GList *
1014 purple_pounces_get_all(void)
1015 {
1016         return pounces;
1017 }
1018
1019 GList *purple_pounces_get_all_for_ui(const char *ui)
1020 {
1021         GList *list = NULL, *iter;
1022         g_return_val_if_fail(ui != NULL, NULL);
1023
1024         for (iter = pounces; iter; iter = iter->next) {
1025                 PurplePounce *pounce = iter->data;
1026                 if (purple_strequal(pounce->ui_type, ui))
1027                         list = g_list_prepend(list, pounce);
1028         }
1029         list = g_list_reverse(list);
1030         return list;
1031 }
1032
1033 static void
1034 free_pounce_handler(gpointer user_data)
1035 {
1036         PurplePounceHandler *handler = (PurplePounceHandler *)user_data;
1037
1038         g_free(handler->ui);
1039         g_free(handler);
1040 }
1041
1042 static void
1043 buddy_state_cb(PurpleBuddy *buddy, PurplePounceEvent event)
1044 {
1045         PurpleAccount *account = purple_buddy_get_account(buddy);
1046         const gchar *name = purple_buddy_get_name(buddy);
1047
1048         purple_pounce_execute(account, name, event);
1049 }
1050
1051 static void
1052 buddy_status_changed_cb(PurpleBuddy *buddy, PurpleStatus *old_status,
1053                         PurpleStatus *status)
1054 {
1055         PurpleAccount *account = purple_buddy_get_account(buddy);
1056         const gchar *name = purple_buddy_get_name(buddy);
1057         gboolean old_available, available;
1058
1059         available = purple_status_is_available(status);
1060         old_available = purple_status_is_available(old_status);
1061
1062         if (available && !old_available)
1063                 purple_pounce_execute(account, name, PURPLE_POUNCE_AWAY_RETURN);
1064         else if (!available && old_available)
1065                 purple_pounce_execute(account, name, PURPLE_POUNCE_AWAY);
1066 }
1067
1068 static void
1069 buddy_idle_changed_cb(PurpleBuddy *buddy, gboolean old_idle, gboolean idle)
1070 {
1071         PurpleAccount *account = purple_buddy_get_account(buddy);
1072         const gchar *name = purple_buddy_get_name(buddy);
1073
1074         if (idle && !old_idle)
1075                 purple_pounce_execute(account, name, PURPLE_POUNCE_IDLE);
1076         else if (!idle && old_idle)
1077                 purple_pounce_execute(account, name, PURPLE_POUNCE_IDLE_RETURN);
1078 }
1079
1080 static void
1081 buddy_typing_cb(PurpleAccount *account, const char *name, void *data)
1082 {
1083         PurpleConversation *conv;
1084
1085         conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, name, account);
1086         if (conv != NULL)
1087         {
1088                 PurpleTypingState state;
1089                 PurplePounceEvent event;
1090
1091                 state = purple_conv_im_get_typing_state(PURPLE_CONV_IM(conv));
1092                 if (state == PURPLE_TYPED)
1093                         event = PURPLE_POUNCE_TYPED;
1094                 else if (state == PURPLE_NOT_TYPING)
1095                         event = PURPLE_POUNCE_TYPING_STOPPED;
1096                 else
1097                         event = PURPLE_POUNCE_TYPING;
1098
1099                 purple_pounce_execute(account, name, event);
1100         }
1101 }
1102
1103 static void
1104 received_message_cb(PurpleAccount *account, const char *name, void *data)
1105 {
1106         purple_pounce_execute(account, name, PURPLE_POUNCE_MESSAGE_RECEIVED);
1107 }
1108
1109 void *
1110 purple_pounces_get_handle(void)
1111 {
1112         static int pounce_handle;
1113
1114         return &pounce_handle;
1115 }
1116
1117 void
1118 purple_pounces_init(void)
1119 {
1120         void *handle       = purple_pounces_get_handle();
1121         void *blist_handle = purple_blist_get_handle();
1122         void *conv_handle  = purple_conversations_get_handle();
1123
1124         pounce_handlers = g_hash_table_new_full(g_str_hash, g_str_equal,
1125                                                                                         g_free, free_pounce_handler);
1126
1127         purple_signal_connect(blist_handle, "buddy-idle-changed",
1128                             handle, PURPLE_CALLBACK(buddy_idle_changed_cb), NULL);
1129         purple_signal_connect(blist_handle, "buddy-status-changed",
1130                             handle, PURPLE_CALLBACK(buddy_status_changed_cb), NULL);
1131         purple_signal_connect(blist_handle, "buddy-signed-on",
1132                                                 handle, PURPLE_CALLBACK(buddy_state_cb),
1133                                                 GINT_TO_POINTER(PURPLE_POUNCE_SIGNON));
1134         purple_signal_connect(blist_handle, "buddy-signed-off",
1135                                                 handle, PURPLE_CALLBACK(buddy_state_cb),
1136                                                 GINT_TO_POINTER(PURPLE_POUNCE_SIGNOFF));
1137
1138         purple_signal_connect(conv_handle, "buddy-typing",
1139                                                 handle, PURPLE_CALLBACK(buddy_typing_cb), NULL);
1140         purple_signal_connect(conv_handle, "buddy-typed",
1141                                                 handle, PURPLE_CALLBACK(buddy_typing_cb), NULL);
1142         purple_signal_connect(conv_handle, "buddy-typing-stopped",
1143                                                 handle, PURPLE_CALLBACK(buddy_typing_cb), NULL);
1144
1145         purple_signal_connect(conv_handle, "received-im-msg",
1146                                                 handle, PURPLE_CALLBACK(received_message_cb), NULL);
1147 }
1148
1149 void
1150 purple_pounces_uninit()
1151 {
1152         if (save_timer != 0)
1153         {
1154                 purple_timeout_remove(save_timer);
1155                 save_timer = 0;
1156                 sync_pounces();
1157         }
1158
1159         purple_signals_disconnect_by_handle(purple_pounces_get_handle());
1160
1161         g_hash_table_destroy(pounce_handlers);
1162         pounce_handlers = NULL;
1163 }