pidgin/gtkmedia.c

   1 /* pidgin
   2  *
   3  * Pidgin 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 "debug.h"
  24 #include "connection.h"
  25 #include "media.h"
  26 #include "mediamanager.h"
  27 #include "pidgin.h"
  28 #include "request.h"
  29
  30 #include "gtkmedia.h"
  31 #include "gtkutils.h"
  32 #include "pidginstock.h"
  33
  34 #ifdef USE_VV
  35 #include "media-gst.h"
  36
  37 #ifdef GDK_WINDOWING_WIN32
  38 #include <gdk/gdkwin32.h>
  39 #endif
  40 #ifdef GDK_WINDOWING_X11
  41 #include <gdk/gdkx.h>
  42 #endif
  43 #ifdef GDK_WINDOWING_QUARTZ
  44 #include <gdk/gdkquartz.h>
  45 #endif
  46 #include <gdk/gdkkeysyms.h>
  47
  48 #include "gtk3compat.h"
  49
  50 #define PIDGIN_TYPE_MEDIA            (pidgin_media_get_type())
  51 #define PIDGIN_MEDIA(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), PIDGIN_TYPE_MEDIA, PidginMedia))
  52 #define PIDGIN_MEDIA_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), PIDGIN_TYPE_MEDIA, PidginMediaClass))
  53 #define PIDGIN_IS_MEDIA(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), PIDGIN_TYPE_MEDIA))
  54 #define PIDGIN_IS_MEDIA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), PIDGIN_TYPE_MEDIA))
  55 #define PIDGIN_MEDIA_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), PIDGIN_TYPE_MEDIA, PidginMediaClass))
  56
  57 typedef struct _PidginMedia PidginMedia;
  58 typedef struct _PidginMediaClass PidginMediaClass;
  59 typedef struct _PidginMediaPrivate PidginMediaPrivate;
  60
  61 typedef enum
  62 {
  63         /* Waiting for response */
  64         PIDGIN_MEDIA_WAITING = 1,
  65         /* Got request */
  66         PIDGIN_MEDIA_REQUESTED,
  67         /* Accepted call */
  68         PIDGIN_MEDIA_ACCEPTED,
  69         /* Rejected call */
  70         PIDGIN_MEDIA_REJECTED,
  71 } PidginMediaState;
  72
  73 struct _PidginMediaClass
  74 {
  75         GtkWindowClass parent_class;
  76 };
  77
  78 struct _PidginMedia
  79 {
  80         GtkWindow parent;
  81         PidginMediaPrivate *priv;
  82 };
  83
  84 struct _PidginMediaPrivate
  85 {
  86         PurpleMedia *media;
  87         gchar *screenname;
  88         gulong level_handler_id;
  89
  90         GtkUIManager *ui;
  91         GtkWidget *menubar;
  92         GtkWidget *statusbar;
  93
  94         GtkWidget *hold;
  95         GtkWidget *mute;
  96         GtkWidget *pause;
  97
  98         GtkWidget *send_progress;
  99         GHashTable *recv_progressbars;
 100
 101         PidginMediaState state;
 102
 103         GtkWidget *display;
 104         GtkWidget *send_widget;
 105         GtkWidget *recv_widget;
 106         GtkWidget *button_widget;
 107         GtkWidget *local_video;
 108         GHashTable *remote_videos;
 109
 110         guint timeout_id;
 111         PurpleMediaSessionType request_type;
 112 };
 113
 114 #define PIDGIN_MEDIA_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), PIDGIN_TYPE_MEDIA, PidginMediaPrivate))
 115
 116 static void pidgin_media_class_init (PidginMediaClass *klass);
 117 static void pidgin_media_init (PidginMedia *media);
 118 static void pidgin_media_dispose (GObject *object);
 119 static void pidgin_media_finalize (GObject *object);
 120 static void pidgin_media_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
 121 static void pidgin_media_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
 122 static void pidgin_media_set_state(PidginMedia *gtkmedia, PidginMediaState state);
 123
 124 static GtkWindowClass *parent_class = NULL;
 125
 126
 127 #if 0
 128 enum {
 129         LAST_SIGNAL
 130 };
 131 static guint pidgin_media_signals[LAST_SIGNAL] = {0};
 132 #endif
 133
 134 enum {
 135         PROP_0,
 136         PROP_MEDIA,
 137         PROP_SCREENNAME
 138 };
 139
 140 static GType
 141 pidgin_media_get_type(void)
 142 {
 143         static GType type = 0;
 144
 145         if (type == 0) {
 146                 static const GTypeInfo info = {
 147                         sizeof(PidginMediaClass),
 148                         NULL,
 149                         NULL,
 150                         (GClassInitFunc) pidgin_media_class_init,
 151                         NULL,
 152                         NULL,
 153                         sizeof(PidginMedia),
 154                         0,
 155                         (GInstanceInitFunc) pidgin_media_init,
 156                         NULL
 157                 };
 158                 type = g_type_register_static(GTK_TYPE_WINDOW, "PidginMedia", &info, 0);
 159         }
 160         return type;
 161 }
 162
 163
 164 static void
 165 pidgin_media_class_init (PidginMediaClass *klass)
 166 {
 167         GObjectClass *gobject_class = (GObjectClass*)klass;
 168 /*      GtkContainerClass *container_class = (GtkContainerClass*)klass; */
 169         parent_class = g_type_class_peek_parent(klass);
 170
 171         gobject_class->dispose = pidgin_media_dispose;
 172         gobject_class->finalize = pidgin_media_finalize;
 173         gobject_class->set_property = pidgin_media_set_property;
 174         gobject_class->get_property = pidgin_media_get_property;
 175
 176         g_object_class_install_property(gobject_class, PROP_MEDIA,
 177                         g_param_spec_object("media",
 178                         "PurpleMedia",
 179                         "The PurpleMedia associated with this media.",
 180                         PURPLE_TYPE_MEDIA,
 181                         G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 182         g_object_class_install_property(gobject_class, PROP_SCREENNAME,
 183                         g_param_spec_string("screenname",
 184                         "Screenname",
 185                         "The screenname of the user this session is with.",
 186                         NULL,
 187                         G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 188
 189         g_type_class_add_private(klass, sizeof(PidginMediaPrivate));
 190 }
 191
 192 static void
 193 pidgin_media_hold_toggled(GtkToggleButton *toggle, PidginMedia *media)
 194 {
 195         purple_media_stream_info(media->priv->media,
 196                         gtk_toggle_button_get_active(toggle) ?
 197                         PURPLE_MEDIA_INFO_HOLD : PURPLE_MEDIA_INFO_UNHOLD,
 198                         NULL, NULL, TRUE);
 199 }
 200
 201 static void
 202 pidgin_media_mute_toggled(GtkToggleButton *toggle, PidginMedia *media)
 203 {
 204         purple_media_stream_info(media->priv->media,
 205                         gtk_toggle_button_get_active(toggle) ?
 206                         PURPLE_MEDIA_INFO_MUTE : PURPLE_MEDIA_INFO_UNMUTE,
 207                         NULL, NULL, TRUE);
 208 }
 209
 210 static void
 211 pidgin_media_pause_toggled(GtkToggleButton *toggle, PidginMedia *media)
 212 {
 213         purple_media_stream_info(media->priv->media,
 214                         gtk_toggle_button_get_active(toggle) ?
 215                         PURPLE_MEDIA_INFO_PAUSE : PURPLE_MEDIA_INFO_UNPAUSE,
 216                         NULL, NULL, TRUE);
 217 }
 218
 219 static gboolean
 220 pidgin_media_delete_event_cb(GtkWidget *widget,
 221                 GdkEvent *event, PidginMedia *media)
 222 {
 223         if (media->priv->media)
 224                 purple_media_stream_info(media->priv->media,
 225                                 PURPLE_MEDIA_INFO_HANGUP, NULL, NULL, TRUE);
 226         return FALSE;
 227 }
 228
 229 #ifdef HAVE_X11
 230 static int
 231 pidgin_x_error_handler(Display *display, XErrorEvent *event)
 232 {
 233         const gchar *error_type;
 234         switch (event->error_code) {
 235 #define XERRORCASE(type) case type: error_type = #type; break
 236                 XERRORCASE(BadAccess);
 237                 XERRORCASE(BadAlloc);
 238                 XERRORCASE(BadAtom);
 239                 XERRORCASE(BadColor);
 240                 XERRORCASE(BadCursor);
 241                 XERRORCASE(BadDrawable);
 242                 XERRORCASE(BadFont);
 243                 XERRORCASE(BadGC);
 244                 XERRORCASE(BadIDChoice);
 245                 XERRORCASE(BadImplementation);
 246                 XERRORCASE(BadLength);
 247                 XERRORCASE(BadMatch);
 248                 XERRORCASE(BadName);
 249                 XERRORCASE(BadPixmap);
 250                 XERRORCASE(BadRequest);
 251                 XERRORCASE(BadValue);
 252                 XERRORCASE(BadWindow);
 253 #undef XERRORCASE
 254                 default:
 255                         error_type = "unknown";
 256                         break;
 257         }
 258         purple_debug_error("media", "A %s Xlib error has occurred. "
 259                         "The program would normally crash now.\n",
 260                         error_type);
 261         return 0;
 262 }
 263 #endif
 264
 265 static void
 266 menu_hangup(GtkAction *action, gpointer data)
 267 {
 268         PidginMedia *gtkmedia = PIDGIN_MEDIA(data);
 269         purple_media_stream_info(gtkmedia->priv->media,
 270                         PURPLE_MEDIA_INFO_HANGUP, NULL, NULL, TRUE);
 271 }
 272
 273 static const GtkActionEntry menu_entries[] = {
 274         { "MediaMenu", NULL, N_("_Media"), NULL, NULL, NULL },
 275         { "Hangup", NULL, N_("_Hangup"), NULL, NULL, G_CALLBACK(menu_hangup) },
 276 };
 277
 278 static const char *media_menu =
 279 "<ui>"
 280         "<menubar name='Media'>"
 281                 "<menu action='MediaMenu'>"
 282                         "<menuitem action='Hangup'/>"
 283                 "</menu>"
 284         "</menubar>"
 285 "</ui>";
 286
 287 static GtkWidget *
 288 setup_menubar(PidginMedia *window)
 289 {
 290         GtkActionGroup *action_group;
 291         GError *error;
 292         GtkAccelGroup *accel_group;
 293         GtkWidget *menu;
 294
 295         action_group = gtk_action_group_new("MediaActions");
 296 #ifdef ENABLE_NLS
 297         gtk_action_group_set_translation_domain(action_group,
 298                                                 PACKAGE);
 299 #endif
 300         gtk_action_group_add_actions(action_group,
 301                                      menu_entries,
 302                                      G_N_ELEMENTS(menu_entries),
 303                                      GTK_WINDOW(window));
 304
 305         window->priv->ui = gtk_ui_manager_new();
 306         gtk_ui_manager_insert_action_group(window->priv->ui, action_group, 0);
 307
 308         accel_group = gtk_ui_manager_get_accel_group(window->priv->ui);
 309         gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
 310
 311         error = NULL;
 312         if (!gtk_ui_manager_add_ui_from_string(window->priv->ui, media_menu, -1, &error))
 313         {
 314                 g_message("building menus failed: %s", error->message);
 315                 g_error_free(error);
 316                 exit(EXIT_FAILURE);
 317         }
 318
 319         menu = gtk_ui_manager_get_widget(window->priv->ui, "/Media");
 320
 321         gtk_widget_show(menu);
 322         return menu;
 323 }
 324
 325 static void
 326 pidgin_media_init (PidginMedia *media)
 327 {
 328         GtkWidget *vbox;
 329         media->priv = PIDGIN_MEDIA_GET_PRIVATE(media);
 330
 331 #ifdef HAVE_X11
 332         XSetErrorHandler(pidgin_x_error_handler);
 333 #endif
 334
 335         vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 336         gtk_container_add(GTK_CONTAINER(media), vbox);
 337
 338         media->priv->statusbar = gtk_statusbar_new();
 339         gtk_box_pack_end(GTK_BOX(vbox), media->priv->statusbar,
 340                         FALSE, FALSE, 0);
 341         gtk_statusbar_push(GTK_STATUSBAR(media->priv->statusbar),
 342                         0, _("Calling..."));
 343         gtk_widget_show(media->priv->statusbar);
 344
 345         media->priv->menubar = setup_menubar(media);
 346         gtk_box_pack_start(GTK_BOX(vbox), media->priv->menubar,
 347                         FALSE, TRUE, 0);
 348
 349         media->priv->display = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 350         gtk_container_set_border_width(GTK_CONTAINER(media->priv->display),
 351                         PIDGIN_HIG_BOX_SPACE);
 352         gtk_box_pack_start(GTK_BOX(vbox), media->priv->display,
 353                         TRUE, TRUE, PIDGIN_HIG_BOX_SPACE);
 354         gtk_widget_show(vbox);
 355
 356         g_signal_connect(G_OBJECT(media), "delete-event",
 357                         G_CALLBACK(pidgin_media_delete_event_cb), media);
 358
 359         media->priv->recv_progressbars =
 360                         g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
 361         media->priv->remote_videos =
 362                         g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
 363 }
 364
 365 static gchar *
 366 create_key(const gchar *session_id, const gchar *participant)
 367 {
 368         return g_strdup_printf("%s_%s", session_id, participant);
 369 }
 370
 371 static void
 372 pidgin_media_insert_widget(PidginMedia *gtkmedia, GtkWidget *widget,
 373                 const gchar *session_id, const gchar *participant)
 374 {
 375         gchar *key = create_key(session_id, participant);
 376         PurpleMediaSessionType type =
 377                         purple_media_get_session_type(gtkmedia->priv->media, session_id);
 378
 379         if (type & PURPLE_MEDIA_AUDIO)
 380                 g_hash_table_insert(gtkmedia->priv->recv_progressbars, key, widget);
 381         else if (type & PURPLE_MEDIA_VIDEO)
 382                 g_hash_table_insert(gtkmedia->priv->remote_videos, key, widget);
 383 }
 384
 385 static GtkWidget *
 386 pidgin_media_get_widget(PidginMedia *gtkmedia,
 387                 const gchar *session_id, const gchar *participant)
 388 {
 389         GtkWidget *widget = NULL;
 390         gchar *key = create_key(session_id, participant);
 391         PurpleMediaSessionType type =
 392                         purple_media_get_session_type(gtkmedia->priv->media, session_id);
 393
 394         if (type & PURPLE_MEDIA_AUDIO)
 395                 widget = g_hash_table_lookup(gtkmedia->priv->recv_progressbars, key);
 396         else if (type & PURPLE_MEDIA_VIDEO)
 397                 widget = g_hash_table_lookup(gtkmedia->priv->remote_videos, key);
 398
 399         g_free(key);
 400         return widget;
 401 }
 402
 403 static void
 404 pidgin_media_remove_widget(PidginMedia *gtkmedia,
 405                 const gchar *session_id, const gchar *participant)
 406 {
 407         GtkWidget *widget = pidgin_media_get_widget(gtkmedia, session_id, participant);
 408
 409         if (widget) {
 410                 PurpleMediaSessionType type =
 411                                 purple_media_get_session_type(gtkmedia->priv->media, session_id);
 412                 gchar *key = create_key(session_id, participant);
 413                 GtkRequisition req;
 414
 415                 if (type & PURPLE_MEDIA_AUDIO) {
 416                         g_hash_table_remove(gtkmedia->priv->recv_progressbars, key);
 417
 418                         if (g_hash_table_size(gtkmedia->priv->recv_progressbars) == 0 &&
 419                                 gtkmedia->priv->send_progress) {
 420
 421                                 gtk_widget_destroy(gtkmedia->priv->send_progress);
 422                                 gtkmedia->priv->send_progress = NULL;
 423
 424                                 gtk_widget_destroy(gtkmedia->priv->mute);
 425                                 gtkmedia->priv->mute = NULL;
 426                         }
 427                 } else if (type & PURPLE_MEDIA_VIDEO) {
 428                         g_hash_table_remove(gtkmedia->priv->remote_videos, key);
 429
 430                         if (g_hash_table_size(gtkmedia->priv->remote_videos) == 0 &&
 431                                 gtkmedia->priv->local_video) {
 432
 433                                 gtk_widget_destroy(gtkmedia->priv->local_video);
 434                                 gtkmedia->priv->local_video = NULL;
 435
 436                                 gtk_widget_destroy(gtkmedia->priv->pause);
 437                                 gtkmedia->priv->pause = NULL;
 438                         }
 439                 }
 440
 441                 g_free(key);
 442
 443                 gtk_widget_destroy(widget);
 444
 445                 gtk_widget_get_preferred_size(GTK_WIDGET(gtkmedia), NULL, &req);
 446                 gtk_window_resize(GTK_WINDOW(gtkmedia), req.width, req.height);
 447         }
 448 }
 449
 450 static void
 451 level_message_cb(PurpleMedia *media, gchar *session_id, gchar *participant,
 452                 double level, PidginMedia *gtkmedia)
 453 {
 454         GtkWidget *progress = NULL;
 455         if (participant == NULL)
 456                 progress = gtkmedia->priv->send_progress;
 457         else
 458                 progress = pidgin_media_get_widget(gtkmedia, session_id, participant);
 459
 460         if (progress)
 461                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress), level);
 462 }
 463
 464
 465 static void
 466 pidgin_media_disconnect_levels(PurpleMedia *media, PidginMedia *gtkmedia)
 467 {
 468         PurpleMediaManager *manager = purple_media_get_manager(media);
 469         GstElement *element = purple_media_manager_get_pipeline(manager);
 470         gulong handler_id = g_signal_handler_find(G_OBJECT(gst_pipeline_get_bus(GST_PIPELINE(element))),
 471                                                   G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0,
 472                                                   NULL, G_CALLBACK(level_message_cb), gtkmedia);
 473         if (handler_id)
 474                 g_signal_handler_disconnect(G_OBJECT(gst_pipeline_get_bus(GST_PIPELINE(element))),
 475                                             handler_id);
 476 }
 477
 478 static void
 479 pidgin_media_dispose(GObject *media)
 480 {
 481         PidginMedia *gtkmedia = PIDGIN_MEDIA(media);
 482         purple_debug_info("gtkmedia", "pidgin_media_dispose\n");
 483
 484         if (gtkmedia->priv->media) {
 485                 purple_request_close_with_handle(gtkmedia);
 486                 purple_media_remove_output_windows(gtkmedia->priv->media);
 487                 pidgin_media_disconnect_levels(gtkmedia->priv->media, gtkmedia);
 488                 g_object_unref(gtkmedia->priv->media);
 489                 gtkmedia->priv->media = NULL;
 490         }
 491
 492         if (gtkmedia->priv->ui) {
 493                 g_object_unref(gtkmedia->priv->ui);
 494                 gtkmedia->priv->ui = NULL;
 495         }
 496
 497         if (gtkmedia->priv->timeout_id != 0)
 498                 g_source_remove(gtkmedia->priv->timeout_id);
 499
 500         if (gtkmedia->priv->recv_progressbars) {
 501                 g_hash_table_destroy(gtkmedia->priv->recv_progressbars);
 502                 g_hash_table_destroy(gtkmedia->priv->remote_videos);
 503                 gtkmedia->priv->recv_progressbars = NULL;
 504                 gtkmedia->priv->remote_videos = NULL;
 505         }
 506
 507         G_OBJECT_CLASS(parent_class)->dispose(media);
 508 }
 509
 510 static void
 511 pidgin_media_finalize(GObject *media)
 512 {
 513         /* PidginMedia *gtkmedia = PIDGIN_MEDIA(media); */
 514         purple_debug_info("gtkmedia", "pidgin_media_finalize\n");
 515
 516         G_OBJECT_CLASS(parent_class)->finalize(media);
 517 }
 518
 519 static void
 520 pidgin_media_emit_message(PidginMedia *gtkmedia, const char *msg)
 521 {
 522         PurpleConversation *conv = purple_conversations_find_with_account(
 523                         gtkmedia->priv->screenname,
 524                         purple_media_get_account(gtkmedia->priv->media));
 525         if (conv != NULL)
 526                 purple_conversation_write_system_message(conv, msg, 0);
 527 }
 528
 529 typedef struct
 530 {
 531         PidginMedia *gtkmedia;
 532         gchar *session_id;
 533         gchar *participant;
 534 } PidginMediaRealizeData;
 535
 536 static gboolean
 537 realize_cb_cb(PidginMediaRealizeData *data)
 538 {
 539         PidginMediaPrivate *priv = data->gtkmedia->priv;
 540         GdkWindow *window = NULL;
 541
 542         if (data->participant == NULL)
 543                 window = gtk_widget_get_window(priv->local_video);
 544         else {
 545                 GtkWidget *widget = pidgin_media_get_widget(data->gtkmedia,
 546                                 data->session_id, data->participant);
 547                 if (widget)
 548                         window = gtk_widget_get_window(widget);
 549         }
 550
 551         if (window) {
 552                 gulong window_id = 0;
 553 #ifdef GDK_WINDOWING_WIN32
 554                 if (GDK_IS_WIN32_WINDOW(window))
 555                         window_id = GPOINTER_TO_UINT(GDK_WINDOW_HWND(window));
 556                 else
 557 #endif
 558 #ifdef GDK_WINDOWING_X11
 559                 if (GDK_IS_X11_WINDOW(window))
 560                         window_id = gdk_x11_window_get_xid(window);
 561                 else
 562 #endif
 563 #ifdef GDK_WINDOWING_QUARTZ
 564                 if (GDK_IS_QUARTZ_WINDOW(window))
 565                         window_id = (gulong)gdk_quartz_window_get_nsview(window);
 566                 else
 567 #endif
 568                         g_warning("Unsupported GDK backend");
 569 #if !(defined(GDK_WINDOWING_WIN32) \
 570    || defined(GDK_WINDOWING_X11) \
 571    || defined(GDK_WINDOWING_QUARTZ))
 572 #               error "Unsupported GDK windowing system"
 573 #endif
 574
 575                 purple_media_set_output_window(priv->media, data->session_id,
 576                                 data->participant, window_id);
 577         }
 578
 579         g_free(data->session_id);
 580         g_free(data->participant);
 581         g_free(data);
 582         return FALSE;
 583 }
 584
 585 static void
 586 realize_cb(GtkWidget *widget, PidginMediaRealizeData *data)
 587 {
 588         g_timeout_add(0, (GSourceFunc)realize_cb_cb, data);
 589 }
 590
 591 static void
 592 pidgin_media_error_cb(PidginMedia *media, const char *error, PidginMedia *gtkmedia)
 593 {
 594         PurpleConversation *conv = purple_conversations_find_with_account(
 595                         gtkmedia->priv->screenname,
 596                         purple_media_get_account(gtkmedia->priv->media));
 597         if (conv != NULL) {
 598                 purple_conversation_write_system_message(
 599                         conv, error, PURPLE_MESSAGE_ERROR);
 600         } else {
 601                 purple_notify_error(NULL, NULL, _("Media error"), error,
 602                         purple_request_cpar_from_conversation(conv));
 603         }
 604
 605         gtk_statusbar_push(GTK_STATUSBAR(gtkmedia->priv->statusbar),
 606                         0, error);
 607 }
 608
 609 static void
 610 pidgin_media_accept_cb(PurpleMedia *media, int index)
 611 {
 612         purple_media_stream_info(media, PURPLE_MEDIA_INFO_ACCEPT,
 613                         NULL, NULL, TRUE);
 614 }
 615
 616 static void
 617 pidgin_media_reject_cb(PurpleMedia *media, int index)
 618 {
 619         GList *iter = purple_media_get_session_ids(media);
 620         for (; iter; iter = g_list_delete_link(iter, iter)) {
 621                 const gchar *sessionid = iter->data;
 622                 if (!purple_media_accepted(media, sessionid, NULL))
 623                         purple_media_stream_info(media, PURPLE_MEDIA_INFO_REJECT,
 624                                         sessionid, NULL, TRUE);
 625         }
 626 }
 627
 628 static gboolean
 629 pidgin_request_timeout_cb(PidginMedia *gtkmedia)
 630 {
 631         PurpleAccount *account;
 632         PurpleBuddy *buddy;
 633         const gchar *alias;
 634         PurpleMediaSessionType type;
 635         gchar *message = NULL;
 636
 637         account = purple_media_get_account(gtkmedia->priv->media);
 638         buddy = purple_blist_find_buddy(account, gtkmedia->priv->screenname);
 639         alias = buddy ? purple_buddy_get_contact_alias(buddy) :
 640                         gtkmedia->priv->screenname;
 641         type = gtkmedia->priv->request_type;
 642         gtkmedia->priv->timeout_id = 0;
 643
 644         if (type & PURPLE_MEDIA_AUDIO && type & PURPLE_MEDIA_VIDEO) {
 645                 message = g_strdup_printf(_("%s wishes to start an audio/video session with you."),
 646                                 alias);
 647         } else if (type & PURPLE_MEDIA_AUDIO) {
 648                 message = g_strdup_printf(_("%s wishes to start an audio session with you."),
 649                                 alias);
 650         } else if (type & PURPLE_MEDIA_VIDEO) {
 651                 message = g_strdup_printf(_("%s wishes to start a video session with you."),
 652                                 alias);
 653         }
 654
 655         gtkmedia->priv->request_type = PURPLE_MEDIA_NONE;
 656         if (!purple_media_accepted(gtkmedia->priv->media, NULL, NULL)) {
 657                 purple_request_accept_cancel(gtkmedia, _("Incoming Call"),
 658                         message, NULL, PURPLE_DEFAULT_ACTION_NONE,
 659                         purple_request_cpar_from_account(account),
 660                         gtkmedia->priv->media, pidgin_media_accept_cb,
 661                         pidgin_media_reject_cb);
 662         }
 663         pidgin_media_emit_message(gtkmedia, message);
 664         g_free(message);
 665         return FALSE;
 666 }
 667
 668 static void
 669 pidgin_media_input_volume_changed(GtkScaleButton *range, double value,
 670                 PurpleMedia *media)
 671 {
 672         double val = (double)value * 100.0;
 673         purple_media_set_input_volume(media, NULL, val);
 674 }
 675
 676 static void
 677 pidgin_media_output_volume_changed(GtkScaleButton *range, double value,
 678                 PurpleMedia *media)
 679 {
 680         double val = (double)value * 100.0;
 681         purple_media_set_output_volume(media, NULL, NULL, val);
 682 }
 683
 684 static void
 685 destroy_parent_widget_cb(GtkWidget *widget, GtkWidget *parent)
 686 {
 687         g_return_if_fail(GTK_IS_WIDGET(parent));
 688
 689         gtk_widget_destroy(parent);
 690 }
 691
 692 static GtkWidget *
 693 pidgin_media_add_audio_widget(PidginMedia *gtkmedia,
 694                 PurpleMediaSessionType type, const gchar *sid)
 695 {
 696         GtkWidget *volume_widget, *progress_parent, *volume, *progress;
 697         double value;
 698
 699         static const gchar * input_volume_icons[] = {
 700                 "microphone-sensitivity-muted-symbolic",
 701                 "microphone-sensitivity-high-symbolic",
 702                 "microphone-sensitivity-low-symbolic",
 703                 "microphone-sensitivity-medium-symbolic",
 704                 NULL
 705         };
 706
 707         if (type & PURPLE_MEDIA_SEND_AUDIO) {
 708                 value = purple_prefs_get_int(
 709                         "/purple/media/audio/volume/input");
 710         } else if (type & PURPLE_MEDIA_RECV_AUDIO) {
 711                 value = purple_prefs_get_int(
 712                         "/purple/media/audio/volume/output");
 713         } else
 714                 g_return_val_if_reached(NULL);
 715
 716         /* Setup widget structure */
 717         volume_widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 718         progress_parent = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 719         gtk_box_pack_start(GTK_BOX(volume_widget),
 720                         progress_parent, TRUE, TRUE, 0);
 721
 722         /* Volume button */
 723         volume = gtk_volume_button_new();
 724         gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume), value/100.0);
 725         gtk_box_pack_end(GTK_BOX(volume_widget),
 726                         volume, FALSE, FALSE, 0);
 727
 728         /* Volume level indicator */
 729         progress = gtk_progress_bar_new();
 730         gtk_widget_set_size_request(progress, 250, 10);
 731         gtk_box_pack_end(GTK_BOX(progress_parent), progress, TRUE, FALSE, 0);
 732
 733         if (type & PURPLE_MEDIA_SEND_AUDIO) {
 734                 g_signal_connect (G_OBJECT(volume), "value-changed",
 735                                 G_CALLBACK(pidgin_media_input_volume_changed),
 736                                 gtkmedia->priv->media);
 737                 gtk_scale_button_set_icons(GTK_SCALE_BUTTON(volume),
 738                                 input_volume_icons);
 739
 740                 gtkmedia->priv->send_progress = progress;
 741         } else if (type & PURPLE_MEDIA_RECV_AUDIO) {
 742                 g_signal_connect (G_OBJECT(volume), "value-changed",
 743                                 G_CALLBACK(pidgin_media_output_volume_changed),
 744                                 gtkmedia->priv->media);
 745
 746                 pidgin_media_insert_widget(gtkmedia, progress, sid, gtkmedia->priv->screenname);
 747         }
 748
 749         g_signal_connect(G_OBJECT(progress), "destroy",
 750                         G_CALLBACK(destroy_parent_widget_cb),
 751                         volume_widget);
 752
 753         gtk_widget_show_all(volume_widget);
 754
 755         return volume_widget;
 756 }
 757
 758 static void
 759 phone_dtmf_pressed_cb(GtkButton *button, gpointer user_data)
 760 {
 761         PidginMedia *gtkmedia = user_data;
 762         gint num;
 763         gchar *sid;
 764
 765         num = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(button), "dtmf-digit"));
 766         sid = g_object_get_data(G_OBJECT(button), "session-id");
 767
 768         purple_media_send_dtmf(gtkmedia->priv->media, sid, num, 25, 50);
 769 }
 770
 771 static inline GtkWidget *
 772 phone_create_button(const gchar *text_hi, const gchar *text_lo)
 773 {
 774         GtkWidget *button;
 775         GtkWidget *label_hi;
 776         GtkWidget *label_lo;
 777         GtkWidget *grid;
 778         const gchar *text_hi_local;
 779
 780         if (text_hi)
 781                 text_hi_local = _(text_hi);
 782         else
 783                 text_hi_local = "";
 784
 785         grid = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 786         gtk_box_set_homogeneous(GTK_BOX(grid), TRUE);
 787
 788         button = gtk_button_new();
 789         label_hi = gtk_label_new(text_hi_local);
 790         gtk_box_pack_end(GTK_BOX(grid), label_hi, FALSE, TRUE, 0);
 791         label_lo = gtk_label_new(text_lo);
 792         gtk_label_set_use_markup(GTK_LABEL(label_lo), TRUE);
 793         gtk_box_pack_end(GTK_BOX(grid), label_lo, FALSE, TRUE, 0);
 794         gtk_container_add(GTK_CONTAINER(button), grid);
 795
 796         return button;
 797 }
 798
 799 static struct phone_label {
 800         gchar *subtext;
 801         gchar *text;
 802         gchar chr;
 803 } phone_labels[] = {
 804         {"<b>1</b>", NULL, '1'},
 805         /* Translators note: These are the letters on the keys of a numeric
 806            keypad; translate according to the tables in §7 of ETSI ES 202 130:
 807            http://webapp.etsi.org/WorkProgram/Report_WorkItem.asp?WKI_ID=11730
 808          */
 809          /* Letters on the '2' key of a numeric keypad */
 810         {"<b>2</b>", N_("ABC"), '2'},
 811          /* Letters on the '3' key of a numeric keypad */
 812         {"<b>3</b>", N_("DEF"), '3'},
 813          /* Letters on the '4' key of a numeric keypad */
 814         {"<b>4</b>", N_("GHI"), '4'},
 815          /* Letters on the '5' key of a numeric keypad */
 816         {"<b>5</b>", N_("JKL"), '5'},
 817          /* Letters on the '6' key of a numeric keypad */
 818         {"<b>6</b>", N_("MNO"), '6'},
 819          /* Letters on the '7' key of a numeric keypad */
 820         {"<b>7</b>", N_("PQRS"), '7'},
 821          /* Letters on the '8' key of a numeric keypad */
 822         {"<b>8</b>", N_("TUV"), '8'},
 823          /* Letters on the '9' key of a numeric keypad */
 824         {"<b>9</b>", N_("WXYZ"), '9'},
 825         {"<b>*</b>", NULL, '*'},
 826         {"<b>0</b>", NULL, '0'},
 827         {"<b>#</b>", NULL, '#'},
 828         {NULL, NULL, 0}
 829 };
 830
 831 static gboolean
 832 pidgin_media_dtmf_key_press_event_cb(GtkWidget *widget,
 833                 GdkEvent *event, gpointer user_data)
 834 {
 835         PidginMedia *gtkmedia = user_data;
 836         GdkEventKey *key = (GdkEventKey *) event;
 837
 838         if (event->type != GDK_KEY_PRESS) {
 839                 return FALSE;
 840         }
 841
 842         if ((key->keyval >= GDK_KEY_0 && key->keyval <= GDK_KEY_9) ||
 843                 key->keyval == GDK_KEY_asterisk ||
 844                 key->keyval == GDK_KEY_numbersign) {
 845                 gchar *sid = g_object_get_data(G_OBJECT(widget), "session-id");
 846
 847                 purple_media_send_dtmf(gtkmedia->priv->media, sid, key->keyval, 25, 50);
 848         }
 849
 850         return FALSE;
 851 }
 852
 853 static GtkWidget *
 854 pidgin_media_add_dtmf_widget(PidginMedia *gtkmedia,
 855                 PurpleMediaSessionType type, const gchar *_sid)
 856 {
 857         GtkWidget *grid = gtk_grid_new();
 858         GtkWidget *button;
 859         gint index = 0;
 860         GtkWindow *win = &gtkmedia->parent;
 861
 862         gtk_grid_set_row_homogeneous(GTK_GRID(grid), TRUE);
 863         gtk_grid_set_column_homogeneous(GTK_GRID(grid), TRUE);
 864
 865         /* Add buttons */
 866         for (index = 0; phone_labels[index].subtext != NULL; index++) {
 867                 button = phone_create_button(phone_labels[index].text,
 868                                 phone_labels[index].subtext);
 869                 g_signal_connect(button, "pressed",
 870                                 G_CALLBACK(phone_dtmf_pressed_cb), gtkmedia);
 871                 g_object_set_data(G_OBJECT(button), "dtmf-digit",
 872                                 GINT_TO_POINTER(phone_labels[index].chr));
 873                 g_object_set_data_full(G_OBJECT(button), "session-id",
 874                                 g_strdup(_sid), g_free);
 875                 gtk_grid_attach(GTK_GRID(grid), button,
 876                                 index % 3, index / 3, 1, 1);
 877                 g_object_set(button, "expand", TRUE, "margin", 2, NULL);
 878         }
 879
 880         g_signal_connect(G_OBJECT(win), "key-press-event",
 881                 G_CALLBACK(pidgin_media_dtmf_key_press_event_cb), gtkmedia);
 882         g_object_set_data_full(G_OBJECT(win), "session-id",
 883                 g_strdup(_sid), g_free);
 884
 885         gtk_widget_show_all(grid);
 886
 887         return grid;
 888 }
 889
 890 static void
 891 pidgin_media_ready_cb(PurpleMedia *media, PidginMedia *gtkmedia, const gchar *sid)
 892 {
 893         GtkWidget *send_widget = NULL, *recv_widget = NULL, *button_widget = NULL;
 894         PurpleMediaSessionType type =
 895                         purple_media_get_session_type(media, sid);
 896         GdkPixbuf *icon = NULL;
 897
 898         if (gtkmedia->priv->recv_widget == NULL
 899                         && type & (PURPLE_MEDIA_RECV_VIDEO |
 900                         PURPLE_MEDIA_RECV_AUDIO)) {
 901                 recv_widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 902                 gtk_box_pack_start(GTK_BOX(gtkmedia->priv->display),
 903                                 recv_widget, TRUE, TRUE, 0);
 904                 gtk_widget_show(recv_widget);
 905         } else {
 906                 recv_widget = gtkmedia->priv->recv_widget;
 907         }
 908         if (gtkmedia->priv->send_widget == NULL
 909                         && type & (PURPLE_MEDIA_SEND_VIDEO |
 910                         PURPLE_MEDIA_SEND_AUDIO)) {
 911                 send_widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 912                 gtk_box_pack_start(GTK_BOX(gtkmedia->priv->display),
 913                                 send_widget, FALSE, TRUE, 0);
 914                 button_widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 915                 gtk_box_pack_end(GTK_BOX(recv_widget), button_widget,
 916                                 FALSE, TRUE, 0);
 917                 gtk_widget_show(send_widget);
 918
 919                 /* Hold button */
 920                 gtkmedia->priv->hold =
 921                                 gtk_toggle_button_new_with_mnemonic(_("_Hold"));
 922                 gtk_box_pack_end(GTK_BOX(button_widget), gtkmedia->priv->hold,
 923                                 FALSE, FALSE, 0);
 924                 gtk_widget_show(gtkmedia->priv->hold);
 925                 g_signal_connect(gtkmedia->priv->hold, "toggled",
 926                                 G_CALLBACK(pidgin_media_hold_toggled),
 927                                 gtkmedia);
 928         } else {
 929                 send_widget = gtkmedia->priv->send_widget;
 930                 button_widget = gtkmedia->priv->button_widget;
 931         }
 932
 933         if (type & PURPLE_MEDIA_RECV_VIDEO) {
 934                 PidginMediaRealizeData *data;
 935                 GtkWidget *aspect;
 936                 GtkWidget *remote_video;
 937
 938                 aspect = gtk_aspect_frame_new(NULL, 0, 0, 4.0/3.0, FALSE);
 939                 gtk_frame_set_shadow_type(GTK_FRAME(aspect), GTK_SHADOW_IN);
 940                 gtk_box_pack_start(GTK_BOX(recv_widget), aspect, TRUE, TRUE, 0);
 941
 942                 data = g_new0(PidginMediaRealizeData, 1);
 943                 data->gtkmedia = gtkmedia;
 944                 data->session_id = g_strdup(sid);
 945                 data->participant = g_strdup(gtkmedia->priv->screenname);
 946
 947                 remote_video = pidgin_create_video_widget();
 948                 g_signal_connect(G_OBJECT(remote_video), "realize",
 949                                 G_CALLBACK(realize_cb), data);
 950                 gtk_container_add(GTK_CONTAINER(aspect), remote_video);
 951                 gtk_widget_set_size_request (GTK_WIDGET(remote_video), 320, 240);
 952                 g_signal_connect(G_OBJECT(remote_video), "destroy",
 953                                 G_CALLBACK(destroy_parent_widget_cb), aspect);
 954
 955                 gtk_widget_show(remote_video);
 956                 gtk_widget_show(aspect);
 957
 958                 pidgin_media_insert_widget(gtkmedia, remote_video,
 959                                 data->session_id, data->participant);
 960         }
 961
 962         if (type & PURPLE_MEDIA_SEND_VIDEO && !gtkmedia->priv->local_video) {
 963                 PidginMediaRealizeData *data;
 964                 GtkWidget *aspect;
 965                 GtkWidget *local_video;
 966
 967                 aspect = gtk_aspect_frame_new(NULL, 0, 0, 4.0/3.0, TRUE);
 968                 gtk_frame_set_shadow_type(GTK_FRAME(aspect), GTK_SHADOW_IN);
 969                 gtk_box_pack_start(GTK_BOX(send_widget), aspect, FALSE, TRUE, 0);
 970
 971                 data = g_new0(PidginMediaRealizeData, 1);
 972                 data->gtkmedia = gtkmedia;
 973                 data->session_id = g_strdup(sid);
 974                 data->participant = NULL;
 975
 976                 local_video = pidgin_create_video_widget();
 977                 g_signal_connect(G_OBJECT(local_video), "realize",
 978                                 G_CALLBACK(realize_cb), data);
 979                 gtk_container_add(GTK_CONTAINER(aspect), local_video);
 980                 gtk_widget_set_size_request (GTK_WIDGET(local_video), 80, 60);
 981                 g_signal_connect(G_OBJECT(local_video), "destroy",
 982                                 G_CALLBACK(destroy_parent_widget_cb), aspect);
 983
 984                 gtk_widget_show(local_video);
 985                 gtk_widget_show(aspect);
 986
 987                 gtkmedia->priv->pause =
 988                                 gtk_toggle_button_new_with_mnemonic(_("_Pause"));
 989                 gtk_box_pack_end(GTK_BOX(button_widget), gtkmedia->priv->pause,
 990                                 FALSE, FALSE, 0);
 991                 gtk_widget_show(gtkmedia->priv->pause);
 992                 g_signal_connect(gtkmedia->priv->pause, "toggled",
 993                                 G_CALLBACK(pidgin_media_pause_toggled),
 994                                 gtkmedia);
 995
 996                 gtkmedia->priv->local_video = local_video;
 997         }
 998         if (type & PURPLE_MEDIA_RECV_AUDIO) {
 999                 gtk_box_pack_end(GTK_BOX(recv_widget),
1000                                 pidgin_media_add_audio_widget(gtkmedia,
1001                                 PURPLE_MEDIA_RECV_AUDIO, sid), FALSE, FALSE, 0);
1002         }
1003
1004         if (type & PURPLE_MEDIA_SEND_AUDIO) {
1005                 gtkmedia->priv->mute =
1006                                 gtk_toggle_button_new_with_mnemonic(_("_Mute"));
1007                 gtk_box_pack_end(GTK_BOX(button_widget), gtkmedia->priv->mute,
1008                                 FALSE, FALSE, 0);
1009                 gtk_widget_show(gtkmedia->priv->mute);
1010                 g_signal_connect(gtkmedia->priv->mute, "toggled",
1011                                 G_CALLBACK(pidgin_media_mute_toggled),
1012                                 gtkmedia);
1013
1014                 gtk_box_pack_end(GTK_BOX(recv_widget),
1015                                 pidgin_media_add_audio_widget(gtkmedia,
1016                                 PURPLE_MEDIA_SEND_AUDIO, sid), FALSE, FALSE, 0);
1017
1018                 gtk_box_pack_end(GTK_BOX(recv_widget),
1019                                 pidgin_media_add_dtmf_widget(gtkmedia,
1020                                 PURPLE_MEDIA_SEND_AUDIO, sid), FALSE, FALSE, 0);
1021         }
1022
1023         if (type & PURPLE_MEDIA_AUDIO &&
1024                         gtkmedia->priv->level_handler_id == 0) {
1025                 gtkmedia->priv->level_handler_id = g_signal_connect(
1026                                 media, "level", G_CALLBACK(level_message_cb),
1027                                 gtkmedia);
1028         }
1029
1030         if (send_widget != NULL)
1031                 gtkmedia->priv->send_widget = send_widget;
1032         if (recv_widget != NULL)
1033                 gtkmedia->priv->recv_widget = recv_widget;
1034         if (button_widget != NULL) {
1035                 gtkmedia->priv->button_widget = button_widget;
1036                 gtk_widget_show(GTK_WIDGET(button_widget));
1037         }
1038
1039         if (purple_media_is_initiator(media, sid, NULL) == FALSE) {
1040                 if (gtkmedia->priv->timeout_id != 0)
1041                         g_source_remove(gtkmedia->priv->timeout_id);
1042                 gtkmedia->priv->request_type |= type;
1043                 gtkmedia->priv->timeout_id = g_timeout_add(500,
1044                                 (GSourceFunc)pidgin_request_timeout_cb,
1045                                 gtkmedia);
1046         }
1047
1048         /* set the window icon according to the type */
1049         if (type & PURPLE_MEDIA_VIDEO) {
1050                 icon = gtk_widget_render_icon(GTK_WIDGET(gtkmedia),
1051                         PIDGIN_STOCK_TOOLBAR_VIDEO_CALL,
1052                         gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_LARGE), NULL);
1053         } else if (type & PURPLE_MEDIA_AUDIO) {
1054                 icon = gtk_widget_render_icon(GTK_WIDGET(gtkmedia),
1055                         PIDGIN_STOCK_TOOLBAR_AUDIO_CALL,
1056                         gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_LARGE), NULL);
1057         }
1058
1059         if (icon) {
1060                 gtk_window_set_icon(GTK_WINDOW(gtkmedia), icon);
1061                 g_object_unref(icon);
1062         }
1063
1064         gtk_widget_show(gtkmedia->priv->display);
1065 }
1066
1067 static void
1068 pidgin_media_state_changed_cb(PurpleMedia *media, PurpleMediaState state,
1069                 gchar *sid, gchar *name, PidginMedia *gtkmedia)
1070 {
1071         purple_debug_info("gtkmedia", "state: %d sid: %s name: %s\n",
1072                         state, sid ? sid : "(null)", name ? name : "(null)");
1073         if (state == PURPLE_MEDIA_STATE_END) {
1074                 if (sid != NULL && name != NULL) {
1075                         pidgin_media_remove_widget(gtkmedia, sid, name);
1076                 } else if (sid == NULL && name == NULL) {
1077                         pidgin_media_emit_message(gtkmedia,
1078                                         _("The call has been terminated."));
1079                         gtk_widget_destroy(GTK_WIDGET(gtkmedia));
1080                 }
1081         } else if (state == PURPLE_MEDIA_STATE_NEW &&
1082                         sid != NULL && name != NULL) {
1083                 pidgin_media_ready_cb(media, gtkmedia, sid);
1084         }
1085 }
1086
1087 static void
1088 pidgin_media_stream_info_cb(PurpleMedia *media, PurpleMediaInfoType type,
1089                 gchar *sid, gchar *name, gboolean local,
1090                 PidginMedia *gtkmedia)
1091 {
1092         if (type == PURPLE_MEDIA_INFO_REJECT) {
1093                 pidgin_media_emit_message(gtkmedia,
1094                                 _("You have rejected the call."));
1095         } else if (type == PURPLE_MEDIA_INFO_ACCEPT) {
1096                 if (local == TRUE)
1097                         purple_request_close_with_handle(gtkmedia);
1098                 pidgin_media_set_state(gtkmedia, PIDGIN_MEDIA_ACCEPTED);
1099                 pidgin_media_emit_message(gtkmedia, _("Call in progress."));
1100                 gtk_statusbar_push(GTK_STATUSBAR(gtkmedia->priv->statusbar),
1101                                 0, _("Call in progress"));
1102                 gtk_widget_show(GTK_WIDGET(gtkmedia));
1103         }
1104 }
1105
1106 static void
1107 pidgin_media_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
1108 {
1109         PidginMedia *media;
1110         g_return_if_fail(PIDGIN_IS_MEDIA(object));
1111
1112         media = PIDGIN_MEDIA(object);
1113         switch (prop_id) {
1114                 case PROP_MEDIA:
1115                 {
1116                         if (media->priv->media)
1117                                 g_object_unref(media->priv->media);
1118                         media->priv->media = g_value_get_object(value);
1119                         g_object_ref(media->priv->media);
1120
1121                         if (purple_media_is_initiator(media->priv->media,
1122                                          NULL, NULL) == TRUE)
1123                                 pidgin_media_set_state(media, PIDGIN_MEDIA_WAITING);
1124                         else
1125                                 pidgin_media_set_state(media, PIDGIN_MEDIA_REQUESTED);
1126
1127                         g_signal_connect(G_OBJECT(media->priv->media), "error",
1128                                 G_CALLBACK(pidgin_media_error_cb), media);
1129                         g_signal_connect(G_OBJECT(media->priv->media), "state-changed",
1130                                 G_CALLBACK(pidgin_media_state_changed_cb), media);
1131                         g_signal_connect(G_OBJECT(media->priv->media), "stream-info",
1132                                 G_CALLBACK(pidgin_media_stream_info_cb), media);
1133                         break;
1134                 }
1135                 case PROP_SCREENNAME:
1136                         g_free(media->priv->screenname);
1137                         media->priv->screenname = g_value_dup_string(value);
1138                         break;
1139                 default:
1140                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1141                         break;
1142         }
1143 }
1144
1145 static void
1146 pidgin_media_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
1147 {
1148         PidginMedia *media;
1149         g_return_if_fail(PIDGIN_IS_MEDIA(object));
1150
1151         media = PIDGIN_MEDIA(object);
1152
1153         switch (prop_id) {
1154                 case PROP_MEDIA:
1155                         g_value_set_object(value, media->priv->media);
1156                         break;
1157                 case PROP_SCREENNAME:
1158                         g_value_set_string(value, media->priv->screenname);
1159                         break;
1160                 default:
1161                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1162                         break;
1163         }
1164 }
1165
1166 static GtkWidget *
1167 pidgin_media_new(PurpleMedia *media, const gchar *screenname)
1168 {
1169         PidginMedia *gtkmedia = g_object_new(pidgin_media_get_type(),
1170                                              "media", media,
1171                                              "screenname", screenname, NULL);
1172         return GTK_WIDGET(gtkmedia);
1173 }
1174
1175 static void
1176 pidgin_media_set_state(PidginMedia *gtkmedia, PidginMediaState state)
1177 {
1178         gtkmedia->priv->state = state;
1179 }
1180
1181 static gboolean
1182 pidgin_media_new_cb(PurpleMediaManager *manager, PurpleMedia *media,
1183                 PurpleAccount *account, gchar *screenname, gpointer nul)
1184 {
1185         PidginMedia *gtkmedia = PIDGIN_MEDIA(
1186                         pidgin_media_new(media, screenname));
1187         PurpleBuddy *buddy = purple_blist_find_buddy(account, screenname);
1188         const gchar *alias = buddy ?
1189                         purple_buddy_get_contact_alias(buddy) : screenname;
1190         gtk_window_set_title(GTK_WINDOW(gtkmedia), alias);
1191
1192         if (purple_media_is_initiator(media, NULL, NULL) == TRUE)
1193                 gtk_widget_show(GTK_WIDGET(gtkmedia));
1194
1195         return TRUE;
1196 }
1197 #endif  /* USE_VV */
1198
1199 void
1200 pidgin_medias_init(void)
1201 {
1202 #ifdef USE_VV
1203         PurpleMediaManager *manager = purple_media_manager_get();
1204         PurpleMediaElementInfo *video_src = NULL;
1205         PurpleMediaElementInfo *video_sink = NULL;
1206         PurpleMediaElementInfo *audio_src = NULL;
1207         PurpleMediaElementInfo *audio_sink = NULL;
1208         const char *pref;
1209
1210         pref = purple_prefs_get_string(
1211                         PIDGIN_PREFS_ROOT "/vvconfig/video/src/device");
1212         if (pref)
1213                 video_src = purple_media_manager_get_element_info(manager, pref);
1214         if (!video_src) {
1215                 pref = "autovideosrc";
1216                 purple_prefs_set_string(
1217                         PIDGIN_PREFS_ROOT "/vvconfig/video/src/device", pref);
1218                 video_src = purple_media_manager_get_element_info(manager,
1219                                 pref);
1220         }
1221
1222         pref = purple_prefs_get_string(
1223                         PIDGIN_PREFS_ROOT "/vvconfig/video/sink/device");
1224         if (pref)
1225                 video_sink = purple_media_manager_get_element_info(manager, pref);
1226         if (!video_sink) {
1227                 pref = "autovideosink";
1228                 purple_prefs_set_string(
1229                         PIDGIN_PREFS_ROOT "/vvconfig/video/sink/device", pref);
1230                 video_sink = purple_media_manager_get_element_info(manager,
1231                                 pref);
1232         }
1233
1234         pref = purple_prefs_get_string(
1235                         PIDGIN_PREFS_ROOT "/vvconfig/audio/src/device");
1236         if (pref)
1237                 audio_src = purple_media_manager_get_element_info(manager, pref);
1238         if (!audio_src) {
1239                 pref = "autoaudiosrc";
1240                 purple_prefs_set_string(
1241                         PIDGIN_PREFS_ROOT "/vvconfig/audio/src/device", pref);
1242                 audio_src = purple_media_manager_get_element_info(manager,
1243                                 pref);
1244         }
1245
1246         pref = purple_prefs_get_string(
1247                         PIDGIN_PREFS_ROOT "/vvconfig/audio/sink/device");
1248         if (pref)
1249                 audio_sink = purple_media_manager_get_element_info(manager, pref);
1250         if (!audio_sink) {
1251                 pref = "autoaudiosink";
1252                 purple_prefs_set_string(
1253                         PIDGIN_PREFS_ROOT "/vvconfig/audio/sink/device", pref);
1254                 audio_sink = purple_media_manager_get_element_info(manager,
1255                                 pref);
1256         }
1257
1258         g_signal_connect(G_OBJECT(manager), "init-media",
1259                          G_CALLBACK(pidgin_media_new_cb), NULL);
1260
1261         purple_media_manager_set_ui_caps(manager,
1262                         PURPLE_MEDIA_CAPS_AUDIO |
1263                         PURPLE_MEDIA_CAPS_AUDIO_SINGLE_DIRECTION |
1264                         PURPLE_MEDIA_CAPS_VIDEO |
1265                         PURPLE_MEDIA_CAPS_VIDEO_SINGLE_DIRECTION |
1266                         PURPLE_MEDIA_CAPS_AUDIO_VIDEO);
1267
1268         purple_debug_info("gtkmedia", "Registering media element types\n");
1269         purple_media_manager_set_active_element(manager, video_src);
1270         purple_media_manager_set_active_element(manager, video_sink);
1271         purple_media_manager_set_active_element(manager, audio_src);
1272         purple_media_manager_set_active_element(manager, audio_sink);
1273 #endif
1274 }
1275