libpurple/whiteboard.c

   1 /*
   2  * purple
   3  *
   4  * Purple is the legal property of its developers, whose names are too numerous
   5  * to list here.  Please refer to the COPYRIGHT file distributed with this
   6  * source distribution.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  21  *
  22  */
  23
  24 #include "internal.h"
  25 #include "glibcompat.h"
  26 #include "whiteboard.h"
  27 #include "protocol.h"
  28
  29 #define PURPLE_WHITEBOARD_GET_PRIVATE(obj) \
  30         (G_TYPE_INSTANCE_GET_PRIVATE((obj), PURPLE_TYPE_WHITEBOARD, PurpleWhiteboardPrivate))
  31
  32 typedef struct _PurpleWhiteboardPrivate  PurpleWhiteboardPrivate;
  33
  34 /* Private data for a whiteboard */
  35 struct _PurpleWhiteboardPrivate
  36 {
  37         int state;                      /* State of whiteboard session          */
  38
  39         PurpleAccount *account;         /* Account associated with this session */
  40         char *who;                      /* Name of the remote user              */
  41
  42         /* TODO Remove this and use protocol-specific subclasses. */
  43         void *proto_data;               /* Protocol specific data               */
  44
  45         PurpleWhiteboardOps *protocol_ops; /* Protocol operations               */
  46
  47         GList *draw_list;               /* List of drawing elements/deltas to
  48                                            send                                 */
  49 };
  50
  51 /* GObject Property enums */
  52 enum
  53 {
  54         PROP_0,
  55         PROP_STATE,
  56         PROP_ACCOUNT,
  57         PROP_WHO,
  58         PROP_DRAW_LIST,
  59         PROP_LAST
  60 };
  61
  62 /******************************************************************************
  63  * Globals
  64  *****************************************************************************/
  65 static GObjectClass *parent_class;
  66 static GParamSpec *properties[PROP_LAST];
  67
  68 static PurpleWhiteboardUiOps *whiteboard_ui_ops = NULL;
  69 /* static PurpleWhiteboardOps *whiteboard_protocol_ops = NULL; */
  70
  71 static GList *wb_list = NULL;
  72
  73 /*static gboolean auto_accept = TRUE; */
  74
  75 /******************************************************************************
  76  * API
  77  *****************************************************************************/
  78 static PurpleWhiteboardUiOps *
  79 purple_whiteboard_ui_ops_copy(PurpleWhiteboardUiOps *ops)
  80 {
  81         PurpleWhiteboardUiOps *ops_new;
  82
  83         g_return_val_if_fail(ops != NULL, NULL);
  84
  85         ops_new = g_new(PurpleWhiteboardUiOps, 1);
  86         *ops_new = *ops;
  87
  88         return ops_new;
  89 }
  90
  91 GType
  92 purple_whiteboard_ui_ops_get_type(void)
  93 {
  94         static GType type = 0;
  95
  96         if (type == 0) {
  97                 type = g_boxed_type_register_static("PurpleWhiteboardUiOps",
  98                                 (GBoxedCopyFunc)purple_whiteboard_ui_ops_copy,
  99                                 (GBoxedFreeFunc)g_free);
 100         }
 101
 102         return type;
 103 }
 104
 105 void purple_whiteboard_set_ui_ops(PurpleWhiteboardUiOps *ops)
 106 {
 107         whiteboard_ui_ops = ops;
 108 }
 109
 110 void purple_whiteboard_set_protocol_ops(PurpleWhiteboard *wb, PurpleWhiteboardOps *ops)
 111 {
 112         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 113
 114         g_return_if_fail(priv != NULL);
 115
 116         priv->protocol_ops = ops;
 117 }
 118
 119 PurpleAccount *purple_whiteboard_get_account(const PurpleWhiteboard *wb)
 120 {
 121         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 122
 123         g_return_val_if_fail(priv != NULL, NULL);
 124
 125         return priv->account;
 126 }
 127
 128 const char *purple_whiteboard_get_who(const PurpleWhiteboard *wb)
 129 {
 130         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 131
 132         g_return_val_if_fail(priv != NULL, NULL);
 133
 134         return priv->who;
 135 }
 136
 137 void purple_whiteboard_set_state(PurpleWhiteboard *wb, int state)
 138 {
 139         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 140
 141         g_return_if_fail(priv != NULL);
 142
 143         priv->state = state;
 144
 145         g_object_notify_by_pspec(G_OBJECT(wb), properties[PROP_STATE]);
 146 }
 147
 148 int purple_whiteboard_get_state(const PurpleWhiteboard *wb)
 149 {
 150         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 151
 152         g_return_val_if_fail(priv != NULL, -1);
 153
 154         return priv->state;
 155 }
 156
 157 void purple_whiteboard_start(PurpleWhiteboard *wb)
 158 {
 159         /* Create frontend for whiteboard */
 160         if(whiteboard_ui_ops && whiteboard_ui_ops->create)
 161                 whiteboard_ui_ops->create(wb);
 162 }
 163
 164 /* Looks through the list of whiteboard sessions for one that is between
 165  * usernames 'me' and 'who'.  Returns a pointer to a matching whiteboard
 166  * session; if none match, it returns NULL.
 167  */
 168 PurpleWhiteboard *purple_whiteboard_get_session(const PurpleAccount *account, const char *who)
 169 {
 170         PurpleWhiteboard *wb;
 171         PurpleWhiteboardPrivate *priv;
 172
 173         GList *l = wb_list;
 174
 175         /* Look for a whiteboard session between the local user and the remote user
 176          */
 177         while(l != NULL)
 178         {
 179                 wb = l->data;
 180                 priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 181
 182                 if(priv->account == account && purple_strequal(priv->who, who))
 183                         return wb;
 184
 185                 l = l->next;
 186         }
 187
 188         return NULL;
 189 }
 190
 191 void purple_whiteboard_draw_list_destroy(GList *draw_list)
 192 {
 193         g_list_free(draw_list);
 194 }
 195
 196 gboolean purple_whiteboard_get_dimensions(const PurpleWhiteboard *wb, int *width, int *height)
 197 {
 198         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 199         PurpleWhiteboardOps *protocol_ops;
 200
 201         g_return_val_if_fail(priv != NULL, FALSE);
 202
 203         protocol_ops = priv->protocol_ops;
 204
 205         if (protocol_ops && protocol_ops->get_dimensions)
 206         {
 207                 protocol_ops->get_dimensions(wb, width, height);
 208                 return TRUE;
 209         }
 210
 211         return FALSE;
 212 }
 213
 214 void purple_whiteboard_set_dimensions(PurpleWhiteboard *wb, int width, int height)
 215 {
 216         if(whiteboard_ui_ops && whiteboard_ui_ops->set_dimensions)
 217                 whiteboard_ui_ops->set_dimensions(wb, width, height);
 218 }
 219
 220 void purple_whiteboard_send_draw_list(PurpleWhiteboard *wb, GList *list)
 221 {
 222         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 223         PurpleWhiteboardOps *protocol_ops;
 224
 225         g_return_if_fail(priv != NULL);
 226
 227         protocol_ops = priv->protocol_ops;
 228
 229         if (protocol_ops && protocol_ops->send_draw_list)
 230                 protocol_ops->send_draw_list(wb, list);
 231 }
 232
 233 void purple_whiteboard_draw_point(PurpleWhiteboard *wb, int x, int y, int color, int size)
 234 {
 235         if(whiteboard_ui_ops && whiteboard_ui_ops->draw_point)
 236                 whiteboard_ui_ops->draw_point(wb, x, y, color, size);
 237 }
 238
 239 void purple_whiteboard_draw_line(PurpleWhiteboard *wb, int x1, int y1, int x2, int y2, int color, int size)
 240 {
 241         if(whiteboard_ui_ops && whiteboard_ui_ops->draw_line)
 242                 whiteboard_ui_ops->draw_line(wb, x1, y1, x2, y2, color, size);
 243 }
 244
 245 void purple_whiteboard_clear(PurpleWhiteboard *wb)
 246 {
 247         if(whiteboard_ui_ops && whiteboard_ui_ops->clear)
 248                 whiteboard_ui_ops->clear(wb);
 249 }
 250
 251 void purple_whiteboard_send_clear(PurpleWhiteboard *wb)
 252 {
 253         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 254         PurpleWhiteboardOps *protocol_ops;
 255
 256         g_return_if_fail(priv != NULL);
 257
 258         protocol_ops = priv->protocol_ops;
 259
 260         if (protocol_ops && protocol_ops->clear)
 261                 protocol_ops->clear(wb);
 262 }
 263
 264 void purple_whiteboard_send_brush(PurpleWhiteboard *wb, int size, int color)
 265 {
 266         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 267         PurpleWhiteboardOps *protocol_ops;
 268
 269         g_return_if_fail(priv != NULL);
 270
 271         protocol_ops = priv->protocol_ops;
 272
 273         if (protocol_ops && protocol_ops->set_brush)
 274                 protocol_ops->set_brush(wb, size, color);
 275 }
 276
 277 gboolean purple_whiteboard_get_brush(const PurpleWhiteboard *wb, int *size, int *color)
 278 {
 279         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 280         PurpleWhiteboardOps *protocol_ops;
 281
 282         g_return_val_if_fail(priv != NULL, FALSE);
 283
 284         protocol_ops = priv->protocol_ops;
 285
 286         if (protocol_ops && protocol_ops->get_brush)
 287         {
 288                 protocol_ops->get_brush(wb, size, color);
 289                 return TRUE;
 290         }
 291         return FALSE;
 292 }
 293
 294 void purple_whiteboard_set_brush(PurpleWhiteboard *wb, int size, int color)
 295 {
 296         if (whiteboard_ui_ops && whiteboard_ui_ops->set_brush)
 297                 whiteboard_ui_ops->set_brush(wb, size, color);
 298 }
 299
 300 GList *purple_whiteboard_get_draw_list(const PurpleWhiteboard *wb)
 301 {
 302         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 303
 304         g_return_val_if_fail(priv != NULL, NULL);
 305
 306         return priv->draw_list;
 307 }
 308
 309 void purple_whiteboard_set_draw_list(PurpleWhiteboard *wb, GList* draw_list)
 310 {
 311         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 312
 313         g_return_if_fail(priv != NULL);
 314
 315         priv->draw_list = draw_list;
 316
 317         g_object_notify_by_pspec(G_OBJECT(wb), properties[PROP_DRAW_LIST]);
 318 }
 319
 320 void purple_whiteboard_set_protocol_data(PurpleWhiteboard *wb, gpointer proto_data)
 321 {
 322         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 323
 324         g_return_if_fail(priv != NULL);
 325
 326         priv->proto_data = proto_data;
 327 }
 328
 329 gpointer purple_whiteboard_get_protocol_data(const PurpleWhiteboard *wb)
 330 {
 331         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 332
 333         g_return_val_if_fail(priv != NULL, NULL);
 334
 335         return priv->proto_data;
 336 }
 337
 338 void purple_whiteboard_set_ui_data(PurpleWhiteboard *wb, gpointer ui_data)
 339 {
 340         g_return_if_fail(PURPLE_IS_WHITEBOARD(wb));
 341
 342         wb->ui_data = ui_data;
 343 }
 344
 345 gpointer purple_whiteboard_get_ui_data(const PurpleWhiteboard *wb)
 346 {
 347         g_return_val_if_fail(PURPLE_IS_WHITEBOARD(wb), NULL);
 348
 349         return wb->ui_data;
 350 }
 351
 352 /******************************************************************************
 353  * GObject code
 354  *****************************************************************************/
 355 /* Set method for GObject properties */
 356 static void
 357 purple_whiteboard_set_property(GObject *obj, guint param_id, const GValue *value,
 358                 GParamSpec *pspec)
 359 {
 360         PurpleWhiteboard *wb = PURPLE_WHITEBOARD(obj);
 361         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 362
 363         switch (param_id) {
 364                 case PROP_STATE:
 365                         purple_whiteboard_set_state(wb, g_value_get_int(value));
 366                         break;
 367                 case PROP_ACCOUNT:
 368                         priv->account = g_value_get_object(value);
 369                         break;
 370                 case PROP_WHO:
 371                         priv->who = g_strdup(g_value_get_string(value));
 372                         break;
 373                 case PROP_DRAW_LIST:
 374                         purple_whiteboard_set_draw_list(wb, g_value_get_pointer(value));
 375                         break;
 376                 default:
 377                         G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
 378                         break;
 379         }
 380 }
 381
 382 /* Get method for GObject properties */
 383 static void
 384 purple_whiteboard_get_property(GObject *obj, guint param_id, GValue *value,
 385                 GParamSpec *pspec)
 386 {
 387         PurpleWhiteboard *wb = PURPLE_WHITEBOARD(obj);
 388
 389         switch (param_id) {
 390                 case PROP_STATE:
 391                         g_value_set_int(value, purple_whiteboard_get_state(wb));
 392                         break;
 393                 case PROP_ACCOUNT:
 394                         g_value_set_object(value, purple_whiteboard_get_account(wb));
 395                         break;
 396                 case PROP_WHO:
 397                         g_value_set_string(value, purple_whiteboard_get_who(wb));
 398                         break;
 399                 case PROP_DRAW_LIST:
 400                         g_value_set_pointer(value, purple_whiteboard_get_draw_list(wb));
 401                         break;
 402                 default:
 403                         G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
 404                         break;
 405         }
 406 }
 407
 408 /* Called when done constructing */
 409 static void
 410 purple_whiteboard_constructed(GObject *object)
 411 {
 412         PurpleWhiteboard *wb = PURPLE_WHITEBOARD(object);
 413         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 414         PurpleProtocol *protocol;
 415
 416         parent_class->constructed(object);
 417
 418         protocol = purple_connection_get_protocol(
 419                                 purple_account_get_connection(priv->account));
 420         purple_whiteboard_set_protocol_ops(wb,
 421                                 purple_protocol_get_whiteboard_ops(protocol));
 422
 423         /* Start up protocol specifics */
 424         if(priv->protocol_ops && priv->protocol_ops->start)
 425                 priv->protocol_ops->start(wb);
 426
 427         wb_list = g_list_append(wb_list, wb);
 428 }
 429
 430 /* GObject finalize function */
 431 static void
 432 purple_whiteboard_finalize(GObject *object)
 433 {
 434         PurpleWhiteboard *wb = PURPLE_WHITEBOARD(object);
 435         PurpleWhiteboardPrivate *priv = PURPLE_WHITEBOARD_GET_PRIVATE(wb);
 436
 437         if(wb->ui_data)
 438         {
 439                 /* Destroy frontend */
 440                 if(whiteboard_ui_ops && whiteboard_ui_ops->destroy)
 441                         whiteboard_ui_ops->destroy(wb);
 442         }
 443
 444         /* Do protocol specific session ending procedures */
 445         if(priv->protocol_ops && priv->protocol_ops->end)
 446                 priv->protocol_ops->end(wb);
 447
 448         wb_list = g_list_remove(wb_list, wb);
 449
 450         g_free(priv->who);
 451
 452         parent_class->finalize(object);
 453 }
 454
 455 /* Class initializer function */
 456 static void
 457 purple_whiteboard_class_init(PurpleWhiteboardClass *klass)
 458 {
 459         GObjectClass *obj_class = G_OBJECT_CLASS(klass);
 460
 461         parent_class = g_type_class_peek_parent(klass);
 462
 463         obj_class->finalize = purple_whiteboard_finalize;
 464         obj_class->constructed = purple_whiteboard_constructed;
 465
 466         /* Setup properties */
 467         obj_class->get_property = purple_whiteboard_get_property;
 468         obj_class->set_property = purple_whiteboard_set_property;
 469
 470         g_type_class_add_private(klass, sizeof(PurpleWhiteboardPrivate));
 471
 472         properties[PROP_STATE] = g_param_spec_int("state", "State",
 473                                 "State of the whiteboard.",
 474                                 G_MININT, G_MAXINT, 0,
 475                                 G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);
 476
 477         properties[PROP_ACCOUNT] = g_param_spec_object("account", "Account",
 478                                 "The whiteboard's account.", PURPLE_TYPE_ACCOUNT,
 479                                 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 480                                 G_PARAM_STATIC_STRINGS);
 481
 482         properties[PROP_WHO] = g_param_spec_string("who", "Who",
 483                                 "Who you're drawing with.", NULL,
 484                                 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 485                                 G_PARAM_STATIC_STRINGS);
 486
 487         properties[PROP_DRAW_LIST] = g_param_spec_pointer("draw-list", "Draw list",
 488                                 "A list of points to draw to the buddy.",
 489                                 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 490
 491         g_object_class_install_properties(obj_class, PROP_LAST, properties);
 492 }
 493
 494 GType
 495 purple_whiteboard_get_type(void)
 496 {
 497         static GType type = 0;
 498
 499         if(type == 0) {
 500                 static const GTypeInfo info = {
 501                         sizeof(PurpleWhiteboardClass),
 502                         NULL,
 503                         NULL,
 504                         (GClassInitFunc)purple_whiteboard_class_init,
 505                         NULL,
 506                         NULL,
 507                         sizeof(PurpleWhiteboard),
 508                         0,
 509                         NULL,
 510                         NULL,
 511                 };
 512
 513                 type = g_type_register_static(G_TYPE_OBJECT, "PurpleWhiteboard",
 514                                 &info, 0);
 515         }
 516
 517         return type;
 518 }
 519
 520 PurpleWhiteboard *purple_whiteboard_new(PurpleAccount *account, const char *who, int state)
 521 {
 522         PurpleWhiteboard *wb;
 523         PurpleProtocol *protocol;
 524
 525         g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
 526         g_return_val_if_fail(who != NULL, NULL);
 527
 528         protocol = purple_protocols_find(purple_account_get_protocol_id(account));
 529
 530         g_return_val_if_fail(PURPLE_IS_PROTOCOL(protocol), NULL);
 531
 532         if (PURPLE_PROTOCOL_IMPLEMENTS(protocol, FACTORY_IFACE, whiteboard_new))
 533                 wb = purple_protocol_factory_iface_whiteboard_new(protocol, account,
 534                                 who, state);
 535         else
 536                 wb = g_object_new(PURPLE_TYPE_WHITEBOARD,
 537                         "account", account,
 538                         "who",     who,
 539                         "state",   state,
 540                         NULL
 541                 );
 542
 543         g_return_val_if_fail(wb != NULL, NULL);
 544
 545         return wb;
 546 }