pidgin/gtkmedia.c

   1 /**
   2  * @file media.c Account API
   3  * @ingroup core
   4  *
   5  * Pidgin
   6  *
   7  * Pidgin is the legal property of its developers, whose names are too numerous
   8  * to list here.  Please refer to the COPYRIGHT file distributed with this
   9  * source distribution.
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  24  */
  25
  26 #include "internal.h"
  27 #include "debug.h"
  28 #include "connection.h"
  29 #include "media.h"
  30 #include "mediamanager.h"
  31 #include "pidgin.h"
  32 #include "request.h"
  33
  34 #include "gtkmedia.h"
  35 #include "gtkutils.h"
  36 #include "pidginstock.h"
  37
  38 #ifdef USE_VV
  39 #include "media-gst.h"
  40
  41 #ifdef _WIN32
  42 #include <gdk/gdkwin32.h>
  43 #endif
  44 #include <gdk/gdkkeysyms.h>
  45
  46 #if !GST_CHECK_VERSION(1,0,0)
  47 #include <gst/interfaces/xoverlay.h>
  48 #endif
  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));
 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));
 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_vbox_new(FALSE, 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_hbox_new(FALSE, 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_size_request(GTK_WIDGET(gtkmedia), &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 * 5);
 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_find_conversation_with_account(
 523                         PURPLE_CONV_TYPE_ANY, gtkmedia->priv->screenname,
 524                         purple_media_get_account(gtkmedia->priv->media));
 525         if (conv != NULL)
 526                 purple_conversation_write(conv, NULL, msg,
 527                                 PURPLE_MESSAGE_SYSTEM, time(NULL));
 528 }
 529
 530 typedef struct
 531 {
 532         PidginMedia *gtkmedia;
 533         gchar *session_id;
 534         gchar *participant;
 535 } PidginMediaRealizeData;
 536
 537 static gboolean
 538 realize_cb_cb(PidginMediaRealizeData *data)
 539 {
 540         PidginMediaPrivate *priv = data->gtkmedia->priv;
 541         GdkWindow *window = NULL;
 542
 543         if (data->participant == NULL)
 544 #if GTK_CHECK_VERSION(2, 14, 0)
 545                 window = gtk_widget_get_window(priv->local_video);
 546 #else
 547                 window = (priv->local_video)->window;
 548 #endif
 549         else {
 550                 GtkWidget *widget = pidgin_media_get_widget(data->gtkmedia,
 551                                 data->session_id, data->participant);
 552                 if (widget)
 553 #if GTK_CHECK_VERSION(2, 14, 0)
 554                         window = gtk_widget_get_window(widget);
 555 #else
 556                         window = widget->window;
 557 #endif
 558         }
 559
 560         if (window) {
 561                 gulong window_id;
 562 #ifdef _WIN32
 563                 window_id = GDK_WINDOW_HWND(window);
 564 #elif defined(HAVE_X11)
 565                 window_id = GDK_WINDOW_XWINDOW(window);
 566 #else
 567 #               error "Unsupported windowing system"
 568 #endif
 569
 570                 purple_media_set_output_window(priv->media, data->session_id,
 571                                 data->participant, window_id);
 572         }
 573
 574         g_free(data->session_id);
 575         g_free(data->participant);
 576         g_free(data);
 577         return FALSE;
 578 }
 579
 580 static void
 581 realize_cb(GtkWidget *widget, PidginMediaRealizeData *data)
 582 {
 583         g_timeout_add(0, (GSourceFunc)realize_cb_cb, data);
 584 }
 585
 586 static void
 587 pidgin_media_error_cb(PidginMedia *media, const char *error, PidginMedia *gtkmedia)
 588 {
 589         PurpleConversation *conv = purple_find_conversation_with_account(
 590                         PURPLE_CONV_TYPE_ANY, gtkmedia->priv->screenname,
 591                         purple_media_get_account(gtkmedia->priv->media));
 592         if (conv != NULL)
 593                 purple_conversation_write(conv, NULL, error,
 594                                 PURPLE_MESSAGE_ERROR, time(NULL));
 595         else
 596                 purple_notify_error(NULL, NULL, _("Media error"), error);
 597
 598         gtk_statusbar_push(GTK_STATUSBAR(gtkmedia->priv->statusbar),
 599                         0, error);
 600 }
 601
 602 static void
 603 pidgin_media_accept_cb(PurpleMedia *media, int index)
 604 {
 605         purple_media_stream_info(media, PURPLE_MEDIA_INFO_ACCEPT,
 606                         NULL, NULL, TRUE);
 607 }
 608
 609 static void
 610 pidgin_media_reject_cb(PurpleMedia *media, int index)
 611 {
 612         GList *iter = purple_media_get_session_ids(media);
 613         for (; iter; iter = g_list_delete_link(iter, iter)) {
 614                 const gchar *sessionid = iter->data;
 615                 if (!purple_media_accepted(media, sessionid, NULL))
 616                         purple_media_stream_info(media, PURPLE_MEDIA_INFO_REJECT,
 617                                         sessionid, NULL, TRUE);
 618         }
 619 }
 620
 621 static gboolean
 622 pidgin_request_timeout_cb(PidginMedia *gtkmedia)
 623 {
 624         PurpleAccount *account;
 625         PurpleBuddy *buddy;
 626         const gchar *alias;
 627         PurpleMediaSessionType type;
 628         gchar *message = NULL;
 629
 630         account = purple_media_get_account(gtkmedia->priv->media);
 631         buddy = purple_find_buddy(account, gtkmedia->priv->screenname);
 632         alias = buddy ? purple_buddy_get_contact_alias(buddy) :
 633                         gtkmedia->priv->screenname;
 634         type = gtkmedia->priv->request_type;
 635         gtkmedia->priv->timeout_id = 0;
 636
 637         if (type & PURPLE_MEDIA_AUDIO && type & PURPLE_MEDIA_VIDEO) {
 638                 message = g_strdup_printf(_("%s wishes to start an audio/video session with you."),
 639                                 alias);
 640         } else if (type & PURPLE_MEDIA_AUDIO) {
 641                 message = g_strdup_printf(_("%s wishes to start an audio session with you."),
 642                                 alias);
 643         } else if (type & PURPLE_MEDIA_VIDEO) {
 644                 message = g_strdup_printf(_("%s wishes to start a video session with you."),
 645                                 alias);
 646         }
 647
 648         gtkmedia->priv->request_type = PURPLE_MEDIA_NONE;
 649         if (!purple_media_accepted(gtkmedia->priv->media, NULL, NULL)) {
 650                 purple_request_accept_cancel(gtkmedia, _("Incoming Call"),
 651                                 message, NULL, PURPLE_DEFAULT_ACTION_NONE,
 652                                 (void*)account, gtkmedia->priv->screenname,
 653                                 NULL, gtkmedia->priv->media,
 654                                 pidgin_media_accept_cb,
 655                                 pidgin_media_reject_cb);
 656         }
 657         pidgin_media_emit_message(gtkmedia, message);
 658         g_free(message);
 659         return FALSE;
 660 }
 661
 662 static void
 663 #if GTK_CHECK_VERSION(2,12,0)
 664 pidgin_media_input_volume_changed(GtkScaleButton *range, double value,
 665                 PurpleMedia *media)
 666 {
 667         double val = (double)value * 100.0;
 668 #else
 669 pidgin_media_input_volume_changed(GtkRange *range, PurpleMedia *media)
 670 {
 671         double val = (double)gtk_range_get_value(GTK_RANGE(range));
 672 #endif
 673         purple_media_set_input_volume(media, NULL, val);
 674 }
 675
 676 static void
 677 #if GTK_CHECK_VERSION(2,12,0)
 678 pidgin_media_output_volume_changed(GtkScaleButton *range, double value,
 679                 PurpleMedia *media)
 680 {
 681         double val = (double)value * 100.0;
 682 #else
 683 pidgin_media_output_volume_changed(GtkRange *range, PurpleMedia *media)
 684 {
 685         double val = (double)gtk_range_get_value(GTK_RANGE(range));
 686 #endif
 687         purple_media_set_output_volume(media, NULL, NULL, val);
 688 }
 689
 690 static void
 691 destroy_parent_widget_cb(GtkWidget *widget, GtkWidget *parent)
 692 {
 693         g_return_if_fail(GTK_IS_WIDGET(parent));
 694
 695         gtk_widget_destroy(parent);
 696 }
 697
 698 static GtkWidget *
 699 pidgin_media_add_audio_widget(PidginMedia *gtkmedia,
 700                 PurpleMediaSessionType type, const gchar *sid)
 701 {
 702         GtkWidget *volume_widget, *progress_parent, *volume, *progress;
 703         double value;
 704
 705         if (type & PURPLE_MEDIA_SEND_AUDIO) {
 706                 value = purple_prefs_get_int(
 707                         "/purple/media/audio/volume/input");
 708         } else if (type & PURPLE_MEDIA_RECV_AUDIO) {
 709                 value = purple_prefs_get_int(
 710                         "/purple/media/audio/volume/output");
 711         } else
 712                 g_return_val_if_reached(NULL);
 713
 714 #if GTK_CHECK_VERSION(2,12,0)
 715         /* Setup widget structure */
 716         volume_widget = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
 717         progress_parent = gtk_vbox_new(FALSE, 0);
 718         gtk_box_pack_start(GTK_BOX(volume_widget),
 719                         progress_parent, TRUE, TRUE, 0);
 720
 721         /* Volume button */
 722         volume = gtk_volume_button_new();
 723         gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume), value/100.0);
 724         gtk_box_pack_end(GTK_BOX(volume_widget),
 725                         volume, FALSE, FALSE, 0);
 726 #else
 727         /* Setup widget structure */
 728         volume_widget = gtk_vbox_new(FALSE, 0);
 729         progress_parent = volume_widget;
 730
 731         /* Volume slider */
 732         volume = gtk_hscale_new_with_range(0.0, 100.0, 5.0);
 733         gtk_range_set_increments(GTK_RANGE(volume), 5.0, 25.0);
 734         gtk_range_set_value(GTK_RANGE(volume), value);
 735         gtk_scale_set_draw_value(GTK_SCALE(volume), FALSE);
 736         gtk_box_pack_end(GTK_BOX(volume_widget),
 737                         volume, TRUE, FALSE, 0);
 738 #endif
 739
 740         /* Volume level indicator */
 741         progress = gtk_progress_bar_new();
 742         gtk_widget_set_size_request(progress, 250, 10);
 743         gtk_box_pack_end(GTK_BOX(progress_parent), progress, TRUE, FALSE, 0);
 744
 745         if (type & PURPLE_MEDIA_SEND_AUDIO) {
 746                 g_signal_connect (G_OBJECT(volume), "value-changed",
 747                                 G_CALLBACK(pidgin_media_input_volume_changed),
 748                                 gtkmedia->priv->media);
 749                 gtkmedia->priv->send_progress = progress;
 750         } else if (type & PURPLE_MEDIA_RECV_AUDIO) {
 751                 g_signal_connect (G_OBJECT(volume), "value-changed",
 752                                 G_CALLBACK(pidgin_media_output_volume_changed),
 753                                 gtkmedia->priv->media);
 754
 755                 pidgin_media_insert_widget(gtkmedia, progress, sid, gtkmedia->priv->screenname);
 756         }
 757
 758         g_signal_connect(G_OBJECT(progress), "destroy",
 759                         G_CALLBACK(destroy_parent_widget_cb),
 760                         volume_widget);
 761
 762         gtk_widget_show_all(volume_widget);
 763
 764         return volume_widget;
 765 }
 766
 767 static void
 768 phone_dtmf_pressed_cb(GtkButton *button, gpointer user_data)
 769 {
 770         PidginMedia *gtkmedia = user_data;
 771         gint num;
 772         gchar *sid;
 773
 774         num = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(button), "dtmf-digit"));
 775         sid = g_object_get_data(G_OBJECT(button), "session-id");
 776
 777         purple_media_send_dtmf(gtkmedia->priv->media, sid, num, 25, 50);
 778 }
 779
 780 static inline GtkWidget *
 781 phone_create_button(const gchar *text_hi, const gchar *text_lo)
 782 {
 783         GtkWidget *button;
 784         GtkWidget *label_hi;
 785         GtkWidget *label_lo;
 786         GtkWidget *grid;
 787         const gchar *text_hi_local;
 788
 789         if (text_hi)
 790                 text_hi_local = _(text_hi);
 791         else
 792                 text_hi_local = "";
 793
 794         grid = gtk_vbox_new(TRUE, 0);
 795
 796         button = gtk_button_new();
 797         label_hi = gtk_label_new(text_hi_local);
 798         gtk_misc_set_alignment(GTK_MISC(label_hi), 0.5, 0.5);
 799         gtk_box_pack_end(GTK_BOX(grid), label_hi, FALSE, TRUE, 0);
 800         label_lo = gtk_label_new(text_lo);
 801         gtk_misc_set_alignment(GTK_MISC(label_lo), 0.5, 0.5);
 802         gtk_label_set_use_markup(GTK_LABEL(label_lo), TRUE);
 803         gtk_box_pack_end(GTK_BOX(grid), label_lo, FALSE, TRUE, 0);
 804         gtk_container_add(GTK_CONTAINER(button), grid);
 805
 806         return button;
 807 }
 808
 809 static struct phone_label {
 810         gchar *subtext;
 811         gchar *text;
 812         gchar chr;
 813 } phone_labels[] = {
 814         {"<b>1</b>", NULL, '1'},
 815         /* Translators note: These are the letters on the keys of a numeric
 816            keypad; translate according to the tables in §7 of ETSI ES 202 130:
 817            http://webapp.etsi.org/WorkProgram/Report_WorkItem.asp?WKI_ID=11730
 818          */
 819          /* Letters on the '2' key of a numeric keypad */
 820         {"<b>2</b>", N_("ABC"), '2'},
 821          /* Letters on the '3' key of a numeric keypad */
 822         {"<b>3</b>", N_("DEF"), '3'},
 823          /* Letters on the '4' key of a numeric keypad */
 824         {"<b>4</b>", N_("GHI"), '4'},
 825          /* Letters on the '5' key of a numeric keypad */
 826         {"<b>5</b>", N_("JKL"), '5'},
 827          /* Letters on the '6' key of a numeric keypad */
 828         {"<b>6</b>", N_("MNO"), '6'},
 829          /* Letters on the '7' key of a numeric keypad */
 830         {"<b>7</b>", N_("PQRS"), '7'},
 831          /* Letters on the '8' key of a numeric keypad */
 832         {"<b>8</b>", N_("TUV"), '8'},
 833          /* Letters on the '9' key of a numeric keypad */
 834         {"<b>9</b>", N_("WXYZ"), '9'},
 835         {"<b>*</b>", NULL, '*'},
 836         {"<b>0</b>", NULL, '0'},
 837         {"<b>#</b>", NULL, '#'},
 838         {NULL, NULL, 0}
 839 };
 840
 841 static gboolean
 842 pidgin_media_dtmf_key_press_event_cb(GtkWidget *widget,
 843                 GdkEvent *event, gpointer user_data)
 844 {
 845         PidginMedia *gtkmedia = user_data;
 846         GdkEventKey *key = (GdkEventKey *) event;
 847
 848         if (event->type != GDK_KEY_PRESS) {
 849                 return FALSE;
 850         }
 851
 852         if ((key->keyval >= GDK_KEY_0 && key->keyval <= GDK_KEY_9) ||
 853                 key->keyval == GDK_KEY_asterisk ||
 854                 key->keyval == GDK_KEY_numbersign) {
 855                 gchar *sid = g_object_get_data(G_OBJECT(widget), "session-id");
 856
 857                 purple_media_send_dtmf(gtkmedia->priv->media, sid, key->keyval, 25, 50);
 858         }
 859
 860         return FALSE;
 861 }
 862
 863 static GtkWidget *
 864 pidgin_media_add_dtmf_widget(PidginMedia *gtkmedia,
 865                 PurpleMediaSessionType type, const gchar *_sid)
 866 {
 867         GtkWidget *grid = gtk_table_new(4, 3, TRUE);
 868         GtkWidget *button;
 869         gint index = 0;
 870         GtkWindow *win = &gtkmedia->parent;
 871
 872         /* Add buttons */
 873         for (index = 0; phone_labels[index].subtext != NULL; index++) {
 874                 button = phone_create_button(phone_labels[index].text,
 875                                 phone_labels[index].subtext);
 876                 g_signal_connect(button, "pressed",
 877                                 G_CALLBACK(phone_dtmf_pressed_cb), gtkmedia);
 878                 g_object_set_data(G_OBJECT(button), "dtmf-digit",
 879                                 GINT_TO_POINTER(phone_labels[index].chr));
 880                 g_object_set_data_full(G_OBJECT(button), "session-id",
 881                                 g_strdup(_sid), g_free);
 882                 gtk_table_attach(GTK_TABLE(grid), button, index % 3,
 883                                 index % 3 + 1, index / 3, index / 3 + 1,
 884                                 GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND,
 885                                 2, 2);
 886         }
 887
 888         g_signal_connect(G_OBJECT(win), "key-press-event",
 889                 G_CALLBACK(pidgin_media_dtmf_key_press_event_cb), gtkmedia);
 890         g_object_set_data_full(G_OBJECT(win), "session-id",
 891                 g_strdup(_sid), g_free);
 892
 893         gtk_widget_show_all(grid);
 894
 895         return grid;
 896 }
 897
 898 static void
 899 pidgin_media_ready_cb(PurpleMedia *media, PidginMedia *gtkmedia, const gchar *sid)
 900 {
 901         GtkWidget *send_widget = NULL, *recv_widget = NULL, *button_widget = NULL;
 902         PurpleMediaSessionType type =
 903                         purple_media_get_session_type(media, sid);
 904         GdkPixbuf *icon = NULL;
 905
 906         if (gtkmedia->priv->recv_widget == NULL
 907                         && type & (PURPLE_MEDIA_RECV_VIDEO |
 908                         PURPLE_MEDIA_RECV_AUDIO)) {
 909                 recv_widget = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
 910                 gtk_box_pack_start(GTK_BOX(gtkmedia->priv->display),
 911                                 recv_widget, TRUE, TRUE, 0);
 912                 gtk_widget_show(recv_widget);
 913         } else {
 914                 recv_widget = gtkmedia->priv->recv_widget;
 915         }
 916         if (gtkmedia->priv->send_widget == NULL
 917                         && type & (PURPLE_MEDIA_SEND_VIDEO |
 918                         PURPLE_MEDIA_SEND_AUDIO)) {
 919                 send_widget = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
 920                 gtk_box_pack_start(GTK_BOX(gtkmedia->priv->display),
 921                                 send_widget, FALSE, TRUE, 0);
 922                 button_widget = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
 923                 gtk_box_pack_end(GTK_BOX(recv_widget), button_widget,
 924                                 FALSE, TRUE, 0);
 925                 gtk_widget_show(send_widget);
 926
 927                 /* Hold button */
 928                 gtkmedia->priv->hold =
 929                                 gtk_toggle_button_new_with_mnemonic(_("_Hold"));
 930                 gtk_box_pack_end(GTK_BOX(button_widget), gtkmedia->priv->hold,
 931                                 FALSE, FALSE, 0);
 932                 gtk_widget_show(gtkmedia->priv->hold);
 933                 g_signal_connect(gtkmedia->priv->hold, "toggled",
 934                                 G_CALLBACK(pidgin_media_hold_toggled),
 935                                 gtkmedia);
 936         } else {
 937                 send_widget = gtkmedia->priv->send_widget;
 938                 button_widget = gtkmedia->priv->button_widget;
 939         }
 940
 941         if (type & PURPLE_MEDIA_RECV_VIDEO) {
 942                 PidginMediaRealizeData *data;
 943                 GtkWidget *aspect;
 944                 GtkWidget *remote_video;
 945                 GdkColor color = {0, 0, 0, 0};
 946
 947                 aspect = gtk_aspect_frame_new(NULL, 0, 0, 4.0/3.0, FALSE);
 948                 gtk_frame_set_shadow_type(GTK_FRAME(aspect), GTK_SHADOW_IN);
 949                 gtk_box_pack_start(GTK_BOX(recv_widget), aspect, TRUE, TRUE, 0);
 950
 951                 data = g_new0(PidginMediaRealizeData, 1);
 952                 data->gtkmedia = gtkmedia;
 953                 data->session_id = g_strdup(sid);
 954                 data->participant = g_strdup(gtkmedia->priv->screenname);
 955
 956                 remote_video = gtk_drawing_area_new();
 957                 gtk_widget_modify_bg(remote_video, GTK_STATE_NORMAL, &color);
 958                 g_signal_connect(G_OBJECT(remote_video), "realize",
 959                                 G_CALLBACK(realize_cb), data);
 960                 gtk_container_add(GTK_CONTAINER(aspect), remote_video);
 961                 gtk_widget_set_size_request (GTK_WIDGET(remote_video), 320, 240);
 962                 g_signal_connect(G_OBJECT(remote_video), "destroy",
 963                                 G_CALLBACK(destroy_parent_widget_cb), aspect);
 964
 965                 gtk_widget_show(remote_video);
 966                 gtk_widget_show(aspect);
 967
 968                 pidgin_media_insert_widget(gtkmedia, remote_video,
 969                                 data->session_id, data->participant);
 970         }
 971
 972         if (type & PURPLE_MEDIA_SEND_VIDEO && !gtkmedia->priv->local_video) {
 973                 PidginMediaRealizeData *data;
 974                 GtkWidget *aspect;
 975                 GtkWidget *local_video;
 976                 GdkColor color = {0, 0, 0, 0};
 977
 978                 aspect = gtk_aspect_frame_new(NULL, 0, 0, 4.0/3.0, TRUE);
 979                 gtk_frame_set_shadow_type(GTK_FRAME(aspect), GTK_SHADOW_IN);
 980                 gtk_box_pack_start(GTK_BOX(send_widget), aspect, FALSE, TRUE, 0);
 981
 982                 data = g_new0(PidginMediaRealizeData, 1);
 983                 data->gtkmedia = gtkmedia;
 984                 data->session_id = g_strdup(sid);
 985                 data->participant = NULL;
 986
 987                 local_video = gtk_drawing_area_new();
 988                 gtk_widget_modify_bg(local_video, GTK_STATE_NORMAL, &color);
 989                 g_signal_connect(G_OBJECT(local_video), "realize",
 990                                 G_CALLBACK(realize_cb), data);
 991                 gtk_container_add(GTK_CONTAINER(aspect), local_video);
 992                 gtk_widget_set_size_request (GTK_WIDGET(local_video), 80, 60);
 993                 g_signal_connect(G_OBJECT(local_video), "destroy",
 994                                 G_CALLBACK(destroy_parent_widget_cb), aspect);
 995
 996                 gtk_widget_show(local_video);
 997                 gtk_widget_show(aspect);
 998
 999                 gtkmedia->priv->pause =
1000                                 gtk_toggle_button_new_with_mnemonic(_("_Pause"));
1001                 gtk_box_pack_end(GTK_BOX(button_widget), gtkmedia->priv->pause,
1002                                 FALSE, FALSE, 0);
1003                 gtk_widget_show(gtkmedia->priv->pause);
1004                 g_signal_connect(gtkmedia->priv->pause, "toggled",
1005                                 G_CALLBACK(pidgin_media_pause_toggled),
1006                                 gtkmedia);
1007
1008                 gtkmedia->priv->local_video = local_video;
1009         }
1010         if (type & PURPLE_MEDIA_RECV_AUDIO) {
1011                 gtk_box_pack_end(GTK_BOX(recv_widget),
1012                                 pidgin_media_add_audio_widget(gtkmedia,
1013                                 PURPLE_MEDIA_RECV_AUDIO, sid), FALSE, FALSE, 0);
1014         }
1015
1016         if (type & PURPLE_MEDIA_SEND_AUDIO) {
1017                 gtkmedia->priv->mute =
1018                                 gtk_toggle_button_new_with_mnemonic(_("_Mute"));
1019                 gtk_box_pack_end(GTK_BOX(button_widget), gtkmedia->priv->mute,
1020                                 FALSE, FALSE, 0);
1021                 gtk_widget_show(gtkmedia->priv->mute);
1022                 g_signal_connect(gtkmedia->priv->mute, "toggled",
1023                                 G_CALLBACK(pidgin_media_mute_toggled),
1024                                 gtkmedia);
1025
1026                 gtk_box_pack_end(GTK_BOX(recv_widget),
1027                                 pidgin_media_add_audio_widget(gtkmedia,
1028                                 PURPLE_MEDIA_SEND_AUDIO, sid), FALSE, FALSE, 0);
1029
1030                 gtk_box_pack_end(GTK_BOX(recv_widget),
1031                                 pidgin_media_add_dtmf_widget(gtkmedia,
1032                                 PURPLE_MEDIA_SEND_AUDIO, sid), FALSE, FALSE, 0);
1033         }
1034
1035         if (type & PURPLE_MEDIA_AUDIO &&
1036                         gtkmedia->priv->level_handler_id == 0) {
1037                 gtkmedia->priv->level_handler_id = g_signal_connect(
1038                                 media, "level", G_CALLBACK(level_message_cb),
1039                                 gtkmedia);
1040         }
1041
1042         if (send_widget != NULL)
1043                 gtkmedia->priv->send_widget = send_widget;
1044         if (recv_widget != NULL)
1045                 gtkmedia->priv->recv_widget = recv_widget;
1046         if (button_widget != NULL) {
1047                 gtkmedia->priv->button_widget = button_widget;
1048                 gtk_widget_show(GTK_WIDGET(button_widget));
1049         }
1050
1051         if (purple_media_is_initiator(media, sid, NULL) == FALSE) {
1052                 if (gtkmedia->priv->timeout_id != 0)
1053                         g_source_remove(gtkmedia->priv->timeout_id);
1054                 gtkmedia->priv->request_type |= type;
1055                 gtkmedia->priv->timeout_id = g_timeout_add(500,
1056                                 (GSourceFunc)pidgin_request_timeout_cb,
1057                                 gtkmedia);
1058         }
1059
1060         /* set the window icon according to the type */
1061         if (type & PURPLE_MEDIA_VIDEO) {
1062                 icon = gtk_widget_render_icon(GTK_WIDGET(gtkmedia),
1063                         PIDGIN_STOCK_TOOLBAR_VIDEO_CALL,
1064                         gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_LARGE), NULL);
1065         } else if (type & PURPLE_MEDIA_AUDIO) {
1066                 icon = gtk_widget_render_icon(GTK_WIDGET(gtkmedia),
1067                         PIDGIN_STOCK_TOOLBAR_AUDIO_CALL,
1068                         gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_LARGE), NULL);
1069         }
1070
1071         if (icon) {
1072                 gtk_window_set_icon(GTK_WINDOW(gtkmedia), icon);
1073                 g_object_unref(icon);
1074         }
1075
1076         gtk_widget_show(gtkmedia->priv->display);
1077 }
1078
1079 static void
1080 pidgin_media_state_changed_cb(PurpleMedia *media, PurpleMediaState state,
1081                 gchar *sid, gchar *name, PidginMedia *gtkmedia)
1082 {
1083         purple_debug_info("gtkmedia", "state: %d sid: %s name: %s\n",
1084                         state, sid ? sid : "(null)", name ? name : "(null)");
1085         if (state == PURPLE_MEDIA_STATE_END) {
1086                 if (sid != NULL && name != NULL) {
1087                         pidgin_media_remove_widget(gtkmedia, sid, name);
1088                 } else if (sid == NULL && name == NULL) {
1089                         pidgin_media_emit_message(gtkmedia,
1090                                         _("The call has been terminated."));
1091                         gtk_widget_destroy(GTK_WIDGET(gtkmedia));
1092                 }
1093         } else if (state == PURPLE_MEDIA_STATE_NEW &&
1094                         sid != NULL && name != NULL) {
1095                 pidgin_media_ready_cb(media, gtkmedia, sid);
1096         }
1097 }
1098
1099 static void
1100 pidgin_media_stream_info_cb(PurpleMedia *media, PurpleMediaInfoType type,
1101                 gchar *sid, gchar *name, gboolean local,
1102                 PidginMedia *gtkmedia)
1103 {
1104         if (type == PURPLE_MEDIA_INFO_REJECT) {
1105                 pidgin_media_emit_message(gtkmedia,
1106                                 _("You have rejected the call."));
1107         } else if (type == PURPLE_MEDIA_INFO_ACCEPT) {
1108                 if (local == TRUE)
1109                         purple_request_close_with_handle(gtkmedia);
1110                 pidgin_media_set_state(gtkmedia, PIDGIN_MEDIA_ACCEPTED);
1111                 pidgin_media_emit_message(gtkmedia, _("Call in progress."));
1112                 gtk_statusbar_push(GTK_STATUSBAR(gtkmedia->priv->statusbar),
1113                                 0, _("Call in progress."));
1114                 gtk_widget_show(GTK_WIDGET(gtkmedia));
1115         }
1116 }
1117
1118 static void
1119 pidgin_media_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
1120 {
1121         PidginMedia *media;
1122         g_return_if_fail(PIDGIN_IS_MEDIA(object));
1123
1124         media = PIDGIN_MEDIA(object);
1125         switch (prop_id) {
1126                 case PROP_MEDIA:
1127                 {
1128                         if (media->priv->media)
1129                                 g_object_unref(media->priv->media);
1130                         media->priv->media = g_value_get_object(value);
1131                         g_object_ref(media->priv->media);
1132
1133                         if (purple_media_is_initiator(media->priv->media,
1134                                          NULL, NULL) == TRUE)
1135                                 pidgin_media_set_state(media, PIDGIN_MEDIA_WAITING);
1136                         else
1137                                 pidgin_media_set_state(media, PIDGIN_MEDIA_REQUESTED);
1138
1139                         g_signal_connect(G_OBJECT(media->priv->media), "error",
1140                                 G_CALLBACK(pidgin_media_error_cb), media);
1141                         g_signal_connect(G_OBJECT(media->priv->media), "state-changed",
1142                                 G_CALLBACK(pidgin_media_state_changed_cb), media);
1143                         g_signal_connect(G_OBJECT(media->priv->media), "stream-info",
1144                                 G_CALLBACK(pidgin_media_stream_info_cb), media);
1145                         break;
1146                 }
1147                 case PROP_SCREENNAME:
1148                         if (media->priv->screenname)
1149                                 g_free(media->priv->screenname);
1150                         media->priv->screenname = g_value_dup_string(value);
1151                         break;
1152                 default:
1153                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1154                         break;
1155         }
1156 }
1157
1158 static void
1159 pidgin_media_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
1160 {
1161         PidginMedia *media;
1162         g_return_if_fail(PIDGIN_IS_MEDIA(object));
1163
1164         media = PIDGIN_MEDIA(object);
1165
1166         switch (prop_id) {
1167                 case PROP_MEDIA:
1168                         g_value_set_object(value, media->priv->media);
1169                         break;
1170                 case PROP_SCREENNAME:
1171                         g_value_set_string(value, media->priv->screenname);
1172                         break;
1173                 default:
1174                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1175                         break;
1176         }
1177 }
1178
1179 static GtkWidget *
1180 pidgin_media_new(PurpleMedia *media, const gchar *screenname)
1181 {
1182         PidginMedia *gtkmedia = g_object_new(pidgin_media_get_type(),
1183                                              "media", media,
1184                                              "screenname", screenname, NULL);
1185         return GTK_WIDGET(gtkmedia);
1186 }
1187
1188 static void
1189 pidgin_media_set_state(PidginMedia *gtkmedia, PidginMediaState state)
1190 {
1191         gtkmedia->priv->state = state;
1192 }
1193
1194 static gboolean
1195 pidgin_media_new_cb(PurpleMediaManager *manager, PurpleMedia *media,
1196                 PurpleAccount *account, gchar *screenname, gpointer nul)
1197 {
1198         PidginMedia *gtkmedia = PIDGIN_MEDIA(
1199                         pidgin_media_new(media, screenname));
1200         PurpleBuddy *buddy = purple_find_buddy(account, screenname);
1201         const gchar *alias = buddy ?
1202                         purple_buddy_get_contact_alias(buddy) : screenname;
1203         gtk_window_set_title(GTK_WINDOW(gtkmedia), alias);
1204
1205         if (purple_media_is_initiator(media, NULL, NULL) == TRUE)
1206                 gtk_widget_show(GTK_WIDGET(gtkmedia));
1207
1208         return TRUE;
1209 }
1210
1211 static void
1212 videosink_disable_last_sample(GstElement *sink)
1213 {
1214         GObjectClass *klass = G_OBJECT_GET_CLASS(sink);
1215
1216         if (g_object_class_find_property(klass, "enable-last-sample")) {
1217                 g_object_set(sink, "enable-last-sample", FALSE, NULL);
1218         }
1219 }
1220
1221 static void
1222 autovideosink_child_added_cb (GstChildProxy *child_proxy, GObject *object,
1223 #if GST_CHECK_VERSION(1,0,0)
1224                 gchar *name,
1225 #endif
1226                 gpointer user_data)
1227 {
1228         videosink_disable_last_sample(GST_ELEMENT(object));
1229 }
1230
1231 static GstElement *
1232 create_default_video_src(PurpleMedia *media,
1233                 const gchar *session_id, const gchar *participant)
1234 {
1235         GstElement *sendbin, *src;
1236         GstPad *pad;
1237         GstPad *ghost;
1238
1239 #ifdef _WIN32
1240         /* autovideosrc doesn't pick ksvideosrc for some reason */
1241         src = gst_element_factory_make("ksvideosrc", NULL);
1242         if (src == NULL)
1243                 src = gst_element_factory_make("dshowvideosrc", NULL);
1244         if (src == NULL)
1245                 src = gst_element_factory_make("autovideosrc", NULL);
1246 #else
1247         src = gst_element_factory_make("gconfvideosrc", NULL);
1248         if (src == NULL)
1249                 src = gst_element_factory_make("autovideosrc", NULL);
1250         if (src == NULL)
1251                 src = gst_element_factory_make("v4l2src", NULL);
1252         if (src == NULL)
1253                 src = gst_element_factory_make("v4lsrc", NULL);
1254 #endif
1255         if (src == NULL) {
1256                 purple_debug_error("gtkmedia", "Unable to find a suitable "
1257                                 "element for the default video source.\n");
1258                 return NULL;
1259         }
1260
1261         sendbin = gst_bin_new("pidgindefaultvideosrc");
1262
1263         gst_bin_add(GST_BIN(sendbin), src);
1264
1265         pad = gst_element_get_static_pad(src, "src");
1266         ghost = gst_ghost_pad_new("ghostsrc", pad);
1267         gst_object_unref(pad);
1268         gst_element_add_pad(sendbin, ghost);
1269
1270         return sendbin;
1271 }
1272
1273 static GstElement *
1274 create_default_video_sink(PurpleMedia *media,
1275                 const gchar *session_id, const gchar *participant)
1276 {
1277         GstElement *sink = gst_element_factory_make("gconfvideosink", NULL);
1278         if (sink == NULL)
1279                 sink = gst_element_factory_make("autovideosink", NULL);
1280         if (sink == NULL)
1281                 purple_debug_error("gtkmedia", "Unable to find a suitable "
1282                                 "element for the default video sink.\n");
1283         if (sink != NULL)
1284                 g_signal_connect(sink, "child-added",
1285                                 G_CALLBACK(autovideosink_child_added_cb), NULL);
1286         return sink;
1287 }
1288
1289 static GstElement *
1290 create_default_audio_src(PurpleMedia *media,
1291                 const gchar *session_id, const gchar *participant)
1292 {
1293         GstElement *src;
1294         src = gst_element_factory_make("gconfaudiosrc", NULL);
1295         if (src == NULL)
1296                 src = gst_element_factory_make("autoaudiosrc", NULL);
1297         if (src == NULL)
1298                 src = gst_element_factory_make("alsasrc", NULL);
1299         if (src == NULL)
1300                 src = gst_element_factory_make("osssrc", NULL);
1301         if (src == NULL)
1302                 src = gst_element_factory_make("dshowaudiosrc", NULL);
1303         if (src == NULL) {
1304                 purple_debug_error("gtkmedia", "Unable to find a suitable "
1305                                 "element for the default audio source.\n");
1306                 return NULL;
1307         }
1308         gst_element_set_name(src, "pidgindefaultaudiosrc");
1309         return src;
1310 }
1311
1312 static GstElement *
1313 create_default_audio_sink(PurpleMedia *media,
1314                 const gchar *session_id, const gchar *participant)
1315 {
1316         GstElement *sink;
1317         sink = gst_element_factory_make("gconfaudiosink", NULL);
1318         if (sink == NULL)
1319                 sink = gst_element_factory_make("autoaudiosink",NULL);
1320         if (sink == NULL) {
1321                 purple_debug_error("gtkmedia", "Unable to find a suitable "
1322                                 "element for the default audio sink.\n");
1323                 return NULL;
1324         }
1325         return sink;
1326 }
1327 #endif  /* USE_VV */
1328
1329 void
1330 pidgin_medias_init(void)
1331 {
1332 #ifdef USE_VV
1333         PurpleMediaManager *manager = purple_media_manager_get();
1334         PurpleMediaElementInfo *default_video_src =
1335                         g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
1336                         "id", "pidgindefaultvideosrc",
1337                         "name", "Pidgin Default Video Source",
1338                         "type", PURPLE_MEDIA_ELEMENT_VIDEO
1339                                         | PURPLE_MEDIA_ELEMENT_SRC
1340                                         | PURPLE_MEDIA_ELEMENT_ONE_SRC
1341                                         | PURPLE_MEDIA_ELEMENT_UNIQUE,
1342                         "create-cb", create_default_video_src, NULL);
1343         PurpleMediaElementInfo *default_video_sink =
1344                         g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
1345                         "id", "pidgindefaultvideosink",
1346                         "name", "Pidgin Default Video Sink",
1347                         "type", PURPLE_MEDIA_ELEMENT_VIDEO
1348                                         | PURPLE_MEDIA_ELEMENT_SINK
1349                                         | PURPLE_MEDIA_ELEMENT_ONE_SINK,
1350                         "create-cb", create_default_video_sink, NULL);
1351         PurpleMediaElementInfo *default_audio_src =
1352                         g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
1353                         "id", "pidgindefaultaudiosrc",
1354                         "name", "Pidgin Default Audio Source",
1355                         "type", PURPLE_MEDIA_ELEMENT_AUDIO
1356                                         | PURPLE_MEDIA_ELEMENT_SRC
1357                                         | PURPLE_MEDIA_ELEMENT_ONE_SRC
1358                                         | PURPLE_MEDIA_ELEMENT_UNIQUE,
1359                         "create-cb", create_default_audio_src, NULL);
1360         PurpleMediaElementInfo *default_audio_sink =
1361                         g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
1362                         "id", "pidgindefaultaudiosink",
1363                         "name", "Pidgin Default Audio Sink",
1364                         "type", PURPLE_MEDIA_ELEMENT_AUDIO
1365                                         | PURPLE_MEDIA_ELEMENT_SINK
1366                                         | PURPLE_MEDIA_ELEMENT_ONE_SINK,
1367                         "create-cb", create_default_audio_sink, NULL);
1368
1369         g_signal_connect(G_OBJECT(manager), "init-media",
1370                          G_CALLBACK(pidgin_media_new_cb), NULL);
1371
1372         purple_media_manager_set_ui_caps(manager,
1373                         PURPLE_MEDIA_CAPS_AUDIO |
1374                         PURPLE_MEDIA_CAPS_AUDIO_SINGLE_DIRECTION |
1375                         PURPLE_MEDIA_CAPS_VIDEO |
1376                         PURPLE_MEDIA_CAPS_VIDEO_SINGLE_DIRECTION |
1377                         PURPLE_MEDIA_CAPS_AUDIO_VIDEO);
1378
1379         purple_debug_info("gtkmedia", "Registering media element types\n");
1380         purple_media_manager_set_active_element(manager, default_video_src);
1381         purple_media_manager_set_active_element(manager, default_video_sink);
1382         purple_media_manager_set_active_element(manager, default_audio_src);
1383         purple_media_manager_set_active_element(manager, default_audio_sink);
1384 #endif
1385 }
1386