libpurple/request.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
  24 #include "glibcompat.h"
  25 #include "notify.h"
  26 #include "request.h"
  27 #include "debug.h"
  28
  29 static PurpleRequestUiOps *request_ui_ops = NULL;
  30 static GList *handles = NULL;
  31
  32 typedef struct
  33 {
  34         GDestroyNotify cb;
  35         gpointer data;
  36 } PurpleRequestCloseNotified;
  37
  38 typedef struct
  39 {
  40         PurpleRequestType type;
  41         void *handle;
  42         void *ui_handle;
  43         GSList *notify_on_close;
  44 } PurpleRequestInfo;
  45
  46 struct _PurpleRequestField
  47 {
  48         PurpleRequestFieldType type;
  49         PurpleRequestFieldGroup *group;
  50
  51         char *id;
  52         char *label;
  53         char *type_hint;
  54
  55         gboolean visible;
  56         gboolean required;
  57         gboolean sensitive;
  58         PurpleRequestFieldSensitivityCb sensitivity_cb;
  59
  60         union
  61         {
  62                 struct
  63                 {
  64                         gboolean multiline;
  65                         gboolean masked;
  66                         char *default_value;
  67                         char *value;
  68
  69                 } string;
  70
  71                 struct
  72                 {
  73                         int default_value;
  74                         int value;
  75                         int lower_bound;
  76                         int upper_bound;
  77                 } integer;
  78
  79                 struct
  80                 {
  81                         gboolean default_value;
  82                         gboolean value;
  83
  84                 } boolean;
  85
  86                 struct
  87                 {
  88                         gpointer default_value;
  89                         gpointer value;
  90
  91                         GList *elements;
  92                         GDestroyNotify data_destroy;
  93                 } choice;
  94
  95                 struct
  96                 {
  97                         GList *items;
  98                         GList *icons;
  99                         GHashTable *item_data;
 100                         GList *selected;
 101                         GHashTable *selected_table;
 102
 103                         gboolean multiple_selection;
 104
 105                 } list;
 106
 107                 struct
 108                 {
 109                         PurpleAccount *default_account;
 110                         PurpleAccount *account;
 111                         gboolean show_all;
 112
 113                         PurpleFilterAccountFunc filter_func;
 114
 115                 } account;
 116
 117                 struct
 118                 {
 119                         unsigned int scale_x;
 120                         unsigned int scale_y;
 121                         const char *buffer;
 122                         gsize size;
 123                 } image;
 124
 125                 struct
 126                 {
 127                         PurpleRequestDatasheet *sheet;
 128                 } datasheet;
 129         } u;
 130
 131         void *ui_data;
 132         char *tooltip;
 133
 134         PurpleRequestFieldValidator validator;
 135         void *validator_data;
 136 };
 137
 138 struct _PurpleRequestFields
 139 {
 140         GList *groups;
 141
 142         GHashTable *fields;
 143
 144         gchar **tab_names;
 145
 146         GList *required_fields;
 147
 148         GList *validated_fields;
 149
 150         GList *autosensitive_fields;
 151
 152         void *ui_data;
 153 };
 154
 155 struct _PurpleRequestFieldGroup
 156 {
 157         PurpleRequestFields *fields_list;
 158
 159         char *title;
 160         gint tab_no;
 161
 162         GList *fields;
 163 };
 164
 165 struct _PurpleRequestCommonParameters
 166 {
 167         int ref_count;
 168
 169         PurpleAccount *account;
 170         PurpleConversation *conv;
 171
 172         PurpleRequestIconType icon_type;
 173         gconstpointer icon_data;
 174         gsize icon_size;
 175
 176         gboolean html;
 177
 178         gboolean compact;
 179
 180         PurpleRequestHelpCb help_cb;
 181         gpointer help_data;
 182
 183         GSList *extra_actions;
 184
 185         gpointer parent_from;
 186 };
 187
 188 static void
 189 purple_request_fields_check_others_sensitivity(PurpleRequestField *field);
 190
 191 PurpleRequestCommonParameters *
 192 purple_request_cpar_new(void)
 193 {
 194         return g_new0(PurpleRequestCommonParameters, 1);
 195 }
 196
 197 PurpleRequestCommonParameters *
 198 purple_request_cpar_from_connection(PurpleConnection *gc)
 199 {
 200         if (gc == NULL)
 201                 return purple_request_cpar_new();
 202         return purple_request_cpar_from_account(
 203                 purple_connection_get_account(gc));
 204 }
 205
 206 PurpleRequestCommonParameters *
 207 purple_request_cpar_from_account(PurpleAccount *account)
 208 {
 209         PurpleRequestCommonParameters *cpar;
 210
 211         cpar = purple_request_cpar_new();
 212         purple_request_cpar_set_account(cpar, account);
 213
 214         return cpar;
 215 }
 216
 217 PurpleRequestCommonParameters *
 218 purple_request_cpar_from_conversation(PurpleConversation *conv)
 219 {
 220         PurpleRequestCommonParameters *cpar;
 221         PurpleAccount *account = NULL;
 222
 223         if (conv != NULL) {
 224                 account = purple_connection_get_account(
 225                         purple_conversation_get_connection(conv));
 226         }
 227
 228         cpar = purple_request_cpar_new();
 229         purple_request_cpar_set_account(cpar, account);
 230         purple_request_cpar_set_conversation(cpar, conv);
 231
 232         return cpar;
 233 }
 234
 235 void
 236 purple_request_cpar_ref(PurpleRequestCommonParameters *cpar)
 237 {
 238         g_return_if_fail(cpar != NULL);
 239
 240         cpar->ref_count++;
 241 }
 242
 243 PurpleRequestCommonParameters *
 244 purple_request_cpar_unref(PurpleRequestCommonParameters *cpar)
 245 {
 246         if (cpar == NULL)
 247                 return NULL;
 248
 249         if (--cpar->ref_count > 0)
 250                 return cpar;
 251
 252         purple_request_cpar_set_extra_actions(cpar, NULL);
 253         g_free(cpar);
 254         return NULL;
 255 }
 256
 257 void
 258 purple_request_cpar_set_account(PurpleRequestCommonParameters *cpar,
 259         PurpleAccount *account)
 260 {
 261         g_return_if_fail(cpar != NULL);
 262
 263         cpar->account = account;
 264 }
 265
 266 PurpleAccount *
 267 purple_request_cpar_get_account(PurpleRequestCommonParameters *cpar)
 268 {
 269         if (cpar == NULL)
 270                 return NULL;
 271
 272         return cpar->account;
 273 }
 274
 275 void
 276 purple_request_cpar_set_conversation(PurpleRequestCommonParameters *cpar,
 277         PurpleConversation *conv)
 278 {
 279         g_return_if_fail(cpar != NULL);
 280
 281         cpar->conv = conv;
 282 }
 283
 284 PurpleConversation *
 285 purple_request_cpar_get_conversation(PurpleRequestCommonParameters *cpar)
 286 {
 287         if (cpar == NULL)
 288                 return NULL;
 289
 290         return cpar->conv;
 291 }
 292
 293 void
 294 purple_request_cpar_set_icon(PurpleRequestCommonParameters *cpar,
 295         PurpleRequestIconType icon_type)
 296 {
 297         g_return_if_fail(cpar != NULL);
 298
 299         cpar->icon_type = icon_type;
 300 }
 301
 302 PurpleRequestIconType
 303 purple_request_cpar_get_icon(PurpleRequestCommonParameters *cpar)
 304 {
 305         if (cpar == NULL)
 306                 return PURPLE_REQUEST_ICON_DEFAULT;
 307
 308         return cpar->icon_type;
 309 }
 310
 311 void
 312 purple_request_cpar_set_custom_icon(PurpleRequestCommonParameters *cpar,
 313         gconstpointer icon_data, gsize icon_size)
 314 {
 315         g_return_if_fail(cpar != NULL);
 316         g_return_if_fail((icon_data == NULL) == (icon_size == 0));
 317
 318         cpar->icon_data = icon_data;
 319         cpar->icon_size = icon_size;
 320 }
 321
 322 gconstpointer
 323 purple_request_cpar_get_custom_icon(PurpleRequestCommonParameters *cpar,
 324         gsize *icon_size)
 325 {
 326         if (cpar == NULL) {
 327                 if (icon_size != NULL)
 328                         *icon_size = 0;
 329                 return NULL;
 330         }
 331
 332         if (icon_size != NULL)
 333                 *icon_size = cpar->icon_size;
 334         return cpar->icon_data;
 335 }
 336
 337 void
 338 purple_request_cpar_set_html(PurpleRequestCommonParameters *cpar,
 339         gboolean enabled)
 340 {
 341         g_return_if_fail(cpar != NULL);
 342
 343         cpar->html = enabled;
 344 }
 345
 346 gboolean
 347 purple_request_cpar_is_html(PurpleRequestCommonParameters *cpar)
 348 {
 349         if (cpar == NULL)
 350                 return FALSE;
 351
 352         return cpar->html;
 353 }
 354
 355 void
 356 purple_request_cpar_set_compact(PurpleRequestCommonParameters *cpar,
 357         gboolean compact)
 358 {
 359         g_return_if_fail(cpar != NULL);
 360
 361         cpar->compact = compact;
 362 }
 363
 364 gboolean
 365 purple_request_cpar_is_compact(PurpleRequestCommonParameters *cpar)
 366 {
 367         if (cpar == NULL)
 368                 return FALSE;
 369
 370         return cpar->compact;
 371 }
 372
 373 void
 374 purple_request_cpar_set_help_cb(PurpleRequestCommonParameters *cpar,
 375         PurpleRequestHelpCb cb, gpointer user_data)
 376 {
 377         g_return_if_fail(cpar != NULL);
 378
 379         cpar->help_cb = cb;
 380         cpar->help_data = cb ? user_data : NULL;
 381 }
 382
 383 PurpleRequestHelpCb
 384 purple_request_cpar_get_help_cb(PurpleRequestCommonParameters *cpar,
 385         gpointer *user_data)
 386 {
 387         if (cpar == NULL)
 388                 return NULL;
 389
 390         if (user_data != NULL)
 391                 *user_data = cpar->help_data;
 392         return cpar->help_cb;
 393 }
 394
 395 void
 396 purple_request_cpar_set_extra_actions(PurpleRequestCommonParameters *cpar, ...)
 397 {
 398         va_list args;
 399         GSList *extra = NULL, *it;
 400
 401         it = cpar->extra_actions;
 402         while (it != NULL) {
 403                 gchar *label = it->data;
 404
 405                 g_free(label);
 406                 it = g_slist_next(it);
 407                 if (it == NULL)
 408                         break;
 409                 it = g_slist_next(it);
 410         }
 411
 412         va_start(args, cpar);
 413
 414         while (TRUE) {
 415                 const gchar *label;
 416                 PurpleRequestFieldsCb cb;
 417
 418                 label = va_arg(args, const gchar*);
 419                 if (label == NULL)
 420                         break;
 421                 cb = va_arg(args, PurpleRequestFieldsCb);
 422
 423                 extra = g_slist_append(extra, g_strdup(label));
 424                 extra = g_slist_append(extra, cb);
 425         }
 426
 427         va_end(args);
 428
 429         cpar->extra_actions = extra;
 430 }
 431
 432 GSList *
 433 purple_request_cpar_get_extra_actions(PurpleRequestCommonParameters *cpar)
 434 {
 435         if (cpar == NULL)
 436                 return NULL;
 437
 438         return cpar->extra_actions;
 439 }
 440
 441 void
 442 purple_request_cpar_set_parent_from(PurpleRequestCommonParameters *cpar,
 443         gpointer ui_handle)
 444 {
 445         g_return_if_fail(cpar != NULL);
 446
 447         cpar->parent_from = ui_handle;
 448 }
 449
 450 gpointer
 451 purple_request_cpar_get_parent_from(PurpleRequestCommonParameters *cpar)
 452 {
 453         if (cpar == NULL)
 454                 return NULL;
 455
 456         return cpar->parent_from;
 457 }
 458
 459 static PurpleRequestInfo *
 460 purple_request_info_from_ui_handle(void *ui_handle)
 461 {
 462         GList *it;
 463
 464         g_return_val_if_fail(ui_handle != NULL, NULL);
 465
 466         for (it = handles; it != NULL; it = g_list_next(it)) {
 467                 PurpleRequestInfo *info = it->data;
 468
 469                 if (info->ui_handle == ui_handle)
 470                         return info;
 471         }
 472
 473         return NULL;
 474 }
 475
 476 PurpleRequestFields *
 477 purple_request_fields_new(void)
 478 {
 479         PurpleRequestFields *fields;
 480
 481         fields = g_new0(PurpleRequestFields, 1);
 482
 483         fields->fields = g_hash_table_new_full(g_str_hash, g_str_equal,
 484                                                                                    g_free, NULL);
 485
 486         return fields;
 487 }
 488
 489 void
 490 purple_request_fields_destroy(PurpleRequestFields *fields)
 491 {
 492         g_return_if_fail(fields != NULL);
 493
 494         g_strfreev(fields->tab_names);
 495         g_list_free_full(fields->groups,
 496                          (GDestroyNotify)purple_request_field_group_destroy);
 497         g_list_free(fields->required_fields);
 498         g_list_free(fields->validated_fields);
 499         g_list_free(fields->autosensitive_fields);
 500         g_hash_table_destroy(fields->fields);
 501         g_free(fields);
 502 }
 503
 504 void
 505 purple_request_fields_add_group(PurpleRequestFields *fields,
 506                                                           PurpleRequestFieldGroup *group)
 507 {
 508         GList *l;
 509         PurpleRequestField *field;
 510
 511         g_return_if_fail(fields != NULL);
 512         g_return_if_fail(group  != NULL);
 513
 514         fields->groups = g_list_append(fields->groups, group);
 515
 516         group->fields_list = fields;
 517
 518         for (l = purple_request_field_group_get_fields(group);
 519                  l != NULL;
 520                  l = l->next) {
 521
 522                 field = l->data;
 523
 524                 g_hash_table_insert(fields->fields,
 525                         g_strdup(purple_request_field_get_id(field)), field);
 526
 527                 if (purple_request_field_is_required(field)) {
 528                         fields->required_fields =
 529                                 g_list_append(fields->required_fields, field);
 530                 }
 531
 532                 if (purple_request_field_is_validatable(field)) {
 533                         fields->validated_fields =
 534                                 g_list_append(fields->validated_fields, field);
 535                 }
 536
 537                 if (field->sensitivity_cb != NULL) {
 538                         fields->autosensitive_fields =
 539                                 g_list_append(fields->autosensitive_fields, field);
 540                 }
 541         }
 542 }
 543
 544 GList *
 545 purple_request_fields_get_groups(const PurpleRequestFields *fields)
 546 {
 547         g_return_val_if_fail(fields != NULL, NULL);
 548
 549         return fields->groups;
 550 }
 551
 552 void
 553 purple_request_fields_set_tab_names(PurpleRequestFields *fields,
 554         const gchar **tab_names)
 555 {
 556         guint i, tab_count;
 557         gchar **new_names;
 558
 559         g_return_if_fail(fields != NULL);
 560
 561         tab_count = (tab_names != NULL) ? g_strv_length((gchar **)tab_names) : 0;
 562         new_names = (tab_count > 0) ? g_new0(gchar*, tab_count + 1) : NULL;
 563         for (i = 0; i < tab_count; i++)
 564                 new_names[i] = g_strdup(tab_names[i]);
 565
 566         g_strfreev(fields->tab_names);
 567         fields->tab_names = new_names;
 568 }
 569
 570 const gchar **
 571 purple_request_fields_get_tab_names(const PurpleRequestFields *fields)
 572 {
 573         g_return_val_if_fail(fields != NULL, NULL);
 574
 575         return (const gchar **)fields->tab_names;
 576 }
 577
 578 gboolean
 579 purple_request_fields_exists(const PurpleRequestFields *fields, const char *id)
 580 {
 581         g_return_val_if_fail(fields != NULL, FALSE);
 582         g_return_val_if_fail(id     != NULL, FALSE);
 583
 584         return (g_hash_table_lookup(fields->fields, id) != NULL);
 585 }
 586
 587 const GList *
 588 purple_request_fields_get_required(const PurpleRequestFields *fields)
 589 {
 590         g_return_val_if_fail(fields != NULL, NULL);
 591
 592         return fields->required_fields;
 593 }
 594
 595 const GList *
 596 purple_request_fields_get_validatable(const PurpleRequestFields *fields)
 597 {
 598         g_return_val_if_fail(fields != NULL, NULL);
 599
 600         return fields->validated_fields;
 601 }
 602
 603 const GList *
 604 purple_request_fields_get_autosensitive(const PurpleRequestFields *fields)
 605 {
 606         g_return_val_if_fail(fields != NULL, NULL);
 607
 608         return fields->autosensitive_fields;
 609 }
 610
 611 gboolean
 612 purple_request_fields_is_field_required(const PurpleRequestFields *fields,
 613                                                                           const char *id)
 614 {
 615         PurpleRequestField *field;
 616
 617         g_return_val_if_fail(fields != NULL, FALSE);
 618         g_return_val_if_fail(id     != NULL, FALSE);
 619
 620         if ((field = purple_request_fields_get_field(fields, id)) == NULL)
 621                 return FALSE;
 622
 623         return purple_request_field_is_required(field);
 624 }
 625
 626 gpointer
 627 purple_request_field_get_ui_data(const PurpleRequestField *field)
 628 {
 629         g_return_val_if_fail(field != NULL, NULL);
 630
 631         return field->ui_data;
 632 }
 633
 634 void
 635 purple_request_field_set_ui_data(PurpleRequestField *field,
 636                                  gpointer ui_data)
 637 {
 638         g_return_if_fail(field != NULL);
 639
 640         field->ui_data = ui_data;
 641 }
 642
 643 gboolean
 644 purple_request_fields_all_required_filled(const PurpleRequestFields *fields)
 645 {
 646         GList *l;
 647
 648         g_return_val_if_fail(fields != NULL, FALSE);
 649
 650         for (l = fields->required_fields; l != NULL; l = l->next)
 651         {
 652                 PurpleRequestField *field = (PurpleRequestField *)l->data;
 653
 654                 if (!purple_request_field_is_filled(field))
 655                         return FALSE;
 656         }
 657
 658         return TRUE;
 659 }
 660
 661 gboolean
 662 purple_request_fields_all_valid(const PurpleRequestFields *fields)
 663 {
 664         GList *l;
 665
 666         g_return_val_if_fail(fields != NULL, FALSE);
 667
 668         for (l = fields->validated_fields; l != NULL; l = l->next)
 669         {
 670                 PurpleRequestField *field = (PurpleRequestField *)l->data;
 671
 672                 if (!purple_request_field_is_valid(field, NULL))
 673                         return FALSE;
 674         }
 675
 676         return TRUE;
 677 }
 678
 679 static void
 680 purple_request_fields_check_sensitivity(PurpleRequestFields *fields)
 681 {
 682         GList *it;
 683
 684         g_return_if_fail(fields != NULL);
 685
 686         for (it = fields->autosensitive_fields; it; it = g_list_next(it)) {
 687                 PurpleRequestField *field = it->data;
 688
 689                 if (field->sensitivity_cb == NULL) {
 690                         g_warn_if_reached();
 691                         continue;
 692                 }
 693
 694                 purple_request_field_set_sensitive(field,
 695                         field->sensitivity_cb(field));
 696         }
 697 }
 698
 699 static void
 700 purple_request_fields_check_others_sensitivity(PurpleRequestField *field)
 701 {
 702         g_return_if_fail(field != NULL);
 703
 704         if (field->group == NULL || field->group->fields_list == NULL)
 705                 return;
 706
 707         purple_request_fields_check_sensitivity(field->group->fields_list);
 708 }
 709
 710 PurpleRequestField *
 711 purple_request_fields_get_field(const PurpleRequestFields *fields, const char *id)
 712 {
 713         PurpleRequestField *field;
 714
 715         g_return_val_if_fail(fields != NULL, NULL);
 716         g_return_val_if_fail(id     != NULL, NULL);
 717
 718         field = g_hash_table_lookup(fields->fields, id);
 719
 720         g_return_val_if_fail(field != NULL, NULL);
 721
 722         return field;
 723 }
 724
 725 const char *
 726 purple_request_fields_get_string(const PurpleRequestFields *fields, const char *id)
 727 {
 728         PurpleRequestField *field;
 729
 730         g_return_val_if_fail(fields != NULL, NULL);
 731         g_return_val_if_fail(id     != NULL, NULL);
 732
 733         if ((field = purple_request_fields_get_field(fields, id)) == NULL)
 734                 return NULL;
 735
 736         return purple_request_field_string_get_value(field);
 737 }
 738
 739 int
 740 purple_request_fields_get_integer(const PurpleRequestFields *fields,
 741                                                                 const char *id)
 742 {
 743         PurpleRequestField *field;
 744
 745         g_return_val_if_fail(fields != NULL, 0);
 746         g_return_val_if_fail(id     != NULL, 0);
 747
 748         if ((field = purple_request_fields_get_field(fields, id)) == NULL)
 749                 return 0;
 750
 751         return purple_request_field_int_get_value(field);
 752 }
 753
 754 gboolean
 755 purple_request_fields_get_bool(const PurpleRequestFields *fields, const char *id)
 756 {
 757         PurpleRequestField *field;
 758
 759         g_return_val_if_fail(fields != NULL, FALSE);
 760         g_return_val_if_fail(id     != NULL, FALSE);
 761
 762         if ((field = purple_request_fields_get_field(fields, id)) == NULL)
 763                 return FALSE;
 764
 765         return purple_request_field_bool_get_value(field);
 766 }
 767
 768 gpointer
 769 purple_request_fields_get_choice(const PurpleRequestFields *fields,
 770         const char *id)
 771 {
 772         PurpleRequestField *field;
 773
 774         g_return_val_if_fail(fields != NULL, NULL);
 775         g_return_val_if_fail(id != NULL, NULL);
 776
 777         if ((field = purple_request_fields_get_field(fields, id)) == NULL)
 778                 return NULL;
 779
 780         return purple_request_field_choice_get_value(field);
 781 }
 782
 783 PurpleAccount *
 784 purple_request_fields_get_account(const PurpleRequestFields *fields,
 785                                                                 const char *id)
 786 {
 787         PurpleRequestField *field;
 788
 789         g_return_val_if_fail(fields != NULL, NULL);
 790         g_return_val_if_fail(id     != NULL, NULL);
 791
 792         if ((field = purple_request_fields_get_field(fields, id)) == NULL)
 793                 return NULL;
 794
 795         return purple_request_field_account_get_value(field);
 796 }
 797
 798 gpointer purple_request_fields_get_ui_data(const PurpleRequestFields *fields)
 799 {
 800         g_return_val_if_fail(fields != NULL, NULL);
 801
 802         return fields->ui_data;
 803 }
 804
 805 void purple_request_fields_set_ui_data(PurpleRequestFields *fields, gpointer ui_data)
 806 {
 807         g_return_if_fail(fields != NULL);
 808
 809         fields->ui_data = ui_data;
 810 }
 811
 812 PurpleRequestFieldGroup *
 813 purple_request_field_group_new(const char *title)
 814 {
 815         PurpleRequestFieldGroup *group;
 816
 817         group = g_new0(PurpleRequestFieldGroup, 1);
 818
 819         group->title = g_strdup(title);
 820
 821         return group;
 822 }
 823
 824 void
 825 purple_request_field_group_set_tab(PurpleRequestFieldGroup *group, guint tab_no)
 826 {
 827         g_return_if_fail(group != NULL);
 828
 829         group->tab_no = tab_no;
 830 }
 831
 832 guint
 833 purple_request_field_group_get_tab(const PurpleRequestFieldGroup *group)
 834 {
 835         return group->tab_no;
 836 }
 837
 838 void
 839 purple_request_field_group_destroy(PurpleRequestFieldGroup *group)
 840 {
 841         g_return_if_fail(group != NULL);
 842
 843         g_free(group->title);
 844
 845         g_list_free_full(group->fields,
 846                          (GDestroyNotify)purple_request_field_destroy);
 847
 848         g_free(group);
 849 }
 850
 851 void
 852 purple_request_field_group_add_field(PurpleRequestFieldGroup *group,
 853                                                                    PurpleRequestField *field)
 854 {
 855         g_return_if_fail(group != NULL);
 856         g_return_if_fail(field != NULL);
 857
 858         group->fields = g_list_append(group->fields, field);
 859
 860         if (group->fields_list != NULL)
 861         {
 862                 g_hash_table_insert(group->fields_list->fields,
 863                                                         g_strdup(purple_request_field_get_id(field)), field);
 864
 865                 if (purple_request_field_is_required(field))
 866                 {
 867                         group->fields_list->required_fields =
 868                                 g_list_append(group->fields_list->required_fields, field);
 869                 }
 870
 871                 if (purple_request_field_is_validatable(field))
 872                 {
 873                         group->fields_list->validated_fields =
 874                                 g_list_append(group->fields_list->validated_fields, field);
 875                 }
 876
 877                 if (field->sensitivity_cb != NULL)
 878                 {
 879                         group->fields_list->autosensitive_fields =
 880                                 g_list_append(group->fields_list->autosensitive_fields, field);
 881                 }
 882         }
 883
 884         field->group = group;
 885
 886 }
 887
 888 const char *
 889 purple_request_field_group_get_title(const PurpleRequestFieldGroup *group)
 890 {
 891         g_return_val_if_fail(group != NULL, NULL);
 892
 893         return group->title;
 894 }
 895
 896 GList *
 897 purple_request_field_group_get_fields(const PurpleRequestFieldGroup *group)
 898 {
 899         g_return_val_if_fail(group != NULL, NULL);
 900
 901         return group->fields;
 902 }
 903
 904 PurpleRequestFields *
 905 purple_request_field_group_get_fields_list(const PurpleRequestFieldGroup *group)
 906 {
 907         g_return_val_if_fail(group != NULL, NULL);
 908
 909         return group->fields_list;
 910 }
 911
 912 PurpleRequestField *
 913 purple_request_field_new(const char *id, const char *text,
 914                                            PurpleRequestFieldType type)
 915 {
 916         PurpleRequestField *field;
 917
 918         g_return_val_if_fail(id   != NULL, NULL);
 919         g_return_val_if_fail(type != PURPLE_REQUEST_FIELD_NONE, NULL);
 920
 921         field = g_new0(PurpleRequestField, 1);
 922
 923         field->id   = g_strdup(id);
 924         field->type = type;
 925
 926         purple_request_field_set_label(field, text);
 927         purple_request_field_set_visible(field, TRUE);
 928         purple_request_field_set_sensitive(field, TRUE);
 929
 930         return field;
 931 }
 932
 933 void
 934 purple_request_field_destroy(PurpleRequestField *field)
 935 {
 936         g_return_if_fail(field != NULL);
 937
 938         g_free(field->id);
 939         g_free(field->label);
 940         g_free(field->type_hint);
 941         g_free(field->tooltip);
 942
 943         if (field->type == PURPLE_REQUEST_FIELD_STRING)
 944         {
 945                 g_free(field->u.string.default_value);
 946                 g_free(field->u.string.value);
 947         }
 948         else if (field->type == PURPLE_REQUEST_FIELD_CHOICE)
 949         {
 950                 if (field->u.choice.elements != NULL)
 951                 {
 952                         GList *it = field->u.choice.elements;
 953                         while (it != NULL) {
 954                                 g_free(it->data);
 955                                 it = g_list_next(it); /* value */
 956                                 if (it == NULL) {
 957                                         g_warn_if_reached();
 958                                         break;
 959                                 }
 960                                 if (it->data && field->u.choice.data_destroy)
 961                                         field->u.choice.data_destroy(it->data);
 962                                 it = g_list_next(it); /* next label */
 963                         }
 964                         g_list_free(field->u.choice.elements);
 965                 }
 966         }
 967         else if (field->type == PURPLE_REQUEST_FIELD_LIST)
 968         {
 969                 g_list_free_full(field->u.list.items, g_free);
 970                 g_list_free_full(field->u.list.selected, g_free);
 971                 g_hash_table_destroy(field->u.list.item_data);
 972                 g_hash_table_destroy(field->u.list.selected_table);
 973         }
 974         else if (field->type == PURPLE_REQUEST_FIELD_DATASHEET)
 975         {
 976                 purple_request_datasheet_free(field->u.datasheet.sheet);
 977         }
 978
 979         g_free(field);
 980 }
 981
 982 void
 983 purple_request_field_set_label(PurpleRequestField *field, const char *label)
 984 {
 985         g_return_if_fail(field != NULL);
 986
 987         g_free(field->label);
 988         field->label = g_strdup(label);
 989 }
 990
 991 void
 992 purple_request_field_set_visible(PurpleRequestField *field, gboolean visible)
 993 {
 994         g_return_if_fail(field != NULL);
 995
 996         field->visible = visible;
 997 }
 998
 999 void
1000 purple_request_field_set_type_hint(PurpleRequestField *field,
1001                                                                  const char *type_hint)
1002 {
1003         g_return_if_fail(field != NULL);
1004
1005         g_free(field->type_hint);
1006         field->type_hint = g_strdup(type_hint);
1007 }
1008
1009 void
1010 purple_request_field_set_tooltip(PurpleRequestField *field, const char *tooltip)
1011 {
1012         g_return_if_fail(field != NULL);
1013
1014         g_free(field->tooltip);
1015         field->tooltip = g_strdup(tooltip);
1016 }
1017
1018 void
1019 purple_request_field_set_required(PurpleRequestField *field, gboolean required)
1020 {
1021         g_return_if_fail(field != NULL);
1022
1023         if (field->required == required)
1024                 return;
1025
1026         field->required = required;
1027
1028         if (field->group != NULL)
1029         {
1030                 if (required)
1031                 {
1032                         field->group->fields_list->required_fields =
1033                                 g_list_append(field->group->fields_list->required_fields,
1034                                                           field);
1035                 }
1036                 else
1037                 {
1038                         field->group->fields_list->required_fields =
1039                                 g_list_remove(field->group->fields_list->required_fields,
1040                                                           field);
1041                 }
1042         }
1043 }
1044
1045 PurpleRequestFieldType
1046 purple_request_field_get_field_type(const PurpleRequestField *field)
1047 {
1048         g_return_val_if_fail(field != NULL, PURPLE_REQUEST_FIELD_NONE);
1049
1050         return field->type;
1051 }
1052
1053 PurpleRequestFieldGroup *
1054 purple_request_field_get_group(const PurpleRequestField *field)
1055 {
1056         g_return_val_if_fail(field != NULL, NULL);
1057
1058         return field->group;
1059 }
1060
1061 const char *
1062 purple_request_field_get_id(const PurpleRequestField *field)
1063 {
1064         g_return_val_if_fail(field != NULL, NULL);
1065
1066         return field->id;
1067 }
1068
1069 const char *
1070 purple_request_field_get_label(const PurpleRequestField *field)
1071 {
1072         g_return_val_if_fail(field != NULL, NULL);
1073
1074         return field->label;
1075 }
1076
1077 gboolean
1078 purple_request_field_is_visible(const PurpleRequestField *field)
1079 {
1080         g_return_val_if_fail(field != NULL, FALSE);
1081
1082         return field->visible;
1083 }
1084
1085 const char *
1086 purple_request_field_get_field_type_hint(const PurpleRequestField *field)
1087 {
1088         g_return_val_if_fail(field != NULL, NULL);
1089
1090         return field->type_hint;
1091 }
1092
1093 const char *
1094 purple_request_field_get_tooltip(const PurpleRequestField *field)
1095 {
1096         g_return_val_if_fail(field != NULL, NULL);
1097
1098         return field->tooltip;
1099 }
1100
1101 gboolean
1102 purple_request_field_is_required(const PurpleRequestField *field)
1103 {
1104         g_return_val_if_fail(field != NULL, FALSE);
1105
1106         return field->required;
1107 }
1108
1109 gboolean
1110 purple_request_field_is_filled(const PurpleRequestField *field)
1111 {
1112         g_return_val_if_fail(field != NULL, FALSE);
1113
1114         switch (purple_request_field_get_field_type(field))
1115         {
1116                 case PURPLE_REQUEST_FIELD_STRING:
1117                         return (purple_request_field_string_get_value(field) != NULL &&
1118                                 *(purple_request_field_string_get_value(field)) != '\0');
1119                 default:
1120                         return TRUE;
1121         }
1122 }
1123
1124 void
1125 purple_request_field_set_validator(PurpleRequestField *field,
1126         PurpleRequestFieldValidator validator, void *user_data)
1127 {
1128         g_return_if_fail(field != NULL);
1129
1130         field->validator = validator;
1131         field->validator_data = validator ? user_data : NULL;
1132
1133         if (field->group != NULL)
1134         {
1135                 PurpleRequestFields *flist = field->group->fields_list;
1136                 flist->validated_fields = g_list_remove(flist->validated_fields,
1137                         field);
1138                 if (validator)
1139                 {
1140                         flist->validated_fields = g_list_append(
1141                                 flist->validated_fields, field);
1142                 }
1143         }
1144 }
1145
1146 gboolean
1147 purple_request_field_is_validatable(PurpleRequestField *field)
1148 {
1149         g_return_val_if_fail(field != NULL, FALSE);
1150
1151         return field->validator != NULL;
1152 }
1153
1154 gboolean
1155 purple_request_field_is_valid(PurpleRequestField *field, gchar **errmsg)
1156 {
1157         gboolean valid;
1158
1159         g_return_val_if_fail(field != NULL, FALSE);
1160
1161         if (!field->validator)
1162                 return TRUE;
1163
1164         if (!purple_request_field_is_required(field) &&
1165                 !purple_request_field_is_filled(field))
1166                 return TRUE;
1167
1168         valid = field->validator(field, errmsg, field->validator_data);
1169
1170         if (valid && errmsg)
1171                 *errmsg = NULL;
1172
1173         return valid;
1174 }
1175
1176 void
1177 purple_request_field_set_sensitive(PurpleRequestField *field,
1178         gboolean sensitive)
1179 {
1180         g_return_if_fail(field != NULL);
1181
1182         field->sensitive = sensitive;
1183 }
1184
1185 gboolean
1186 purple_request_field_is_sensitive(PurpleRequestField *field)
1187 {
1188         g_return_val_if_fail(field != NULL, FALSE);
1189
1190         return field->sensitive;
1191 }
1192
1193 void
1194 purple_request_field_set_sensitivity_cb(PurpleRequestField *field,
1195         PurpleRequestFieldSensitivityCb cb)
1196 {
1197         PurpleRequestFields *flist;
1198
1199         g_return_if_fail(field != NULL);
1200
1201         field->sensitivity_cb = cb;
1202
1203         if (!field->group || !field->group->fields_list)
1204                 return;
1205         flist = field->group->fields_list;
1206         flist->autosensitive_fields = g_list_remove(flist->autosensitive_fields,
1207                 field);
1208         if (cb != NULL)
1209         {
1210                 flist->autosensitive_fields = g_list_append(
1211                         flist->autosensitive_fields, field);
1212         }
1213 }
1214
1215 PurpleRequestField *
1216 purple_request_field_string_new(const char *id, const char *text,
1217                                                           const char *default_value, gboolean multiline)
1218 {
1219         PurpleRequestField *field;
1220
1221         g_return_val_if_fail(id   != NULL, NULL);
1222         g_return_val_if_fail(text != NULL, NULL);
1223
1224         field = purple_request_field_new(id, text, PURPLE_REQUEST_FIELD_STRING);
1225
1226         field->u.string.multiline = multiline;
1227
1228         purple_request_field_string_set_default_value(field, default_value);
1229         purple_request_field_string_set_value(field, default_value);
1230
1231         return field;
1232 }
1233
1234 void
1235 purple_request_field_string_set_default_value(PurpleRequestField *field,
1236                                                                                         const char *default_value)
1237 {
1238         g_return_if_fail(field != NULL);
1239         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_STRING);
1240
1241         g_free(field->u.string.default_value);
1242         field->u.string.default_value = g_strdup(default_value);
1243 }
1244
1245 void
1246 purple_request_field_string_set_value(PurpleRequestField *field, const char *value)
1247 {
1248         g_return_if_fail(field != NULL);
1249         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_STRING);
1250
1251         g_free(field->u.string.value);
1252         field->u.string.value = g_strdup(value);
1253
1254         purple_request_fields_check_others_sensitivity(field);
1255 }
1256
1257 void
1258 purple_request_field_string_set_masked(PurpleRequestField *field, gboolean masked)
1259 {
1260         g_return_if_fail(field != NULL);
1261         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_STRING);
1262
1263         field->u.string.masked = masked;
1264 }
1265
1266 const char *
1267 purple_request_field_string_get_default_value(const PurpleRequestField *field)
1268 {
1269         g_return_val_if_fail(field != NULL, NULL);
1270         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_STRING, NULL);
1271
1272         return field->u.string.default_value;
1273 }
1274
1275 const char *
1276 purple_request_field_string_get_value(const PurpleRequestField *field)
1277 {
1278         g_return_val_if_fail(field != NULL, NULL);
1279         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_STRING, NULL);
1280
1281         return field->u.string.value;
1282 }
1283
1284 gboolean
1285 purple_request_field_string_is_multiline(const PurpleRequestField *field)
1286 {
1287         g_return_val_if_fail(field != NULL, FALSE);
1288         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_STRING, FALSE);
1289
1290         return field->u.string.multiline;
1291 }
1292
1293 gboolean
1294 purple_request_field_string_is_masked(const PurpleRequestField *field)
1295 {
1296         g_return_val_if_fail(field != NULL, FALSE);
1297         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_STRING, FALSE);
1298
1299         return field->u.string.masked;
1300 }
1301
1302 PurpleRequestField *
1303 purple_request_field_int_new(const char *id, const char *text,
1304         int default_value, int lower_bound, int upper_bound)
1305 {
1306         PurpleRequestField *field;
1307
1308         g_return_val_if_fail(id   != NULL, NULL);
1309         g_return_val_if_fail(text != NULL, NULL);
1310
1311         field = purple_request_field_new(id, text, PURPLE_REQUEST_FIELD_INTEGER);
1312
1313         purple_request_field_int_set_lower_bound(field, lower_bound);
1314         purple_request_field_int_set_upper_bound(field, upper_bound);
1315         purple_request_field_int_set_default_value(field, default_value);
1316         purple_request_field_int_set_value(field, default_value);
1317
1318         return field;
1319 }
1320
1321 void
1322 purple_request_field_int_set_default_value(PurpleRequestField *field,
1323                                                                                  int default_value)
1324 {
1325         g_return_if_fail(field != NULL);
1326         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_INTEGER);
1327
1328         field->u.integer.default_value = default_value;
1329 }
1330
1331 void
1332 purple_request_field_int_set_lower_bound(PurpleRequestField *field,
1333         int lower_bound)
1334 {
1335         g_return_if_fail(field != NULL);
1336         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_INTEGER);
1337
1338         field->u.integer.lower_bound = lower_bound;
1339 }
1340
1341 void
1342 purple_request_field_int_set_upper_bound(PurpleRequestField *field,
1343         int upper_bound)
1344 {
1345         g_return_if_fail(field != NULL);
1346         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_INTEGER);
1347
1348         field->u.integer.upper_bound = upper_bound;
1349 }
1350
1351 void
1352 purple_request_field_int_set_value(PurpleRequestField *field, int value)
1353 {
1354         g_return_if_fail(field != NULL);
1355         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_INTEGER);
1356
1357         if (value < field->u.integer.lower_bound ||
1358                 value > field->u.integer.upper_bound) {
1359                 purple_debug_error("request", "Int value out of bounds\n");
1360                 return;
1361         }
1362
1363         field->u.integer.value = value;
1364
1365         purple_request_fields_check_others_sensitivity(field);
1366 }
1367
1368 int
1369 purple_request_field_int_get_default_value(const PurpleRequestField *field)
1370 {
1371         g_return_val_if_fail(field != NULL, 0);
1372         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_INTEGER, 0);
1373
1374         return field->u.integer.default_value;
1375 }
1376
1377 int
1378 purple_request_field_int_get_lower_bound(const PurpleRequestField *field)
1379 {
1380         g_return_val_if_fail(field != NULL, 0);
1381         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_INTEGER, 0);
1382
1383         return field->u.integer.lower_bound;
1384 }
1385
1386 int
1387 purple_request_field_int_get_upper_bound(const PurpleRequestField *field)
1388 {
1389         g_return_val_if_fail(field != NULL, 0);
1390         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_INTEGER, 0);
1391
1392         return field->u.integer.upper_bound;
1393 }
1394
1395 int
1396 purple_request_field_int_get_value(const PurpleRequestField *field)
1397 {
1398         g_return_val_if_fail(field != NULL, 0);
1399         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_INTEGER, 0);
1400
1401         return field->u.integer.value;
1402 }
1403
1404 PurpleRequestField *
1405 purple_request_field_bool_new(const char *id, const char *text,
1406                                                         gboolean default_value)
1407 {
1408         PurpleRequestField *field;
1409
1410         g_return_val_if_fail(id   != NULL, NULL);
1411         g_return_val_if_fail(text != NULL, NULL);
1412
1413         field = purple_request_field_new(id, text, PURPLE_REQUEST_FIELD_BOOLEAN);
1414
1415         purple_request_field_bool_set_default_value(field, default_value);
1416         purple_request_field_bool_set_value(field, default_value);
1417
1418         return field;
1419 }
1420
1421 void
1422 purple_request_field_bool_set_default_value(PurpleRequestField *field,
1423                                                                                   gboolean default_value)
1424 {
1425         g_return_if_fail(field != NULL);
1426         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_BOOLEAN);
1427
1428         field->u.boolean.default_value = default_value;
1429 }
1430
1431 void
1432 purple_request_field_bool_set_value(PurpleRequestField *field, gboolean value)
1433 {
1434         g_return_if_fail(field != NULL);
1435         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_BOOLEAN);
1436
1437         field->u.boolean.value = value;
1438
1439         purple_request_fields_check_others_sensitivity(field);
1440 }
1441
1442 gboolean
1443 purple_request_field_bool_get_default_value(const PurpleRequestField *field)
1444 {
1445         g_return_val_if_fail(field != NULL, FALSE);
1446         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_BOOLEAN, FALSE);
1447
1448         return field->u.boolean.default_value;
1449 }
1450
1451 gboolean
1452 purple_request_field_bool_get_value(const PurpleRequestField *field)
1453 {
1454         g_return_val_if_fail(field != NULL, FALSE);
1455         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_BOOLEAN, FALSE);
1456
1457         return field->u.boolean.value;
1458 }
1459
1460 PurpleRequestField *
1461 purple_request_field_choice_new(const char *id, const char *text,
1462         gpointer default_value)
1463 {
1464         PurpleRequestField *field;
1465
1466         g_return_val_if_fail(id   != NULL, NULL);
1467         g_return_val_if_fail(text != NULL, NULL);
1468
1469         field = purple_request_field_new(id, text, PURPLE_REQUEST_FIELD_CHOICE);
1470
1471         purple_request_field_choice_set_default_value(field, default_value);
1472         purple_request_field_choice_set_value(field, default_value);
1473
1474         return field;
1475 }
1476
1477 void
1478 purple_request_field_choice_add(PurpleRequestField *field, const char *label,
1479         gpointer value)
1480 {
1481         g_return_if_fail(field != NULL);
1482         g_return_if_fail(label != NULL);
1483         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_CHOICE);
1484
1485         field->u.choice.elements = g_list_append(field->u.choice.elements,
1486                 g_strdup(label));
1487         field->u.choice.elements = g_list_append(field->u.choice.elements,
1488                 value);
1489 }
1490
1491 void
1492 purple_request_field_choice_set_default_value(PurpleRequestField *field,
1493         gpointer default_value)
1494 {
1495         g_return_if_fail(field != NULL);
1496         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_CHOICE);
1497
1498         field->u.choice.default_value = default_value;
1499 }
1500
1501 void
1502 purple_request_field_choice_set_value(PurpleRequestField *field, gpointer value)
1503 {
1504         g_return_if_fail(field != NULL);
1505         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_CHOICE);
1506
1507         field->u.choice.value = value;
1508
1509         purple_request_fields_check_others_sensitivity(field);
1510 }
1511
1512 gpointer
1513 purple_request_field_choice_get_default_value(const PurpleRequestField *field)
1514 {
1515         g_return_val_if_fail(field != NULL, NULL);
1516         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_CHOICE, NULL);
1517
1518         return field->u.choice.default_value;
1519 }
1520
1521 gpointer
1522 purple_request_field_choice_get_value(const PurpleRequestField *field)
1523 {
1524         g_return_val_if_fail(field != NULL, NULL);
1525         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_CHOICE, NULL);
1526
1527         return field->u.choice.value;
1528 }
1529
1530 GList *
1531 purple_request_field_choice_get_elements(const PurpleRequestField *field)
1532 {
1533         g_return_val_if_fail(field != NULL, NULL);
1534         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_CHOICE, NULL);
1535
1536         return field->u.choice.elements;
1537 }
1538
1539 void
1540 purple_request_field_choice_set_data_destructor(PurpleRequestField *field,
1541         GDestroyNotify destroy)
1542 {
1543         g_return_if_fail(field != NULL);
1544         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_CHOICE);
1545
1546         field->u.choice.data_destroy = destroy;
1547 }
1548
1549 PurpleRequestField *
1550 purple_request_field_list_new(const char *id, const char *text)
1551 {
1552         PurpleRequestField *field;
1553
1554         g_return_val_if_fail(id   != NULL, NULL);
1555
1556         field = purple_request_field_new(id, text, PURPLE_REQUEST_FIELD_LIST);
1557
1558         field->u.list.item_data = g_hash_table_new_full(g_str_hash, g_str_equal,
1559                                                                                                         g_free, NULL);
1560
1561         field->u.list.selected_table =
1562                 g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
1563
1564         return field;
1565 }
1566
1567 void
1568 purple_request_field_list_set_multi_select(PurpleRequestField *field,
1569                                                                                  gboolean multi_select)
1570 {
1571         g_return_if_fail(field != NULL);
1572         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_LIST);
1573
1574         field->u.list.multiple_selection = multi_select;
1575 }
1576
1577 gboolean
1578 purple_request_field_list_get_multi_select(const PurpleRequestField *field)
1579 {
1580         g_return_val_if_fail(field != NULL, FALSE);
1581         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_LIST, FALSE);
1582
1583         return field->u.list.multiple_selection;
1584 }
1585
1586 void *
1587 purple_request_field_list_get_data(const PurpleRequestField *field,
1588                                                                  const char *text)
1589 {
1590         g_return_val_if_fail(field != NULL, NULL);
1591         g_return_val_if_fail(text  != NULL, NULL);
1592         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_LIST, NULL);
1593
1594         return g_hash_table_lookup(field->u.list.item_data, text);
1595 }
1596
1597 void
1598 purple_request_field_list_add_icon(PurpleRequestField *field, const char *item, const char* icon_path,
1599                                                         void *data)
1600 {
1601         g_return_if_fail(field != NULL);
1602         g_return_if_fail(item  != NULL);
1603         g_return_if_fail(data  != NULL);
1604         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_LIST);
1605
1606         if (icon_path)
1607         {
1608                 if (field->u.list.icons == NULL)
1609                 {
1610                         GList *l;
1611                         for (l = field->u.list.items ; l != NULL ; l = l->next)
1612                         {
1613                                 /* Order doesn't matter, because we're just
1614                                  * filing in blank items.  So, we use
1615                                  * g_list_prepend() because it's faster. */
1616                                 field->u.list.icons = g_list_prepend(field->u.list.icons, NULL);
1617                         }
1618                 }
1619                 field->u.list.icons = g_list_append(field->u.list.icons, g_strdup(icon_path));
1620         }
1621         else if (field->u.list.icons)
1622         {
1623                 /* Keep this even with the items list. */
1624                 field->u.list.icons = g_list_append(field->u.list.icons, NULL);
1625         }
1626
1627         field->u.list.items = g_list_append(field->u.list.items, g_strdup(item));
1628         g_hash_table_insert(field->u.list.item_data, g_strdup(item), data);
1629 }
1630
1631 void
1632 purple_request_field_list_add_selected(PurpleRequestField *field, const char *item)
1633 {
1634         g_return_if_fail(field != NULL);
1635         g_return_if_fail(item  != NULL);
1636         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_LIST);
1637
1638         if (!purple_request_field_list_get_multi_select(field) &&
1639                 field->u.list.selected != NULL)
1640         {
1641                 purple_debug_warning("request",
1642                                                    "More than one item added to non-multi-select "
1643                                                    "field %s\n",
1644                                                    purple_request_field_get_id(field));
1645                 return;
1646         }
1647
1648         field->u.list.selected = g_list_append(field->u.list.selected,
1649                                                                                    g_strdup(item));
1650
1651         g_hash_table_insert(field->u.list.selected_table, g_strdup(item), NULL);
1652 }
1653
1654 void
1655 purple_request_field_list_clear_selected(PurpleRequestField *field)
1656 {
1657         g_return_if_fail(field != NULL);
1658         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_LIST);
1659
1660         if (field->u.list.selected != NULL)
1661         {
1662                 g_list_free_full(field->u.list.selected, g_free);
1663                 field->u.list.selected = NULL;
1664         }
1665
1666         g_hash_table_destroy(field->u.list.selected_table);
1667
1668         field->u.list.selected_table =
1669                 g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
1670 }
1671
1672 void
1673 purple_request_field_list_set_selected(PurpleRequestField *field, GList *items)
1674 {
1675         GList *l;
1676
1677         g_return_if_fail(field != NULL);
1678         g_return_if_fail(items != NULL);
1679         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_LIST);
1680
1681         purple_request_field_list_clear_selected(field);
1682
1683         if (!purple_request_field_list_get_multi_select(field) && items->next) {
1684                 purple_debug_warning("request",
1685                                                    "More than one item added to non-multi-select "
1686                                                    "field %s\n",
1687                                                    purple_request_field_get_id(field));
1688                 return;
1689         }
1690
1691         for (l = items; l != NULL; l = l->next)
1692         {
1693                 field->u.list.selected = g_list_append(field->u.list.selected,
1694                                         g_strdup(l->data));
1695                 g_hash_table_insert(field->u.list.selected_table,
1696                                                         g_strdup((char *)l->data), NULL);
1697         }
1698 }
1699
1700 gboolean
1701 purple_request_field_list_is_selected(const PurpleRequestField *field,
1702                                                                         const char *item)
1703 {
1704         g_return_val_if_fail(field != NULL, FALSE);
1705         g_return_val_if_fail(item  != NULL, FALSE);
1706         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_LIST, FALSE);
1707
1708         return g_hash_table_lookup_extended(field->u.list.selected_table,
1709                                                                                 item, NULL, NULL);
1710 }
1711
1712 GList *
1713 purple_request_field_list_get_selected(const PurpleRequestField *field)
1714 {
1715         g_return_val_if_fail(field != NULL, NULL);
1716         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_LIST, NULL);
1717
1718         return field->u.list.selected;
1719 }
1720
1721 GList *
1722 purple_request_field_list_get_items(const PurpleRequestField *field)
1723 {
1724         g_return_val_if_fail(field != NULL, NULL);
1725         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_LIST, NULL);
1726
1727         return field->u.list.items;
1728 }
1729
1730 GList *
1731 purple_request_field_list_get_icons(const PurpleRequestField *field)
1732 {
1733         g_return_val_if_fail(field != NULL, NULL);
1734         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_LIST, NULL);
1735
1736         return field->u.list.icons;
1737 }
1738
1739 PurpleRequestField *
1740 purple_request_field_label_new(const char *id, const char *text)
1741 {
1742         PurpleRequestField *field;
1743
1744         g_return_val_if_fail(id   != NULL, NULL);
1745         g_return_val_if_fail(text != NULL, NULL);
1746
1747         field = purple_request_field_new(id, text, PURPLE_REQUEST_FIELD_LABEL);
1748
1749         return field;
1750 }
1751
1752 PurpleRequestField *
1753 purple_request_field_image_new(const char *id, const char *text, const char *buf, gsize size)
1754 {
1755         PurpleRequestField *field;
1756
1757         g_return_val_if_fail(id   != NULL, NULL);
1758         g_return_val_if_fail(text != NULL, NULL);
1759         g_return_val_if_fail(buf  != NULL, NULL);
1760         g_return_val_if_fail(size > 0, NULL);
1761
1762         field = purple_request_field_new(id, text, PURPLE_REQUEST_FIELD_IMAGE);
1763
1764         field->u.image.buffer  = g_memdup(buf, size);
1765         field->u.image.size    = size;
1766         field->u.image.scale_x = 1;
1767         field->u.image.scale_y = 1;
1768
1769         return field;
1770 }
1771
1772 void
1773 purple_request_field_image_set_scale(PurpleRequestField *field, unsigned int x, unsigned int y)
1774 {
1775         g_return_if_fail(field != NULL);
1776         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_IMAGE);
1777
1778         field->u.image.scale_x = x;
1779         field->u.image.scale_y = y;
1780 }
1781
1782 const char *
1783 purple_request_field_image_get_buffer(PurpleRequestField *field)
1784 {
1785         g_return_val_if_fail(field != NULL, NULL);
1786         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_IMAGE, NULL);
1787
1788         return field->u.image.buffer;
1789 }
1790
1791 gsize
1792 purple_request_field_image_get_size(PurpleRequestField *field)
1793 {
1794         g_return_val_if_fail(field != NULL, 0);
1795         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_IMAGE, 0);
1796
1797         return field->u.image.size;
1798 }
1799
1800 unsigned int
1801 purple_request_field_image_get_scale_x(PurpleRequestField *field)
1802 {
1803         g_return_val_if_fail(field != NULL, 0);
1804         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_IMAGE, 0);
1805
1806         return field->u.image.scale_x;
1807 }
1808
1809 unsigned int
1810 purple_request_field_image_get_scale_y(PurpleRequestField *field)
1811 {
1812         g_return_val_if_fail(field != NULL, 0);
1813         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_IMAGE, 0);
1814
1815         return field->u.image.scale_y;
1816 }
1817
1818 PurpleRequestField *
1819 purple_request_field_account_new(const char *id, const char *text,
1820                                                            PurpleAccount *account)
1821 {
1822         PurpleRequestField *field;
1823
1824         g_return_val_if_fail(id   != NULL, NULL);
1825         g_return_val_if_fail(text != NULL, NULL);
1826
1827         field = purple_request_field_new(id, text, PURPLE_REQUEST_FIELD_ACCOUNT);
1828
1829         if (account == NULL && purple_connections_get_all() != NULL)
1830         {
1831                 account = purple_connection_get_account(
1832                         (PurpleConnection *)purple_connections_get_all()->data);
1833         }
1834
1835         purple_request_field_account_set_default_value(field, account);
1836         purple_request_field_account_set_value(field, account);
1837
1838         return field;
1839 }
1840
1841 void
1842 purple_request_field_account_set_default_value(PurpleRequestField *field,
1843                                                                                          PurpleAccount *default_value)
1844 {
1845         g_return_if_fail(field != NULL);
1846         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_ACCOUNT);
1847
1848         field->u.account.default_account = default_value;
1849 }
1850
1851 void
1852 purple_request_field_account_set_value(PurpleRequestField *field,
1853                                                                          PurpleAccount *value)
1854 {
1855         g_return_if_fail(field != NULL);
1856         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_ACCOUNT);
1857
1858         field->u.account.account = value;
1859
1860         purple_request_fields_check_others_sensitivity(field);
1861 }
1862
1863 void
1864 purple_request_field_account_set_show_all(PurpleRequestField *field,
1865                                                                                 gboolean show_all)
1866 {
1867         g_return_if_fail(field != NULL);
1868         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_ACCOUNT);
1869
1870         if (field->u.account.show_all == show_all)
1871                 return;
1872
1873         field->u.account.show_all = show_all;
1874
1875         if (!show_all)
1876         {
1877                 if (purple_account_is_connected(field->u.account.default_account))
1878                 {
1879                         purple_request_field_account_set_default_value(field,
1880                                 (PurpleAccount *)purple_connections_get_all()->data);
1881                 }
1882
1883                 if (purple_account_is_connected(field->u.account.account))
1884                 {
1885                         purple_request_field_account_set_value(field,
1886                                 (PurpleAccount *)purple_connections_get_all()->data);
1887                 }
1888         }
1889 }
1890
1891 void
1892 purple_request_field_account_set_filter(PurpleRequestField *field,
1893                                                                           PurpleFilterAccountFunc filter_func)
1894 {
1895         g_return_if_fail(field != NULL);
1896         g_return_if_fail(field->type == PURPLE_REQUEST_FIELD_ACCOUNT);
1897
1898         field->u.account.filter_func = filter_func;
1899 }
1900
1901 PurpleAccount *
1902 purple_request_field_account_get_default_value(const PurpleRequestField *field)
1903 {
1904         g_return_val_if_fail(field != NULL, NULL);
1905         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_ACCOUNT, NULL);
1906
1907         return field->u.account.default_account;
1908 }
1909
1910 PurpleAccount *
1911 purple_request_field_account_get_value(const PurpleRequestField *field)
1912 {
1913         g_return_val_if_fail(field != NULL, NULL);
1914         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_ACCOUNT, NULL);
1915
1916         return field->u.account.account;
1917 }
1918
1919 gboolean
1920 purple_request_field_account_get_show_all(const PurpleRequestField *field)
1921 {
1922         g_return_val_if_fail(field != NULL, FALSE);
1923         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_ACCOUNT, FALSE);
1924
1925         return field->u.account.show_all;
1926 }
1927
1928 PurpleFilterAccountFunc
1929 purple_request_field_account_get_filter(const PurpleRequestField *field)
1930 {
1931         g_return_val_if_fail(field != NULL, FALSE);
1932         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_ACCOUNT, FALSE);
1933
1934         return field->u.account.filter_func;
1935 }
1936
1937 PurpleRequestField *
1938 purple_request_field_datasheet_new(const char *id,
1939         const gchar *text, PurpleRequestDatasheet *sheet)
1940 {
1941         PurpleRequestField *field;
1942
1943         g_return_val_if_fail(id != NULL, NULL);
1944         g_return_val_if_fail(sheet != NULL, NULL);
1945
1946         field = purple_request_field_new(id, text, PURPLE_REQUEST_FIELD_DATASHEET);
1947
1948         field->u.datasheet.sheet = sheet;
1949
1950         return field;
1951 }
1952
1953 PurpleRequestDatasheet *
1954 purple_request_field_datasheet_get_sheet(PurpleRequestField *field)
1955 {
1956         g_return_val_if_fail(field != NULL, NULL);
1957         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_DATASHEET, NULL);
1958
1959         return field->u.datasheet.sheet;
1960 }
1961
1962 /* -- */
1963
1964 gboolean
1965 purple_request_field_email_validator(PurpleRequestField *field, gchar **errmsg,
1966         void *user_data)
1967 {
1968         const char *value;
1969
1970         g_return_val_if_fail(field != NULL, FALSE);
1971         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_STRING, FALSE);
1972
1973         value = purple_request_field_string_get_value(field);
1974
1975         if (value != NULL && purple_email_is_valid(value))
1976                 return TRUE;
1977
1978         if (errmsg)
1979                 *errmsg = g_strdup(_("Invalid email address"));
1980         return FALSE;
1981 }
1982
1983 gboolean
1984 purple_request_field_alphanumeric_validator(PurpleRequestField *field,
1985         gchar **errmsg, void *allowed_characters)
1986 {
1987         const char *value;
1988         gchar invalid_char = '\0';
1989
1990         g_return_val_if_fail(field != NULL, FALSE);
1991         g_return_val_if_fail(field->type == PURPLE_REQUEST_FIELD_STRING, FALSE);
1992
1993         value = purple_request_field_string_get_value(field);
1994
1995         g_return_val_if_fail(value != NULL, FALSE);
1996
1997         if (allowed_characters)
1998         {
1999                 gchar *value_r = g_strdup(value);
2000                 g_strcanon(value_r, allowed_characters, '\0');
2001                 invalid_char = value[strlen(value_r)];
2002                 g_free(value_r);
2003         }
2004         else
2005         {
2006                 while (value)
2007                 {
2008                         if (!g_ascii_isalnum(*value))
2009                         {
2010                                 invalid_char = *value;
2011                                 break;
2012                         }
2013                         value++;
2014                 }
2015         }
2016         if (!invalid_char)
2017                 return TRUE;
2018
2019         if (errmsg)
2020                 *errmsg = g_strdup_printf(_("Invalid character '%c'"),
2021                         invalid_char);
2022         return FALSE;
2023 }
2024
2025 /* -- */
2026
2027 static gchar *
2028 purple_request_strip_html_custom(const gchar *html)
2029 {
2030         gchar *tmp, *ret;
2031
2032         tmp = purple_strreplace(html, "\n", "<br>");
2033         ret = purple_markup_strip_html(tmp);
2034         g_free(tmp);
2035
2036         return ret;
2037 }
2038
2039 static gchar **
2040 purple_request_strip_html(PurpleRequestCommonParameters *cpar,
2041         const char **primary, const char **secondary)
2042 {
2043         PurpleRequestUiOps *ops = purple_request_get_ui_ops();
2044         gchar **ret;
2045
2046         if (!purple_request_cpar_is_html(cpar))
2047                 return NULL;
2048         if (ops->features & PURPLE_REQUEST_FEATURE_HTML)
2049                 return NULL;
2050
2051         ret = g_new0(gchar*, 3);
2052         *primary = ret[0] = purple_request_strip_html_custom(*primary);
2053         *secondary = ret[1] = purple_request_strip_html_custom(*secondary);
2054
2055         return ret;
2056 }
2057
2058 void *
2059 purple_request_input(void *handle, const char *title, const char *primary,
2060                                    const char *secondary, const char *default_value,
2061                                    gboolean multiline, gboolean masked, gchar *hint,
2062                                    const char *ok_text, GCallback ok_cb,
2063                                    const char *cancel_text, GCallback cancel_cb,
2064                                    PurpleRequestCommonParameters *cpar,
2065                                    void *user_data)
2066 {
2067         PurpleRequestUiOps *ops;
2068
2069         if (G_UNLIKELY(ok_text == NULL || ok_cb == NULL)) {
2070                 purple_request_cpar_unref(cpar);
2071                 g_warn_if_fail(ok_text != NULL);
2072                 g_warn_if_fail(ok_cb != NULL);
2073                 g_return_val_if_reached(NULL);
2074         }
2075
2076         ops = purple_request_get_ui_ops();
2077
2078         if (ops != NULL && ops->request_input != NULL) {
2079                 PurpleRequestInfo *info;
2080                 gchar **tmp;
2081
2082                 tmp = purple_request_strip_html(cpar, &primary, &secondary);
2083
2084                 info            = g_new0(PurpleRequestInfo, 1);
2085                 info->type      = PURPLE_REQUEST_INPUT;
2086                 info->handle    = handle;
2087                 info->ui_handle = ops->request_input(title, primary, secondary,
2088                         default_value, multiline, masked, hint, ok_text, ok_cb,
2089                         cancel_text, cancel_cb, cpar, user_data);
2090
2091                 handles = g_list_append(handles, info);
2092
2093                 g_strfreev(tmp);
2094                 purple_request_cpar_unref(cpar);
2095                 return info->ui_handle;
2096         }
2097
2098         purple_request_cpar_unref(cpar);
2099         return NULL;
2100 }
2101
2102 void *
2103 purple_request_choice(void *handle, const char *title, const char *primary,
2104         const char *secondary, gpointer default_value, const char *ok_text,
2105         GCallback ok_cb, const char *cancel_text, GCallback cancel_cb,
2106         PurpleRequestCommonParameters *cpar, void *user_data, ...)
2107 {
2108         void *ui_handle;
2109         va_list args;
2110
2111         if (G_UNLIKELY(ok_text == NULL || ok_cb == NULL)) {
2112                 purple_request_cpar_unref(cpar);
2113                 g_warn_if_fail(ok_text != NULL);
2114                 g_warn_if_fail(ok_cb != NULL);
2115                 g_return_val_if_reached(NULL);
2116         }
2117
2118         va_start(args, user_data);
2119         ui_handle = purple_request_choice_varg(handle, title, primary, secondary,
2120                                              default_value, ok_text, ok_cb,
2121                                              cancel_text, cancel_cb,
2122                                              cpar, user_data, args);
2123         va_end(args);
2124
2125         return ui_handle;
2126 }
2127
2128 void *
2129 purple_request_choice_varg(void *handle, const char *title, const char *primary,
2130         const char *secondary, gpointer default_value, const char *ok_text,
2131         GCallback ok_cb, const char *cancel_text, GCallback cancel_cb,
2132         PurpleRequestCommonParameters *cpar, void *user_data, va_list choices)
2133 {
2134         PurpleRequestUiOps *ops;
2135
2136         if (G_UNLIKELY(ok_text == NULL || ok_cb == NULL ||
2137                 cancel_text == NULL))
2138         {
2139                 purple_request_cpar_unref(cpar);
2140                 g_warn_if_fail(ok_text != NULL);
2141                 g_warn_if_fail(ok_cb != NULL);
2142                 g_warn_if_fail(cancel_text != NULL);
2143                 g_return_val_if_reached(NULL);
2144         }
2145
2146         ops = purple_request_get_ui_ops();
2147
2148         if (ops != NULL && ops->request_choice != NULL) {
2149                 PurpleRequestInfo *info;
2150                 gchar **tmp;
2151
2152                 tmp = purple_request_strip_html(cpar, &primary, &secondary);
2153
2154                 info            = g_new0(PurpleRequestInfo, 1);
2155                 info->type      = PURPLE_REQUEST_CHOICE;
2156                 info->handle    = handle;
2157                 info->ui_handle = ops->request_choice(title, primary, secondary,
2158                         default_value, ok_text, ok_cb, cancel_text, cancel_cb,
2159                         cpar, user_data, choices);
2160
2161                 handles = g_list_append(handles, info);
2162
2163                 g_strfreev(tmp);
2164                 purple_request_cpar_unref(cpar);
2165                 return info->ui_handle;
2166         }
2167
2168         purple_request_cpar_unref(cpar);
2169         return NULL;
2170 }
2171
2172 void *
2173 purple_request_action(void *handle, const char *title, const char *primary,
2174         const char *secondary, int default_action,
2175         PurpleRequestCommonParameters *cpar, void *user_data,
2176         size_t action_count, ...)
2177 {
2178         void *ui_handle;
2179         va_list args;
2180
2181         va_start(args, action_count);
2182         ui_handle = purple_request_action_varg(handle, title, primary,
2183                 secondary, default_action, cpar, user_data, action_count, args);
2184         va_end(args);
2185
2186         return ui_handle;
2187 }
2188
2189 void *
2190 purple_request_action_varg(void *handle, const char *title, const char *primary,
2191         const char *secondary, int default_action,
2192         PurpleRequestCommonParameters *cpar, void *user_data,
2193         size_t action_count, va_list actions)
2194 {
2195         PurpleRequestUiOps *ops;
2196
2197         ops = purple_request_get_ui_ops();
2198
2199         if (ops != NULL && ops->request_action != NULL) {
2200                 PurpleRequestInfo *info;
2201                 gchar **tmp;
2202
2203                 tmp = purple_request_strip_html(cpar, &primary, &secondary);
2204
2205                 info            = g_new0(PurpleRequestInfo, 1);
2206                 info->type      = PURPLE_REQUEST_ACTION;
2207                 info->handle    = handle;
2208                 info->ui_handle = ops->request_action(title, primary, secondary,
2209                         default_action, cpar, user_data, action_count, actions);
2210
2211                 handles = g_list_append(handles, info);
2212
2213                 g_strfreev(tmp);
2214                 purple_request_cpar_unref(cpar);
2215                 return info->ui_handle;
2216         }
2217
2218         purple_request_cpar_unref(cpar);
2219         return NULL;
2220 }
2221
2222 void *
2223 purple_request_wait(void *handle, const char *title, const char *primary,
2224         const char *secondary, gboolean with_progress,
2225         PurpleRequestCancelCb cancel_cb, PurpleRequestCommonParameters *cpar,
2226         void *user_data)
2227 {
2228         PurpleRequestUiOps *ops;
2229
2230         if (primary == NULL)
2231                 primary = _("Please wait...");
2232
2233         ops = purple_request_get_ui_ops();
2234
2235         if (ops != NULL && ops->request_wait != NULL) {
2236                 PurpleRequestInfo *info;
2237                 gchar **tmp;
2238
2239                 tmp = purple_request_strip_html(cpar, &primary, &secondary);
2240
2241                 info            = g_new0(PurpleRequestInfo, 1);
2242                 info->type      = PURPLE_REQUEST_WAIT;
2243                 info->handle    = handle;
2244                 info->ui_handle = ops->request_wait(title, primary, secondary,
2245                         with_progress, cancel_cb, cpar, user_data);
2246
2247                 handles = g_list_append(handles, info);
2248
2249                 g_strfreev(tmp);
2250                 purple_request_cpar_unref(cpar);
2251                 return info->ui_handle;
2252         }
2253
2254         if (cpar == NULL)
2255                 cpar = purple_request_cpar_new();
2256         if (purple_request_cpar_get_icon(cpar) == PURPLE_REQUEST_ICON_DEFAULT)
2257                 purple_request_cpar_set_icon(cpar, PURPLE_REQUEST_ICON_WAIT);
2258
2259         return purple_request_action(handle, title, primary, secondary,
2260                 PURPLE_DEFAULT_ACTION_NONE, cpar, user_data,
2261                 cancel_cb ? 1 : 0, _("Cancel"), cancel_cb);
2262 }
2263
2264 void
2265 purple_request_wait_pulse(void *ui_handle)
2266 {
2267         PurpleRequestUiOps *ops;
2268
2269         ops = purple_request_get_ui_ops();
2270
2271         if (ops == NULL || ops->request_wait_update == NULL)
2272                 return;
2273
2274         ops->request_wait_update(ui_handle, TRUE, 0.0);
2275 }
2276
2277 void
2278 purple_request_wait_progress(void *ui_handle, gfloat fraction)
2279 {
2280         PurpleRequestUiOps *ops;
2281
2282         ops = purple_request_get_ui_ops();
2283
2284         if (ops == NULL || ops->request_wait_update == NULL)
2285                 return;
2286
2287         if (fraction < 0.0 || fraction > 1.0) {
2288                 purple_debug_warning("request", "Fraction parameter out of "
2289                         "range: %f", fraction);
2290                 if (fraction < 0.0)
2291                         fraction = 0.0;
2292                 else /* if (fraction > 1.0) */
2293                         fraction = 1.0;
2294         }
2295
2296         ops->request_wait_update(ui_handle, FALSE, fraction);
2297 }
2298
2299 static void
2300 purple_request_fields_strip_html(PurpleRequestFields *fields)
2301 {
2302         GList *itg;
2303
2304         for (itg = fields->groups; itg != NULL; itg = g_list_next(itg)) {
2305                 PurpleRequestFieldGroup *group = itg->data;
2306                 GList *itf;
2307
2308                 for (itf = group->fields; itf != NULL; itf = g_list_next(itf)) {
2309                         PurpleRequestField *field = itf->data;
2310                         gchar *new_label;
2311
2312                         new_label = purple_request_strip_html_custom(
2313                                 field->label);
2314                         if (g_strcmp0(new_label, field->label) == 0) {
2315                                 g_free(new_label);
2316                                 continue;
2317                         }
2318                         g_free(field->label);
2319                         field->label = new_label;
2320                 }
2321         }
2322 }
2323
2324 void *
2325 purple_request_fields(void *handle, const char *title, const char *primary,
2326         const char *secondary, PurpleRequestFields *fields, const char *ok_text,
2327         GCallback ok_cb, const char *cancel_text, GCallback cancel_cb,
2328         PurpleRequestCommonParameters *cpar, void *user_data)
2329 {
2330         PurpleRequestUiOps *ops;
2331
2332         if (G_UNLIKELY(fields == NULL ||
2333                 ((ok_text == NULL) != (ok_cb == NULL)) ||
2334                 cancel_text == NULL))
2335         {
2336                 purple_request_cpar_unref(cpar);
2337                 g_warn_if_fail(fields != NULL);
2338                 g_warn_if_fail((ok_text == NULL) != (ok_cb == NULL));
2339                 g_warn_if_fail(cancel_text != NULL);
2340                 g_return_val_if_reached(NULL);
2341         }
2342
2343         ops = purple_request_get_ui_ops();
2344
2345         if (purple_request_cpar_is_html(cpar) &&
2346                 !((ops->features & PURPLE_REQUEST_FEATURE_HTML)))
2347         {
2348                 purple_request_fields_strip_html(fields);
2349         }
2350
2351         purple_request_fields_check_sensitivity(fields);
2352
2353         if (ops != NULL && ops->request_fields != NULL) {
2354                 PurpleRequestInfo *info;
2355                 gchar **tmp;
2356
2357                 tmp = purple_request_strip_html(cpar, &primary, &secondary);
2358
2359                 info            = g_new0(PurpleRequestInfo, 1);
2360                 info->type      = PURPLE_REQUEST_FIELDS;
2361                 info->handle    = handle;
2362                 info->ui_handle = ops->request_fields(title, primary, secondary,
2363                         fields, ok_text, ok_cb, cancel_text, cancel_cb,
2364                         cpar, user_data);
2365
2366                 handles = g_list_append(handles, info);
2367
2368                 g_strfreev(tmp);
2369                 purple_request_cpar_unref(cpar);
2370                 return info->ui_handle;
2371         }
2372
2373         purple_request_cpar_unref(cpar);
2374         return NULL;
2375 }
2376
2377 void *
2378 purple_request_file(void *handle, const char *title, const char *filename,
2379         gboolean savedialog, GCallback ok_cb, GCallback cancel_cb,
2380         PurpleRequestCommonParameters *cpar, void *user_data)
2381 {
2382         PurpleRequestUiOps *ops;
2383
2384         ops = purple_request_get_ui_ops();
2385
2386         if (ops != NULL && ops->request_file != NULL) {
2387                 PurpleRequestInfo *info;
2388
2389                 info            = g_new0(PurpleRequestInfo, 1);
2390                 info->type      = PURPLE_REQUEST_FILE;
2391                 info->handle    = handle;
2392                 info->ui_handle = ops->request_file(title, filename, savedialog,
2393                         ok_cb, cancel_cb, cpar, user_data);
2394                 handles = g_list_append(handles, info);
2395
2396                 purple_request_cpar_unref(cpar);
2397                 return info->ui_handle;
2398         }
2399
2400         purple_request_cpar_unref(cpar);
2401         return NULL;
2402 }
2403
2404 void *
2405 purple_request_folder(void *handle, const char *title, const char *dirname,
2406         GCallback ok_cb, GCallback cancel_cb,
2407         PurpleRequestCommonParameters *cpar, void *user_data)
2408 {
2409         PurpleRequestUiOps *ops;
2410
2411         ops = purple_request_get_ui_ops();
2412
2413         if (ops != NULL && ops->request_file != NULL) {
2414                 PurpleRequestInfo *info;
2415
2416                 info            = g_new0(PurpleRequestInfo, 1);
2417                 info->type      = PURPLE_REQUEST_FOLDER;
2418                 info->handle    = handle;
2419                 info->ui_handle = ops->request_folder(title, dirname, ok_cb,
2420                         cancel_cb, cpar, user_data);
2421                 handles = g_list_append(handles, info);
2422
2423                 purple_request_cpar_unref(cpar);
2424                 return info->ui_handle;
2425         }
2426
2427         purple_request_cpar_unref(cpar);
2428         return NULL;
2429 }
2430
2431 gboolean
2432 purple_request_is_valid_ui_handle(void *ui_handle, PurpleRequestType *type)
2433 {
2434         PurpleRequestInfo *info;
2435
2436         if (ui_handle == NULL)
2437                 return FALSE;
2438
2439         info = purple_request_info_from_ui_handle(ui_handle);
2440
2441         if (info == NULL)
2442                 return FALSE;
2443
2444         if (type != NULL)
2445                 *type = info->type;
2446
2447         return TRUE;
2448 }
2449
2450 void
2451 purple_request_add_close_notify(void *ui_handle, GDestroyNotify notify,
2452         gpointer notify_data)
2453 {
2454         PurpleRequestInfo *info;
2455         PurpleRequestCloseNotified *notified;
2456
2457         g_return_if_fail(ui_handle != NULL);
2458         g_return_if_fail(notify != NULL);
2459
2460         info = purple_request_info_from_ui_handle(ui_handle);
2461         g_return_if_fail(info != NULL);
2462
2463         notified = g_new0(PurpleRequestCloseNotified, 1);
2464         notified->cb = notify;
2465         notified->data = notify_data;
2466
2467         info->notify_on_close = g_slist_append(info->notify_on_close, notified);
2468 }
2469
2470 static void
2471 purple_request_close_info(PurpleRequestInfo *info)
2472 {
2473         PurpleRequestUiOps *ops;
2474         GSList *it;
2475
2476         ops = purple_request_get_ui_ops();
2477
2478         purple_notify_close_with_handle(info->ui_handle);
2479         purple_request_close_with_handle(info->ui_handle);
2480
2481         if (ops != NULL && ops->close_request != NULL)
2482                 ops->close_request(info->type, info->ui_handle);
2483
2484         for (it = info->notify_on_close; it; it = g_slist_next(it)) {
2485                 PurpleRequestCloseNotified *notify = it->data;
2486
2487                 notify->cb(notify->data);
2488         }
2489
2490         g_slist_free_full(info->notify_on_close, g_free);
2491         g_free(info);
2492 }
2493
2494 void
2495 purple_request_close(PurpleRequestType type, void *ui_handle)
2496 {
2497         GList *l;
2498
2499         g_return_if_fail(ui_handle != NULL);
2500
2501         for (l = handles; l != NULL; l = l->next) {
2502                 PurpleRequestInfo *info = l->data;
2503
2504                 if (info->ui_handle == ui_handle) {
2505                         handles = g_list_remove(handles, info);
2506                         purple_request_close_info(info);
2507                         break;
2508                 }
2509         }
2510 }
2511
2512 void
2513 purple_request_close_with_handle(void *handle)
2514 {
2515         GList *l, *l_next;
2516
2517         g_return_if_fail(handle != NULL);
2518
2519         for (l = handles; l != NULL; l = l_next) {
2520                 PurpleRequestInfo *info = l->data;
2521
2522                 l_next = l->next;
2523
2524                 if (info->handle == handle) {
2525                         handles = g_list_remove(handles, info);
2526                         purple_request_close_info(info);
2527                 }
2528         }
2529 }
2530
2531 void
2532 purple_request_set_ui_ops(PurpleRequestUiOps *ops)
2533 {
2534         request_ui_ops = ops;
2535 }
2536
2537 PurpleRequestUiOps *
2538 purple_request_get_ui_ops(void)
2539 {
2540         return request_ui_ops;
2541 }
2542
2543 /**************************************************************************
2544  * GBoxed code
2545  **************************************************************************/
2546 static PurpleRequestUiOps *
2547 purple_request_ui_ops_copy(PurpleRequestUiOps *ops)
2548 {
2549         PurpleRequestUiOps *ops_new;
2550
2551         g_return_val_if_fail(ops != NULL, NULL);
2552
2553         ops_new = g_new(PurpleRequestUiOps, 1);
2554         *ops_new = *ops;
2555
2556         return ops_new;
2557 }
2558
2559 GType
2560 purple_request_ui_ops_get_type(void)
2561 {
2562         static GType type = 0;
2563
2564         if (type == 0) {
2565                 type = g_boxed_type_register_static("PurpleRequestUiOps",
2566                                 (GBoxedCopyFunc)purple_request_ui_ops_copy,
2567                                 (GBoxedFreeFunc)g_free);
2568         }
2569
2570         return type;
2571 }