src/empathy-streamed-media-window.c

   1 /*
   2  * empathy-streamed-media-window.c - Source for EmpathyStreamedMediaWindow
   3  * Copyright (C) 2008-2009 Collabora Ltd.
   4  * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25
  26 #include <math.h>
  27
  28 #include <gdk/gdkkeysyms.h>
  29 #include <gst/gst.h>
  30 #include <gtk/gtk.h>
  31 #include <glib/gi18n.h>
  32
  33 #include <telepathy-glib/util.h>
  34 #include <telepathy-farsight/channel.h>
  35 #include <telepathy-glib/util.h>
  36
  37 #include <gst/farsight/fs-element-added-notifier.h>
  38 #include <gst/farsight/fs-utils.h>
  39
  40 #include <libempathy/empathy-tp-contact-factory.h>
  41 #include <libempathy/empathy-utils.h>
  42 #include <libempathy-gtk/empathy-avatar-image.h>
  43 #include <libempathy-gtk/empathy-dialpad-widget.h>
  44 #include <libempathy-gtk/empathy-ui-utils.h>
  45 #include <libempathy-gtk/empathy-sound-manager.h>
  46 #include <libempathy-gtk/empathy-geometry.h>
  47 #include <libempathy-gtk/empathy-images.h>
  48
  49 #define DEBUG_FLAG EMPATHY_DEBUG_VOIP
  50 #include <libempathy/empathy-debug.h>
  51
  52 #include "empathy-streamed-media-window.h"
  53 #include "empathy-streamed-media-window-fullscreen.h"
  54 #include "empathy-video-widget.h"
  55 #include "empathy-audio-src.h"
  56 #include "empathy-audio-sink.h"
  57 #include "empathy-video-src.h"
  58 #include "ev-sidebar.h"
  59
  60 #define CONTENT_HBOX_BORDER_WIDTH 6
  61 #define CONTENT_HBOX_SPACING 3
  62 #define CONTENT_HBOX_CHILDREN_PACKING_PADDING 3
  63
  64 #define SELF_VIDEO_SECTION_WIDTH 160
  65 #define SELF_VIDEO_SECTION_HEIGTH 120
  66
  67 /* The avatar's default width and height are set to the same value because we
  68    want a square icon. */
  69 #define REMOTE_CONTACT_AVATAR_DEFAULT_WIDTH EMPATHY_VIDEO_WIDGET_DEFAULT_HEIGHT
  70 #define REMOTE_CONTACT_AVATAR_DEFAULT_HEIGHT \
  71   EMPATHY_VIDEO_WIDGET_DEFAULT_HEIGHT
  72
  73 /* If an video input error occurs, the error message will start with "v4l" */
  74 #define VIDEO_INPUT_ERROR_PREFIX "v4l"
  75
  76 /* The time interval in milliseconds between 2 outgoing rings */
  77 #define MS_BETWEEN_RING 500
  78
  79 G_DEFINE_TYPE(EmpathyStreamedMediaWindow, empathy_streamed_media_window, GTK_TYPE_WINDOW)
  80
  81 /* signal enum */
  82 #if 0
  83 enum
  84 {
  85     LAST_SIGNAL
  86 };
  87
  88 static guint signals[LAST_SIGNAL] = {0};
  89 #endif
  90
  91 enum {
  92   PROP_STREAMED_MEDIA_HANDLER = 1,
  93 };
  94
  95 typedef enum {
  96   CONNECTING,
  97   CONNECTED,
  98   DISCONNECTED,
  99   REDIALING
 100 } CallState;
 101
 102 typedef enum {
 103   CAMERA_STATE_OFF = 0,
 104   CAMERA_STATE_PREVIEW,
 105   CAMERA_STATE_ON,
 106 } CameraState;
 107
 108 /* private structure */
 109 typedef struct _EmpathyStreamedMediaWindowPriv EmpathyStreamedMediaWindowPriv;
 110
 111 struct _EmpathyStreamedMediaWindowPriv
 112 {
 113   gboolean dispose_has_run;
 114   EmpathyStreamedMediaHandler *handler;
 115   EmpathyContact *contact;
 116
 117   guint call_state;
 118   gboolean outgoing;
 119
 120   GtkUIManager *ui_manager;
 121   GtkWidget *errors_vbox;
 122   /* widget displays the video received from the remote user. This widget is
 123    * alive only during call. */
 124   GtkWidget *video_output;
 125   GtkWidget *video_preview;
 126   GtkWidget *remote_user_avatar_widget;
 127   GtkWidget *self_user_avatar_widget;
 128   GtkWidget *sidebar;
 129   GtkWidget *sidebar_button;
 130   GtkWidget *statusbar;
 131   GtkWidget *volume_button;
 132   GtkWidget *redial_button;
 133   GtkWidget *mic_button;
 134   GtkWidget *toolbar;
 135   GtkWidget *pane;
 136   GtkAction *redial;
 137   GtkAction *menu_fullscreen;
 138   GtkAction *action_camera_on;
 139   GtkWidget *tool_button_camera_off;
 140   GtkWidget *tool_button_camera_preview;
 141   GtkWidget *tool_button_camera_on;
 142
 143   /* The frames and boxes that contain self and remote avatar and video
 144      input/output. When we redial, we destroy and re-create the boxes */
 145   GtkWidget *remote_user_output_frame;
 146   GtkWidget *self_user_output_frame;
 147   GtkWidget *remote_user_output_hbox;
 148   GtkWidget *self_user_output_hbox;
 149
 150   /* We keep a reference on the hbox which contains the main content so we can
 151      easilly repack everything when toggling fullscreen */
 152   GtkWidget *content_hbox;
 153
 154   /* This vbox is contained in the content_hbox and it contains the
 155      self_user_output_frame and the sidebar button. When toggling fullscreen,
 156      it needs to be repacked. We keep a reference on it for easier access. */
 157   GtkWidget *vbox;
 158
 159   gulong video_output_motion_handler_id;
 160   guint bus_message_source_id;
 161
 162   gdouble volume;
 163   GtkWidget *volume_scale;
 164   GtkWidget *volume_progress_bar;
 165   GtkAdjustment *audio_input_adj;
 166
 167   GtkWidget *dtmf_panel;
 168
 169   /* Details vbox */
 170   GtkWidget *details_vbox;
 171   GtkWidget *vcodec_encoding_label;
 172   GtkWidget *acodec_encoding_label;
 173   GtkWidget *vcodec_decoding_label;
 174   GtkWidget *acodec_decoding_label;
 175
 176   GtkWidget *audio_remote_candidate_label;
 177   GtkWidget *audio_local_candidate_label;
 178   GtkWidget *video_remote_candidate_label;
 179   GtkWidget *video_local_candidate_label;
 180   GtkWidget *video_remote_candidate_info_img;
 181   GtkWidget *video_local_candidate_info_img;
 182   GtkWidget *audio_remote_candidate_info_img;
 183   GtkWidget *audio_local_candidate_info_img;
 184
 185   GstElement *video_input;
 186   GstElement *audio_input;
 187   GstElement *audio_output;
 188   GstElement *pipeline;
 189   GstElement *video_tee;
 190
 191   GstElement *funnel;
 192
 193   FsElementAddedNotifier *fsnotifier;
 194
 195   guint context_id;
 196
 197   GTimer *timer;
 198   guint timer_id;
 199
 200   GtkWidget *video_contrast;
 201   GtkWidget *video_brightness;
 202   GtkWidget *video_gamma;
 203
 204   GMutex *lock;
 205   gboolean call_started;
 206   gboolean sending_video;
 207   CameraState camera_state;
 208
 209   EmpathyStreamedMediaWindowFullscreen *fullscreen;
 210   gboolean is_fullscreen;
 211
 212   /* Those fields represent the state of the window before it actually was in
 213      fullscreen mode. */
 214   gboolean sidebar_was_visible_before_fs;
 215   gint original_width_before_fs;
 216   gint original_height_before_fs;
 217
 218   /* TRUE if the call should be started when the pipeline is playing */
 219   gboolean start_call_when_playing;
 220   /* TRUE if we requested to set the pipeline in the playing state */
 221   gboolean pipeline_playing;
 222
 223   EmpathySoundManager *sound_mgr;
 224 };
 225
 226 #define GET_PRIV(o) \
 227   (G_TYPE_INSTANCE_GET_PRIVATE ((o), EMPATHY_TYPE_STREAMED_MEDIA_WINDOW, \
 228     EmpathyStreamedMediaWindowPriv))
 229
 230 static void empathy_streamed_media_window_realized_cb (GtkWidget *widget,
 231   EmpathyStreamedMediaWindow *window);
 232
 233 static gboolean empathy_streamed_media_window_delete_cb (GtkWidget *widget,
 234   GdkEvent *event, EmpathyStreamedMediaWindow *window);
 235
 236 static gboolean empathy_streamed_media_window_state_event_cb (GtkWidget *widget,
 237   GdkEventWindowState *event, EmpathyStreamedMediaWindow *window);
 238
 239 static void empathy_streamed_media_window_sidebar_toggled_cb (GtkToggleButton *toggle,
 240   EmpathyStreamedMediaWindow *window);
 241
 242 static void empathy_streamed_media_window_set_send_video (EmpathyStreamedMediaWindow *window,
 243   CameraState state);
 244
 245 static void empathy_streamed_media_window_mic_toggled_cb (
 246   GtkToggleToolButton *toggle, EmpathyStreamedMediaWindow *window);
 247
 248 static void empathy_streamed_media_window_sidebar_hidden_cb (EvSidebar *sidebar,
 249   EmpathyStreamedMediaWindow *window);
 250
 251 static void empathy_streamed_media_window_sidebar_shown_cb (EvSidebar *sidebar,
 252   EmpathyStreamedMediaWindow *window);
 253
 254 static void empathy_streamed_media_window_hangup_cb (gpointer object,
 255   EmpathyStreamedMediaWindow *window);
 256
 257 static void empathy_streamed_media_window_fullscreen_cb (gpointer object,
 258   EmpathyStreamedMediaWindow *window);
 259
 260 static void empathy_streamed_media_window_fullscreen_toggle (EmpathyStreamedMediaWindow *window);
 261
 262 static gboolean empathy_streamed_media_window_video_button_press_cb (
 263   GtkWidget *video_output, GdkEventButton *event, EmpathyStreamedMediaWindow *window);
 264
 265 static gboolean empathy_streamed_media_window_key_press_cb (GtkWidget *video_output,
 266   GdkEventKey *event, EmpathyStreamedMediaWindow *window);
 267
 268 static gboolean empathy_streamed_media_window_video_output_motion_notify (
 269   GtkWidget *widget, GdkEventMotion *event, EmpathyStreamedMediaWindow *window);
 270
 271 static void empathy_streamed_media_window_video_menu_popup (EmpathyStreamedMediaWindow *window,
 272   guint button);
 273
 274 static void empathy_streamed_media_window_redial_cb (gpointer object,
 275   EmpathyStreamedMediaWindow *window);
 276
 277 static void empathy_streamed_media_window_restart_call (EmpathyStreamedMediaWindow *window);
 278
 279 static void empathy_streamed_media_window_status_message (EmpathyStreamedMediaWindow *window,
 280   gchar *message);
 281
 282 static void empathy_streamed_media_window_update_avatars_visibility (EmpathyTpStreamedMedia *call,
 283   EmpathyStreamedMediaWindow *window);
 284
 285 static gboolean empathy_streamed_media_window_bus_message (GstBus *bus,
 286   GstMessage *message, gpointer user_data);
 287
 288 static void
 289 empathy_streamed_media_window_volume_changed_cb (GtkScaleButton *button,
 290   gdouble value, EmpathyStreamedMediaWindow *window);
 291
 292 static void block_camera_control_signals (EmpathyStreamedMediaWindow *self);
 293 static void unblock_camera_control_signals (EmpathyStreamedMediaWindow *self);
 294
 295 static void
 296 empathy_streamed_media_window_setup_toolbar (EmpathyStreamedMediaWindow *self)
 297 {
 298   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 299   GtkToolItem *tool_item;
 300   GtkWidget *camera_off_icon;
 301   GdkPixbuf *pixbuf, *modded_pixbuf;
 302
 303   /* set the icon of the 'camera off' button by greying off the webcam icon */
 304   pixbuf = empathy_pixbuf_from_icon_name ("camera-web",
 305       GTK_ICON_SIZE_SMALL_TOOLBAR);
 306
 307   modded_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
 308       gdk_pixbuf_get_width (pixbuf),
 309       gdk_pixbuf_get_height (pixbuf));
 310
 311   gdk_pixbuf_saturate_and_pixelate (pixbuf, modded_pixbuf, 1.0, TRUE);
 312   g_object_unref (pixbuf);
 313
 314   camera_off_icon = gtk_image_new_from_pixbuf (modded_pixbuf);
 315   g_object_unref (modded_pixbuf);
 316   gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (
 317         priv->tool_button_camera_off), camera_off_icon);
 318
 319   /* Add an empty expanded GtkToolItem so the volume button is at the end of
 320    * the toolbar. */
 321   tool_item = gtk_tool_item_new ();
 322   gtk_tool_item_set_expand (tool_item, TRUE);
 323   gtk_widget_show (GTK_WIDGET (tool_item));
 324   gtk_toolbar_insert (GTK_TOOLBAR (priv->toolbar), tool_item, -1);
 325
 326   priv->volume_button = gtk_volume_button_new ();
 327   /* FIXME listen to the audiosinks signals and update the button according to
 328    * that, for now starting out at 1.0 and assuming only the app changes the
 329    * volume will do */
 330   gtk_scale_button_set_value (GTK_SCALE_BUTTON (priv->volume_button), 1.0);
 331   g_signal_connect (G_OBJECT (priv->volume_button), "value-changed",
 332     G_CALLBACK (empathy_streamed_media_window_volume_changed_cb), self);
 333
 334   tool_item = gtk_tool_item_new ();
 335   gtk_container_add (GTK_CONTAINER (tool_item), priv->volume_button);
 336   gtk_widget_show_all (GTK_WIDGET (tool_item));
 337   gtk_toolbar_insert (GTK_TOOLBAR (priv->toolbar), tool_item, -1);
 338 }
 339
 340 static void
 341 dtmf_start_tone_cb (EmpathyDialpadWidget *dialpad,
 342     TpDTMFEvent event,
 343     EmpathyStreamedMediaWindow *window)
 344 {
 345   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
 346   EmpathyTpStreamedMedia *call;
 347
 348   g_object_get (priv->handler, "tp-call", &call, NULL);
 349
 350   empathy_tp_streamed_media_start_tone (call, event);
 351
 352   g_object_unref (call);
 353 }
 354
 355 static void
 356 dtmf_stop_tone_cb (EmpathyDialpadWidget *self,
 357     TpDTMFEvent event,
 358     EmpathyStreamedMediaWindow *window)
 359 {
 360   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
 361   EmpathyTpStreamedMedia *call;
 362
 363   g_object_get (priv->handler, "tp-call", &call, NULL);
 364
 365   empathy_tp_streamed_media_stop_tone (call);
 366
 367   g_object_unref (call);
 368 }
 369
 370 static GtkWidget *
 371 empathy_streamed_media_window_create_video_input_add_slider (EmpathyStreamedMediaWindow *self,
 372   gchar *label_text, GtkWidget *bin)
 373 {
 374    GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
 375    GtkWidget *scale = gtk_vscale_new_with_range (0, 100, 10);
 376    GtkWidget *label = gtk_label_new (label_text);
 377
 378    gtk_widget_set_sensitive (scale, FALSE);
 379
 380    gtk_container_add (GTK_CONTAINER (bin), vbox);
 381
 382    gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
 383    gtk_box_pack_start (GTK_BOX (vbox), scale, TRUE, TRUE, 0);
 384    gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 385
 386    return scale;
 387 }
 388
 389 static void
 390 empathy_streamed_media_window_video_contrast_changed_cb (GtkAdjustment *adj,
 391   EmpathyStreamedMediaWindow *self)
 392
 393 {
 394   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 395
 396   empathy_video_src_set_channel (priv->video_input,
 397     EMPATHY_GST_VIDEO_SRC_CHANNEL_CONTRAST, gtk_adjustment_get_value (adj));
 398 }
 399
 400 static void
 401 empathy_streamed_media_window_video_brightness_changed_cb (GtkAdjustment *adj,
 402   EmpathyStreamedMediaWindow *self)
 403
 404 {
 405   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 406
 407   empathy_video_src_set_channel (priv->video_input,
 408     EMPATHY_GST_VIDEO_SRC_CHANNEL_BRIGHTNESS, gtk_adjustment_get_value (adj));
 409 }
 410
 411 static void
 412 empathy_streamed_media_window_video_gamma_changed_cb (GtkAdjustment *adj,
 413   EmpathyStreamedMediaWindow *self)
 414
 415 {
 416   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 417
 418   empathy_video_src_set_channel (priv->video_input,
 419     EMPATHY_GST_VIDEO_SRC_CHANNEL_GAMMA, gtk_adjustment_get_value (adj));
 420 }
 421
 422
 423 static GtkWidget *
 424 empathy_streamed_media_window_create_video_input (EmpathyStreamedMediaWindow *self)
 425 {
 426   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 427   GtkWidget *hbox;
 428
 429   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
 430   gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
 431
 432   priv->video_contrast = empathy_streamed_media_window_create_video_input_add_slider (
 433     self,  _("Contrast"), hbox);
 434
 435   priv->video_brightness = empathy_streamed_media_window_create_video_input_add_slider (
 436     self,  _("Brightness"), hbox);
 437
 438   priv->video_gamma = empathy_streamed_media_window_create_video_input_add_slider (
 439     self,  _("Gamma"), hbox);
 440
 441   return hbox;
 442 }
 443
 444 static void
 445 empathy_streamed_media_window_setup_video_input (EmpathyStreamedMediaWindow *self)
 446 {
 447   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 448   guint supported;
 449   GtkAdjustment *adj;
 450
 451   supported = empathy_video_src_get_supported_channels (priv->video_input);
 452
 453   if (supported & EMPATHY_GST_VIDEO_SRC_SUPPORTS_CONTRAST)
 454     {
 455       adj = gtk_range_get_adjustment (GTK_RANGE (priv->video_contrast));
 456
 457       gtk_adjustment_set_value (adj,
 458         empathy_video_src_get_channel (priv->video_input,
 459           EMPATHY_GST_VIDEO_SRC_CHANNEL_CONTRAST));
 460
 461       g_signal_connect (G_OBJECT (adj), "value-changed",
 462         G_CALLBACK (empathy_streamed_media_window_video_contrast_changed_cb), self);
 463
 464       gtk_widget_set_sensitive (priv->video_contrast, TRUE);
 465     }
 466
 467   if (supported & EMPATHY_GST_VIDEO_SRC_SUPPORTS_BRIGHTNESS)
 468     {
 469       adj = gtk_range_get_adjustment (GTK_RANGE (priv->video_brightness));
 470
 471       gtk_adjustment_set_value (adj,
 472         empathy_video_src_get_channel (priv->video_input,
 473           EMPATHY_GST_VIDEO_SRC_CHANNEL_BRIGHTNESS));
 474
 475       g_signal_connect (G_OBJECT (adj), "value-changed",
 476         G_CALLBACK (empathy_streamed_media_window_video_brightness_changed_cb), self);
 477       gtk_widget_set_sensitive (priv->video_brightness, TRUE);
 478     }
 479
 480   if (supported & EMPATHY_GST_VIDEO_SRC_SUPPORTS_GAMMA)
 481     {
 482       adj = gtk_range_get_adjustment (GTK_RANGE (priv->video_gamma));
 483
 484       gtk_adjustment_set_value (adj,
 485         empathy_video_src_get_channel (priv->video_input,
 486           EMPATHY_GST_VIDEO_SRC_CHANNEL_GAMMA));
 487
 488       g_signal_connect (G_OBJECT (adj), "value-changed",
 489         G_CALLBACK (empathy_streamed_media_window_video_gamma_changed_cb), self);
 490       gtk_widget_set_sensitive (priv->video_gamma, TRUE);
 491     }
 492 }
 493
 494 static void
 495 empathy_streamed_media_window_mic_volume_changed_cb (GtkAdjustment *adj,
 496   EmpathyStreamedMediaWindow *self)
 497 {
 498   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 499   gdouble volume;
 500
 501   volume = gtk_adjustment_get_value (adj)/100.0;
 502
 503   /* Don't store the volume because of muting */
 504   if (volume > 0 || gtk_toggle_tool_button_get_active (
 505         GTK_TOGGLE_TOOL_BUTTON (priv->mic_button)))
 506     priv->volume = volume;
 507
 508   /* Ensure that the toggle button is active if the volume is > 0 and inactive
 509    * if it's smaller than 0 */
 510   if ((volume > 0) != gtk_toggle_tool_button_get_active (
 511         GTK_TOGGLE_TOOL_BUTTON (priv->mic_button)))
 512     gtk_toggle_tool_button_set_active (
 513       GTK_TOGGLE_TOOL_BUTTON (priv->mic_button), volume > 0);
 514
 515   empathy_audio_src_set_volume (EMPATHY_GST_AUDIO_SRC (priv->audio_input),
 516     volume);
 517 }
 518
 519 static void
 520 empathy_streamed_media_window_audio_input_level_changed_cb (EmpathyGstAudioSrc *src,
 521   gdouble level, EmpathyStreamedMediaWindow *window)
 522 {
 523   gdouble value;
 524   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
 525
 526   value = CLAMP (pow (10, level / 20), 0.0, 1.0);
 527   gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (priv->volume_progress_bar),
 528       value);
 529 }
 530
 531 static GtkWidget *
 532 empathy_streamed_media_window_create_audio_input (EmpathyStreamedMediaWindow *self)
 533 {
 534   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 535   GtkWidget *hbox, *vbox, *label;
 536
 537   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
 538   gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
 539
 540   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
 541   gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 3);
 542
 543   priv->volume_scale = gtk_vscale_new_with_range (0, 150, 100);
 544   gtk_range_set_inverted (GTK_RANGE (priv->volume_scale), TRUE);
 545   label = gtk_label_new (_("Volume"));
 546
 547   priv->audio_input_adj = gtk_range_get_adjustment (
 548     GTK_RANGE (priv->volume_scale));
 549   priv->volume =  empathy_audio_src_get_volume (EMPATHY_GST_AUDIO_SRC
 550     (priv->audio_input));
 551   gtk_adjustment_set_value (priv->audio_input_adj, priv->volume * 100);
 552
 553   g_signal_connect (G_OBJECT (priv->audio_input_adj), "value-changed",
 554     G_CALLBACK (empathy_streamed_media_window_mic_volume_changed_cb), self);
 555
 556   gtk_box_pack_start (GTK_BOX (vbox), priv->volume_scale, TRUE, TRUE, 3);
 557   gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 3);
 558
 559   priv->volume_progress_bar = gtk_progress_bar_new ();
 560
 561   gtk_orientable_set_orientation (GTK_ORIENTABLE (priv->volume_progress_bar),
 562       GTK_ORIENTATION_VERTICAL);
 563
 564   gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (priv->volume_progress_bar),
 565       0);
 566
 567   gtk_box_pack_start (GTK_BOX (hbox), priv->volume_progress_bar, FALSE, FALSE,
 568       3);
 569
 570   return hbox;
 571 }
 572
 573 static void
 574 create_video_output_widget (EmpathyStreamedMediaWindow *self)
 575 {
 576   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 577   GstBus *bus;
 578
 579   g_assert (priv->video_output == NULL);
 580   g_assert (priv->pipeline != NULL);
 581
 582   bus = gst_pipeline_get_bus (GST_PIPELINE (priv->pipeline));
 583   priv->video_output = empathy_video_widget_new (bus);
 584
 585   gtk_box_pack_start (GTK_BOX (priv->remote_user_output_hbox),
 586       priv->video_output, TRUE, TRUE, 0);
 587
 588   gtk_widget_add_events (priv->video_output,
 589       GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
 590   g_signal_connect (G_OBJECT (priv->video_output), "button-press-event",
 591       G_CALLBACK (empathy_streamed_media_window_video_button_press_cb), self);
 592
 593   g_object_unref (bus);
 594 }
 595
 596 static void
 597 create_video_input (EmpathyStreamedMediaWindow *self)
 598 {
 599   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 600
 601   g_assert (priv->video_input == NULL);
 602   priv->video_input = empathy_video_src_new ();
 603   gst_object_ref (priv->video_input);
 604   gst_object_sink (priv->video_input);
 605 }
 606
 607 static void
 608 create_audio_input (EmpathyStreamedMediaWindow *self)
 609 {
 610   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 611
 612   g_assert (priv->audio_input == NULL);
 613   priv->audio_input = empathy_audio_src_new ();
 614   gst_object_ref (priv->audio_input);
 615   gst_object_sink (priv->audio_input);
 616
 617   tp_g_signal_connect_object (priv->audio_input, "peak-level-changed",
 618     G_CALLBACK (empathy_streamed_media_window_audio_input_level_changed_cb),
 619     self, 0);
 620 }
 621
 622 static void
 623 add_video_preview_to_pipeline (EmpathyStreamedMediaWindow *self)
 624 {
 625   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 626   GstElement *preview;
 627
 628   g_assert (priv->video_preview != NULL);
 629   g_assert (priv->pipeline != NULL);
 630   g_assert (priv->video_input != NULL);
 631   g_assert (priv->video_tee != NULL);
 632
 633   preview = empathy_video_widget_get_element (
 634       EMPATHY_VIDEO_WIDGET (priv->video_preview));
 635
 636   if (!gst_bin_add (GST_BIN (priv->pipeline), priv->video_input))
 637     {
 638       g_warning ("Could not add video input to pipeline");
 639       return;
 640     }
 641
 642   if (!gst_bin_add (GST_BIN (priv->pipeline), priv->video_tee))
 643     {
 644       g_warning ("Could not add video tee to pipeline");
 645       return;
 646     }
 647
 648   if (!gst_bin_add (GST_BIN (priv->pipeline), preview))
 649     {
 650       g_warning ("Could not add video preview to pipeline");
 651       return;
 652     }
 653
 654   if (!gst_element_link (priv->video_input, priv->video_tee))
 655     {
 656       g_warning ("Could not link video input to video tee");
 657       return;
 658     }
 659
 660   if (!gst_element_link (priv->video_tee, preview))
 661     {
 662       g_warning ("Could not link video tee to video preview");
 663       return;
 664     }
 665 }
 666
 667 static void
 668 create_video_preview (EmpathyStreamedMediaWindow *self)
 669 {
 670   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 671   GstBus *bus;
 672
 673   g_assert (priv->video_preview == NULL);
 674   g_assert (priv->video_tee == NULL);
 675
 676   bus = gst_pipeline_get_bus (GST_PIPELINE (priv->pipeline));
 677
 678   priv->video_preview = empathy_video_widget_new_with_size (bus,
 679       SELF_VIDEO_SECTION_WIDTH, SELF_VIDEO_SECTION_HEIGTH);
 680   g_object_set (priv->video_preview,
 681       "sync", FALSE,
 682       "async", TRUE,
 683       "flip-video", TRUE,
 684       NULL);
 685
 686   gtk_box_pack_start (GTK_BOX (priv->self_user_output_hbox),
 687       priv->video_preview, TRUE, TRUE, 0);
 688
 689   priv->video_tee = gst_element_factory_make ("tee", NULL);
 690   gst_object_ref (priv->video_tee);
 691   gst_object_sink (priv->video_tee);
 692
 693   g_object_unref (bus);
 694 }
 695
 696 static void
 697 play_camera (EmpathyStreamedMediaWindow *window,
 698     gboolean play)
 699 {
 700   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
 701   GstElement *preview;
 702   GstState state;
 703
 704   if (priv->video_preview == NULL)
 705     {
 706       create_video_preview (window);
 707       add_video_preview_to_pipeline (window);
 708     }
 709
 710   if (play)
 711     state = GST_STATE_PLAYING;
 712   else
 713     state = GST_STATE_NULL;
 714
 715   preview = empathy_video_widget_get_element (
 716       EMPATHY_VIDEO_WIDGET (priv->video_preview));
 717
 718   gst_element_set_state (preview, state);
 719   gst_element_set_state (priv->video_input, state);
 720   gst_element_set_state (priv->video_tee, state);
 721 }
 722
 723 static void
 724 display_video_preview (EmpathyStreamedMediaWindow *self,
 725     gboolean display)
 726 {
 727   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 728
 729   if (display)
 730     {
 731       /* Display the preview and hide the self avatar */
 732       DEBUG ("Show video preview");
 733
 734       play_camera (self, TRUE);
 735       gtk_widget_show (priv->video_preview);
 736       gtk_widget_hide (priv->self_user_avatar_widget);
 737     }
 738   else
 739     {
 740       /* Display the self avatar and hide the preview */
 741       DEBUG ("Show self avatar");
 742
 743       if (priv->video_preview != NULL)
 744         {
 745           gtk_widget_hide (priv->video_preview);
 746           play_camera (self, FALSE);
 747         }
 748       gtk_widget_show (priv->self_user_avatar_widget);
 749     }
 750 }
 751
 752 static void
 753 empathy_streamed_media_window_set_state_connecting (EmpathyStreamedMediaWindow *window)
 754 {
 755   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
 756
 757   empathy_streamed_media_window_status_message (window, _("Connecting…"));
 758   priv->call_state = CONNECTING;
 759
 760   if (priv->outgoing)
 761     empathy_sound_manager_start_playing (priv->sound_mgr, GTK_WIDGET (window),
 762         EMPATHY_SOUND_PHONE_OUTGOING, MS_BETWEEN_RING);
 763 }
 764
 765 static void
 766 disable_camera (EmpathyStreamedMediaWindow *self)
 767 {
 768   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 769
 770   if (priv->camera_state == CAMERA_STATE_OFF)
 771     return;
 772
 773   DEBUG ("Disable camera");
 774
 775   display_video_preview (self, FALSE);
 776
 777   if (priv->camera_state == CAMERA_STATE_ON)
 778     empathy_streamed_media_window_set_send_video (self, CAMERA_STATE_OFF);
 779
 780   block_camera_control_signals (self);
 781   gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (
 782         priv->tool_button_camera_on), FALSE);
 783   gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (
 784       priv->tool_button_camera_preview), FALSE);
 785
 786   gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (
 787       priv->tool_button_camera_off), TRUE);
 788   gtk_radio_action_set_current_value (GTK_RADIO_ACTION (priv->action_camera_on),
 789       CAMERA_STATE_OFF);
 790   unblock_camera_control_signals (self);
 791
 792   priv->camera_state = CAMERA_STATE_OFF;
 793 }
 794
 795 static void
 796 tool_button_camera_off_toggled_cb (GtkToggleToolButton *toggle,
 797   EmpathyStreamedMediaWindow *self)
 798 {
 799   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 800
 801   if (!gtk_toggle_tool_button_get_active (toggle))
 802     {
 803       if (priv->camera_state == CAMERA_STATE_OFF)
 804         {
 805           /* We can't change the state by disabling the button */
 806           block_camera_control_signals (self);
 807           gtk_toggle_tool_button_set_active (toggle, TRUE);
 808           unblock_camera_control_signals (self);
 809         }
 810
 811       return;
 812     }
 813
 814   disable_camera (self);
 815 }
 816
 817 static void
 818 enable_preview (EmpathyStreamedMediaWindow *self)
 819 {
 820   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 821
 822   if (priv->camera_state == CAMERA_STATE_PREVIEW)
 823     return;
 824
 825   DEBUG ("Enable preview");
 826
 827   if (priv->camera_state == CAMERA_STATE_ON)
 828     {
 829       /* preview is already displayed so we just have to stop sending */
 830       empathy_streamed_media_window_set_send_video (self, CAMERA_STATE_PREVIEW);
 831     }
 832   else
 833     {
 834       display_video_preview (self, TRUE);
 835     }
 836
 837   block_camera_control_signals (self);
 838   gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (
 839       priv->tool_button_camera_off), FALSE);
 840   gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (
 841         priv->tool_button_camera_on), FALSE);
 842
 843   gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (
 844         priv->tool_button_camera_preview), TRUE);
 845   gtk_radio_action_set_current_value (GTK_RADIO_ACTION (priv->action_camera_on),
 846       CAMERA_STATE_PREVIEW);
 847   unblock_camera_control_signals (self);
 848
 849   priv->camera_state = CAMERA_STATE_PREVIEW;
 850 }
 851
 852 static void
 853 tool_button_camera_preview_toggled_cb (GtkToggleToolButton *toggle,
 854   EmpathyStreamedMediaWindow *self)
 855 {
 856   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 857
 858   if (!gtk_toggle_tool_button_get_active (toggle))
 859     {
 860       if (priv->camera_state == CAMERA_STATE_PREVIEW)
 861         {
 862           /* We can't change the state by disabling the button */
 863           block_camera_control_signals (self);
 864           gtk_toggle_tool_button_set_active (toggle, TRUE);
 865           unblock_camera_control_signals (self);
 866         }
 867
 868       return;
 869     }
 870
 871   enable_preview (self);
 872 }
 873
 874 static void
 875 enable_camera (EmpathyStreamedMediaWindow *self)
 876 {
 877   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 878
 879   if (priv->camera_state == CAMERA_STATE_ON)
 880     return;
 881
 882   if (priv->video_input == NULL)
 883     {
 884       DEBUG ("Can't enable camera, no input");
 885       return;
 886     }
 887
 888
 889   DEBUG ("Enable camera");
 890
 891   empathy_streamed_media_window_set_send_video (self, CAMERA_STATE_ON);
 892
 893   block_camera_control_signals (self);
 894   gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (
 895       priv->tool_button_camera_off), FALSE);
 896   gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (
 897         priv->tool_button_camera_preview), FALSE);
 898
 899   gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (
 900       priv->tool_button_camera_on), TRUE);
 901   gtk_radio_action_set_current_value (GTK_RADIO_ACTION (priv->action_camera_on),
 902       CAMERA_STATE_ON);
 903   unblock_camera_control_signals (self);
 904
 905   priv->camera_state = CAMERA_STATE_ON;
 906 }
 907
 908 static void
 909 tool_button_camera_on_toggled_cb (GtkToggleToolButton *toggle,
 910   EmpathyStreamedMediaWindow *self)
 911 {
 912   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 913
 914   if (!gtk_toggle_tool_button_get_active (toggle))
 915     {
 916       if (priv->camera_state == CAMERA_STATE_ON)
 917         {
 918           /* We can't change the state by disabling the button */
 919           block_camera_control_signals (self);
 920           gtk_toggle_tool_button_set_active (toggle, TRUE);
 921           unblock_camera_control_signals (self);
 922         }
 923
 924       return;
 925     }
 926
 927   enable_camera (self);
 928 }
 929
 930 static void
 931 action_camera_change_cb (GtkRadioAction *action,
 932     GtkRadioAction *current,
 933     EmpathyStreamedMediaWindow *self)
 934 {
 935   CameraState state;
 936
 937   state = gtk_radio_action_get_current_value (current);
 938
 939   switch (state)
 940     {
 941       case CAMERA_STATE_OFF:
 942         disable_camera (self);
 943         break;
 944
 945       case CAMERA_STATE_PREVIEW:
 946         enable_preview (self);
 947         break;
 948
 949       case CAMERA_STATE_ON:
 950         enable_camera (self);
 951         break;
 952
 953       default:
 954         g_assert_not_reached ();
 955     }
 956 }
 957
 958 static void
 959 create_pipeline (EmpathyStreamedMediaWindow *self)
 960 {
 961   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 962   GstBus *bus;
 963
 964   g_assert (priv->pipeline == NULL);
 965
 966   priv->pipeline = gst_pipeline_new (NULL);
 967   priv->pipeline_playing = FALSE;
 968
 969   bus = gst_pipeline_get_bus (GST_PIPELINE (priv->pipeline));
 970   priv->bus_message_source_id = gst_bus_add_watch (bus,
 971       empathy_streamed_media_window_bus_message, self);
 972
 973   g_object_unref (bus);
 974 }
 975
 976
 977 static void
 978 empathy_streamed_media_window_init (EmpathyStreamedMediaWindow *self)
 979 {
 980   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
 981   GtkBuilder *gui;
 982   GtkWidget *top_vbox;
 983   GtkWidget *h;
 984   GtkWidget *arrow;
 985   GtkWidget *page;
 986   gchar *filename;
 987   GtkWidget *scroll;
 988
 989   filename = empathy_file_lookup ("empathy-streamed-media-window.ui", "src");
 990   gui = empathy_builder_get_file (filename,
 991     "call_window_vbox", &top_vbox,
 992     "errors_vbox", &priv->errors_vbox,
 993     "pane", &priv->pane,
 994     "statusbar", &priv->statusbar,
 995     "redial", &priv->redial_button,
 996     "microphone", &priv->mic_button,
 997     "toolbar", &priv->toolbar,
 998     "menuredial", &priv->redial,
 999     "ui_manager", &priv->ui_manager,
1000     "menufullscreen", &priv->menu_fullscreen,
1001     "camera_off", &priv->tool_button_camera_off,
1002     "camera_preview", &priv->tool_button_camera_preview,
1003     "camera_on", &priv->tool_button_camera_on,
1004     "action_camera_on",  &priv->action_camera_on,
1005     "details_vbox",  &priv->details_vbox,
1006     "vcodec_encoding_label", &priv->vcodec_encoding_label,
1007     "acodec_encoding_label", &priv->acodec_encoding_label,
1008     "acodec_decoding_label", &priv->acodec_decoding_label,
1009     "vcodec_decoding_label", &priv->vcodec_decoding_label,
1010     "audio_remote_candidate_label", &priv->audio_remote_candidate_label,
1011     "audio_local_candidate_label", &priv->audio_local_candidate_label,
1012     "video_remote_candidate_label", &priv->video_remote_candidate_label,
1013     "video_local_candidate_label", &priv->video_local_candidate_label,
1014     "video_remote_candidate_info_img", &priv->video_remote_candidate_info_img,
1015     "video_local_candidate_info_img", &priv->video_local_candidate_info_img,
1016     "audio_remote_candidate_info_img", &priv->audio_remote_candidate_info_img,
1017     "audio_local_candidate_info_img", &priv->audio_local_candidate_info_img,
1018     NULL);
1019   g_free (filename);
1020
1021   empathy_builder_connect (gui, self,
1022     "menuhangup", "activate", empathy_streamed_media_window_hangup_cb,
1023     "hangup", "clicked", empathy_streamed_media_window_hangup_cb,
1024     "menuredial", "activate", empathy_streamed_media_window_redial_cb,
1025     "redial", "clicked", empathy_streamed_media_window_redial_cb,
1026     "microphone", "toggled", empathy_streamed_media_window_mic_toggled_cb,
1027     "menufullscreen", "activate", empathy_streamed_media_window_fullscreen_cb,
1028     "camera_off", "toggled", tool_button_camera_off_toggled_cb,
1029     "camera_preview", "toggled", tool_button_camera_preview_toggled_cb,
1030     "camera_on", "toggled", tool_button_camera_on_toggled_cb,
1031     "action_camera_on", "changed", action_camera_change_cb,
1032     NULL);
1033
1034   gtk_action_set_sensitive (priv->menu_fullscreen, FALSE);
1035
1036   priv->lock = g_mutex_new ();
1037
1038   gtk_container_add (GTK_CONTAINER (self), top_vbox);
1039
1040   priv->content_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL,
1041       CONTENT_HBOX_SPACING);
1042   gtk_container_set_border_width (GTK_CONTAINER (priv->content_hbox),
1043                                   CONTENT_HBOX_BORDER_WIDTH);
1044   gtk_paned_pack1 (GTK_PANED (priv->pane), priv->content_hbox, TRUE, FALSE);
1045
1046   /* remote user output frame */
1047   priv->remote_user_output_frame = gtk_frame_new (NULL);
1048   gtk_widget_set_size_request (priv->remote_user_output_frame,
1049       EMPATHY_VIDEO_WIDGET_DEFAULT_WIDTH, EMPATHY_VIDEO_WIDGET_DEFAULT_HEIGHT);
1050   gtk_box_pack_start (GTK_BOX (priv->content_hbox),
1051       priv->remote_user_output_frame, TRUE, TRUE,
1052       CONTENT_HBOX_CHILDREN_PACKING_PADDING);
1053
1054   priv->remote_user_output_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1055
1056   priv->remote_user_avatar_widget = gtk_image_new ();
1057
1058   gtk_box_pack_start (GTK_BOX (priv->remote_user_output_hbox),
1059       priv->remote_user_avatar_widget, TRUE, TRUE, 0);
1060
1061   gtk_container_add (GTK_CONTAINER (priv->remote_user_output_frame),
1062       priv->remote_user_output_hbox);
1063
1064   /* self user output frame */
1065   priv->self_user_output_frame = gtk_frame_new (NULL);
1066   gtk_widget_set_size_request (priv->self_user_output_frame,
1067       SELF_VIDEO_SECTION_WIDTH, SELF_VIDEO_SECTION_HEIGTH);
1068
1069   priv->self_user_output_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1070
1071   priv->self_user_avatar_widget = gtk_image_new ();
1072   gtk_box_pack_start (GTK_BOX (priv->self_user_output_hbox),
1073       priv->self_user_avatar_widget, TRUE, TRUE, 0);
1074
1075   gtk_container_add (GTK_CONTAINER (priv->self_user_output_frame),
1076       priv->self_user_output_hbox);
1077
1078   create_pipeline (self);
1079   create_video_output_widget (self);
1080   create_audio_input (self);
1081   create_video_input (self);
1082
1083   priv->fsnotifier = fs_element_added_notifier_new ();
1084   fs_element_added_notifier_add (priv->fsnotifier, GST_BIN (priv->pipeline));
1085
1086   /* The call will be started as soon the pipeline is playing */
1087   priv->start_call_when_playing = TRUE;
1088
1089   priv->vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
1090   gtk_box_pack_start (GTK_BOX (priv->content_hbox), priv->vbox,
1091       FALSE, FALSE, CONTENT_HBOX_CHILDREN_PACKING_PADDING);
1092   gtk_box_pack_start (GTK_BOX (priv->vbox), priv->self_user_output_frame,
1093       FALSE, FALSE, 0);
1094
1095   empathy_streamed_media_window_setup_toolbar (self);
1096
1097   priv->sidebar_button = gtk_toggle_button_new_with_mnemonic (_("_Sidebar"));
1098   arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
1099   g_signal_connect (G_OBJECT (priv->sidebar_button), "toggled",
1100     G_CALLBACK (empathy_streamed_media_window_sidebar_toggled_cb), self);
1101
1102   gtk_button_set_image (GTK_BUTTON (priv->sidebar_button), arrow);
1103
1104   h = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
1105   gtk_box_pack_end (GTK_BOX (priv->vbox), h, FALSE, FALSE, 3);
1106   gtk_box_pack_end (GTK_BOX (h), priv->sidebar_button, FALSE, FALSE, 3);
1107
1108   priv->sidebar = ev_sidebar_new ();
1109   g_signal_connect (G_OBJECT (priv->sidebar),
1110     "hide", G_CALLBACK (empathy_streamed_media_window_sidebar_hidden_cb), self);
1111   g_signal_connect (G_OBJECT (priv->sidebar),
1112     "show", G_CALLBACK (empathy_streamed_media_window_sidebar_shown_cb), self);
1113   gtk_paned_pack2 (GTK_PANED (priv->pane), priv->sidebar, FALSE, FALSE);
1114
1115   page = empathy_streamed_media_window_create_audio_input (self);
1116   ev_sidebar_add_page (EV_SIDEBAR (priv->sidebar), "audio-input",
1117       _("Audio input"), page);
1118
1119   page = empathy_streamed_media_window_create_video_input (self);
1120   ev_sidebar_add_page (EV_SIDEBAR (priv->sidebar), "video-input",
1121       _("Video input"), page);
1122
1123   priv->dtmf_panel = empathy_dialpad_widget_new ();
1124   g_signal_connect (priv->dtmf_panel, "start-tone",
1125       G_CALLBACK (dtmf_start_tone_cb), self);
1126   g_signal_connect (priv->dtmf_panel, "stop-tone",
1127       G_CALLBACK (dtmf_stop_tone_cb), self);
1128   ev_sidebar_add_page (EV_SIDEBAR (priv->sidebar), "dialpad",
1129       _("Dialpad"), priv->dtmf_panel);
1130
1131   gtk_widget_set_sensitive (priv->dtmf_panel, FALSE);
1132
1133   /* Put the details vbox in a scroll window as it can require a lot of
1134    * horizontal space. */
1135   scroll = gtk_scrolled_window_new (NULL, NULL);
1136   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scroll),
1137       priv->details_vbox);
1138
1139   ev_sidebar_add_page (EV_SIDEBAR (priv->sidebar), "details",
1140       _("Details"), scroll);
1141
1142   gtk_widget_show_all (top_vbox);
1143
1144   gtk_widget_hide (priv->sidebar);
1145
1146   priv->fullscreen = empathy_streamed_media_window_fullscreen_new (self);
1147   empathy_streamed_media_window_fullscreen_set_video_widget (priv->fullscreen,
1148       priv->video_output);
1149   g_signal_connect (G_OBJECT (priv->fullscreen->leave_fullscreen_button),
1150       "clicked", G_CALLBACK (empathy_streamed_media_window_fullscreen_cb), self);
1151
1152   g_signal_connect (G_OBJECT (self), "realize",
1153     G_CALLBACK (empathy_streamed_media_window_realized_cb), self);
1154
1155   g_signal_connect (G_OBJECT (self), "delete-event",
1156     G_CALLBACK (empathy_streamed_media_window_delete_cb), self);
1157
1158   g_signal_connect (G_OBJECT (self), "window-state-event",
1159     G_CALLBACK (empathy_streamed_media_window_state_event_cb), self);
1160
1161   g_signal_connect (G_OBJECT (self), "key-press-event",
1162       G_CALLBACK (empathy_streamed_media_window_key_press_cb), self);
1163
1164   priv->timer = g_timer_new ();
1165
1166   g_object_ref (priv->ui_manager);
1167   g_object_unref (gui);
1168
1169   priv->sound_mgr = empathy_sound_manager_dup_singleton ();
1170
1171   empathy_geometry_bind (GTK_WINDOW (self), "av-window");
1172 }
1173
1174 /* Instead of specifying a width and a height, we specify only one size. That's
1175    because we want a square avatar icon.  */
1176 static void
1177 init_contact_avatar_with_size (EmpathyContact *contact,
1178     GtkWidget *image_widget,
1179     gint size)
1180 {
1181   GdkPixbuf *pixbuf_avatar = NULL;
1182
1183   if (contact != NULL)
1184     {
1185       pixbuf_avatar = empathy_pixbuf_avatar_from_contact_scaled (contact,
1186         size, size);
1187     }
1188
1189   if (pixbuf_avatar == NULL)
1190     {
1191       pixbuf_avatar = empathy_pixbuf_from_icon_name_sized (
1192           EMPATHY_IMAGE_AVATAR_DEFAULT, size);
1193     }
1194
1195   gtk_image_set_from_pixbuf (GTK_IMAGE (image_widget), pixbuf_avatar);
1196
1197   if (pixbuf_avatar != NULL)
1198     g_object_unref (pixbuf_avatar);
1199 }
1200
1201 static void
1202 set_window_title (EmpathyStreamedMediaWindow *self)
1203 {
1204   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1205   gchar *tmp;
1206
1207   /* translators: Call is a noun and %s is the contact name. This string
1208    * is used in the window title */
1209   tmp = g_strdup_printf (_("Call with %s"),
1210       empathy_contact_get_alias (priv->contact));
1211   gtk_window_set_title (GTK_WINDOW (self), tmp);
1212   g_free (tmp);
1213 }
1214
1215 static void
1216 contact_name_changed_cb (EmpathyContact *contact,
1217     GParamSpec *pspec, EmpathyStreamedMediaWindow *self)
1218 {
1219   set_window_title (self);
1220 }
1221
1222 static void
1223 contact_avatar_changed_cb (EmpathyContact *contact,
1224     GParamSpec *pspec, GtkWidget *avatar_widget)
1225 {
1226   int size;
1227   GtkAllocation allocation;
1228
1229   gtk_widget_get_allocation (avatar_widget, &allocation);
1230   size = allocation.height;
1231
1232   if (size == 0)
1233     {
1234       /* the widget is not allocated yet, set a default size */
1235       size = MIN (REMOTE_CONTACT_AVATAR_DEFAULT_HEIGHT,
1236           REMOTE_CONTACT_AVATAR_DEFAULT_WIDTH);
1237     }
1238
1239   init_contact_avatar_with_size (contact, avatar_widget, size);
1240 }
1241
1242 static void
1243 empathy_streamed_media_window_got_self_contact_cb (TpConnection *connection,
1244     EmpathyContact *contact, const GError *error, gpointer user_data,
1245     GObject *weak_object)
1246 {
1247   EmpathyStreamedMediaWindow *self = EMPATHY_STREAMED_MEDIA_WINDOW (user_data);
1248   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1249
1250   init_contact_avatar_with_size (contact, priv->self_user_avatar_widget,
1251       MIN (SELF_VIDEO_SECTION_WIDTH, SELF_VIDEO_SECTION_HEIGTH));
1252
1253   g_signal_connect (contact, "notify::avatar",
1254       G_CALLBACK (contact_avatar_changed_cb), priv->self_user_avatar_widget);
1255 }
1256
1257 static void
1258 empathy_streamed_media_window_setup_avatars (EmpathyStreamedMediaWindow *self,
1259     EmpathyStreamedMediaHandler *handler)
1260 {
1261   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1262
1263   g_object_get (handler, "contact", &(priv->contact), NULL);
1264
1265   if (priv->contact != NULL)
1266     {
1267       TpConnection *connection;
1268
1269       set_window_title (self);
1270
1271       g_signal_connect (priv->contact, "notify::name",
1272           G_CALLBACK (contact_name_changed_cb), self);
1273       g_signal_connect (priv->contact, "notify::avatar",
1274           G_CALLBACK (contact_avatar_changed_cb),
1275           priv->remote_user_avatar_widget);
1276
1277       /* Retreiving the self avatar */
1278       connection = empathy_contact_get_connection (priv->contact);
1279       empathy_tp_contact_factory_get_from_handle (connection,
1280           tp_connection_get_self_handle (connection),
1281           empathy_streamed_media_window_got_self_contact_cb, self, NULL, G_OBJECT (self));
1282     }
1283   else
1284     {
1285       g_warning ("call handler doesn't have a contact");
1286       /* translators: Call is a noun. This string is used in the window
1287        * title */
1288       gtk_window_set_title (GTK_WINDOW (self), _("Call"));
1289
1290       /* Since we can't access the remote contact, we can't get a connection
1291          to it and can't get the self contact (and its avatar). This means
1292          that we have to manually set the self avatar. */
1293       init_contact_avatar_with_size (NULL, priv->self_user_avatar_widget,
1294           MIN (SELF_VIDEO_SECTION_WIDTH, SELF_VIDEO_SECTION_HEIGTH));
1295     }
1296
1297   init_contact_avatar_with_size (priv->contact,
1298       priv->remote_user_avatar_widget,
1299       MIN (REMOTE_CONTACT_AVATAR_DEFAULT_WIDTH,
1300           REMOTE_CONTACT_AVATAR_DEFAULT_HEIGHT));
1301
1302   /* The remote avatar is shown by default and will be hidden when we receive
1303      video from the remote side. */
1304   gtk_widget_hide (priv->video_output);
1305   gtk_widget_show (priv->remote_user_avatar_widget);
1306 }
1307
1308 static void
1309 update_send_codec (EmpathyStreamedMediaWindow *self,
1310     gboolean audio)
1311 {
1312   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1313   FsCodec *codec;
1314   GtkWidget *widget;
1315   gchar *tmp;
1316
1317   if (audio)
1318     {
1319       codec = empathy_streamed_media_handler_get_send_audio_codec (priv->handler);
1320       widget = priv->acodec_encoding_label;
1321     }
1322   else
1323     {
1324       codec = empathy_streamed_media_handler_get_send_video_codec (priv->handler);
1325       widget = priv->vcodec_encoding_label;
1326     }
1327
1328   if (codec == NULL)
1329     return;
1330
1331   tmp = g_strdup_printf ("%s/%u", codec->encoding_name, codec->clock_rate);
1332   gtk_label_set_text (GTK_LABEL (widget), tmp);
1333   g_free (tmp);
1334 }
1335
1336 static void
1337 send_audio_codec_notify_cb (GObject *object,
1338     GParamSpec *pspec,
1339     gpointer user_data)
1340 {
1341   EmpathyStreamedMediaWindow *self = user_data;
1342
1343   update_send_codec (self, TRUE);
1344 }
1345
1346 static void
1347 send_video_codec_notify_cb (GObject *object,
1348     GParamSpec *pspec,
1349     gpointer user_data)
1350 {
1351   EmpathyStreamedMediaWindow *self = user_data;
1352
1353   update_send_codec (self, FALSE);
1354 }
1355
1356 static void
1357 update_recv_codec (EmpathyStreamedMediaWindow *self,
1358     gboolean audio)
1359 {
1360   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1361   GList *codecs, *l;
1362   GtkWidget *widget;
1363   GString *str = NULL;
1364
1365   if (audio)
1366     {
1367       codecs = empathy_streamed_media_handler_get_recv_audio_codecs (priv->handler);
1368       widget = priv->acodec_decoding_label;
1369     }
1370   else
1371     {
1372       codecs = empathy_streamed_media_handler_get_recv_video_codecs (priv->handler);
1373       widget = priv->vcodec_decoding_label;
1374     }
1375
1376   if (codecs == NULL)
1377     return;
1378
1379   for (l = codecs; l != NULL; l = g_list_next (l))
1380     {
1381       FsCodec *codec = l->data;
1382
1383       if (str == NULL)
1384         str = g_string_new (NULL);
1385       else
1386         g_string_append (str, ", ");
1387
1388       g_string_append_printf (str, "%s/%u", codec->encoding_name,
1389           codec->clock_rate);
1390     }
1391
1392   gtk_label_set_text (GTK_LABEL (widget), str->str);
1393   g_string_free (str, TRUE);
1394 }
1395
1396 static void
1397 recv_audio_codecs_notify_cb (GObject *object,
1398     GParamSpec *pspec,
1399     gpointer user_data)
1400 {
1401   EmpathyStreamedMediaWindow *self = user_data;
1402
1403   update_recv_codec (self, TRUE);
1404 }
1405
1406 static void
1407 recv_video_codecs_notify_cb (GObject *object,
1408     GParamSpec *pspec,
1409     gpointer user_data)
1410 {
1411   EmpathyStreamedMediaWindow *self = user_data;
1412
1413   update_recv_codec (self, FALSE);
1414 }
1415
1416 static const gchar *
1417 candidate_type_to_str (FsCandidate *candidate)
1418 {
1419   switch (candidate->type)
1420     {
1421       case FS_CANDIDATE_TYPE_HOST:
1422         return "host";
1423       case FS_CANDIDATE_TYPE_SRFLX:
1424         return "server reflexive";
1425       case FS_CANDIDATE_TYPE_PRFLX:
1426         return "peer reflexive";
1427       case FS_CANDIDATE_TYPE_RELAY:
1428         return "relay";
1429       case FS_CANDIDATE_TYPE_MULTICAST:
1430         return "multicast";
1431     }
1432
1433   return NULL;
1434 }
1435
1436 static const gchar *
1437 candidate_type_to_desc (FsCandidate *candidate)
1438 {
1439   switch (candidate->type)
1440     {
1441       case FS_CANDIDATE_TYPE_HOST:
1442         return _("The IP address as seen by the machine");
1443       case FS_CANDIDATE_TYPE_SRFLX:
1444         return _("The IP address as seen by a server on the Internet");
1445       case FS_CANDIDATE_TYPE_PRFLX:
1446         return _("The IP address of the peer as seen by the other side");
1447       case FS_CANDIDATE_TYPE_RELAY:
1448         return _("The IP address of a relay server");
1449       case FS_CANDIDATE_TYPE_MULTICAST:
1450         return _("The IP address of the multicast group");
1451     }
1452
1453   return NULL;
1454 }
1455
1456 static void
1457 update_candidat_widget (EmpathyStreamedMediaWindow *self,
1458     GtkWidget *label,
1459     GtkWidget *img,
1460     FsCandidate *candidate)
1461 {
1462   gchar *str;
1463
1464   g_assert (candidate != NULL);
1465   str = g_strdup_printf ("%s %u (%s)", candidate->ip,
1466       candidate->port, candidate_type_to_str (candidate));
1467
1468   gtk_label_set_text (GTK_LABEL (label), str);
1469   gtk_widget_set_tooltip_text (img, candidate_type_to_desc (candidate));
1470
1471   g_free (str);
1472 }
1473
1474 static void
1475 candidates_changed_cb (GObject *object,
1476     FsMediaType type,
1477     EmpathyStreamedMediaWindow *self)
1478 {
1479   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1480   FsCandidate *candidate = NULL;
1481
1482   if (type == FS_MEDIA_TYPE_VIDEO)
1483     {
1484       /* Update remote candidate */
1485       candidate = empathy_streamed_media_handler_get_video_remote_candidate (
1486           priv->handler);
1487
1488       update_candidat_widget (self, priv->video_remote_candidate_label,
1489           priv->video_remote_candidate_info_img, candidate);
1490
1491       /* Update local candidate */
1492       candidate = empathy_streamed_media_handler_get_video_local_candidate (
1493           priv->handler);
1494
1495       update_candidat_widget (self, priv->video_local_candidate_label,
1496           priv->video_local_candidate_info_img, candidate);
1497     }
1498   else
1499     {
1500       /* Update remote candidate */
1501       candidate = empathy_streamed_media_handler_get_audio_remote_candidate (
1502           priv->handler);
1503
1504       update_candidat_widget (self, priv->audio_remote_candidate_label,
1505           priv->audio_remote_candidate_info_img, candidate);
1506
1507       /* Update local candidate */
1508       candidate = empathy_streamed_media_handler_get_audio_local_candidate (
1509           priv->handler);
1510
1511       update_candidat_widget (self, priv->audio_local_candidate_label,
1512           priv->audio_local_candidate_info_img, candidate);
1513     }
1514 }
1515
1516 static void
1517 empathy_streamed_media_window_constructed (GObject *object)
1518 {
1519   EmpathyStreamedMediaWindow *self = EMPATHY_STREAMED_MEDIA_WINDOW (object);
1520   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1521   EmpathyTpStreamedMedia *call;
1522
1523   g_assert (priv->handler != NULL);
1524
1525   g_object_get (priv->handler, "tp-call", &call, NULL);
1526   priv->outgoing = (call == NULL);
1527   if (call != NULL)
1528     g_object_unref (call);
1529
1530   empathy_streamed_media_window_setup_avatars (self, priv->handler);
1531   empathy_streamed_media_window_set_state_connecting (self);
1532
1533   if (!empathy_streamed_media_handler_has_initial_video (priv->handler))
1534     {
1535       gtk_toggle_tool_button_set_active (
1536           GTK_TOGGLE_TOOL_BUTTON (priv->tool_button_camera_off), TRUE);
1537     }
1538   /* If call has InitialVideo, the preview will be started once the call has
1539    * been started (start_call()). */
1540
1541   update_send_codec (self, TRUE);
1542   update_send_codec (self, FALSE);
1543   update_recv_codec (self, TRUE);
1544   update_recv_codec (self, FALSE);
1545
1546   tp_g_signal_connect_object (priv->handler, "notify::send-audio-codec",
1547       G_CALLBACK (send_audio_codec_notify_cb), self, 0);
1548   tp_g_signal_connect_object (priv->handler, "notify::send-video-codec",
1549       G_CALLBACK (send_video_codec_notify_cb), self, 0);
1550   tp_g_signal_connect_object (priv->handler, "notify::recv-audio-codecs",
1551       G_CALLBACK (recv_audio_codecs_notify_cb), self, 0);
1552   tp_g_signal_connect_object (priv->handler, "notify::recv-video-codecs",
1553       G_CALLBACK (recv_video_codecs_notify_cb), self, 0);
1554
1555   tp_g_signal_connect_object (priv->handler, "candidates-changed",
1556       G_CALLBACK (candidates_changed_cb), self, 0);
1557 }
1558
1559 static void empathy_streamed_media_window_dispose (GObject *object);
1560 static void empathy_streamed_media_window_finalize (GObject *object);
1561
1562 static void
1563 empathy_streamed_media_window_set_property (GObject *object,
1564   guint property_id, const GValue *value, GParamSpec *pspec)
1565 {
1566   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (object);
1567
1568   switch (property_id)
1569     {
1570       case PROP_STREAMED_MEDIA_HANDLER:
1571         priv->handler = g_value_dup_object (value);
1572         break;
1573       default:
1574         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1575     }
1576 }
1577
1578 static void
1579 empathy_streamed_media_window_get_property (GObject *object,
1580   guint property_id, GValue *value, GParamSpec *pspec)
1581 {
1582   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (object);
1583
1584   switch (property_id)
1585     {
1586       case PROP_STREAMED_MEDIA_HANDLER:
1587         g_value_set_object (value, priv->handler);
1588         break;
1589       default:
1590         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1591     }
1592 }
1593
1594 static void
1595 empathy_streamed_media_window_class_init (
1596   EmpathyStreamedMediaWindowClass *empathy_streamed_media_window_class)
1597 {
1598   GObjectClass *object_class = G_OBJECT_CLASS (empathy_streamed_media_window_class);
1599   GParamSpec *param_spec;
1600
1601   g_type_class_add_private (empathy_streamed_media_window_class,
1602     sizeof (EmpathyStreamedMediaWindowPriv));
1603
1604   object_class->constructed = empathy_streamed_media_window_constructed;
1605   object_class->set_property = empathy_streamed_media_window_set_property;
1606   object_class->get_property = empathy_streamed_media_window_get_property;
1607
1608   object_class->dispose = empathy_streamed_media_window_dispose;
1609   object_class->finalize = empathy_streamed_media_window_finalize;
1610
1611   param_spec = g_param_spec_object ("handler",
1612     "handler", "The call handler",
1613     EMPATHY_TYPE_STREAMED_MEDIA_HANDLER,
1614     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
1615   g_object_class_install_property (object_class,
1616     PROP_STREAMED_MEDIA_HANDLER, param_spec);
1617 }
1618
1619 static void
1620 empathy_streamed_media_window_video_stream_changed_cb (EmpathyTpStreamedMedia *call,
1621     GParamSpec *property, EmpathyStreamedMediaWindow *self)
1622 {
1623   DEBUG ("video stream changed");
1624   empathy_streamed_media_window_update_avatars_visibility (call, self);
1625 }
1626
1627 void
1628 empathy_streamed_media_window_dispose (GObject *object)
1629 {
1630   EmpathyTpStreamedMedia *call;
1631   EmpathyStreamedMediaWindow *self = EMPATHY_STREAMED_MEDIA_WINDOW (object);
1632   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1633
1634   if (priv->dispose_has_run)
1635     return;
1636
1637   priv->dispose_has_run = TRUE;
1638
1639   g_object_get (priv->handler, "tp-call", &call, NULL);
1640
1641   if (call != NULL)
1642     {
1643       g_object_unref (call);
1644     }
1645
1646   if (priv->handler != NULL)
1647     {
1648       empathy_streamed_media_handler_stop_call (priv->handler);
1649       g_object_unref (priv->handler);
1650     }
1651   priv->handler = NULL;
1652
1653   if (priv->bus_message_source_id != 0)
1654     {
1655       g_source_remove (priv->bus_message_source_id);
1656       priv->bus_message_source_id = 0;
1657     }
1658
1659   if (priv->pipeline != NULL)
1660     g_object_unref (priv->pipeline);
1661   priv->pipeline = NULL;
1662
1663   if (priv->video_input != NULL)
1664     g_object_unref (priv->video_input);
1665   priv->video_input = NULL;
1666
1667   if (priv->audio_input != NULL)
1668     g_object_unref (priv->audio_input);
1669   priv->audio_input = NULL;
1670
1671   if (priv->video_tee != NULL)
1672     g_object_unref (priv->video_tee);
1673   priv->video_tee = NULL;
1674
1675   if (priv->fsnotifier != NULL)
1676     g_object_unref (priv->fsnotifier);
1677   priv->fsnotifier = NULL;
1678
1679   if (priv->timer_id != 0)
1680     g_source_remove (priv->timer_id);
1681   priv->timer_id = 0;
1682
1683   if (priv->ui_manager != NULL)
1684     g_object_unref (priv->ui_manager);
1685   priv->ui_manager = NULL;
1686
1687   if (priv->fullscreen != NULL)
1688     g_object_unref (priv->fullscreen);
1689   priv->fullscreen = NULL;
1690
1691   if (priv->contact != NULL)
1692     {
1693       g_signal_handlers_disconnect_by_func (priv->contact,
1694           contact_name_changed_cb, self);
1695       g_object_unref (priv->contact);
1696       priv->contact = NULL;
1697     }
1698
1699   tp_clear_object (&priv->sound_mgr);
1700
1701   /* release any references held by the object here */
1702   if (G_OBJECT_CLASS (empathy_streamed_media_window_parent_class)->dispose)
1703     G_OBJECT_CLASS (empathy_streamed_media_window_parent_class)->dispose (object);
1704 }
1705
1706 static void
1707 disconnect_video_output_motion_handler (EmpathyStreamedMediaWindow *self)
1708 {
1709   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1710
1711   if (priv->video_output_motion_handler_id != 0)
1712     {
1713       g_signal_handler_disconnect (G_OBJECT (priv->video_output),
1714           priv->video_output_motion_handler_id);
1715       priv->video_output_motion_handler_id = 0;
1716     }
1717 }
1718
1719 void
1720 empathy_streamed_media_window_finalize (GObject *object)
1721 {
1722   EmpathyStreamedMediaWindow *self = EMPATHY_STREAMED_MEDIA_WINDOW (object);
1723   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1724
1725   disconnect_video_output_motion_handler (self);
1726
1727   /* free any data held directly by the object here */
1728   g_mutex_free (priv->lock);
1729
1730   g_timer_destroy (priv->timer);
1731
1732   G_OBJECT_CLASS (empathy_streamed_media_window_parent_class)->finalize (object);
1733 }
1734
1735
1736 EmpathyStreamedMediaWindow *
1737 empathy_streamed_media_window_new (EmpathyStreamedMediaHandler *handler)
1738 {
1739   return EMPATHY_STREAMED_MEDIA_WINDOW (
1740     g_object_new (EMPATHY_TYPE_STREAMED_MEDIA_WINDOW, "handler", handler, NULL));
1741 }
1742
1743 static void
1744 empathy_streamed_media_window_conference_added_cb (EmpathyStreamedMediaHandler *handler,
1745   GstElement *conference, gpointer user_data)
1746 {
1747   EmpathyStreamedMediaWindow *self = EMPATHY_STREAMED_MEDIA_WINDOW (user_data);
1748   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1749   GKeyFile *keyfile;
1750
1751   keyfile = fs_utils_get_default_element_properties (conference);
1752   if (keyfile != NULL)
1753     fs_element_added_notifier_set_properties_from_keyfile (priv->fsnotifier,
1754         keyfile);
1755
1756   gst_bin_add (GST_BIN (priv->pipeline), conference);
1757
1758   gst_element_set_state (conference, GST_STATE_PLAYING);
1759 }
1760
1761 static gboolean
1762 empathy_streamed_media_window_request_resource_cb (EmpathyStreamedMediaHandler *handler,
1763   FsMediaType type, FsStreamDirection direction, gpointer user_data)
1764 {
1765   EmpathyStreamedMediaWindow *self = EMPATHY_STREAMED_MEDIA_WINDOW (user_data);
1766   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1767
1768   if (type != FS_MEDIA_TYPE_VIDEO)
1769     return TRUE;
1770
1771   if (direction == FS_DIRECTION_RECV)
1772     return TRUE;
1773
1774   /* video and direction is send */
1775   return priv->video_input != NULL;
1776 }
1777
1778 static gboolean
1779 empathy_streamed_media_window_reset_pipeline (EmpathyStreamedMediaWindow *self)
1780 {
1781   GstStateChangeReturn state_change_return;
1782   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1783
1784   if (priv->pipeline == NULL)
1785     return TRUE;
1786
1787   if (priv->bus_message_source_id != 0)
1788     {
1789       g_source_remove (priv->bus_message_source_id);
1790       priv->bus_message_source_id = 0;
1791     }
1792
1793   state_change_return = gst_element_set_state (priv->pipeline, GST_STATE_NULL);
1794
1795   if (state_change_return == GST_STATE_CHANGE_SUCCESS ||
1796         state_change_return == GST_STATE_CHANGE_NO_PREROLL)
1797     {
1798       if (priv->pipeline != NULL)
1799         g_object_unref (priv->pipeline);
1800       priv->pipeline = NULL;
1801
1802       g_signal_handlers_disconnect_by_func (priv->audio_input_adj,
1803           empathy_streamed_media_window_mic_volume_changed_cb, self);
1804
1805       if (priv->video_tee != NULL)
1806         g_object_unref (priv->video_tee);
1807       priv->video_tee = NULL;
1808
1809       if (priv->video_preview != NULL)
1810         gtk_widget_destroy (priv->video_preview);
1811       priv->video_preview = NULL;
1812
1813       priv->funnel = NULL;
1814
1815       create_pipeline (self);
1816       /* Call will be started when user will hit the 'redial' button */
1817       priv->start_call_when_playing = FALSE;
1818       gst_element_set_state (priv->pipeline, GST_STATE_PAUSED);
1819
1820       return TRUE;
1821     }
1822   else
1823     {
1824       g_message ("Error: could not destroy pipeline. Closing call window");
1825       gtk_widget_destroy (GTK_WIDGET (self));
1826
1827       return FALSE;
1828     }
1829 }
1830
1831 static void
1832 reset_details_pane (EmpathyStreamedMediaWindow *self)
1833 {
1834   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1835
1836   /* translators: encoding video codec is unknown */
1837   gtk_label_set_text (GTK_LABEL (priv->vcodec_encoding_label),
1838       C_("codec", "Unknown"));
1839   /* translators: encoding audio codec is unknown */
1840   gtk_label_set_text (GTK_LABEL (priv->acodec_encoding_label),
1841       C_("codec", "Unknown"));
1842   /* translators: decoding video codec is unknown */
1843   gtk_label_set_text (GTK_LABEL (priv->vcodec_decoding_label),
1844       C_("codec", "Unknown"));
1845   /* translators: decoding audio codec is unknown */
1846   gtk_label_set_text (GTK_LABEL (priv->acodec_decoding_label),
1847       C_("codec", "Unknown"));
1848 }
1849
1850 static gboolean
1851 empathy_streamed_media_window_disconnected (EmpathyStreamedMediaWindow *self,
1852     gboolean restart)
1853 {
1854   gboolean could_disconnect = FALSE;
1855   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1856   gboolean could_reset_pipeline;
1857
1858   /* Leave full screen mode if needed */
1859   gtk_window_unfullscreen (GTK_WINDOW (self));
1860
1861   gtk_action_set_sensitive (priv->menu_fullscreen, FALSE);
1862
1863   could_reset_pipeline = empathy_streamed_media_window_reset_pipeline (self);
1864
1865   if (priv->call_state == CONNECTING)
1866       empathy_sound_manager_stop (priv->sound_mgr,
1867           EMPATHY_SOUND_PHONE_OUTGOING);
1868
1869   if (priv->call_state != REDIALING)
1870     priv->call_state = DISCONNECTED;
1871
1872   if (could_reset_pipeline)
1873     {
1874       g_mutex_lock (priv->lock);
1875
1876       g_timer_stop (priv->timer);
1877
1878       if (priv->timer_id != 0)
1879         g_source_remove (priv->timer_id);
1880       priv->timer_id = 0;
1881
1882       g_mutex_unlock (priv->lock);
1883
1884       if (!restart)
1885         /* We are about to destroy the window, no need to update it or create
1886          * a video preview */
1887         return TRUE;
1888
1889       empathy_streamed_media_window_status_message (self, _("Disconnected"));
1890
1891       gtk_action_set_sensitive (priv->redial, TRUE);
1892       gtk_widget_set_sensitive (priv->redial_button, TRUE);
1893
1894       /* Unsensitive the camera and mic button */
1895       gtk_widget_set_sensitive (priv->tool_button_camera_on, FALSE);
1896       gtk_action_set_sensitive (priv->action_camera_on, FALSE);
1897       gtk_widget_set_sensitive (priv->mic_button, FALSE);
1898
1899       /* Be sure that the mic button is enabled */
1900       gtk_toggle_tool_button_set_active (
1901           GTK_TOGGLE_TOOL_BUTTON (priv->mic_button), TRUE);
1902
1903       if (priv->camera_state == CAMERA_STATE_ON)
1904         {
1905           /* Enable the 'preview' button as we are not sending atm. */
1906           gtk_toggle_tool_button_set_active (
1907               GTK_TOGGLE_TOOL_BUTTON (priv->tool_button_camera_preview), TRUE);
1908         }
1909       else if (priv->camera_state == CAMERA_STATE_PREVIEW)
1910         {
1911           /* Restart the preview with the new pipeline. */
1912           display_video_preview (self, TRUE);
1913         }
1914
1915       gtk_progress_bar_set_fraction (
1916           GTK_PROGRESS_BAR (priv->volume_progress_bar), 0);
1917
1918       /* destroy the video output; it will be recreated when we'll redial */
1919       disconnect_video_output_motion_handler (self);
1920       gtk_widget_destroy (priv->video_output);
1921       priv->video_output = NULL;
1922
1923       gtk_widget_show (priv->remote_user_avatar_widget);
1924
1925       reset_details_pane (self);
1926
1927       priv->sending_video = FALSE;
1928       priv->call_started = FALSE;
1929
1930       could_disconnect = TRUE;
1931
1932       /* TODO: display the self avatar of the preview (depends if the "Always
1933        * Show Video Preview" is enabled or not) */
1934     }
1935
1936   return could_disconnect;
1937 }
1938
1939
1940 static void
1941 empathy_streamed_media_window_channel_closed_cb (EmpathyStreamedMediaHandler *handler,
1942     gpointer user_data)
1943 {
1944   EmpathyStreamedMediaWindow *self = EMPATHY_STREAMED_MEDIA_WINDOW (user_data);
1945   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1946
1947   if (empathy_streamed_media_window_disconnected (self, TRUE) &&
1948       priv->call_state == REDIALING)
1949       empathy_streamed_media_window_restart_call (self);
1950 }
1951
1952
1953 static void
1954 empathy_streamed_media_window_channel_stream_closed_cb (EmpathyStreamedMediaHandler *handler,
1955     TfStream *stream, gpointer user_data)
1956 {
1957   EmpathyStreamedMediaWindow *self = EMPATHY_STREAMED_MEDIA_WINDOW (user_data);
1958   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
1959   guint media_type;
1960
1961   g_object_get (stream, "media-type", &media_type, NULL);
1962
1963   /*
1964    * This assumes that there is only one video stream per channel...
1965    */
1966
1967   if (media_type == TP_MEDIA_STREAM_TYPE_VIDEO)
1968     {
1969       if (priv->funnel != NULL)
1970         {
1971           GstElement *output;
1972
1973           output = empathy_video_widget_get_element (EMPATHY_VIDEO_WIDGET
1974               (priv->video_output));
1975
1976           gst_element_set_state (output, GST_STATE_NULL);
1977           gst_element_set_state (priv->funnel, GST_STATE_NULL);
1978
1979           gst_bin_remove (GST_BIN (priv->pipeline), output);
1980           gst_bin_remove (GST_BIN (priv->pipeline), priv->funnel);
1981           priv->funnel = NULL;
1982         }
1983     }
1984   else if (media_type == TP_MEDIA_STREAM_TYPE_AUDIO)
1985     {
1986       if (priv->audio_output != NULL)
1987         {
1988           gst_element_set_state (priv->audio_output, GST_STATE_NULL);
1989
1990           gst_bin_remove (GST_BIN (priv->pipeline), priv->audio_output);
1991           priv->audio_output = NULL;
1992         }
1993     }
1994 }
1995
1996 /* Called with global lock held */
1997 static GstPad *
1998 empathy_streamed_media_window_get_video_sink_pad (EmpathyStreamedMediaWindow *self)
1999 {
2000   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
2001   GstPad *pad;
2002   GstElement *output;
2003
2004   if (priv->funnel == NULL)
2005     {
2006       output = empathy_video_widget_get_element (EMPATHY_VIDEO_WIDGET
2007         (priv->video_output));
2008
2009       priv->funnel = gst_element_factory_make ("fsfunnel", NULL);
2010
2011       if (!priv->funnel)
2012         {
2013           g_warning ("Could not create fsfunnel");
2014           return NULL;
2015         }
2016
2017       if (!gst_bin_add (GST_BIN (priv->pipeline), priv->funnel))
2018         {
2019           gst_object_unref (priv->funnel);
2020           priv->funnel = NULL;
2021           g_warning ("Could  not add funnel to pipeline");
2022           return NULL;
2023         }
2024
2025       if (!gst_bin_add (GST_BIN (priv->pipeline), output))
2026         {
2027           g_warning ("Could not add the video output widget to the pipeline");
2028           goto error;
2029         }
2030
2031       if (!gst_element_link (priv->funnel, output))
2032         {
2033           g_warning ("Could not link output sink to funnel");
2034           goto error_output_added;
2035         }
2036
2037       if (gst_element_set_state (output, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE)
2038         {
2039           g_warning ("Could not start video sink");
2040           goto error_output_added;
2041         }
2042
2043       if (gst_element_set_state (priv->funnel, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE)
2044         {
2045           g_warning ("Could not start funnel");
2046           goto error_output_added;
2047         }
2048     }
2049
2050   pad = gst_element_get_request_pad (priv->funnel, "sink%d");
2051
2052   if (!pad)
2053     g_warning ("Could not get request pad from funnel");
2054
2055   return pad;
2056
2057
2058  error_output_added:
2059
2060   gst_element_set_locked_state (priv->funnel, TRUE);
2061   gst_element_set_locked_state (output, TRUE);
2062
2063   gst_element_set_state (priv->funnel, GST_STATE_NULL);
2064   gst_element_set_state (output, GST_STATE_NULL);
2065
2066   gst_bin_remove (GST_BIN (priv->pipeline), output);
2067   gst_element_set_locked_state (output, FALSE);
2068
2069  error:
2070
2071   gst_bin_remove (GST_BIN (priv->pipeline), priv->funnel);
2072   priv->funnel = NULL;
2073
2074   return NULL;
2075 }
2076
2077 /* Called with global lock held */
2078 static GstPad *
2079 empathy_streamed_media_window_get_audio_sink_pad (EmpathyStreamedMediaWindow *self)
2080 {
2081   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
2082   GstPad *pad;
2083   GstPadTemplate *template;
2084
2085   if (priv->audio_output == NULL)
2086     {
2087       priv->audio_output = empathy_audio_sink_new ();
2088
2089       if (!gst_bin_add (GST_BIN (priv->pipeline), priv->audio_output))
2090         {
2091           g_warning ("Could not add audio sink to pipeline");
2092           g_object_unref (priv->audio_output);
2093           goto error_add_output;
2094         }
2095
2096       if (gst_element_set_state (priv->audio_output, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE)
2097         {
2098           g_warning ("Could not start audio sink");
2099           goto error;
2100         }
2101     }
2102
2103   template = gst_element_class_get_pad_template (
2104     GST_ELEMENT_GET_CLASS (priv->audio_output), "sink%d");
2105
2106   pad = gst_element_request_pad (priv->audio_output,
2107     template, NULL, NULL);
2108
2109   if (pad == NULL)
2110     {
2111       g_warning ("Could not get sink pad from sink");
2112       return NULL;
2113     }
2114
2115   return pad;
2116
2117 error:
2118   gst_element_set_locked_state (priv->audio_output, TRUE);
2119   gst_element_set_state (priv->audio_output, GST_STATE_NULL);
2120   gst_bin_remove (GST_BIN (priv->pipeline), priv->audio_output);
2121   priv->audio_output = NULL;
2122
2123 error_add_output:
2124
2125   return NULL;
2126 }
2127
2128 static gboolean
2129 empathy_streamed_media_window_update_timer (gpointer user_data)
2130 {
2131   EmpathyStreamedMediaWindow *self = EMPATHY_STREAMED_MEDIA_WINDOW (user_data);
2132   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
2133   gchar *str;
2134   gdouble time_;
2135
2136   time_ = g_timer_elapsed (priv->timer, NULL);
2137
2138   /* Translators: number of minutes:seconds the caller has been connected */
2139   str = g_strdup_printf (_("Connected — %d:%02dm"), (int) time_ / 60,
2140     (int) time_ % 60);
2141   empathy_streamed_media_window_status_message (self, str);
2142   g_free (str);
2143
2144   return TRUE;
2145 }
2146
2147 static void
2148 display_error (EmpathyStreamedMediaWindow *self,
2149     EmpathyTpStreamedMedia *call,
2150     const gchar *img,
2151     const gchar *title,
2152     const gchar *desc,
2153     const gchar *details)
2154 {
2155   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
2156   GtkWidget *info_bar;
2157   GtkWidget *content_area;
2158   GtkWidget *hbox;
2159   GtkWidget *vbox;
2160   GtkWidget *image;
2161   GtkWidget *label;
2162   gchar *txt;
2163
2164   /* Create info bar */
2165   info_bar = gtk_info_bar_new_with_buttons (GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
2166       NULL);
2167
2168   gtk_info_bar_set_message_type (GTK_INFO_BAR (info_bar), GTK_MESSAGE_WARNING);
2169
2170   content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (info_bar));
2171
2172   /* hbox containing the image and the messages vbox */
2173   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
2174   gtk_container_add (GTK_CONTAINER (content_area), hbox);
2175
2176   /* Add image */
2177   image = gtk_image_new_from_icon_name (img, GTK_ICON_SIZE_DIALOG);
2178   gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
2179
2180   /* vbox containing the main message and the details expander */
2181   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
2182   gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
2183
2184   /* Add text */
2185   txt = g_strdup_printf ("<b>%s</b>\n%s", title, desc);
2186
2187   label = gtk_label_new (NULL);
2188   gtk_label_set_markup (GTK_LABEL (label), txt);
2189   gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
2190   gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
2191   g_free (txt);
2192
2193   gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
2194
2195   /* Add details */
2196   if (details != NULL)
2197     {
2198       GtkWidget *expander;
2199
2200       expander = gtk_expander_new (_("Technical Details"));
2201
2202       txt = g_strdup_printf ("<i>%s</i>", details);
2203
2204       label = gtk_label_new (NULL);
2205       gtk_label_set_markup (GTK_LABEL (label), txt);
2206       gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
2207       gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
2208       g_free (txt);
2209
2210       gtk_container_add (GTK_CONTAINER (expander), label);
2211       gtk_box_pack_start (GTK_BOX (vbox), expander, TRUE, TRUE, 0);
2212     }
2213
2214   g_signal_connect (info_bar, "response",
2215       G_CALLBACK (gtk_widget_destroy), NULL);
2216
2217   gtk_box_pack_start (GTK_BOX (priv->errors_vbox), info_bar,
2218       FALSE, FALSE, CONTENT_HBOX_CHILDREN_PACKING_PADDING);
2219   gtk_widget_show_all (info_bar);
2220 }
2221
2222 static gchar *
2223 media_stream_error_to_txt (EmpathyStreamedMediaWindow *self,
2224     EmpathyTpStreamedMedia *call,
2225     gboolean audio,
2226     TpMediaStreamError error)
2227 {
2228   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
2229   const gchar *cm;
2230   gchar *url;
2231   gchar *result;
2232
2233   switch (error)
2234     {
2235       case TP_MEDIA_STREAM_ERROR_CODEC_NEGOTIATION_FAILED:
2236         if (audio)
2237           return g_strdup_printf (
2238               _("%s's software does not understand any of the audio formats "
2239                 "supported by your computer"),
2240             empathy_contact_get_alias (priv->contact));
2241         else
2242           return g_strdup_printf (
2243               _("%s's software does not understand any of the video formats "
2244                 "supported by your computer"),
2245             empathy_contact_get_alias (priv->contact));
2246
2247       case TP_MEDIA_STREAM_ERROR_CONNECTION_FAILED:
2248         return g_strdup_printf (
2249             _("Can't establish a connection to %s. "
2250               "One of you might be on a network that does not allow "
2251               "direct connections."),
2252           empathy_contact_get_alias (priv->contact));
2253
2254       case TP_MEDIA_STREAM_ERROR_NETWORK_ERROR:
2255           return g_strdup (_("There was a failure on the network"));
2256
2257       case TP_MEDIA_STREAM_ERROR_NO_CODECS:
2258         if (audio)
2259           return g_strdup (_("The audio formats necessary for this call "
2260                 "are not installed on your computer"));
2261         else
2262           return g_strdup (_("The video formats necessary for this call "
2263                 "are not installed on your computer"));
2264
2265       case TP_MEDIA_STREAM_ERROR_INVALID_CM_BEHAVIOR:
2266         cm = empathy_tp_streamed_media_get_connection_manager (call);
2267
2268         url = g_strdup_printf ("http://bugs.freedesktop.org/enter_bug.cgi?"
2269             "product=Telepathy&amp;component=%s", cm);
2270
2271         result = g_strdup_printf (
2272             _("Something unexpected happened in a Telepathy component. "
2273               "Please <a href=\"%s\">report this bug</a> and attach "
2274               "logs gathered from the 'Debug' window in the Help menu."), url);
2275
2276         g_free (url);
2277         return result;
2278
2279       case TP_MEDIA_STREAM_ERROR_MEDIA_ERROR:
2280         return g_strdup (_("There was a failure in the call engine"));
2281
2282       case TP_MEDIA_STREAM_ERROR_EOS:
2283         return g_strdup (_("The end of the stream was reached"));
2284
2285       case TP_MEDIA_STREAM_ERROR_UNKNOWN:
2286       default:
2287         return NULL;
2288     }
2289 }
2290
2291 static void
2292 empathy_streamed_media_window_stream_error (EmpathyStreamedMediaWindow *self,
2293     EmpathyTpStreamedMedia *call,
2294     gboolean audio,
2295     guint code,
2296     const gchar *msg,
2297     const gchar *icon,
2298     const gchar *title)
2299 {
2300   gchar *desc;
2301
2302   desc = media_stream_error_to_txt (self, call, audio, code);
2303   if (desc == NULL)
2304     {
2305       /* No description, use the error message. That's not great as it's not
2306        * localized but it's better than nothing. */
2307       display_error (self, call, icon, title, msg, NULL);
2308     }
2309   else
2310     {
2311       display_error (self, call, icon, title, desc, msg);
2312       g_free (desc);
2313     }
2314 }
2315
2316 static void
2317 empathy_streamed_media_window_audio_stream_error (EmpathyTpStreamedMedia *call,
2318     guint code,
2319     const gchar *msg,
2320     EmpathyStreamedMediaWindow *self)
2321 {
2322   empathy_streamed_media_window_stream_error (self, call, TRUE, code, msg,
2323       "gnome-stock-mic", _("Can't establish audio stream"));
2324 }
2325
2326 static void
2327 empathy_streamed_media_window_video_stream_error (EmpathyTpStreamedMedia *call,
2328     guint code,
2329     const gchar *msg,
2330     EmpathyStreamedMediaWindow *self)
2331 {
2332   empathy_streamed_media_window_stream_error (self, call, FALSE, code, msg,
2333       "camera-web", _("Can't establish video stream"));
2334 }
2335
2336 static gboolean
2337 empathy_streamed_media_window_connected (gpointer user_data)
2338 {
2339   EmpathyStreamedMediaWindow *self = EMPATHY_STREAMED_MEDIA_WINDOW (user_data);
2340   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
2341   EmpathyTpStreamedMedia *call;
2342   gboolean can_send_video;
2343
2344   empathy_sound_manager_stop (priv->sound_mgr, EMPATHY_SOUND_PHONE_OUTGOING);
2345
2346   can_send_video = priv->video_input != NULL && priv->contact != NULL &&
2347     empathy_contact_can_voip_video (priv->contact);
2348
2349   g_object_get (priv->handler, "tp-call", &call, NULL);
2350
2351   tp_g_signal_connect_object (call, "notify::video-stream",
2352     G_CALLBACK (empathy_streamed_media_window_video_stream_changed_cb),
2353     self, 0);
2354
2355   if (empathy_tp_streamed_media_has_dtmf (call))
2356     gtk_widget_set_sensitive (priv->dtmf_panel, TRUE);
2357
2358   if (priv->video_input == NULL)
2359     empathy_streamed_media_window_set_send_video (self, CAMERA_STATE_OFF);
2360
2361   priv->sending_video = can_send_video ?
2362     empathy_tp_streamed_media_is_sending_video (call) : FALSE;
2363
2364   gtk_toggle_tool_button_set_active (
2365       GTK_TOGGLE_TOOL_BUTTON (priv->tool_button_camera_on),
2366       priv->sending_video && priv->video_input != NULL);
2367   gtk_widget_set_sensitive (priv->tool_button_camera_on, can_send_video);
2368   gtk_action_set_sensitive (priv->action_camera_on, can_send_video);
2369
2370   gtk_action_set_sensitive (priv->redial, FALSE);
2371   gtk_widget_set_sensitive (priv->redial_button, FALSE);
2372
2373   gtk_widget_set_sensitive (priv->mic_button, TRUE);
2374
2375   empathy_streamed_media_window_update_avatars_visibility (call, self);
2376
2377   g_object_unref (call);
2378
2379   g_mutex_lock (priv->lock);
2380
2381   priv->timer_id = g_timeout_add_seconds (1,
2382     empathy_streamed_media_window_update_timer, self);
2383
2384   g_mutex_unlock (priv->lock);
2385
2386   empathy_streamed_media_window_update_timer (self);
2387
2388   gtk_action_set_sensitive (priv->menu_fullscreen, TRUE);
2389
2390   return FALSE;
2391 }
2392
2393
2394 /* Called from the streaming thread */
2395 static gboolean
2396 empathy_streamed_media_window_src_added_cb (EmpathyStreamedMediaHandler *handler,
2397   GstPad *src, guint media_type, gpointer user_data)
2398 {
2399   EmpathyStreamedMediaWindow *self = EMPATHY_STREAMED_MEDIA_WINDOW (user_data);
2400   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
2401   gboolean retval = FALSE;
2402
2403   GstPad *pad;
2404
2405   g_mutex_lock (priv->lock);
2406
2407   if (priv->call_state != CONNECTED)
2408     {
2409       g_timer_start (priv->timer);
2410       priv->timer_id = g_idle_add  (empathy_streamed_media_window_connected, self);
2411       priv->call_state = CONNECTED;
2412     }
2413
2414   switch (media_type)
2415     {
2416       case TP_MEDIA_STREAM_TYPE_AUDIO:
2417         pad = empathy_streamed_media_window_get_audio_sink_pad (self);
2418         break;
2419       case TP_MEDIA_STREAM_TYPE_VIDEO:
2420         gtk_widget_hide (priv->remote_user_avatar_widget);
2421         gtk_widget_show (priv->video_output);
2422         pad = empathy_streamed_media_window_get_video_sink_pad (self);
2423         break;
2424       default:
2425         g_assert_not_reached ();
2426     }
2427
2428   if (pad == NULL)
2429     goto out;
2430
2431   if (GST_PAD_LINK_FAILED (gst_pad_link (src, pad)))
2432       g_warning ("Could not link %s sink pad",
2433           media_type == TP_MEDIA_STREAM_TYPE_AUDIO ? "audio" : "video");
2434   else
2435       retval = TRUE;
2436
2437   gst_object_unref (pad);
2438
2439  out:
2440
2441   /* If no sink could be linked, try to add fakesink to prevent the whole call
2442    * aborting */
2443
2444   if (!retval)
2445     {
2446       GstElement *fakesink = gst_element_factory_make ("fakesink", NULL);
2447
2448       if (gst_bin_add (GST_BIN (priv->pipeline), fakesink))
2449         {
2450           GstPad *sinkpad = gst_element_get_static_pad (fakesink, "sink");
2451           if (gst_element_set_state (fakesink, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE ||
2452               GST_PAD_LINK_FAILED (gst_pad_link (src, sinkpad)))
2453             {
2454               gst_element_set_locked_state (fakesink, TRUE);
2455               gst_element_set_state (fakesink, GST_STATE_NULL);
2456               gst_bin_remove (GST_BIN (priv->pipeline), fakesink);
2457             }
2458           else
2459             {
2460               DEBUG ("Could not link real sink, linked fakesink instead");
2461             }
2462           gst_object_unref (sinkpad);
2463         }
2464       else
2465         {
2466           gst_object_unref (fakesink);
2467         }
2468     }
2469
2470
2471   g_mutex_unlock (priv->lock);
2472
2473   return TRUE;
2474 }
2475
2476 static gboolean
2477 empathy_streamed_media_window_sink_added_cb (EmpathyStreamedMediaHandler *handler,
2478   GstPad *sink, guint media_type, gpointer user_data)
2479 {
2480   EmpathyStreamedMediaWindow *self = EMPATHY_STREAMED_MEDIA_WINDOW (user_data);
2481   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
2482   GstPad *pad;
2483   gboolean retval = FALSE;
2484
2485   switch (media_type)
2486     {
2487       case TP_MEDIA_STREAM_TYPE_AUDIO:
2488         if (!gst_bin_add (GST_BIN (priv->pipeline), priv->audio_input))
2489           {
2490             g_warning ("Could not add audio source to pipeline");
2491             break;
2492           }
2493
2494         pad = gst_element_get_static_pad (priv->audio_input, "src");
2495         if (!pad)
2496           {
2497             gst_bin_remove (GST_BIN (priv->pipeline), priv->audio_input);
2498             g_warning ("Could not get source pad from audio source");
2499             break;
2500           }
2501
2502         if (GST_PAD_LINK_FAILED (gst_pad_link (pad, sink)))
2503           {
2504             gst_bin_remove (GST_BIN (priv->pipeline), priv->audio_input);
2505             g_warning ("Could not link audio source to farsight");
2506             break;
2507           }
2508
2509         if (gst_element_set_state (priv->audio_input, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE)
2510           {
2511             g_warning ("Could not start audio source");
2512             gst_element_set_state (priv->audio_input, GST_STATE_NULL);
2513             gst_bin_remove (GST_BIN (priv->pipeline), priv->audio_input);
2514             break;
2515           }
2516
2517         retval = TRUE;
2518         break;
2519       case TP_MEDIA_STREAM_TYPE_VIDEO:
2520         if (priv->video_input != NULL)
2521           {
2522             if (priv->video_tee != NULL)
2523               {
2524                 pad = gst_element_get_request_pad (priv->video_tee, "src%d");
2525                 if (GST_PAD_LINK_FAILED (gst_pad_link (pad, sink)))
2526                   {
2527                     g_warning ("Could not link videp soure input pipeline");
2528                     break;
2529                   }
2530                 gst_object_unref (pad);
2531               }
2532
2533             retval = TRUE;
2534           }
2535         break;
2536       default:
2537         g_assert_not_reached ();
2538     }
2539
2540   return retval;
2541 }
2542
2543 static void
2544 empathy_streamed_media_window_remove_video_input (EmpathyStreamedMediaWindow *self)
2545 {
2546   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
2547   GstElement *preview;
2548
2549   disable_camera (self);
2550
2551   DEBUG ("remove video input");
2552   preview = empathy_video_widget_get_element (
2553     EMPATHY_VIDEO_WIDGET (priv->video_preview));
2554
2555   gst_element_set_state (priv->video_input, GST_STATE_NULL);
2556   gst_element_set_state (priv->video_tee, GST_STATE_NULL);
2557   gst_element_set_state (preview, GST_STATE_NULL);
2558
2559   gst_bin_remove_many (GST_BIN (priv->pipeline), priv->video_input,
2560     priv->video_tee, preview, NULL);
2561
2562   g_object_unref (priv->video_input);
2563   priv->video_input = NULL;
2564   g_object_unref (priv->video_tee);
2565   priv->video_tee = NULL;
2566   gtk_widget_destroy (priv->video_preview);
2567   priv->video_preview = NULL;
2568
2569   gtk_widget_set_sensitive (priv->tool_button_camera_on, FALSE);
2570   gtk_action_set_sensitive (priv->action_camera_on, FALSE);
2571   gtk_widget_set_sensitive (priv->tool_button_camera_preview, FALSE);
2572 }
2573
2574 static void
2575 start_call (EmpathyStreamedMediaWindow *self)
2576 {
2577   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
2578
2579   priv->call_started = TRUE;
2580   empathy_streamed_media_handler_start_call (priv->handler,
2581       empathy_get_current_action_time ());
2582
2583   if (empathy_streamed_media_handler_has_initial_video (priv->handler))
2584     {
2585       /* Enable 'send video' buttons and display the preview */
2586       gtk_toggle_tool_button_set_active (
2587           GTK_TOGGLE_TOOL_BUTTON (priv->tool_button_camera_on), TRUE);
2588     }
2589 }
2590
2591 static gboolean
2592 empathy_streamed_media_window_bus_message (GstBus *bus, GstMessage *message,
2593   gpointer user_data)
2594 {
2595   EmpathyStreamedMediaWindow *self = EMPATHY_STREAMED_MEDIA_WINDOW (user_data);
2596   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
2597   GstState newstate;
2598
2599   empathy_streamed_media_handler_bus_message (priv->handler, bus, message);
2600
2601   switch (GST_MESSAGE_TYPE (message))
2602     {
2603       case GST_MESSAGE_STATE_CHANGED:
2604         if (GST_MESSAGE_SRC (message) == GST_OBJECT (priv->video_input))
2605           {
2606             gst_message_parse_state_changed (message, NULL, &newstate, NULL);
2607             if (newstate == GST_STATE_PAUSED)
2608                 empathy_streamed_media_window_setup_video_input (self);
2609           }
2610         if (GST_MESSAGE_SRC (message) == GST_OBJECT (priv->pipeline) &&
2611             !priv->call_started)
2612           {
2613             gst_message_parse_state_changed (message, NULL, &newstate, NULL);
2614             if (newstate == GST_STATE_PAUSED)
2615               {
2616                 gst_element_set_state (priv->pipeline, GST_STATE_PLAYING);
2617                 priv->pipeline_playing = TRUE;
2618
2619                 if (priv->start_call_when_playing)
2620                   start_call (self);
2621               }
2622           }
2623         break;
2624       case GST_MESSAGE_ERROR:
2625         {
2626           GError *error = NULL;
2627           GstElement *gst_error;
2628           gchar *debug;
2629
2630           gst_message_parse_error (message, &error, &debug);
2631           gst_error = GST_ELEMENT (GST_MESSAGE_SRC (message));
2632
2633           g_message ("Element error: %s -- %s\n", error->message, debug);
2634
2635           if (g_str_has_prefix (gst_element_get_name (gst_error),
2636                 VIDEO_INPUT_ERROR_PREFIX))
2637             {
2638               /* Remove the video input and continue */
2639               if (priv->video_input != NULL)
2640                 empathy_streamed_media_window_remove_video_input (self);
2641               gst_element_set_state (priv->pipeline, GST_STATE_PLAYING);
2642             }
2643           else
2644             {
2645               empathy_streamed_media_window_disconnected (self, TRUE);
2646             }
2647           g_error_free (error);
2648           g_free (debug);
2649         }
2650       case GST_MESSAGE_UNKNOWN:
2651       case GST_MESSAGE_EOS:
2652       case GST_MESSAGE_WARNING:
2653       case GST_MESSAGE_INFO:
2654       case GST_MESSAGE_TAG:
2655       case GST_MESSAGE_BUFFERING:
2656       case GST_MESSAGE_STATE_DIRTY:
2657       case GST_MESSAGE_STEP_DONE:
2658       case GST_MESSAGE_CLOCK_PROVIDE:
2659       case GST_MESSAGE_CLOCK_LOST:
2660       case GST_MESSAGE_NEW_CLOCK:
2661       case GST_MESSAGE_STRUCTURE_CHANGE:
2662       case GST_MESSAGE_STREAM_STATUS:
2663       case GST_MESSAGE_APPLICATION:
2664       case GST_MESSAGE_ELEMENT:
2665       case GST_MESSAGE_SEGMENT_START:
2666       case GST_MESSAGE_SEGMENT_DONE:
2667       case GST_MESSAGE_DURATION:
2668       case GST_MESSAGE_ANY:
2669       default:
2670         break;
2671     }
2672
2673   return TRUE;
2674 }
2675
2676 static void
2677 empathy_streamed_media_window_update_avatars_visibility (EmpathyTpStreamedMedia *call,
2678     EmpathyStreamedMediaWindow *window)
2679 {
2680   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
2681
2682   if (empathy_tp_streamed_media_is_receiving_video (call))
2683     {
2684       gtk_widget_hide (priv->remote_user_avatar_widget);
2685       gtk_widget_show (priv->video_output);
2686     }
2687   else
2688     {
2689       gtk_widget_hide (priv->video_output);
2690       gtk_widget_show (priv->remote_user_avatar_widget);
2691     }
2692 }
2693
2694 static void
2695 call_handler_notify_tp_streamed_media_cb (EmpathyStreamedMediaHandler *handler,
2696     GParamSpec *spec,
2697     EmpathyStreamedMediaWindow *self)
2698 {
2699   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
2700   EmpathyTpStreamedMedia *call;
2701
2702   g_object_get (priv->handler, "tp-call", &call, NULL);
2703   if (call == NULL)
2704     return;
2705
2706   tp_g_signal_connect_object (call, "audio-stream-error",
2707       G_CALLBACK (empathy_streamed_media_window_audio_stream_error), self, 0);
2708   tp_g_signal_connect_object (call, "video-stream-error",
2709       G_CALLBACK (empathy_streamed_media_window_video_stream_error), self, 0);
2710
2711   g_object_unref (call);
2712 }
2713
2714 static void
2715 empathy_streamed_media_window_realized_cb (GtkWidget *widget, EmpathyStreamedMediaWindow *window)
2716 {
2717   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
2718   EmpathyTpStreamedMedia *call;
2719
2720   g_signal_connect (priv->handler, "conference-added",
2721     G_CALLBACK (empathy_streamed_media_window_conference_added_cb), window);
2722   g_signal_connect (priv->handler, "request-resource",
2723     G_CALLBACK (empathy_streamed_media_window_request_resource_cb), window);
2724   g_signal_connect (priv->handler, "closed",
2725     G_CALLBACK (empathy_streamed_media_window_channel_closed_cb), window);
2726   g_signal_connect (priv->handler, "src-pad-added",
2727     G_CALLBACK (empathy_streamed_media_window_src_added_cb), window);
2728   g_signal_connect (priv->handler, "sink-pad-added",
2729     G_CALLBACK (empathy_streamed_media_window_sink_added_cb), window);
2730   g_signal_connect (priv->handler, "stream-closed",
2731     G_CALLBACK (empathy_streamed_media_window_channel_stream_closed_cb), window);
2732
2733   g_object_get (priv->handler, "tp-call", &call, NULL);
2734   if (call != NULL)
2735     {
2736       tp_g_signal_connect_object (call, "audio-stream-error",
2737         G_CALLBACK (empathy_streamed_media_window_audio_stream_error), window,
2738         0);
2739       tp_g_signal_connect_object (call, "video-stream-error",
2740         G_CALLBACK (empathy_streamed_media_window_video_stream_error), window,
2741         0);
2742
2743       g_object_unref (call);
2744     }
2745   else
2746     {
2747       /* tp-call doesn't exist yet, we'll connect signals once it has been
2748        * set */
2749       g_signal_connect (priv->handler, "notify::tp-call",
2750         G_CALLBACK (call_handler_notify_tp_streamed_media_cb), window);
2751     }
2752
2753   gst_element_set_state (priv->pipeline, GST_STATE_PAUSED);
2754 }
2755
2756 static gboolean
2757 empathy_streamed_media_window_delete_cb (GtkWidget *widget, GdkEvent*event,
2758   EmpathyStreamedMediaWindow *window)
2759 {
2760   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
2761
2762   if (priv->pipeline != NULL)
2763     {
2764       if (priv->bus_message_source_id != 0)
2765         {
2766           g_source_remove (priv->bus_message_source_id);
2767           priv->bus_message_source_id = 0;
2768         }
2769
2770       gst_element_set_state (priv->pipeline, GST_STATE_NULL);
2771     }
2772
2773   if (priv->call_state == CONNECTING)
2774     empathy_sound_manager_stop (priv->sound_mgr, EMPATHY_SOUND_PHONE_OUTGOING);
2775
2776   return FALSE;
2777 }
2778
2779 static void
2780 show_controls (EmpathyStreamedMediaWindow *window, gboolean set_fullscreen)
2781 {
2782   GtkWidget *menu;
2783   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
2784
2785   menu = gtk_ui_manager_get_widget (priv->ui_manager,
2786             "/menubar1");
2787
2788   if (set_fullscreen)
2789     {
2790       gtk_widget_hide (priv->sidebar);
2791       gtk_widget_hide (menu);
2792       gtk_widget_hide (priv->vbox);
2793       gtk_widget_hide (priv->statusbar);
2794       gtk_widget_hide (priv->toolbar);
2795     }
2796   else
2797     {
2798       if (priv->sidebar_was_visible_before_fs)
2799         gtk_widget_show (priv->sidebar);
2800
2801       gtk_widget_show (menu);
2802       gtk_widget_show (priv->vbox);
2803       gtk_widget_show (priv->statusbar);
2804       gtk_widget_show (priv->toolbar);
2805
2806       gtk_window_resize (GTK_WINDOW (window), priv->original_width_before_fs,
2807           priv->original_height_before_fs);
2808     }
2809 }
2810
2811 static void
2812 show_borders (EmpathyStreamedMediaWindow *window, gboolean set_fullscreen)
2813 {
2814   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
2815
2816   gtk_container_set_border_width (GTK_CONTAINER (priv->content_hbox),
2817       set_fullscreen ? 0 : CONTENT_HBOX_BORDER_WIDTH);
2818   gtk_box_set_spacing (GTK_BOX (priv->content_hbox),
2819       set_fullscreen ? 0 : CONTENT_HBOX_SPACING);
2820
2821   if (priv->video_output != NULL)
2822     {
2823       gtk_box_set_child_packing (GTK_BOX (priv->content_hbox),
2824           priv->video_output, TRUE, TRUE,
2825           set_fullscreen ? 0 : CONTENT_HBOX_CHILDREN_PACKING_PADDING,
2826           GTK_PACK_START);
2827     }
2828
2829   gtk_box_set_child_packing (GTK_BOX (priv->content_hbox),
2830       priv->vbox, TRUE, TRUE,
2831       set_fullscreen ? 0 : CONTENT_HBOX_CHILDREN_PACKING_PADDING,
2832       GTK_PACK_START);
2833 }
2834
2835 static gboolean
2836 empathy_streamed_media_window_state_event_cb (GtkWidget *widget,
2837   GdkEventWindowState *event, EmpathyStreamedMediaWindow *window)
2838 {
2839   if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN)
2840     {
2841       EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
2842       gboolean set_fullscreen = event->new_window_state &
2843         GDK_WINDOW_STATE_FULLSCREEN;
2844
2845       if (set_fullscreen)
2846         {
2847           gboolean sidebar_was_visible;
2848           GtkAllocation allocation;
2849           gint original_width, original_height;
2850
2851           gtk_widget_get_allocation (GTK_WIDGET (window), &allocation);
2852           original_width = allocation.width;
2853           original_height = allocation.height;
2854
2855           g_object_get (priv->sidebar, "visible", &sidebar_was_visible, NULL);
2856
2857           priv->sidebar_was_visible_before_fs = sidebar_was_visible;
2858           priv->original_width_before_fs = original_width;
2859           priv->original_height_before_fs = original_height;
2860
2861           if (priv->video_output_motion_handler_id == 0 &&
2862                 priv->video_output != NULL)
2863             {
2864               priv->video_output_motion_handler_id = g_signal_connect (
2865                   G_OBJECT (priv->video_output), "motion-notify-event",
2866                   G_CALLBACK (empathy_streamed_media_window_video_output_motion_notify),
2867                   window);
2868             }
2869         }
2870       else
2871         {
2872           disconnect_video_output_motion_handler (window);
2873         }
2874
2875       empathy_streamed_media_window_fullscreen_set_fullscreen (priv->fullscreen,
2876           set_fullscreen);
2877       show_controls (window, set_fullscreen);
2878       show_borders (window, set_fullscreen);
2879       gtk_action_set_stock_id (priv->menu_fullscreen,
2880           (set_fullscreen ? "gtk-leave-fullscreen" : "gtk-fullscreen"));
2881       priv->is_fullscreen = set_fullscreen;
2882   }
2883
2884   return FALSE;
2885 }
2886
2887 static void
2888 empathy_streamed_media_window_sidebar_toggled_cb (GtkToggleButton *toggle,
2889   EmpathyStreamedMediaWindow *window)
2890 {
2891   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
2892   GtkWidget *arrow;
2893   int w, h, handle_size;
2894   GtkAllocation allocation, sidebar_allocation;
2895
2896   gtk_widget_get_allocation (GTK_WIDGET (window), &allocation);
2897   w = allocation.width;
2898   h = allocation.height;
2899
2900   gtk_widget_style_get (priv->pane, "handle_size", &handle_size, NULL);
2901
2902   gtk_widget_get_allocation (priv->sidebar, &sidebar_allocation);
2903   if (gtk_toggle_button_get_active (toggle))
2904     {
2905       arrow = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_NONE);
2906       gtk_widget_show (priv->sidebar);
2907       w += sidebar_allocation.width + handle_size;
2908     }
2909   else
2910     {
2911       arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
2912       w -= sidebar_allocation.width + handle_size;
2913       gtk_widget_hide (priv->sidebar);
2914     }
2915
2916   gtk_button_set_image (GTK_BUTTON (priv->sidebar_button), arrow);
2917
2918   if (w > 0 && h > 0)
2919     gtk_window_resize (GTK_WINDOW (window), w, h);
2920 }
2921
2922 static void
2923 empathy_streamed_media_window_set_send_video (EmpathyStreamedMediaWindow *window,
2924   CameraState state)
2925 {
2926   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
2927   EmpathyTpStreamedMedia *call;
2928
2929   priv->sending_video = (state == CAMERA_STATE_ON);
2930
2931   if (state == CAMERA_STATE_PREVIEW ||
2932       state == CAMERA_STATE_ON)
2933     {
2934       /* When we start sending video, we want to show the video preview by
2935          default. */
2936       display_video_preview (window, TRUE);
2937     }
2938   else
2939     {
2940       display_video_preview (window, FALSE);
2941     }
2942
2943   if (priv->call_state != CONNECTED)
2944     return;
2945
2946   g_object_get (priv->handler, "tp-call", &call, NULL);
2947   DEBUG ("%s sending video", priv->sending_video ? "start": "stop");
2948   empathy_tp_streamed_media_request_video_stream_direction (call, priv->sending_video);
2949   g_object_unref (call);
2950 }
2951
2952 static void
2953 empathy_streamed_media_window_mic_toggled_cb (GtkToggleToolButton *toggle,
2954   EmpathyStreamedMediaWindow *window)
2955 {
2956   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
2957   gboolean active;
2958
2959   active = (gtk_toggle_tool_button_get_active (toggle));
2960
2961   if (active)
2962     {
2963       empathy_audio_src_set_volume (EMPATHY_GST_AUDIO_SRC (priv->audio_input),
2964         priv->volume);
2965       gtk_adjustment_set_value (priv->audio_input_adj, priv->volume * 100);
2966     }
2967   else
2968     {
2969       /* TODO, Instead of setting the input volume to 0 we should probably
2970        * stop sending but this would cause the audio call to drop if both
2971        * sides mute at the same time on certain CMs AFAIK. Need to revisit this
2972        * in the future. GNOME #574574
2973        */
2974       empathy_audio_src_set_volume (EMPATHY_GST_AUDIO_SRC (priv->audio_input),
2975         0);
2976       gtk_adjustment_set_value (priv->audio_input_adj, 0);
2977     }
2978 }
2979
2980 static void
2981 empathy_streamed_media_window_sidebar_hidden_cb (EvSidebar *sidebar,
2982   EmpathyStreamedMediaWindow *window)
2983 {
2984   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
2985
2986   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->sidebar_button),
2987     FALSE);
2988 }
2989
2990 static void
2991 empathy_streamed_media_window_sidebar_shown_cb (EvSidebar *sidebar,
2992   EmpathyStreamedMediaWindow *window)
2993 {
2994   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
2995
2996   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->sidebar_button),
2997     TRUE);
2998 }
2999
3000 static void
3001 empathy_streamed_media_window_hangup_cb (gpointer object,
3002                                EmpathyStreamedMediaWindow *window)
3003 {
3004   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
3005
3006   empathy_streamed_media_handler_stop_call (priv->handler);
3007
3008   if (empathy_streamed_media_window_disconnected (window, FALSE))
3009     gtk_widget_destroy (GTK_WIDGET (window));
3010 }
3011
3012 static void
3013 empathy_streamed_media_window_restart_call (EmpathyStreamedMediaWindow *window)
3014 {
3015   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
3016
3017   /* Remove error info bars */
3018   gtk_container_forall (GTK_CONTAINER (priv->errors_vbox),
3019       (GtkCallback) gtk_widget_destroy, NULL);
3020
3021   create_video_output_widget (window);
3022
3023   g_signal_connect (G_OBJECT (priv->audio_input_adj), "value-changed",
3024       G_CALLBACK (empathy_streamed_media_window_mic_volume_changed_cb), window);
3025
3026   /* While the call was disconnected, the input volume might have changed.
3027    * However, since the audio_input source was destroyed, its volume has not
3028    * been updated during that time. That's why we manually update it here */
3029   empathy_streamed_media_window_mic_volume_changed_cb (priv->audio_input_adj, window);
3030
3031   priv->outgoing = TRUE;
3032   empathy_streamed_media_window_set_state_connecting (window);
3033
3034   if (priv->pipeline_playing)
3035     start_call (window);
3036   else
3037     /* call will be started when the pipeline is ready */
3038     priv->start_call_when_playing = TRUE;
3039
3040
3041   empathy_streamed_media_window_setup_avatars (window, priv->handler);
3042
3043   gtk_action_set_sensitive (priv->redial, FALSE);
3044   gtk_widget_set_sensitive (priv->redial_button, FALSE);
3045 }
3046
3047 static void
3048 empathy_streamed_media_window_redial_cb (gpointer object,
3049     EmpathyStreamedMediaWindow *window)
3050 {
3051   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
3052
3053   if (priv->call_state == CONNECTED)
3054     priv->call_state = REDIALING;
3055
3056   empathy_streamed_media_handler_stop_call (priv->handler);
3057
3058   if (priv->call_state != CONNECTED)
3059     empathy_streamed_media_window_restart_call (window);
3060 }
3061
3062 static void
3063 empathy_streamed_media_window_fullscreen_cb (gpointer object,
3064                                    EmpathyStreamedMediaWindow *window)
3065 {
3066   empathy_streamed_media_window_fullscreen_toggle (window);
3067 }
3068
3069 static void
3070 empathy_streamed_media_window_fullscreen_toggle (EmpathyStreamedMediaWindow *window)
3071 {
3072   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
3073
3074   if (priv->is_fullscreen)
3075     gtk_window_unfullscreen (GTK_WINDOW (window));
3076   else
3077     gtk_window_fullscreen (GTK_WINDOW (window));
3078 }
3079
3080 static gboolean
3081 empathy_streamed_media_window_video_button_press_cb (GtkWidget *video_output,
3082   GdkEventButton *event, EmpathyStreamedMediaWindow *window)
3083 {
3084   if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
3085     {
3086       empathy_streamed_media_window_video_menu_popup (window, event->button);
3087       return TRUE;
3088     }
3089
3090   return FALSE;
3091 }
3092
3093 static gboolean
3094 empathy_streamed_media_window_key_press_cb (GtkWidget *video_output,
3095   GdkEventKey *event, EmpathyStreamedMediaWindow *window)
3096 {
3097   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
3098
3099   if (priv->is_fullscreen && event->keyval == GDK_KEY_Escape)
3100     {
3101       /* Since we are in fullscreen mode, toggling will bring us back to
3102          normal mode. */
3103       empathy_streamed_media_window_fullscreen_toggle (window);
3104       return TRUE;
3105     }
3106
3107   return FALSE;
3108 }
3109
3110 static gboolean
3111 empathy_streamed_media_window_video_output_motion_notify (GtkWidget *widget,
3112     GdkEventMotion *event, EmpathyStreamedMediaWindow *window)
3113 {
3114   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
3115
3116   if (priv->is_fullscreen)
3117     {
3118       empathy_streamed_media_window_fullscreen_show_popup (priv->fullscreen);
3119       return TRUE;
3120     }
3121   return FALSE;
3122 }
3123
3124 static void
3125 empathy_streamed_media_window_video_menu_popup (EmpathyStreamedMediaWindow *window,
3126   guint button)
3127 {
3128   GtkWidget *menu;
3129   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
3130
3131   menu = gtk_ui_manager_get_widget (priv->ui_manager,
3132             "/video-popup");
3133   gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
3134       button, gtk_get_current_event_time ());
3135   gtk_menu_shell_select_first (GTK_MENU_SHELL (menu), FALSE);
3136 }
3137
3138 static void
3139 empathy_streamed_media_window_status_message (EmpathyStreamedMediaWindow *window,
3140   gchar *message)
3141 {
3142   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
3143
3144   if (priv->context_id == 0)
3145     {
3146       priv->context_id = gtk_statusbar_get_context_id (
3147         GTK_STATUSBAR (priv->statusbar), "voip call status messages");
3148     }
3149   else
3150     {
3151       gtk_statusbar_pop (GTK_STATUSBAR (priv->statusbar), priv->context_id);
3152     }
3153
3154   gtk_statusbar_push (GTK_STATUSBAR (priv->statusbar), priv->context_id,
3155     message);
3156 }
3157
3158 static void
3159 empathy_streamed_media_window_volume_changed_cb (GtkScaleButton *button,
3160   gdouble value, EmpathyStreamedMediaWindow *window)
3161 {
3162   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (window);
3163
3164   if (priv->audio_output == NULL)
3165     return;
3166
3167   empathy_audio_sink_set_volume (EMPATHY_GST_AUDIO_SINK (priv->audio_output),
3168     value);
3169 }
3170
3171 /* block all the signals related to camera control widgets. This is useful
3172  * when we are manually updating the UI and so don't want to fire the
3173  * callbacks */
3174 static void
3175 block_camera_control_signals (EmpathyStreamedMediaWindow *self)
3176 {
3177   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
3178
3179   g_signal_handlers_block_by_func (priv->tool_button_camera_off,
3180       tool_button_camera_off_toggled_cb, self);
3181   g_signal_handlers_block_by_func (priv->tool_button_camera_preview,
3182       tool_button_camera_preview_toggled_cb, self);
3183   g_signal_handlers_block_by_func (priv->tool_button_camera_on,
3184       tool_button_camera_on_toggled_cb, self);
3185   g_signal_handlers_block_by_func (priv->action_camera_on,
3186       action_camera_change_cb, self);
3187 }
3188
3189 static void
3190 unblock_camera_control_signals (EmpathyStreamedMediaWindow *self)
3191 {
3192   EmpathyStreamedMediaWindowPriv *priv = GET_PRIV (self);
3193
3194   g_signal_handlers_unblock_by_func (priv->tool_button_camera_off,
3195       tool_button_camera_off_toggled_cb, self);
3196   g_signal_handlers_unblock_by_func (priv->tool_button_camera_preview,
3197       tool_button_camera_preview_toggled_cb, self);
3198   g_signal_handlers_unblock_by_func (priv->tool_button_camera_on,
3199       tool_button_camera_on_toggled_cb, self);
3200   g_signal_handlers_unblock_by_func (priv->action_camera_on,
3201       action_camera_change_cb, self);
3202 }