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