libpurple/roomlist.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 "glibcompat.h"
  24
  25 #include "account.h"
  26 #include "connection.h"
  27 #include "debug.h"
  28 #include "roomlist.h"
  29 #include "server.h"
  30
  31 typedef struct _PurpleRoomlistPrivate  PurpleRoomlistPrivate;
  32
  33 /*
  34  * Private data for a room list.
  35  */
  36 struct _PurpleRoomlistPrivate {
  37         PurpleAccount *account;  /* The account this list belongs to. */
  38         GList *fields;           /* The fields.                       */
  39         GList *rooms;            /* The list of rooms.                */
  40         gboolean in_progress;    /* The listing is in progress.       */
  41
  42         /* TODO Remove this and use protocol-specific subclasses. */
  43         gpointer proto_data;     /* Protocol private data.             */
  44 };
  45
  46 /*
  47  * Represents a room.
  48  */
  49 struct _PurpleRoomlistRoom {
  50         PurpleRoomlistRoomType type; /* The type of room. */
  51         gchar *name; /* The name of the room. */
  52         GList *fields; /* Other fields. */
  53         PurpleRoomlistRoom *parent; /* The parent room, or NULL. */
  54         gboolean expanded_once; /* A flag the UI uses to avoid multiple expand protocol cbs. */
  55 };
  56
  57 /*
  58  * A field a room might have.
  59  */
  60 struct _PurpleRoomlistField {
  61         PurpleRoomlistFieldType type; /* The type of field. */
  62         gchar *label; /* The i18n user displayed name of the field. */
  63         gchar *name; /* The internal name of the field. */
  64         gboolean hidden; /* Hidden? */
  65 };
  66
  67 /* Room list property enums */
  68 enum
  69 {
  70         PROP_0,
  71         PROP_ACCOUNT,
  72         PROP_FIELDS,
  73         PROP_IN_PROGRESS,
  74         PROP_LAST
  75 };
  76
  77 static GParamSpec *properties[PROP_LAST];
  78 static PurpleRoomlistUiOps *ops = NULL;
  79
  80 G_DEFINE_TYPE_WITH_PRIVATE(PurpleRoomlist, purple_roomlist, G_TYPE_OBJECT);
  81
  82 static void purple_roomlist_field_free(PurpleRoomlistField *f);
  83 static void purple_roomlist_room_destroy(PurpleRoomlist *list, PurpleRoomlistRoom *r);
  84
  85 /**************************************************************************/
  86 /* Room List API                                                          */
  87 /**************************************************************************/
  88
  89 void purple_roomlist_show_with_account(PurpleAccount *account)
  90 {
  91         if (ops && ops->show_with_account)
  92                 ops->show_with_account(account);
  93 }
  94
  95 PurpleAccount *purple_roomlist_get_account(PurpleRoomlist *list)
  96 {
  97         PurpleRoomlistPrivate *priv = NULL;
  98
  99         g_return_val_if_fail(PURPLE_IS_ROOMLIST(list), NULL);
 100
 101         priv = purple_roomlist_get_instance_private(list);
 102         return priv->account;
 103 }
 104
 105 void purple_roomlist_set_fields(PurpleRoomlist *list, GList *fields)
 106 {
 107         PurpleRoomlistPrivate *priv = NULL;
 108
 109         g_return_if_fail(PURPLE_IS_ROOMLIST(list));
 110
 111         priv = purple_roomlist_get_instance_private(list);
 112         priv->fields = fields;
 113
 114         if (ops && ops->set_fields)
 115                 ops->set_fields(list, fields);
 116
 117         g_object_notify_by_pspec(G_OBJECT(list), properties[PROP_FIELDS]);
 118 }
 119
 120 void purple_roomlist_set_in_progress(PurpleRoomlist *list, gboolean in_progress)
 121 {
 122         PurpleRoomlistPrivate *priv = NULL;
 123
 124         g_return_if_fail(PURPLE_IS_ROOMLIST(list));
 125
 126         priv = purple_roomlist_get_instance_private(list);
 127         priv->in_progress = in_progress;
 128
 129         if (ops && ops->in_progress)
 130                 ops->in_progress(list, in_progress);
 131
 132         g_object_notify_by_pspec(G_OBJECT(list), properties[PROP_IN_PROGRESS]);
 133 }
 134
 135 gboolean purple_roomlist_get_in_progress(PurpleRoomlist *list)
 136 {
 137         PurpleRoomlistPrivate *priv = NULL;
 138
 139         g_return_val_if_fail(PURPLE_IS_ROOMLIST(list), FALSE);
 140
 141         priv = purple_roomlist_get_instance_private(list);
 142         return priv->in_progress;
 143 }
 144
 145 void purple_roomlist_room_add(PurpleRoomlist *list, PurpleRoomlistRoom *room)
 146 {
 147         PurpleRoomlistPrivate *priv = NULL;
 148
 149         g_return_if_fail(PURPLE_IS_ROOMLIST(list));
 150         g_return_if_fail(room != NULL);
 151
 152         priv = purple_roomlist_get_instance_private(list);
 153         priv->rooms = g_list_append(priv->rooms, room);
 154
 155         if (ops && ops->add_room)
 156                 ops->add_room(list, room);
 157 }
 158
 159 PurpleRoomlist *purple_roomlist_get_list(PurpleConnection *gc)
 160 {
 161         PurpleProtocol *protocol = NULL;
 162
 163         g_return_val_if_fail(PURPLE_IS_CONNECTION(gc), NULL);
 164         g_return_val_if_fail(PURPLE_CONNECTION_IS_CONNECTED(gc), NULL);
 165
 166         protocol = purple_connection_get_protocol(gc);
 167
 168         if(protocol)
 169                 return purple_protocol_roomlist_iface_get_list(protocol, gc);
 170
 171         return NULL;
 172 }
 173
 174 void purple_roomlist_cancel_get_list(PurpleRoomlist *list)
 175 {
 176         PurpleRoomlistPrivate *priv = NULL;
 177         PurpleProtocol *protocol = NULL;
 178         PurpleConnection *gc;
 179
 180         g_return_if_fail(PURPLE_IS_ROOMLIST(list));
 181
 182         priv = purple_roomlist_get_instance_private(list);
 183
 184         gc = purple_account_get_connection(priv->account);
 185         g_return_if_fail(PURPLE_IS_CONNECTION(gc));
 186
 187         if(gc)
 188                 protocol = purple_connection_get_protocol(gc);
 189
 190         if(protocol)
 191                 purple_protocol_roomlist_iface_cancel(protocol, list);
 192 }
 193
 194 void purple_roomlist_expand_category(PurpleRoomlist *list, PurpleRoomlistRoom *category)
 195 {
 196         PurpleRoomlistPrivate *priv = NULL;
 197         PurpleProtocol *protocol = NULL;
 198         PurpleConnection *gc;
 199
 200         g_return_if_fail(PURPLE_IS_ROOMLIST(list));
 201         g_return_if_fail(category != NULL);
 202         g_return_if_fail(category->type & PURPLE_ROOMLIST_ROOMTYPE_CATEGORY);
 203
 204         priv = purple_roomlist_get_instance_private(list);
 205
 206         gc = purple_account_get_connection(priv->account);
 207         g_return_if_fail(PURPLE_IS_CONNECTION(gc));
 208
 209         if(gc)
 210                 protocol = purple_connection_get_protocol(gc);
 211
 212         if(protocol)
 213                 purple_protocol_roomlist_iface_expand_category(protocol, list, category);
 214 }
 215
 216 GList * purple_roomlist_get_fields(PurpleRoomlist *list)
 217 {
 218         PurpleRoomlistPrivate *priv = NULL;
 219
 220         g_return_val_if_fail(PURPLE_IS_ROOMLIST(list), NULL);
 221
 222         priv = purple_roomlist_get_instance_private(list);
 223         return priv->fields;
 224 }
 225
 226 gpointer purple_roomlist_get_protocol_data(PurpleRoomlist *list)
 227 {
 228         PurpleRoomlistPrivate *priv = NULL;
 229
 230         g_return_val_if_fail(PURPLE_IS_ROOMLIST(list), NULL);
 231
 232         priv = purple_roomlist_get_instance_private(list);
 233         return priv->proto_data;
 234 }
 235
 236 void purple_roomlist_set_protocol_data(PurpleRoomlist *list, gpointer proto_data)
 237 {
 238         PurpleRoomlistPrivate *priv = NULL;
 239
 240         g_return_if_fail(PURPLE_IS_ROOMLIST(list));
 241
 242         priv = purple_roomlist_get_instance_private(list);
 243         priv->proto_data = proto_data;
 244 }
 245
 246 gpointer purple_roomlist_get_ui_data(PurpleRoomlist *list)
 247 {
 248         g_return_val_if_fail(PURPLE_IS_ROOMLIST(list), NULL);
 249
 250         return list->ui_data;
 251 }
 252
 253 void purple_roomlist_set_ui_data(PurpleRoomlist *list, gpointer ui_data)
 254 {
 255         g_return_if_fail(PURPLE_IS_ROOMLIST(list));
 256
 257         list->ui_data = ui_data;
 258 }
 259
 260 /**************************************************************************/
 261 /* Room List GObject code                                                 */
 262 /**************************************************************************/
 263
 264 /* Set method for GObject properties */
 265 static void
 266 purple_roomlist_set_property(GObject *obj, guint param_id, const GValue *value,
 267                 GParamSpec *pspec)
 268 {
 269         PurpleRoomlist *list = PURPLE_ROOMLIST(obj);
 270         PurpleRoomlistPrivate *priv =
 271                         purple_roomlist_get_instance_private(list);
 272
 273         switch (param_id) {
 274                 case PROP_ACCOUNT:
 275                         priv->account = g_value_get_object(value);
 276                         break;
 277                 case PROP_FIELDS:
 278                         purple_roomlist_set_fields(list, g_value_get_pointer(value));
 279                         break;
 280                 case PROP_IN_PROGRESS:
 281                         purple_roomlist_set_in_progress(list, g_value_get_boolean(value));
 282                         break;
 283                 default:
 284                         G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
 285                         break;
 286         }
 287 }
 288
 289 /* Get method for GObject properties */
 290 static void
 291 purple_roomlist_get_property(GObject *obj, guint param_id, GValue *value,
 292                 GParamSpec *pspec)
 293 {
 294         PurpleRoomlist *list = PURPLE_ROOMLIST(obj);
 295
 296         switch (param_id) {
 297                 case PROP_ACCOUNT:
 298                         g_value_set_object(value, purple_roomlist_get_account(list));
 299                         break;
 300                 case PROP_FIELDS:
 301                         g_value_set_pointer(value, purple_roomlist_get_fields(list));
 302                         break;
 303                 case PROP_IN_PROGRESS:
 304                         g_value_set_boolean(value, purple_roomlist_get_in_progress(list));
 305                         break;
 306                 default:
 307                         G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
 308                         break;
 309         }
 310 }
 311
 312 static void
 313 purple_roomlist_init(PurpleRoomlist *list)
 314 {
 315 }
 316
 317 /* Called when done constructing */
 318 static void
 319 purple_roomlist_constructed(GObject *object)
 320 {
 321         PurpleRoomlist *list = PURPLE_ROOMLIST(object);
 322
 323         G_OBJECT_CLASS(purple_roomlist_parent_class)->constructed(object);
 324
 325         if (ops && ops->create)
 326                 ops->create(list);
 327 }
 328
 329 /* GObject finalize function */
 330 static void
 331 purple_roomlist_finalize(GObject *object)
 332 {
 333         PurpleRoomlist *list = PURPLE_ROOMLIST(object);
 334         PurpleRoomlistPrivate *priv =
 335                         purple_roomlist_get_instance_private(list);
 336         GList *l;
 337
 338         purple_debug_misc("roomlist", "destroying list %p\n", list);
 339
 340         if (ops && ops->destroy)
 341                 ops->destroy(list);
 342
 343         for (l = priv->rooms; l; l = l->next) {
 344                 PurpleRoomlistRoom *r = l->data;
 345                 purple_roomlist_room_destroy(list, r);
 346         }
 347         g_list_free(priv->rooms);
 348
 349         g_list_foreach(priv->fields, (GFunc)purple_roomlist_field_free, NULL);
 350         g_list_free(priv->fields);
 351
 352         G_OBJECT_CLASS(purple_roomlist_parent_class)->finalize(object);
 353 }
 354
 355 /* Class initializer function */
 356 static void
 357 purple_roomlist_class_init(PurpleRoomlistClass *klass)
 358 {
 359         GObjectClass *obj_class = G_OBJECT_CLASS(klass);
 360
 361         obj_class->finalize = purple_roomlist_finalize;
 362         obj_class->constructed = purple_roomlist_constructed;
 363
 364         /* Setup properties */
 365         obj_class->get_property = purple_roomlist_get_property;
 366         obj_class->set_property = purple_roomlist_set_property;
 367
 368         properties[PROP_ACCOUNT] = g_param_spec_object("account", "Account",
 369                                 "The account for the room list.",
 370                                 PURPLE_TYPE_ACCOUNT,
 371                                 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 372                                 G_PARAM_STATIC_STRINGS);
 373
 374         properties[PROP_FIELDS] = g_param_spec_pointer("fields", "Fields",
 375                                 "The list of fields for a roomlist.",
 376                                 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 377
 378         properties[PROP_IN_PROGRESS] = g_param_spec_boolean("in-progress",
 379                                 "In progress",
 380                                 "Whether the room list is being fetched.", FALSE,
 381                                 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 382
 383         g_object_class_install_properties(obj_class, PROP_LAST, properties);
 384 }
 385
 386 PurpleRoomlist *purple_roomlist_new(PurpleAccount *account)
 387 {
 388         PurpleRoomlist *list;
 389         PurpleProtocol *protocol;
 390
 391         g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
 392
 393         protocol = purple_protocols_find(purple_account_get_protocol_id(account));
 394
 395         g_return_val_if_fail(PURPLE_IS_PROTOCOL(protocol), NULL);
 396
 397         if (PURPLE_PROTOCOL_IMPLEMENTS(protocol, FACTORY, roomlist_new))
 398                 list = purple_protocol_factory_iface_roomlist_new(protocol, account);
 399         else
 400                 list = g_object_new(PURPLE_TYPE_ROOMLIST,
 401                         "account", account,
 402                         NULL
 403                 );
 404
 405         g_return_val_if_fail(list != NULL, NULL);
 406
 407         return list;
 408 }
 409
 410 /**************************************************************************
 411  * Protocol Roomlist Interface API
 412  **************************************************************************/
 413 #define DEFINE_PROTOCOL_FUNC(protocol,funcname,...) \
 414         PurpleProtocolRoomlistInterface *roomlist_iface = \
 415                 PURPLE_PROTOCOL_ROOMLIST_GET_IFACE(protocol); \
 416         if (roomlist_iface && roomlist_iface->funcname) \
 417                 roomlist_iface->funcname(__VA_ARGS__);
 418
 419 #define DEFINE_PROTOCOL_FUNC_WITH_RETURN(protocol,defaultreturn,funcname,...) \
 420         PurpleProtocolRoomlistInterface *roomlist_iface = \
 421                 PURPLE_PROTOCOL_ROOMLIST_GET_IFACE(protocol); \
 422         if (roomlist_iface && roomlist_iface->funcname) \
 423                 return roomlist_iface->funcname(__VA_ARGS__); \
 424         else \
 425                 return defaultreturn;
 426
 427 GType
 428 purple_protocol_roomlist_iface_get_type(void)
 429 {
 430         static GType type = 0;
 431
 432         if (G_UNLIKELY(type == 0)) {
 433                 static const GTypeInfo info = {
 434                         .class_size = sizeof(PurpleProtocolRoomlistInterface),
 435                 };
 436
 437                 type = g_type_register_static(G_TYPE_INTERFACE,
 438                                 "PurpleProtocolRoomlistInterface", &info, 0);
 439         }
 440         return type;
 441 }
 442
 443 PurpleRoomlist *
 444 purple_protocol_roomlist_iface_get_list(PurpleProtocol *protocol,
 445                 PurpleConnection *gc)
 446 {
 447         DEFINE_PROTOCOL_FUNC_WITH_RETURN(protocol, NULL, get_list, gc);
 448 }
 449
 450 void
 451 purple_protocol_roomlist_iface_cancel(PurpleProtocol *protocol,
 452                 PurpleRoomlist *list)
 453 {
 454         DEFINE_PROTOCOL_FUNC(protocol, cancel, list);
 455 }
 456
 457 void
 458 purple_protocol_roomlist_iface_expand_category(PurpleProtocol *protocol,
 459                 PurpleRoomlist *list, PurpleRoomlistRoom *category)
 460 {
 461         DEFINE_PROTOCOL_FUNC(protocol, expand_category, list, category);
 462 }
 463
 464 char *
 465 purple_protocol_roomlist_iface_room_serialize(PurpleProtocol *protocol,
 466                 PurpleRoomlistRoom *room)
 467 {
 468         DEFINE_PROTOCOL_FUNC_WITH_RETURN(protocol, NULL, room_serialize, room);
 469 }
 470
 471 #undef DEFINE_PROTOCOL_FUNC_WITH_RETURN
 472 #undef DEFINE_PROTOCOL_FUNC
 473
 474 /**************************************************************************/
 475 /* Room API                                                               */
 476 /**************************************************************************/
 477
 478 PurpleRoomlistRoom *purple_roomlist_room_new(PurpleRoomlistRoomType type, const gchar *name,
 479                                          PurpleRoomlistRoom *parent)
 480 {
 481         PurpleRoomlistRoom *room;
 482
 483         g_return_val_if_fail(name != NULL, NULL);
 484
 485         room = g_new0(PurpleRoomlistRoom, 1);
 486         room->type = type;
 487         room->name = g_strdup(name);
 488         room->parent = parent;
 489
 490         return room;
 491 }
 492
 493 void purple_roomlist_room_add_field(PurpleRoomlist *list, PurpleRoomlistRoom *room, gconstpointer field)
 494 {
 495         PurpleRoomlistPrivate *priv = NULL;
 496         PurpleRoomlistField *f;
 497
 498         g_return_if_fail(PURPLE_IS_ROOMLIST(list));
 499         g_return_if_fail(room != NULL);
 500
 501         priv = purple_roomlist_get_instance_private(list);
 502         g_return_if_fail(priv->fields != NULL);
 503
 504         /* If this is the first call for this room, grab the first field in
 505          * the Roomlist's fields.  Otherwise, grab the field that is one
 506          * more than the number of fields already present for the room.
 507          * (This works because g_list_nth_data() is zero-indexed and
 508          * g_list_length() is one-indexed.) */
 509         if (!room->fields)
 510                 f = priv->fields->data;
 511         else
 512                 f = g_list_nth_data(priv->fields, g_list_length(room->fields));
 513
 514         g_return_if_fail(f != NULL);
 515
 516         switch(f->type) {
 517                 case PURPLE_ROOMLIST_FIELD_STRING:
 518                         room->fields = g_list_append(room->fields, g_strdup(field));
 519                         break;
 520                 case PURPLE_ROOMLIST_FIELD_BOOL:
 521                 case PURPLE_ROOMLIST_FIELD_INT:
 522                         room->fields = g_list_append(room->fields, GINT_TO_POINTER(field));
 523                         break;
 524         }
 525
 526         g_object_notify_by_pspec(G_OBJECT(list), properties[PROP_FIELDS]);
 527 }
 528
 529 void purple_roomlist_room_join(PurpleRoomlist *list, PurpleRoomlistRoom *room)
 530 {
 531         PurpleRoomlistPrivate *priv = NULL;
 532         GHashTable *components;
 533         GList *l, *j;
 534         PurpleConnection *gc;
 535
 536         g_return_if_fail(PURPLE_IS_ROOMLIST(list));
 537         g_return_if_fail(room != NULL);
 538
 539         priv = purple_roomlist_get_instance_private(list);
 540
 541         gc = purple_account_get_connection(priv->account);
 542         if (!gc)
 543                 return;
 544
 545         components = g_hash_table_new(g_str_hash, g_str_equal);
 546
 547         g_hash_table_replace(components, "name", room->name);
 548         for (l = priv->fields, j = room->fields; l && j; l = l->next, j = j->next) {
 549                 PurpleRoomlistField *f = l->data;
 550
 551                 g_hash_table_replace(components, f->name, j->data);
 552         }
 553
 554         purple_serv_join_chat(gc, components);
 555
 556         g_hash_table_destroy(components);
 557 }
 558
 559 PurpleRoomlistRoomType purple_roomlist_room_get_room_type(PurpleRoomlistRoom *room)
 560 {
 561         return room->type;
 562 }
 563
 564 const char * purple_roomlist_room_get_name(PurpleRoomlistRoom *room)
 565 {
 566         return room->name;
 567 }
 568
 569 PurpleRoomlistRoom * purple_roomlist_room_get_parent(PurpleRoomlistRoom *room)
 570 {
 571         return room->parent;
 572 }
 573
 574 gboolean purple_roomlist_room_get_expanded_once(PurpleRoomlistRoom *room)
 575 {
 576         g_return_val_if_fail(room != NULL, FALSE);
 577
 578         return room->expanded_once;
 579 }
 580
 581 void purple_roomlist_room_set_expanded_once(PurpleRoomlistRoom *room, gboolean expanded_once)
 582 {
 583         g_return_if_fail(room != NULL);
 584
 585         room->expanded_once = expanded_once;
 586 }
 587
 588 GList *purple_roomlist_room_get_fields(PurpleRoomlistRoom *room)
 589 {
 590         return room->fields;
 591 }
 592
 593 static void purple_roomlist_room_destroy(PurpleRoomlist *list, PurpleRoomlistRoom *r)
 594 {
 595         PurpleRoomlistPrivate *priv =
 596                         purple_roomlist_get_instance_private(list);
 597         GList *l, *j;
 598
 599         for (l = priv->fields, j = r->fields; l && j; l = l->next, j = j->next) {
 600                 PurpleRoomlistField *f = l->data;
 601                 if (f->type == PURPLE_ROOMLIST_FIELD_STRING)
 602                         g_free(j->data);
 603         }
 604
 605         g_list_free(r->fields);
 606         g_free(r->name);
 607         g_free(r);
 608 }
 609
 610 /**************************************************************************/
 611 /* Room GBoxed code                                                       */
 612 /**************************************************************************/
 613
 614 static PurpleRoomlistRoom *purple_roomlist_room_copy(PurpleRoomlistRoom *r)
 615 {
 616         g_return_val_if_fail(r != NULL, NULL);
 617
 618         return purple_roomlist_room_new(r->type, r->name, r->parent);
 619 }
 620
 621 static void purple_roomlist_room_free(PurpleRoomlistRoom *r)
 622 {
 623         g_return_if_fail(r != NULL);
 624
 625         g_list_free(r->fields);
 626         g_free(r->name);
 627         g_free(r);
 628 }
 629
 630 GType purple_roomlist_room_get_type(void)
 631 {
 632         static GType type = 0;
 633
 634         if (type == 0) {
 635                 type = g_boxed_type_register_static("PurpleRoomlistRoom",
 636                                 (GBoxedCopyFunc)purple_roomlist_room_copy,
 637                                 (GBoxedFreeFunc)purple_roomlist_room_free);
 638         }
 639
 640         return type;
 641 }
 642
 643 /**************************************************************************/
 644 /* Room Field API                                                         */
 645 /**************************************************************************/
 646
 647 PurpleRoomlistField *purple_roomlist_field_new(PurpleRoomlistFieldType type,
 648                                            const gchar *label, const gchar *name,
 649                                            gboolean hidden)
 650 {
 651         PurpleRoomlistField *f;
 652
 653         g_return_val_if_fail(label != NULL, NULL);
 654         g_return_val_if_fail(name != NULL, NULL);
 655
 656         f = g_new0(PurpleRoomlistField, 1);
 657
 658         f->type = type;
 659         f->label = g_strdup(label);
 660         f->name = g_strdup(name);
 661         f->hidden = hidden;
 662
 663         return f;
 664 }
 665
 666 PurpleRoomlistFieldType purple_roomlist_field_get_field_type(PurpleRoomlistField *field)
 667 {
 668         return field->type;
 669 }
 670
 671 const char * purple_roomlist_field_get_label(PurpleRoomlistField *field)
 672 {
 673         return field->label;
 674 }
 675
 676 gboolean purple_roomlist_field_get_hidden(PurpleRoomlistField *field)
 677 {
 678         return field->hidden;
 679 }
 680
 681 /**************************************************************************/
 682 /* Room Field GBoxed code                                                 */
 683 /**************************************************************************/
 684
 685 static PurpleRoomlistField *purple_roomlist_field_copy(PurpleRoomlistField *f)
 686 {
 687         g_return_val_if_fail(f != NULL, NULL);
 688
 689         return purple_roomlist_field_new(f->type, f->label, f->name, f->hidden);
 690 }
 691
 692 static void purple_roomlist_field_free(PurpleRoomlistField *f)
 693 {
 694         g_return_if_fail(f != NULL);
 695
 696         g_free(f->label);
 697         g_free(f->name);
 698         g_free(f);
 699 }
 700
 701 GType purple_roomlist_field_get_type(void)
 702 {
 703         static GType type = 0;
 704
 705         if (type == 0) {
 706                 type = g_boxed_type_register_static("PurpleRoomlistField",
 707                                 (GBoxedCopyFunc)purple_roomlist_field_copy,
 708                                 (GBoxedFreeFunc)purple_roomlist_field_free);
 709         }
 710
 711         return type;
 712 }
 713
 714 /**************************************************************************/
 715 /* UI Registration Functions                                              */
 716 /**************************************************************************/
 717
 718 void purple_roomlist_set_ui_ops(PurpleRoomlistUiOps *ui_ops)
 719 {
 720         ops = ui_ops;
 721 }
 722
 723 PurpleRoomlistUiOps *purple_roomlist_get_ui_ops(void)
 724 {
 725         return ops;
 726 }
 727
 728 /**************************************************************************
 729  * UI Ops GBoxed code
 730  **************************************************************************/
 731
 732 static PurpleRoomlistUiOps *
 733 purple_roomlist_ui_ops_copy(PurpleRoomlistUiOps *ops)
 734 {
 735         PurpleRoomlistUiOps *ops_new;
 736
 737         g_return_val_if_fail(ops != NULL, NULL);
 738
 739         ops_new = g_new(PurpleRoomlistUiOps, 1);
 740         *ops_new = *ops;
 741
 742         return ops_new;
 743 }
 744
 745 GType
 746 purple_roomlist_ui_ops_get_type(void)
 747 {
 748         static GType type = 0;
 749
 750         if (type == 0) {
 751                 type = g_boxed_type_register_static("PurpleRoomlistUiOps",
 752                                 (GBoxedCopyFunc)purple_roomlist_ui_ops_copy,
 753                                 (GBoxedFreeFunc)g_free);
 754         }
 755
 756         return type;
 757 }