libpurple/notify.c

   1 /* purple
   2  *
   3  * Purple is the legal property of its developers, whose names are too numerous
   4  * to list here.  Please refer to the COPYRIGHT file distributed with this
   5  * source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  20  */
  21 #define _PURPLE_NOTIFY_C_
  22
  23 #include "internal.h"
  24 #include "dbus-maybe.h"
  25 #include "notify.h"
  26
  27 static PurpleNotifyUiOps *notify_ui_ops = NULL;
  28 static GList *handles = NULL;
  29
  30 typedef struct
  31 {
  32         PurpleNotifyType type;
  33         void *handle;
  34         void *ui_handle;
  35         PurpleNotifyCloseCallback cb;
  36         gpointer cb_user_data;
  37 } PurpleNotifyInfo;
  38
  39 /*
  40  * Definition of a user info entry
  41  */
  42 struct _PurpleNotifyUserInfoEntry
  43 {
  44         char *label;
  45         char *value;
  46         PurpleNotifyUserInfoEntryType type;
  47 };
  48
  49 struct _PurpleNotifyUserInfo
  50 {
  51         GQueue entries;
  52 };
  53
  54 /*
  55  * Single column of a search result.
  56  */
  57 struct _PurpleNotifySearchColumn
  58 {
  59         char *title;           /* Title of the column. */
  60         gboolean visible;      /* Should the column be visible to the user. Defaults to TRUE. */
  61
  62 };
  63
  64 void *
  65 purple_notify_message(void *handle, PurpleNotifyMessageType type, const char *title,
  66         const char *primary, const char *secondary,
  67         PurpleRequestCommonParameters *cpar, PurpleNotifyCloseCallback cb,
  68         gpointer user_data)
  69 {
  70         PurpleNotifyUiOps *ops;
  71
  72         g_return_val_if_fail(primary != NULL, NULL);
  73
  74         ops = purple_notify_get_ui_ops();
  75
  76         if (ops != NULL && ops->notify_message != NULL) {
  77                 void *ui_handle = ops->notify_message(type, title, primary,
  78                         secondary, cpar);
  79                 if (ui_handle != NULL) {
  80
  81                         PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
  82                         info->type = PURPLE_NOTIFY_MESSAGE;
  83                         info->handle = handle;
  84                         info->ui_handle = ui_handle;
  85                         info->cb = cb;
  86                         info->cb_user_data = user_data;
  87
  88                         handles = g_list_append(handles, info);
  89
  90                         return info->ui_handle;
  91                 }
  92
  93         }
  94
  95         if (cb != NULL)
  96                 cb(user_data);
  97
  98         return NULL;
  99 }
 100
 101 void *
 102 purple_notify_email(void *handle, const char *subject, const char *from,
 103                                   const char *to, const char *url, PurpleNotifyCloseCallback cb,
 104                                   gpointer user_data)
 105 {
 106         PurpleNotifyUiOps *ops;
 107
 108         ops = purple_notify_get_ui_ops();
 109
 110         if (ops != NULL && ops->notify_email != NULL) {
 111                 void *ui_handle;
 112
 113                 purple_signal_emit(purple_notify_get_handle(), "displaying-email-notification",
 114                                                    subject, from, to, url);
 115
 116                 ui_handle = ops->notify_email(handle, subject, from, to, url);
 117
 118                 if (ui_handle != NULL) {
 119
 120                         PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
 121                         info->type = PURPLE_NOTIFY_EMAIL;
 122                         info->handle = handle;
 123                         info->ui_handle = ui_handle;
 124                         info->cb = cb;
 125                         info->cb_user_data = user_data;
 126
 127                         handles = g_list_append(handles, info);
 128
 129                         return info->ui_handle;
 130                 }
 131         }
 132
 133         if (cb != NULL)
 134                 cb(user_data);
 135
 136         return NULL;
 137 }
 138
 139 void *
 140 purple_notify_emails(void *handle, size_t count, gboolean detailed,
 141                                    const char **subjects, const char **froms,
 142                                    const char **tos, const char **urls,
 143                                    PurpleNotifyCloseCallback cb, gpointer user_data)
 144 {
 145         PurpleNotifyUiOps *ops;
 146
 147         if (count == 1) {
 148                 return purple_notify_email(handle,
 149                                                                  (subjects == NULL ? NULL : *subjects),
 150                                                                  (froms    == NULL ? NULL : *froms),
 151                                                                  (tos      == NULL ? NULL : *tos),
 152                                                                  (urls     == NULL ? NULL : *urls),
 153                                                                  cb, user_data);
 154         }
 155
 156         ops = purple_notify_get_ui_ops();
 157
 158         if (ops != NULL && ops->notify_emails != NULL) {
 159                 void *ui_handle;
 160
 161                 purple_signal_emit(purple_notify_get_handle(), "displaying-emails-notification",
 162                                                         subjects, froms, tos, urls, count);
 163
 164                 ui_handle = ops->notify_emails(handle, count, detailed, subjects,
 165                                                                                          froms, tos, urls);
 166
 167                 if (ui_handle != NULL) {
 168                         PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
 169                         info->type = PURPLE_NOTIFY_EMAILS;
 170                         info->handle = handle;
 171                         info->ui_handle = ui_handle;
 172                         info->cb = cb;
 173                         info->cb_user_data = user_data;
 174
 175                         handles = g_list_append(handles, info);
 176
 177                         return info->ui_handle;
 178                 }
 179
 180         }
 181
 182         if (cb != NULL)
 183                 cb(user_data);
 184
 185         return NULL;
 186 }
 187
 188 void *
 189 purple_notify_formatted(void *handle, const char *title, const char *primary,
 190                                           const char *secondary, const char *text,
 191                                           PurpleNotifyCloseCallback cb, gpointer user_data)
 192 {
 193         PurpleNotifyUiOps *ops;
 194
 195         g_return_val_if_fail(primary != NULL, NULL);
 196
 197         ops = purple_notify_get_ui_ops();
 198
 199         if (ops != NULL && ops->notify_formatted != NULL) {
 200                 void *ui_handle = ops->notify_formatted(title, primary, secondary, text);
 201
 202                 if (ui_handle != NULL) {
 203
 204                         PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
 205                         info->type = PURPLE_NOTIFY_FORMATTED;
 206                         info->handle = handle;
 207                         info->ui_handle = ui_handle;
 208                         info->cb = cb;
 209                         info->cb_user_data = user_data;
 210
 211                         handles = g_list_append(handles, info);
 212
 213                         return info->ui_handle;
 214                 }
 215         }
 216
 217         if (cb != NULL)
 218                 cb(user_data);
 219         return NULL;
 220 }
 221
 222 void *
 223 purple_notify_searchresults(PurpleConnection *gc, const char *title,
 224                                                   const char *primary, const char *secondary,
 225                                                   PurpleNotifySearchResults *results, PurpleNotifyCloseCallback cb,
 226                                                   gpointer user_data)
 227 {
 228         PurpleNotifyUiOps *ops;
 229
 230         ops = purple_notify_get_ui_ops();
 231
 232         if (ops != NULL && ops->notify_searchresults != NULL) {
 233                 void *ui_handle = ops->notify_searchresults(gc, title, primary,
 234                                                                                                         secondary, results, user_data);
 235                 if (ui_handle != NULL) {
 236
 237                         PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
 238                         info->type      = PURPLE_NOTIFY_SEARCHRESULTS;
 239                         info->handle    = gc;
 240                         info->ui_handle = ui_handle;
 241                         info->cb = cb;
 242                         info->cb_user_data = user_data;
 243
 244                         handles = g_list_append(handles, info);
 245
 246                         return info->ui_handle;
 247                 }
 248         }
 249
 250         if (cb != NULL)
 251                 cb(user_data);
 252
 253         return NULL;
 254 }
 255
 256 void
 257 purple_notify_searchresults_free(PurpleNotifySearchResults *results)
 258 {
 259         GList *l;
 260
 261         g_return_if_fail(results != NULL);
 262
 263         for (l = results->buttons; l; l = g_list_delete_link(l, l)) {
 264                 PurpleNotifySearchButton *button = l->data;
 265                 g_free(button->label);
 266                 g_free(button);
 267         }
 268
 269         for (l = results->rows; l; l = g_list_delete_link(l, l)) {
 270                 GList *row = l->data;
 271                 g_list_foreach(row, (GFunc)g_free, NULL);
 272                 g_list_free(row);
 273         }
 274
 275         for (l = results->columns; l; l = g_list_delete_link(l, l)) {
 276                 PurpleNotifySearchColumn *column = l->data;
 277                 g_free(column->title);
 278                 g_free(column);
 279         }
 280
 281         g_free(results);
 282 }
 283
 284 void
 285 purple_notify_searchresults_new_rows(PurpleConnection *gc,
 286                 PurpleNotifySearchResults *results,
 287                 void *data)
 288 {
 289         PurpleNotifyUiOps *ops;
 290
 291         ops = purple_notify_get_ui_ops();
 292
 293         if (ops != NULL && ops->notify_searchresults != NULL) {
 294                 ops->notify_searchresults_new_rows(gc, results, data);
 295         }
 296 }
 297
 298 void
 299 purple_notify_searchresults_button_add(PurpleNotifySearchResults *results,
 300                                                                          PurpleNotifySearchButtonType type,
 301                                                                          PurpleNotifySearchResultsCallback cb)
 302 {
 303         PurpleNotifySearchButton *button;
 304
 305         g_return_if_fail(results != NULL);
 306         g_return_if_fail(cb != NULL);
 307
 308         button = g_new0(PurpleNotifySearchButton, 1);
 309         button->callback = cb;
 310         button->type = type;
 311
 312         results->buttons = g_list_append(results->buttons, button);
 313 }
 314
 315
 316 void
 317 purple_notify_searchresults_button_add_labeled(PurpleNotifySearchResults *results,
 318                                              const char *label,
 319                                              PurpleNotifySearchResultsCallback cb) {
 320         PurpleNotifySearchButton *button;
 321
 322         g_return_if_fail(results != NULL);
 323         g_return_if_fail(cb != NULL);
 324         g_return_if_fail(label != NULL);
 325         g_return_if_fail(*label != '\0');
 326
 327         button = g_new0(PurpleNotifySearchButton, 1);
 328         button->callback = cb;
 329         button->type = PURPLE_NOTIFY_BUTTON_LABELED;
 330         button->label = g_strdup(label);
 331
 332         results->buttons = g_list_append(results->buttons, button);
 333 }
 334
 335
 336 PurpleNotifySearchResults *
 337 purple_notify_searchresults_new()
 338 {
 339         PurpleNotifySearchResults *rs = g_new0(PurpleNotifySearchResults, 1);
 340
 341         return rs;
 342 }
 343
 344 void
 345 purple_notify_searchresults_column_add(PurpleNotifySearchResults *results,
 346                                                                          PurpleNotifySearchColumn *column)
 347 {
 348         g_return_if_fail(results != NULL);
 349         g_return_if_fail(column  != NULL);
 350
 351         results->columns = g_list_append(results->columns, column);
 352 }
 353
 354 void purple_notify_searchresults_row_add(PurpleNotifySearchResults *results,
 355                                                                            GList *row)
 356 {
 357         g_return_if_fail(results != NULL);
 358         g_return_if_fail(row     != NULL);
 359
 360         results->rows = g_list_append(results->rows, row);
 361 }
 362
 363 PurpleNotifySearchColumn *
 364 purple_notify_searchresults_column_new(const char *title)
 365 {
 366         PurpleNotifySearchColumn *sc;
 367
 368         g_return_val_if_fail(title != NULL, NULL);
 369
 370         sc = g_new0(PurpleNotifySearchColumn, 1);
 371         sc->title = g_strdup(title);
 372         sc->visible = TRUE;
 373
 374         return sc;
 375 }
 376
 377 const char *purple_notify_searchresult_column_get_title(const PurpleNotifySearchColumn *column)
 378 {
 379         g_return_val_if_fail(column != NULL, NULL);
 380
 381         return column->title;
 382 }
 383
 384 void purple_notify_searchresult_column_set_visible(PurpleNotifySearchColumn *column, gboolean visible)
 385 {
 386         g_return_if_fail(column != NULL);
 387
 388         column->visible = visible;
 389 }
 390
 391 gboolean
 392 purple_notify_searchresult_column_is_visible(const PurpleNotifySearchColumn *column)
 393 {
 394         g_return_val_if_fail(column != NULL, FALSE);
 395
 396         return column->visible;
 397 }
 398
 399 void *
 400 purple_notify_userinfo(PurpleConnection *gc, const char *who,
 401                                                    PurpleNotifyUserInfo *user_info, PurpleNotifyCloseCallback cb, gpointer user_data)
 402 {
 403         PurpleNotifyUiOps *ops;
 404
 405         g_return_val_if_fail(who != NULL, NULL);
 406
 407         ops = purple_notify_get_ui_ops();
 408
 409         if (ops != NULL && ops->notify_userinfo != NULL) {
 410                 void *ui_handle;
 411
 412                 purple_signal_emit(purple_notify_get_handle(), "displaying-userinfo",
 413                                                  purple_connection_get_account(gc), who, user_info);
 414
 415                 ui_handle = ops->notify_userinfo(gc, who, user_info);
 416
 417                 if (ui_handle != NULL) {
 418
 419                         PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
 420                         info->type = PURPLE_NOTIFY_USERINFO;
 421                         info->handle = gc;
 422                         info->ui_handle = ui_handle;
 423                         info->cb = cb;
 424                         info->cb_user_data = user_data;
 425
 426                         handles = g_list_append(handles, info);
 427
 428                         return info->ui_handle;
 429                 }
 430         }
 431
 432         if (cb != NULL)
 433                 cb(user_data);
 434
 435         return NULL;
 436 }
 437
 438 PurpleNotifyUserInfoEntry *
 439 purple_notify_user_info_entry_new(const char *label, const char *value)
 440 {
 441         PurpleNotifyUserInfoEntry *user_info_entry;
 442
 443         user_info_entry = g_new0(PurpleNotifyUserInfoEntry, 1);
 444         PURPLE_DBUS_REGISTER_POINTER(user_info_entry, PurpleNotifyUserInfoEntry);
 445         user_info_entry->label = g_strdup(label);
 446         user_info_entry->value = g_strdup(value);
 447         user_info_entry->type = PURPLE_NOTIFY_USER_INFO_ENTRY_PAIR;
 448
 449         return user_info_entry;
 450 }
 451
 452 void
 453 purple_notify_user_info_entry_destroy(PurpleNotifyUserInfoEntry *user_info_entry)
 454 {
 455         g_return_if_fail(user_info_entry != NULL);
 456
 457         g_free(user_info_entry->label);
 458         g_free(user_info_entry->value);
 459         PURPLE_DBUS_UNREGISTER_POINTER(user_info_entry);
 460         g_free(user_info_entry);
 461 }
 462
 463 PurpleNotifyUserInfo *
 464 purple_notify_user_info_new()
 465 {
 466         PurpleNotifyUserInfo *user_info;
 467
 468         user_info = g_new0(PurpleNotifyUserInfo, 1);
 469         PURPLE_DBUS_REGISTER_POINTER(user_info, PurpleNotifyUserInfo);
 470         g_queue_init(&user_info->entries);
 471
 472         return user_info;
 473 }
 474
 475 void
 476 purple_notify_user_info_destroy(PurpleNotifyUserInfo *user_info)
 477 {
 478         GList *l;
 479
 480         for (l = user_info->entries.head; l != NULL; l = l->next) {
 481                 PurpleNotifyUserInfoEntry *user_info_entry = l->data;
 482
 483                 purple_notify_user_info_entry_destroy(user_info_entry);
 484         }
 485
 486         g_queue_clear(&user_info->entries);
 487         PURPLE_DBUS_UNREGISTER_POINTER(user_info);
 488         g_free(user_info);
 489 }
 490
 491 GQueue *
 492 purple_notify_user_info_get_entries(PurpleNotifyUserInfo *user_info)
 493 {
 494         g_return_val_if_fail(user_info != NULL, NULL);
 495
 496         return &user_info->entries;
 497 }
 498
 499 char *
 500 purple_notify_user_info_get_text_with_newline(PurpleNotifyUserInfo *user_info, const char *newline)
 501 {
 502         GList *l;
 503         GString *text;
 504
 505         text = g_string_new("");
 506
 507         for (l = user_info->entries.head; l != NULL; l = l->next) {
 508                 PurpleNotifyUserInfoEntry *user_info_entry = l->data;
 509                 /* Add a newline before a section header */
 510                 if (user_info_entry->type == PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_HEADER)
 511                         g_string_append(text, newline);
 512
 513                 /* Handle the label/value pair itself */
 514                 /* XXX Todo: Use a larger size for a section header? */
 515                 if (user_info_entry->label)
 516                         g_string_append_printf(text, "<b>%s</b>", user_info_entry->label);
 517                 if (user_info_entry->label && user_info_entry->value)
 518                         g_string_append(text, ": ");
 519                 if (user_info_entry->value)
 520                         g_string_append(text, user_info_entry->value);
 521
 522                 /* Display a section break as a horizontal line */
 523                 if (user_info_entry->type == PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_BREAK)
 524                         g_string_append(text, "<HR>");
 525
 526                 /* Don't insert a new line before or after a section break; <HR> does that for us */
 527                 if ((user_info_entry->type != PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_BREAK) &&
 528                         (l->next && ((((PurpleNotifyUserInfoEntry *)(l->next->data))->type != PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_BREAK))))
 529                         g_string_append(text, newline);
 530
 531                 /* Add an extra newline after a section header */
 532                 if (user_info_entry->type == PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_HEADER)
 533                         g_string_append(text, newline);
 534         }
 535
 536         return g_string_free(text, FALSE);
 537 }
 538
 539
 540 const gchar *
 541 purple_notify_user_info_entry_get_label(PurpleNotifyUserInfoEntry *user_info_entry)
 542 {
 543         g_return_val_if_fail(user_info_entry != NULL, NULL);
 544
 545         return user_info_entry->label;
 546 }
 547
 548 void
 549 purple_notify_user_info_entry_set_label(PurpleNotifyUserInfoEntry *user_info_entry, const char *label)
 550 {
 551         g_return_if_fail(user_info_entry != NULL);
 552
 553         g_free(user_info_entry->label);
 554         user_info_entry->label = g_strdup(label);
 555 }
 556
 557 const gchar *
 558 purple_notify_user_info_entry_get_value(PurpleNotifyUserInfoEntry *user_info_entry)
 559 {
 560         g_return_val_if_fail(user_info_entry != NULL, NULL);
 561
 562         return user_info_entry->value;
 563 }
 564
 565 void
 566 purple_notify_user_info_entry_set_value(PurpleNotifyUserInfoEntry *user_info_entry, const char *value)
 567 {
 568         g_return_if_fail(user_info_entry != NULL);
 569
 570         g_free(user_info_entry->value);
 571         user_info_entry->value = g_strdup(value);
 572 }
 573
 574 PurpleNotifyUserInfoEntryType
 575 purple_notify_user_info_entry_get_entry_type(PurpleNotifyUserInfoEntry *user_info_entry)
 576 {
 577         g_return_val_if_fail(user_info_entry != NULL, PURPLE_NOTIFY_USER_INFO_ENTRY_PAIR);
 578
 579         return user_info_entry->type;
 580 }
 581
 582 void
 583 purple_notify_user_info_entry_set_entry_type(PurpleNotifyUserInfoEntry *user_info_entry,
 584                 PurpleNotifyUserInfoEntryType type)
 585 {
 586         g_return_if_fail(user_info_entry != NULL);
 587
 588         user_info_entry->type = type;
 589 }
 590
 591 void
 592 purple_notify_user_info_add_pair_html(PurpleNotifyUserInfo *user_info, const char *label, const char *value)
 593 {
 594         PurpleNotifyUserInfoEntry *entry;
 595
 596         entry = purple_notify_user_info_entry_new(label, value);
 597         g_queue_push_tail(&user_info->entries, entry);
 598 }
 599
 600 void
 601 purple_notify_user_info_add_pair_plaintext(PurpleNotifyUserInfo *user_info, const char *label, const char *value)
 602 {
 603         gchar *escaped;
 604
 605         escaped = g_markup_escape_text(value, -1);
 606         purple_notify_user_info_add_pair_html(user_info, label, escaped);
 607         g_free(escaped);
 608 }
 609
 610 void
 611 purple_notify_user_info_prepend_pair_html(PurpleNotifyUserInfo *user_info, const char *label, const char *value)
 612 {
 613         PurpleNotifyUserInfoEntry *entry;
 614
 615         entry = purple_notify_user_info_entry_new(label, value);
 616         g_queue_push_head(&user_info->entries, entry);
 617 }
 618
 619 void
 620 purple_notify_user_info_prepend_pair_plaintext(PurpleNotifyUserInfo *user_info, const char *label, const char *value)
 621 {
 622         gchar *escaped;
 623
 624         escaped = g_markup_escape_text(value, -1);
 625         purple_notify_user_info_prepend_pair_html(user_info, label, escaped);
 626         g_free(escaped);
 627 }
 628
 629 void
 630 purple_notify_user_info_remove_entry(PurpleNotifyUserInfo *user_info, PurpleNotifyUserInfoEntry *entry)
 631 {
 632         g_return_if_fail(user_info != NULL);
 633         g_return_if_fail(entry != NULL);
 634
 635         g_queue_remove(&user_info->entries, entry);
 636 }
 637
 638 void
 639 purple_notify_user_info_add_section_header(PurpleNotifyUserInfo *user_info, const char *label)
 640 {
 641         PurpleNotifyUserInfoEntry *entry;
 642
 643         entry = purple_notify_user_info_entry_new(label, NULL);
 644         entry->type = PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_HEADER;
 645
 646         g_queue_push_tail(&user_info->entries, entry);
 647 }
 648
 649 void
 650 purple_notify_user_info_prepend_section_header(PurpleNotifyUserInfo *user_info, const char *label)
 651 {
 652         PurpleNotifyUserInfoEntry *entry;
 653
 654         entry = purple_notify_user_info_entry_new(label, NULL);
 655         entry->type = PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_HEADER;
 656
 657         g_queue_push_head(&user_info->entries, entry);
 658 }
 659
 660 void
 661 purple_notify_user_info_add_section_break(PurpleNotifyUserInfo *user_info)
 662 {
 663         PurpleNotifyUserInfoEntry *entry;
 664
 665         entry = purple_notify_user_info_entry_new(NULL, NULL);
 666         entry->type = PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_BREAK;
 667
 668         g_queue_push_tail(&user_info->entries, entry);
 669 }
 670
 671 void
 672 purple_notify_user_info_prepend_section_break(PurpleNotifyUserInfo *user_info)
 673 {
 674         PurpleNotifyUserInfoEntry *entry;
 675
 676         entry = purple_notify_user_info_entry_new(NULL, NULL);
 677         entry->type = PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_BREAK;
 678
 679         g_queue_push_head(&user_info->entries, entry);
 680 }
 681
 682 void
 683 purple_notify_user_info_remove_last_item(PurpleNotifyUserInfo *user_info)
 684 {
 685         PurpleNotifyUserInfoEntry *entry;
 686
 687         entry = g_queue_pop_tail(&user_info->entries);
 688         if (entry)
 689                 purple_notify_user_info_entry_destroy(entry);
 690 }
 691
 692 static PurpleNotifyUserInfo *
 693 purple_notify_user_info_copy(PurpleNotifyUserInfo *user_info)
 694 {
 695         PurpleNotifyUserInfo *user_info_copy;
 696         GList *l;
 697
 698         g_return_val_if_fail(user_info != NULL, NULL);
 699
 700         user_info_copy = purple_notify_user_info_new();
 701
 702         for (l = user_info->entries.head; l != NULL; l = l->next) {
 703                 PurpleNotifyUserInfoEntry *new_entry, *user_info_entry = l->data;
 704
 705                 new_entry = purple_notify_user_info_entry_new(user_info_entry->label,
 706                                 user_info_entry->value);
 707                 new_entry->type = user_info_entry->type;
 708                 g_queue_push_tail(&user_info_copy->entries, new_entry);
 709         }
 710
 711         return user_info_copy;
 712 }
 713
 714 GType
 715 purple_notify_user_info_get_type(void)
 716 {
 717         static GType type = 0;
 718
 719         if (type == 0) {
 720                 type = g_boxed_type_register_static("PurpleNotifyUserInfo",
 721                                 (GBoxedCopyFunc)purple_notify_user_info_copy,
 722                                 (GBoxedFreeFunc)purple_notify_user_info_destroy);
 723         }
 724
 725         return type;
 726 }
 727
 728 void *
 729 purple_notify_uri(void *handle, const char *uri)
 730 {
 731         PurpleNotifyUiOps *ops;
 732
 733         g_return_val_if_fail(uri != NULL, NULL);
 734
 735         ops = purple_notify_get_ui_ops();
 736
 737         if (ops != NULL && ops->notify_uri != NULL) {
 738
 739                 void *ui_handle = ops->notify_uri(uri);
 740
 741                 if (ui_handle != NULL) {
 742
 743                         PurpleNotifyInfo *info = g_new0(PurpleNotifyInfo, 1);
 744                         info->type = PURPLE_NOTIFY_URI;
 745                         info->handle = handle;
 746                         info->ui_handle = ui_handle;
 747
 748                         handles = g_list_append(handles, info);
 749
 750                         return info->ui_handle;
 751                 }
 752         }
 753
 754         return NULL;
 755 }
 756
 757 gboolean
 758 purple_notify_is_valid_ui_handle(void *ui_handle, PurpleNotifyType *type)
 759 {
 760         GList *it;
 761
 762         if (ui_handle == NULL)
 763                 return FALSE;
 764
 765         for (it = handles; it != NULL; it = g_list_next(it)) {
 766                 PurpleNotifyInfo *info = it->data;
 767
 768                 if (info->ui_handle != ui_handle)
 769                         continue;
 770
 771                 if (type != NULL)
 772                         *type = info->type;
 773                 return TRUE;
 774         }
 775
 776         return FALSE;
 777 }
 778
 779 void
 780 purple_notify_close(PurpleNotifyType type, void *ui_handle)
 781 {
 782         GList *l;
 783         PurpleNotifyUiOps *ops;
 784
 785         g_return_if_fail(ui_handle != NULL);
 786
 787         ops = purple_notify_get_ui_ops();
 788
 789         for (l = handles; l != NULL; l = l->next) {
 790                 PurpleNotifyInfo *info = l->data;
 791
 792                 if (info->ui_handle == ui_handle) {
 793                         handles = g_list_remove(handles, info);
 794
 795                         if (ops != NULL && ops->close_notify != NULL)
 796                                 ops->close_notify(info->type, ui_handle);
 797
 798                         if (info->cb != NULL)
 799                                 info->cb(info->cb_user_data);
 800
 801                         g_free(info);
 802
 803                         break;
 804                 }
 805         }
 806 }
 807
 808 void
 809 purple_notify_close_with_handle(void *handle)
 810 {
 811         GList *l, *prev = NULL;
 812         PurpleNotifyUiOps *ops;
 813
 814         g_return_if_fail(handle != NULL);
 815
 816         ops = purple_notify_get_ui_ops();
 817
 818         for (l = handles; l != NULL; l = prev ? prev->next : handles) {
 819                 PurpleNotifyInfo *info = l->data;
 820
 821                 if (info->handle == handle) {
 822                         handles = g_list_remove(handles, info);
 823
 824                         if (ops != NULL && ops->close_notify != NULL)
 825                                 ops->close_notify(info->type, info->ui_handle);
 826
 827                         if (info->cb != NULL)
 828                                 info->cb(info->cb_user_data);
 829
 830                         g_free(info);
 831                 } else
 832                         prev = l;
 833         }
 834 }
 835
 836 static PurpleNotifyUiOps *
 837 purple_notify_ui_ops_copy(PurpleNotifyUiOps *ops)
 838 {
 839         PurpleNotifyUiOps *ops_new;
 840
 841         g_return_val_if_fail(ops != NULL, NULL);
 842
 843         ops_new = g_new(PurpleNotifyUiOps, 1);
 844         *ops_new = *ops;
 845
 846         return ops_new;
 847 }
 848
 849 GType
 850 purple_notify_ui_ops_get_type(void)
 851 {
 852         static GType type = 0;
 853
 854         if (type == 0) {
 855                 type = g_boxed_type_register_static("PurpleNotifyUiOps",
 856                                 (GBoxedCopyFunc)purple_notify_ui_ops_copy,
 857                                 (GBoxedFreeFunc)g_free);
 858         }
 859
 860         return type;
 861 }
 862
 863 static PurpleNotifySearchButton *
 864 purple_notify_search_button_copy(PurpleNotifySearchButton *button)
 865 {
 866         PurpleNotifySearchButton *button_new;
 867
 868         g_return_val_if_fail(button != NULL, NULL);
 869
 870         button_new = g_new(PurpleNotifySearchButton, 1);
 871         *button_new = *button;
 872
 873         return button_new;
 874 }
 875
 876 GType
 877 purple_notify_search_button_get_type(void)
 878 {
 879         static GType type = 0;
 880
 881         if (type == 0) {
 882                 type = g_boxed_type_register_static("PurpleNotifySearchButton",
 883                                 (GBoxedCopyFunc)purple_notify_search_button_copy,
 884                                 (GBoxedFreeFunc)g_free);
 885         }
 886
 887         return type;
 888 }
 889
 890 void
 891 purple_notify_set_ui_ops(PurpleNotifyUiOps *ops)
 892 {
 893         notify_ui_ops = ops;
 894 }
 895
 896 PurpleNotifyUiOps *
 897 purple_notify_get_ui_ops(void)
 898 {
 899         return notify_ui_ops;
 900 }
 901
 902 void *
 903 purple_notify_get_handle(void)
 904 {
 905         static int handle;
 906
 907         return &handle;
 908 }
 909
 910 void
 911 purple_notify_init(void)
 912 {
 913         gpointer handle = purple_notify_get_handle();
 914
 915         purple_signal_register(handle, "displaying-email-notification",
 916                                                  purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER,
 917                                                  G_TYPE_NONE, 4, G_TYPE_STRING, G_TYPE_STRING,
 918                                                  G_TYPE_STRING, G_TYPE_STRING);
 919
 920         purple_signal_register(handle, "displaying-emails-notification",
 921                                                  purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER_UINT,
 922                                                  G_TYPE_NONE, 5, G_TYPE_POINTER, G_TYPE_POINTER,
 923                                                  G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_UINT);
 924
 925         purple_signal_register(handle, "displaying-emails-clear",
 926                                                  purple_marshal_VOID, G_TYPE_NONE, 0);
 927
 928         purple_signal_register(handle, "displaying-userinfo",
 929                                                  purple_marshal_VOID__POINTER_POINTER_POINTER,
 930                                                  G_TYPE_NONE, 3, PURPLE_TYPE_ACCOUNT, G_TYPE_STRING,
 931                                                  PURPLE_TYPE_NOTIFY_USER_INFO);
 932 }
 933
 934 void
 935 purple_notify_uninit(void)
 936 {
 937         purple_signals_unregister_by_instance(purple_notify_get_handle());
 938 }