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