libpurple/notify.c

   1 /**
   2  * @file notify.c Notification 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 #define _PURPLE_NOTIFY_C_
  27
  28 #include "internal.h"
  29 #include "dbus-maybe.h"
  30 #include "notify.h"
  31
  32 static PurpleNotifyUiOps *notify_ui_ops = NULL;
  33 static GList *handles = NULL;
  34
  35 typedef struct
  36 {
  37         PurpleNotifyType type;
  38         void *handle;
  39         void *ui_handle;
  40         PurpleNotifyCloseCallback cb;
  41         gpointer cb_user_data;
  42 } PurpleNotifyInfo;
  43
  44 /**
  45  * Definition of a user info entry
  46  */
  47 struct _PurpleNotifyUserInfoEntry
  48 {
  49         char *label;
  50         char *value;
  51         PurpleNotifyUserInfoEntryType type;
  52 };
  53
  54 struct _PurpleNotifyUserInfo
  55 {
  56         GList *user_info_entries;
  57 };
  58
  59 void *
  60 purple_notify_message(void *handle, PurpleNotifyMsgType type,
  61                                         const char *title, const char *primary,
  62                                         const char *secondary, PurpleNotifyCloseCallback cb, gpointer user_data)
  63 {
  64         PurpleNotifyUiOps *ops;
  65
  66         g_return_val_if_fail(primary != NULL, NULL);
  67
  68         ops = purple_notify_get_ui_ops();
  69
  70         if (ops != NULL && ops->notify_message != NULL) {
  71                 void *ui_handle = ops->notify_message(type, title, primary,
  72                                                                                           secondary);
  73                 if (ui_handle != NULL) {
  74
  75                         PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
  76                         info->type = PURPLE_NOTIFY_MESSAGE;
  77                         info->handle = handle;
  78                         info->ui_handle = ui_handle;
  79                         info->cb = cb;
  80                         info->cb_user_data = user_data;
  81
  82                         handles = g_list_append(handles, info);
  83
  84                         return info->ui_handle;
  85                 }
  86
  87         }
  88
  89         if (cb != NULL)
  90                 cb(user_data);
  91
  92         return NULL;
  93 }
  94
  95 void *
  96 purple_notify_email(void *handle, const char *subject, const char *from,
  97                                   const char *to, const char *url, PurpleNotifyCloseCallback cb,
  98                                   gpointer user_data)
  99 {
 100         PurpleNotifyUiOps *ops;
 101
 102         ops = purple_notify_get_ui_ops();
 103
 104         if (ops != NULL && ops->notify_email != NULL) {
 105                 void *ui_handle;
 106
 107                 purple_signal_emit(purple_notify_get_handle(), "displaying-email-notification",
 108                                                    subject, from, to, url);
 109
 110                 ui_handle = ops->notify_email(handle, subject, from, to, url);
 111
 112                 if (ui_handle != NULL) {
 113
 114                         PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
 115                         info->type = PURPLE_NOTIFY_EMAIL;
 116                         info->handle = handle;
 117                         info->ui_handle = ui_handle;
 118                         info->cb = cb;
 119                         info->cb_user_data = user_data;
 120
 121                         handles = g_list_append(handles, info);
 122
 123                         return info->ui_handle;
 124                 }
 125         }
 126
 127         if (cb != NULL)
 128                 cb(user_data);
 129
 130         return NULL;
 131 }
 132
 133 void *
 134 purple_notify_emails(void *handle, size_t count, gboolean detailed,
 135                                    const char **subjects, const char **froms,
 136                                    const char **tos, const char **urls,
 137                                    PurpleNotifyCloseCallback cb, gpointer user_data)
 138 {
 139         PurpleNotifyUiOps *ops;
 140
 141         if (count == 1) {
 142                 return purple_notify_email(handle,
 143                                                                  (subjects == NULL ? NULL : *subjects),
 144                                                                  (froms    == NULL ? NULL : *froms),
 145                                                                  (tos      == NULL ? NULL : *tos),
 146                                                                  (urls     == NULL ? NULL : *urls),
 147                                                                  cb, user_data);
 148         }
 149
 150         ops = purple_notify_get_ui_ops();
 151
 152         if (ops != NULL && ops->notify_emails != NULL) {
 153                 void *ui_handle;
 154
 155                 purple_signal_emit(purple_notify_get_handle(), "displaying-emails-notification",
 156                                                         subjects, froms, tos, urls, count);
 157
 158                 ui_handle = ops->notify_emails(handle, count, detailed, subjects,
 159                                                                                          froms, tos, urls);
 160
 161                 if (ui_handle != NULL) {
 162                         PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
 163                         info->type = PURPLE_NOTIFY_EMAILS;
 164                         info->handle = handle;
 165                         info->ui_handle = ui_handle;
 166                         info->cb = cb;
 167                         info->cb_user_data = user_data;
 168
 169                         handles = g_list_append(handles, info);
 170
 171                         return info->ui_handle;
 172                 }
 173
 174         }
 175
 176         if (cb != NULL)
 177                 cb(user_data);
 178
 179         return NULL;
 180 }
 181
 182 void *
 183 purple_notify_formatted(void *handle, const char *title, const char *primary,
 184                                           const char *secondary, const char *text,
 185                                           PurpleNotifyCloseCallback cb, gpointer user_data)
 186 {
 187         PurpleNotifyUiOps *ops;
 188
 189         g_return_val_if_fail(primary != NULL, NULL);
 190
 191         ops = purple_notify_get_ui_ops();
 192
 193         if (ops != NULL && ops->notify_formatted != NULL) {
 194                 void *ui_handle = ops->notify_formatted(title, primary, secondary, text);
 195
 196                 if (ui_handle != NULL) {
 197
 198                         PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
 199                         info->type = PURPLE_NOTIFY_FORMATTED;
 200                         info->handle = handle;
 201                         info->ui_handle = ui_handle;
 202                         info->cb = cb;
 203                         info->cb_user_data = user_data;
 204
 205                         handles = g_list_append(handles, info);
 206
 207                         return info->ui_handle;
 208                 }
 209         }
 210
 211         if (cb != NULL)
 212                 cb(user_data);
 213         return NULL;
 214 }
 215
 216 void *
 217 purple_notify_searchresults(PurpleConnection *gc, const char *title,
 218                                                   const char *primary, const char *secondary,
 219                                                   PurpleNotifySearchResults *results, PurpleNotifyCloseCallback cb,
 220                                                   gpointer user_data)
 221 {
 222         PurpleNotifyUiOps *ops;
 223
 224         ops = purple_notify_get_ui_ops();
 225
 226         if (ops != NULL && ops->notify_searchresults != NULL) {
 227                 void *ui_handle = ops->notify_searchresults(gc, title, primary,
 228                                                                                                         secondary, results, user_data);
 229                 if (ui_handle != NULL) {
 230
 231                         PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
 232                         info->type      = PURPLE_NOTIFY_SEARCHRESULTS;
 233                         info->handle    = gc;
 234                         info->ui_handle = ui_handle;
 235                         info->cb = cb;
 236                         info->cb_user_data = user_data;
 237
 238                         handles = g_list_append(handles, info);
 239
 240                         return info->ui_handle;
 241                 }
 242         }
 243
 244         if (cb != NULL)
 245                 cb(user_data);
 246
 247         return NULL;
 248 }
 249
 250 void
 251 purple_notify_searchresults_free(PurpleNotifySearchResults *results)
 252 {
 253         GList *l;
 254
 255         g_return_if_fail(results != NULL);
 256
 257         for (l = results->buttons; l; l = g_list_delete_link(l, l)) {
 258                 PurpleNotifySearchButton *button = l->data;
 259                 g_free(button->label);
 260                 g_free(button);
 261         }
 262
 263         for (l = results->rows; l; l = g_list_delete_link(l, l)) {
 264                 GList *row = l->data;
 265                 g_list_foreach(row, (GFunc)g_free, NULL);
 266                 g_list_free(row);
 267         }
 268
 269         for (l = results->columns; l; l = g_list_delete_link(l, l)) {
 270                 PurpleNotifySearchColumn *column = l->data;
 271                 g_free(column->title);
 272                 g_free(column);
 273         }
 274
 275         g_free(results);
 276 }
 277
 278 void
 279 purple_notify_searchresults_new_rows(PurpleConnection *gc,
 280                 PurpleNotifySearchResults *results,
 281                 void *data)
 282 {
 283         PurpleNotifyUiOps *ops;
 284
 285         ops = purple_notify_get_ui_ops();
 286
 287         if (ops != NULL && ops->notify_searchresults != NULL) {
 288                 ops->notify_searchresults_new_rows(gc, results, data);
 289         }
 290 }
 291
 292 void
 293 purple_notify_searchresults_button_add(PurpleNotifySearchResults *results,
 294                                                                          PurpleNotifySearchButtonType type,
 295                                                                          PurpleNotifySearchResultsCallback cb)
 296 {
 297         PurpleNotifySearchButton *button;
 298
 299         g_return_if_fail(results != NULL);
 300         g_return_if_fail(cb != NULL);
 301
 302         button = g_new0(PurpleNotifySearchButton, 1);
 303         button->callback = cb;
 304         button->type = type;
 305
 306         results->buttons = g_list_append(results->buttons, button);
 307 }
 308
 309
 310 void
 311 purple_notify_searchresults_button_add_labeled(PurpleNotifySearchResults *results,
 312                                              const char *label,
 313                                              PurpleNotifySearchResultsCallback cb) {
 314         PurpleNotifySearchButton *button;
 315
 316         g_return_if_fail(results != NULL);
 317         g_return_if_fail(cb != NULL);
 318         g_return_if_fail(label != NULL);
 319         g_return_if_fail(*label != '\0');
 320
 321         button = g_new0(PurpleNotifySearchButton, 1);
 322         button->callback = cb;
 323         button->type = PURPLE_NOTIFY_BUTTON_LABELED;
 324         button->label = g_strdup(label);
 325
 326         results->buttons = g_list_append(results->buttons, button);
 327 }
 328
 329
 330 PurpleNotifySearchResults *
 331 purple_notify_searchresults_new()
 332 {
 333         PurpleNotifySearchResults *rs = g_new0(PurpleNotifySearchResults, 1);
 334
 335         return rs;
 336 }
 337
 338 void
 339 purple_notify_searchresults_column_add(PurpleNotifySearchResults *results,
 340                                                                          PurpleNotifySearchColumn *column)
 341 {
 342         g_return_if_fail(results != NULL);
 343         g_return_if_fail(column  != NULL);
 344
 345         results->columns = g_list_append(results->columns, column);
 346 }
 347
 348 void purple_notify_searchresults_row_add(PurpleNotifySearchResults *results,
 349                                                                            GList *row)
 350 {
 351         g_return_if_fail(results != NULL);
 352         g_return_if_fail(row     != NULL);
 353
 354         results->rows = g_list_append(results->rows, row);
 355 }
 356
 357 PurpleNotifySearchColumn *
 358 purple_notify_searchresults_column_new(const char *title)
 359 {
 360         PurpleNotifySearchColumn *sc;
 361
 362         g_return_val_if_fail(title != NULL, NULL);
 363
 364         sc = g_new0(PurpleNotifySearchColumn, 1);
 365         sc->title = g_strdup(title);
 366
 367         return sc;
 368 }
 369
 370 guint
 371 purple_notify_searchresults_get_columns_count(PurpleNotifySearchResults *results)
 372 {
 373         g_return_val_if_fail(results != NULL, 0);
 374
 375         return g_list_length(results->columns);
 376 }
 377
 378 guint
 379 purple_notify_searchresults_get_rows_count(PurpleNotifySearchResults *results)
 380 {
 381         g_return_val_if_fail(results != NULL, 0);
 382
 383         return g_list_length(results->rows);
 384 }
 385
 386 char *
 387 purple_notify_searchresults_column_get_title(PurpleNotifySearchResults *results,
 388                                                                                    unsigned int column_id)
 389 {
 390         g_return_val_if_fail(results != NULL, NULL);
 391
 392         return ((PurpleNotifySearchColumn *)g_list_nth_data(results->columns, column_id))->title;
 393 }
 394
 395 GList *
 396 purple_notify_searchresults_row_get(PurpleNotifySearchResults *results,
 397                                                                   unsigned int row_id)
 398 {
 399         g_return_val_if_fail(results != NULL, NULL);
 400
 401         return g_list_nth_data(results->rows, row_id);
 402 }
 403
 404 void *
 405 purple_notify_userinfo(PurpleConnection *gc, const char *who,
 406                                                    PurpleNotifyUserInfo *user_info, PurpleNotifyCloseCallback cb, gpointer user_data)
 407 {
 408         PurpleNotifyUiOps *ops;
 409
 410         g_return_val_if_fail(who != NULL, NULL);
 411
 412         ops = purple_notify_get_ui_ops();
 413
 414         if (ops != NULL && ops->notify_userinfo != NULL) {
 415                 void *ui_handle;
 416
 417                 purple_signal_emit(purple_notify_get_handle(), "displaying-userinfo",
 418                                                  purple_connection_get_account(gc), who, user_info);
 419
 420                 ui_handle = ops->notify_userinfo(gc, who, user_info);
 421
 422                 if (ui_handle != NULL) {
 423
 424                         PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
 425                         info->type = PURPLE_NOTIFY_USERINFO;
 426                         info->handle = gc;
 427                         info->ui_handle = ui_handle;
 428                         info->cb = cb;
 429                         info->cb_user_data = user_data;
 430
 431                         handles = g_list_append(handles, info);
 432
 433                         return info->ui_handle;
 434                 }
 435         }
 436
 437         if (cb != NULL)
 438                 cb(user_data);
 439
 440         return NULL;
 441 }
 442
 443 PurpleNotifyUserInfoEntry *
 444 purple_notify_user_info_entry_new(const char *label, const char *value)
 445 {
 446         PurpleNotifyUserInfoEntry *user_info_entry;
 447
 448         user_info_entry = g_new0(PurpleNotifyUserInfoEntry, 1);
 449         PURPLE_DBUS_REGISTER_POINTER(user_info_entry, PurpleNotifyUserInfoEntry);
 450         user_info_entry->label = g_strdup(label);
 451         user_info_entry->value = g_strdup(value);
 452         user_info_entry->type = PURPLE_NOTIFY_USER_INFO_ENTRY_PAIR;
 453
 454         return user_info_entry;
 455 }
 456
 457 static void
 458 purple_notify_user_info_entry_destroy(PurpleNotifyUserInfoEntry *user_info_entry)
 459 {
 460         g_return_if_fail(user_info_entry != NULL);
 461
 462         g_free(user_info_entry->label);
 463         g_free(user_info_entry->value);
 464         PURPLE_DBUS_UNREGISTER_POINTER(user_info_entry);
 465         g_free(user_info_entry);
 466 }
 467
 468 PurpleNotifyUserInfo *
 469 purple_notify_user_info_new()
 470 {
 471         PurpleNotifyUserInfo *user_info;
 472
 473         user_info = g_new0(PurpleNotifyUserInfo, 1);
 474         PURPLE_DBUS_REGISTER_POINTER(user_info, PurpleNotifyUserInfo);
 475         user_info->user_info_entries = NULL;
 476
 477         return user_info;
 478 }
 479
 480 void
 481 purple_notify_user_info_destroy(PurpleNotifyUserInfo *user_info)
 482 {
 483         GList *l;
 484
 485         for (l = user_info->user_info_entries; l != NULL; l = l->next) {
 486                 PurpleNotifyUserInfoEntry *user_info_entry = l->data;
 487
 488                 purple_notify_user_info_entry_destroy(user_info_entry);
 489         }
 490
 491         g_list_free(user_info->user_info_entries);
 492         PURPLE_DBUS_UNREGISTER_POINTER(user_info);
 493         g_free(user_info);
 494 }
 495
 496 GList *
 497 purple_notify_user_info_get_entries(PurpleNotifyUserInfo *user_info)
 498 {
 499         g_return_val_if_fail(user_info != NULL, NULL);
 500
 501         return user_info->user_info_entries;
 502 }
 503
 504 char *
 505 purple_notify_user_info_get_text_with_newline(PurpleNotifyUserInfo *user_info, const char *newline)
 506 {
 507         GList *l;
 508         GString *text;
 509
 510         text = g_string_new("");
 511
 512         for (l = user_info->user_info_entries; l != NULL; l = l->next) {
 513                 PurpleNotifyUserInfoEntry *user_info_entry = l->data;
 514                 /* Add a newline before a section header */
 515                 if (user_info_entry->type == PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_HEADER)
 516                         g_string_append(text, newline);
 517
 518                 /* Handle the label/value pair itself */
 519                 /* XXX Todo: Use a larger size for a section header? */
 520                 if (user_info_entry->label)
 521                         g_string_append_printf(text, "<b>%s</b>", user_info_entry->label);
 522                 if (user_info_entry->label && user_info_entry->value)
 523                         g_string_append(text, ": ");
 524                 if (user_info_entry->value)
 525                         g_string_append(text, user_info_entry->value);
 526
 527                 /* Display a section break as a horizontal line */
 528                 if (user_info_entry->type == PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_BREAK)
 529                         g_string_append(text, "<HR>");
 530
 531                 /* Don't insert a new line before or after a section break; <HR> does that for us */
 532                 if ((user_info_entry->type != PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_BREAK) &&
 533                         (l->next && ((((PurpleNotifyUserInfoEntry *)(l->next->data))->type != PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_BREAK))))
 534                         g_string_append(text, newline);
 535
 536                 /* Add an extra newline after a section header */
 537                 if (user_info_entry->type == PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_HEADER)
 538                         g_string_append(text, newline);
 539         }
 540
 541         return g_string_free(text, FALSE);
 542 }
 543
 544
 545 const gchar *
 546 purple_notify_user_info_entry_get_label(PurpleNotifyUserInfoEntry *user_info_entry)
 547 {
 548         g_return_val_if_fail(user_info_entry != NULL, NULL);
 549
 550         return user_info_entry->label;
 551 }
 552
 553 void
 554 purple_notify_user_info_entry_set_label(PurpleNotifyUserInfoEntry *user_info_entry, const char *label)
 555 {
 556         g_return_if_fail(user_info_entry != NULL);
 557
 558         g_free(user_info_entry->label);
 559         user_info_entry->label = g_strdup(label);
 560 }
 561
 562 const gchar *
 563 purple_notify_user_info_entry_get_value(PurpleNotifyUserInfoEntry *user_info_entry)
 564 {
 565         g_return_val_if_fail(user_info_entry != NULL, NULL);
 566
 567         return user_info_entry->value;
 568 }
 569
 570 void
 571 purple_notify_user_info_entry_set_value(PurpleNotifyUserInfoEntry *user_info_entry, const char *value)
 572 {
 573         g_return_if_fail(user_info_entry != NULL);
 574
 575         g_free(user_info_entry->value);
 576         user_info_entry->value = g_strdup(value);
 577 }
 578
 579 PurpleNotifyUserInfoEntryType
 580 purple_notify_user_info_entry_get_type(PurpleNotifyUserInfoEntry *user_info_entry)
 581 {
 582         g_return_val_if_fail(user_info_entry != NULL, PURPLE_NOTIFY_USER_INFO_ENTRY_PAIR);
 583
 584         return user_info_entry->type;
 585 }
 586
 587 void
 588 purple_notify_user_info_entry_set_type(PurpleNotifyUserInfoEntry *user_info_entry, PurpleNotifyUserInfoEntryType type)
 589 {
 590         g_return_if_fail(user_info_entry != NULL);
 591
 592         user_info_entry->type = type;
 593 }
 594
 595 void
 596 purple_notify_user_info_add_pair(PurpleNotifyUserInfo *user_info, const char *label, const char *value)
 597 {
 598         PurpleNotifyUserInfoEntry *entry;
 599
 600         entry = purple_notify_user_info_entry_new(label, value);
 601         user_info->user_info_entries = g_list_append(user_info->user_info_entries, entry);
 602 }
 603
 604 void
 605 purple_notify_user_info_prepend_pair(PurpleNotifyUserInfo *user_info, const char *label, const char *value)
 606 {
 607         PurpleNotifyUserInfoEntry *entry;
 608
 609         entry = purple_notify_user_info_entry_new(label, value);
 610         user_info->user_info_entries = g_list_prepend(user_info->user_info_entries, entry);
 611 }
 612
 613 void
 614 purple_notify_user_info_remove_entry(PurpleNotifyUserInfo *user_info, PurpleNotifyUserInfoEntry *entry)
 615 {
 616         g_return_if_fail(user_info != NULL);
 617         g_return_if_fail(entry != NULL);
 618
 619         user_info->user_info_entries = g_list_remove(user_info->user_info_entries, entry);
 620 }
 621
 622 void
 623 purple_notify_user_info_add_section_header(PurpleNotifyUserInfo *user_info, const char *label)
 624 {
 625         PurpleNotifyUserInfoEntry *entry;
 626
 627         entry = purple_notify_user_info_entry_new(label, NULL);
 628         entry->type = PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_HEADER;
 629
 630         user_info->user_info_entries = g_list_append(user_info->user_info_entries, entry);
 631 }
 632
 633 void
 634 purple_notify_user_info_prepend_section_header(PurpleNotifyUserInfo *user_info, const char *label)
 635 {
 636         PurpleNotifyUserInfoEntry *entry;
 637
 638         entry = purple_notify_user_info_entry_new(label, NULL);
 639         entry->type = PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_HEADER;
 640
 641         user_info->user_info_entries = g_list_prepend(user_info->user_info_entries, entry);
 642 }
 643
 644 void
 645 purple_notify_user_info_add_section_break(PurpleNotifyUserInfo *user_info)
 646 {
 647         PurpleNotifyUserInfoEntry *entry;
 648
 649         entry = purple_notify_user_info_entry_new(NULL, NULL);
 650         entry->type = PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_BREAK;
 651
 652         user_info->user_info_entries = g_list_append(user_info->user_info_entries, entry);
 653 }
 654
 655 void
 656 purple_notify_user_info_prepend_section_break(PurpleNotifyUserInfo *user_info)
 657 {
 658         PurpleNotifyUserInfoEntry *entry;
 659
 660         entry = purple_notify_user_info_entry_new(NULL, NULL);
 661         entry->type = PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_BREAK;
 662
 663         user_info->user_info_entries = g_list_prepend(user_info->user_info_entries, entry);
 664 }
 665
 666 void
 667 purple_notify_user_info_remove_last_item(PurpleNotifyUserInfo *user_info)
 668 {
 669         GList *last = g_list_last(user_info->user_info_entries);
 670         if (last) {
 671                 purple_notify_user_info_entry_destroy(last->data);
 672                 user_info->user_info_entries = g_list_delete_link(user_info->user_info_entries, last);
 673         }
 674 }
 675
 676 void *
 677 purple_notify_uri(void *handle, const char *uri)
 678 {
 679         PurpleNotifyUiOps *ops;
 680
 681         g_return_val_if_fail(uri != NULL, NULL);
 682
 683         ops = purple_notify_get_ui_ops();
 684
 685         if (ops != NULL && ops->notify_uri != NULL) {
 686
 687                 void *ui_handle = ops->notify_uri(uri);
 688
 689                 if (ui_handle != NULL) {
 690
 691                         PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
 692                         info->type = PURPLE_NOTIFY_URI;
 693                         info->handle = handle;
 694                         info->ui_handle = ui_handle;
 695
 696                         handles = g_list_append(handles, info);
 697
 698                         return info->ui_handle;
 699                 }
 700         }
 701
 702         return NULL;
 703 }
 704
 705 void
 706 purple_notify_close(PurpleNotifyType type, void *ui_handle)
 707 {
 708         GList *l;
 709         PurpleNotifyUiOps *ops;
 710
 711         g_return_if_fail(ui_handle != NULL);
 712
 713         ops = purple_notify_get_ui_ops();
 714
 715         for (l = handles; l != NULL; l = l->next) {
 716                 PurpleNotifyInfo *info = l->data;
 717
 718                 if (info->ui_handle == ui_handle) {
 719                         handles = g_list_remove(handles, info);
 720
 721                         if (ops != NULL && ops->close_notify != NULL)
 722                                 ops->close_notify(info->type, ui_handle);
 723
 724                         if (info->cb != NULL)
 725                                 info->cb(info->cb_user_data);
 726
 727                         g_free(info);
 728
 729                         break;
 730                 }
 731         }
 732 }
 733
 734 void
 735 purple_notify_close_with_handle(void *handle)
 736 {
 737         GList *l, *prev = NULL;
 738         PurpleNotifyUiOps *ops;
 739
 740         g_return_if_fail(handle != NULL);
 741
 742         ops = purple_notify_get_ui_ops();
 743
 744         for (l = handles; l != NULL; l = prev ? prev->next : handles) {
 745                 PurpleNotifyInfo *info = l->data;
 746
 747                 if (info->handle == handle) {
 748                         handles = g_list_remove(handles, info);
 749
 750                         if (ops != NULL && ops->close_notify != NULL)
 751                                 ops->close_notify(info->type, info->ui_handle);
 752
 753                         if (info->cb != NULL)
 754                                 info->cb(info->cb_user_data);
 755
 756                         g_free(info);
 757                 } else
 758                         prev = l;
 759         }
 760 }
 761
 762 void
 763 purple_notify_set_ui_ops(PurpleNotifyUiOps *ops)
 764 {
 765         notify_ui_ops = ops;
 766 }
 767
 768 PurpleNotifyUiOps *
 769 purple_notify_get_ui_ops(void)
 770 {
 771         return notify_ui_ops;
 772 }
 773
 774 void *
 775 purple_notify_get_handle(void)
 776 {
 777         static int handle;
 778
 779         return &handle;
 780 }
 781
 782 void
 783 purple_notify_init(void)
 784 {
 785         gpointer handle = purple_notify_get_handle();
 786
 787         purple_signal_register(handle, "displaying-email-notification",
 788                                                  purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER, NULL, 4,
 789                                                  purple_value_new(PURPLE_TYPE_STRING),
 790                                                  purple_value_new(PURPLE_TYPE_STRING),
 791                                                  purple_value_new(PURPLE_TYPE_STRING),
 792                                                  purple_value_new(PURPLE_TYPE_STRING));
 793
 794         purple_signal_register(handle, "displaying-emails-notification",
 795                                                  purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER_UINT, NULL, 5,
 796                                                  purple_value_new(PURPLE_TYPE_POINTER),
 797                                                  purple_value_new(PURPLE_TYPE_POINTER),
 798                                                  purple_value_new(PURPLE_TYPE_POINTER),
 799                                                  purple_value_new(PURPLE_TYPE_POINTER),
 800                                                  purple_value_new(PURPLE_TYPE_UINT));
 801
 802         purple_signal_register(handle, "displaying-userinfo",
 803                                                  purple_marshal_VOID__POINTER_POINTER_POINTER, NULL, 3,
 804                                                  purple_value_new(PURPLE_TYPE_SUBTYPE,
 805                                                                                 PURPLE_SUBTYPE_ACCOUNT),
 806                                                  purple_value_new(PURPLE_TYPE_STRING),
 807                                                  purple_value_new(PURPLE_TYPE_SUBTYPE,
 808                                                                                 PURPLE_SUBTYPE_USERINFO));
 809 }
 810
 811 void
 812 purple_notify_uninit(void)
 813 {
 814         purple_signals_unregister_by_instance(purple_notify_get_handle());
 815 }