2 * empathy-call-window.c - Source for EmpathyCallWindow
3 * Copyright (C) 2008 Collabora Ltd.
4 * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk>
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.
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.
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
29 #include <glib/gi18n.h>
31 #include <telepathy-farsight/channel.h>
33 #include <libempathy/empathy-utils.h>
34 #include <libempathy-gtk/empathy-video-widget.h>
35 #include <libempathy-gtk/empathy-audio-src.h>
36 #include <libempathy-gtk/empathy-audio-sink.h>
37 #include <libempathy-gtk/empathy-video-src.h>
38 #include <libempathy-gtk/empathy-ui-utils.h>
40 #include "empathy-call-window.h"
42 #include "empathy-sidebar.h"
44 #define BUTTON_ID "empathy-call-dtmf-button-id"
46 G_DEFINE_TYPE(EmpathyCallWindow, empathy_call_window, GTK_TYPE_WINDOW)
55 static guint signals[LAST_SIGNAL] = {0};
59 PROP_CALL_HANDLER = 1,
62 /* private structure */
63 typedef struct _EmpathyCallWindowPriv EmpathyCallWindowPriv;
65 struct _EmpathyCallWindowPriv
67 gboolean dispose_has_run;
68 EmpathyCallHandler *handler;
72 GtkUIManager *ui_manager;
73 GtkWidget *video_output;
74 GtkWidget *video_preview;
76 GtkWidget *sidebar_button;
78 GtkWidget *volume_button;
79 GtkWidget *mic_button;
80 GtkWidget *camera_button;
83 GtkAction *send_video;
86 GtkAdjustment *audio_input_adj;
88 GtkWidget *dtmf_panel;
90 GstElement *video_input;
91 GstElement *audio_input;
92 GstElement *audio_output;
94 GstElement *video_tee;
97 GstElement *liveadder;
104 GtkWidget *video_contrast;
105 GtkWidget *video_brightness;
106 GtkWidget *video_gamma;
109 gboolean call_started;
110 gboolean sending_video;
113 #define GET_PRIV(o) \
114 (G_TYPE_INSTANCE_GET_PRIVATE ((o), EMPATHY_TYPE_CALL_WINDOW, \
115 EmpathyCallWindowPriv))
117 static void empathy_call_window_realized_cb (GtkWidget *widget,
118 EmpathyCallWindow *window);
120 static gboolean empathy_call_window_delete_cb (GtkWidget *widget,
121 GdkEvent*event, EmpathyCallWindow *window);
123 static void empathy_call_window_sidebar_toggled_cb (GtkToggleButton *toggle,
124 EmpathyCallWindow *window);
126 static void empathy_call_window_camera_toggled_cb (GtkToggleToolButton *toggle,
127 EmpathyCallWindow *window);
129 static void empathy_call_window_send_video_toggled_cb (GtkToggleAction *toggle,
130 EmpathyCallWindow *window);
132 static void empathy_call_window_show_preview_toggled_cb (GtkToggleAction *toggle,
133 EmpathyCallWindow *window);
135 static void empathy_call_window_mic_toggled_cb (
136 GtkToggleToolButton *toggle, EmpathyCallWindow *window);
138 static void empathy_call_window_sidebar_hidden_cb (EmpathySidebar *sidebar,
139 EmpathyCallWindow *window);
141 static void empathy_call_window_hangup_cb (gpointer object,
142 EmpathyCallWindow *window);
144 static void empathy_call_window_status_message (EmpathyCallWindow *window,
147 static gboolean empathy_call_window_bus_message (GstBus *bus,
148 GstMessage *message, gpointer user_data);
151 empathy_call_window_volume_changed_cb (GtkScaleButton *button,
152 gdouble value, EmpathyCallWindow *window);
155 empathy_call_window_setup_toolbar (EmpathyCallWindow *self)
157 EmpathyCallWindowPriv *priv = GET_PRIV (self);
158 GtkToolItem *tool_item;
160 /* Add an empty expanded GtkToolItem so the volume button is at the end of
162 tool_item = gtk_tool_item_new ();
163 gtk_tool_item_set_expand (tool_item, TRUE);
164 gtk_widget_show (GTK_WIDGET (tool_item));
165 gtk_toolbar_insert (GTK_TOOLBAR (priv->toolbar), tool_item, -1);
167 priv->volume_button = gtk_volume_button_new ();
168 /* FIXME listen to the audiosinks signals and update the button according to
169 * that, for now starting out at 1.0 and assuming only the app changes the
171 gtk_scale_button_set_value (GTK_SCALE_BUTTON (priv->volume_button), 1.0);
172 g_signal_connect (G_OBJECT (priv->volume_button), "value-changed",
173 G_CALLBACK (empathy_call_window_volume_changed_cb), self);
175 tool_item = gtk_tool_item_new ();
176 gtk_container_add (GTK_CONTAINER (tool_item), priv->volume_button);
177 gtk_widget_show_all (GTK_WIDGET (tool_item));
178 gtk_toolbar_insert (GTK_TOOLBAR (priv->toolbar), tool_item, -1);
182 dtmf_button_pressed_cb (GtkButton *button, EmpathyCallWindow *window)
184 EmpathyCallWindowPriv *priv = GET_PRIV (window);
189 g_object_get (priv->handler, "tp-call", &call, NULL);
191 button_quark = g_quark_from_static_string (BUTTON_ID);
192 event = GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (button),
195 empathy_tp_call_start_tone (call, event);
197 g_object_unref (call);
201 dtmf_button_released_cb (GtkButton *button, EmpathyCallWindow *window)
203 EmpathyCallWindowPriv *priv = GET_PRIV (window);
206 g_object_get (priv->handler, "tp-call", &call, NULL);
208 empathy_tp_call_stop_tone (call);
210 g_object_unref (call);
214 empathy_call_window_create_dtmf (EmpathyCallWindow *self)
222 } dtmfbuttons[] = { { "1", TP_DTMF_EVENT_DIGIT_1 },
223 { "2", TP_DTMF_EVENT_DIGIT_2 },
224 { "3", TP_DTMF_EVENT_DIGIT_3 },
225 { "4", TP_DTMF_EVENT_DIGIT_4 },
226 { "5", TP_DTMF_EVENT_DIGIT_5 },
227 { "6", TP_DTMF_EVENT_DIGIT_6 },
228 { "7", TP_DTMF_EVENT_DIGIT_7 },
229 { "8", TP_DTMF_EVENT_DIGIT_8 },
230 { "9", TP_DTMF_EVENT_DIGIT_9 },
231 { "#", TP_DTMF_EVENT_HASH },
232 { "0", TP_DTMF_EVENT_DIGIT_0 },
233 { "*", TP_DTMF_EVENT_ASTERISK },
236 button_quark = g_quark_from_static_string (BUTTON_ID);
238 table = gtk_table_new (4, 3, TRUE);
240 for (i = 0; dtmfbuttons[i].label != NULL; i++)
242 GtkWidget *button = gtk_button_new_with_label (dtmfbuttons[i].label);
243 gtk_table_attach (GTK_TABLE (table), button, i % 3, i % 3 + 1,
244 i/3, i/3 + 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 1, 1);
246 g_object_set_qdata (G_OBJECT (button), button_quark,
247 GUINT_TO_POINTER (dtmfbuttons[i].event));
249 g_signal_connect (G_OBJECT (button), "pressed",
250 G_CALLBACK (dtmf_button_pressed_cb), self);
251 g_signal_connect (G_OBJECT (button), "released",
252 G_CALLBACK (dtmf_button_released_cb), self);
259 empathy_call_window_create_video_input_add_slider (EmpathyCallWindow *self,
260 gchar *label_text, GtkWidget *bin)
262 GtkWidget *vbox = gtk_vbox_new (FALSE, 2);
263 GtkWidget *scale = gtk_vscale_new_with_range (0, 100, 10);
264 GtkWidget *label = gtk_label_new (label_text);
266 gtk_widget_set_sensitive (scale, FALSE);
268 gtk_container_add (GTK_CONTAINER (bin), vbox);
270 gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
271 gtk_box_pack_start (GTK_BOX (vbox), scale, TRUE, TRUE, 0);
272 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
278 empathy_call_window_video_contrast_changed_cb (GtkAdjustment *adj,
279 EmpathyCallWindow *self)
282 EmpathyCallWindowPriv *priv = GET_PRIV (self);
284 empathy_video_src_set_channel (priv->video_input,
285 EMPATHY_GST_VIDEO_SRC_CHANNEL_CONTRAST, gtk_adjustment_get_value (adj));
289 empathy_call_window_video_brightness_changed_cb (GtkAdjustment *adj,
290 EmpathyCallWindow *self)
293 EmpathyCallWindowPriv *priv = GET_PRIV (self);
295 empathy_video_src_set_channel (priv->video_input,
296 EMPATHY_GST_VIDEO_SRC_CHANNEL_BRIGHTNESS, gtk_adjustment_get_value (adj));
300 empathy_call_window_video_gamma_changed_cb (GtkAdjustment *adj,
301 EmpathyCallWindow *self)
304 EmpathyCallWindowPriv *priv = GET_PRIV (self);
306 empathy_video_src_set_channel (priv->video_input,
307 EMPATHY_GST_VIDEO_SRC_CHANNEL_GAMMA, gtk_adjustment_get_value (adj));
312 empathy_call_window_create_video_input (EmpathyCallWindow *self)
314 EmpathyCallWindowPriv *priv = GET_PRIV (self);
317 hbox = gtk_hbox_new (TRUE, 3);
319 priv->video_contrast = empathy_call_window_create_video_input_add_slider (
320 self, _("Contrast"), hbox);
322 priv->video_brightness = empathy_call_window_create_video_input_add_slider (
323 self, _("Brightness"), hbox);
325 priv->video_gamma = empathy_call_window_create_video_input_add_slider (
326 self, _("Gamma"), hbox);
332 empathy_call_window_setup_video_input (EmpathyCallWindow *self)
334 EmpathyCallWindowPriv *priv = GET_PRIV (self);
338 supported = empathy_video_src_get_supported_channels (priv->video_input);
340 if (supported & EMPATHY_GST_VIDEO_SRC_SUPPORTS_CONTRAST)
342 adj = gtk_range_get_adjustment (GTK_RANGE (priv->video_contrast));
344 gtk_adjustment_set_value (adj,
345 empathy_video_src_get_channel (priv->video_input,
346 EMPATHY_GST_VIDEO_SRC_CHANNEL_CONTRAST));
348 g_signal_connect (G_OBJECT (adj), "value-changed",
349 G_CALLBACK (empathy_call_window_video_contrast_changed_cb), self);
351 gtk_widget_set_sensitive (priv->video_contrast, TRUE);
354 if (supported & EMPATHY_GST_VIDEO_SRC_SUPPORTS_BRIGHTNESS)
356 adj = gtk_range_get_adjustment (GTK_RANGE (priv->video_brightness));
358 gtk_adjustment_set_value (adj,
359 empathy_video_src_get_channel (priv->video_input,
360 EMPATHY_GST_VIDEO_SRC_CHANNEL_BRIGHTNESS));
362 g_signal_connect (G_OBJECT (adj), "value-changed",
363 G_CALLBACK (empathy_call_window_video_brightness_changed_cb), self);
364 gtk_widget_set_sensitive (priv->video_brightness, TRUE);
367 if (supported & EMPATHY_GST_VIDEO_SRC_SUPPORTS_GAMMA)
369 adj = gtk_range_get_adjustment (GTK_RANGE (priv->video_gamma));
371 gtk_adjustment_set_value (adj,
372 empathy_video_src_get_channel (priv->video_input,
373 EMPATHY_GST_VIDEO_SRC_CHANNEL_GAMMA));
375 g_signal_connect (G_OBJECT (adj), "value-changed",
376 G_CALLBACK (empathy_call_window_video_gamma_changed_cb), self);
377 gtk_widget_set_sensitive (priv->video_gamma, TRUE);
382 empathy_call_window_mic_volume_changed_cb (GtkAdjustment *adj,
383 EmpathyCallWindow *self)
385 EmpathyCallWindowPriv *priv = GET_PRIV (self);
388 volume = gtk_adjustment_get_value (adj)/100.0;
390 /* Don't store the volume because of muting */
391 if (volume > 0 || gtk_toggle_tool_button_get_active (
392 GTK_TOGGLE_TOOL_BUTTON (priv->mic_button)))
393 priv->volume = volume;
395 /* Ensure that the toggle button is active if the volume is > 0 and inactive
396 * if it's smaller then 0 */
397 if ((volume > 0) != gtk_toggle_tool_button_get_active (
398 GTK_TOGGLE_TOOL_BUTTON (priv->mic_button)))
399 gtk_toggle_tool_button_set_active (
400 GTK_TOGGLE_TOOL_BUTTON (priv->mic_button), volume > 0);
402 empathy_audio_src_set_volume (EMPATHY_GST_AUDIO_SRC (priv->audio_input),
407 empathy_call_window_audio_input_level_changed_cb (EmpathyGstAudioSrc *src,
408 gdouble level, GtkProgressBar *bar)
412 value = CLAMP (pow (10, level / 20), 0.0, 1.0);
413 gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (bar), value);
417 empathy_call_window_create_audio_input (EmpathyCallWindow *self)
419 EmpathyCallWindowPriv *priv = GET_PRIV (self);
420 GtkWidget *hbox, *vbox, *scale, *progress, *label;
423 hbox = gtk_hbox_new (TRUE, 3);
425 vbox = gtk_vbox_new (FALSE, 3);
426 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 3);
428 scale = gtk_vscale_new_with_range (0, 150, 100);
429 gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
430 label = gtk_label_new (_("Volume"));
432 priv->audio_input_adj = adj = gtk_range_get_adjustment (GTK_RANGE (scale));
433 priv->volume = empathy_audio_src_get_volume (EMPATHY_GST_AUDIO_SRC
434 (priv->audio_input));
435 gtk_adjustment_set_value (adj, priv->volume * 100);
437 g_signal_connect (G_OBJECT (adj), "value-changed",
438 G_CALLBACK (empathy_call_window_mic_volume_changed_cb), self);
440 gtk_box_pack_start (GTK_BOX (vbox), scale, TRUE, TRUE, 3);
441 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 3);
443 progress = gtk_progress_bar_new ();
444 gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (progress),
445 GTK_PROGRESS_BOTTOM_TO_TOP);
446 gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress), 0);
448 g_signal_connect (priv->audio_input, "peak-level-changed",
449 G_CALLBACK (empathy_call_window_audio_input_level_changed_cb), progress);
451 gtk_box_pack_start (GTK_BOX (hbox), progress, FALSE, FALSE, 3);
457 empathy_call_window_init (EmpathyCallWindow *self)
459 EmpathyCallWindowPriv *priv = GET_PRIV (self);
461 GtkWidget *vbox, *top_vbox;
468 filename = empathy_file_lookup ("empathy-call-window.ui", "src");
469 gui = empathy_builder_get_file (filename,
470 "call_window_vbox", &top_vbox,
472 "statusbar", &priv->statusbar,
473 "microphone", &priv->mic_button,
474 "camera", &priv->camera_button,
475 "toolbar", &priv->toolbar,
476 "send_video", &priv->send_video,
477 "ui_manager", &priv->ui_manager,
480 empathy_builder_connect (gui, self,
481 "menuhangup", "activate", empathy_call_window_hangup_cb,
482 "hangup", "clicked", empathy_call_window_hangup_cb,
483 "microphone", "toggled", empathy_call_window_mic_toggled_cb,
484 "camera", "toggled", empathy_call_window_camera_toggled_cb,
485 "send_video", "toggled", empathy_call_window_send_video_toggled_cb,
486 "show_preview", "toggled", empathy_call_window_show_preview_toggled_cb,
489 priv->lock = g_mutex_new ();
491 gtk_container_add (GTK_CONTAINER (self), top_vbox);
493 empathy_call_window_setup_toolbar (self);
495 priv->pipeline = gst_pipeline_new (NULL);
497 hbox = gtk_hbox_new (FALSE, 3);
498 gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
499 gtk_paned_pack1 (GTK_PANED (priv->pane), hbox, TRUE, FALSE);
501 bus = gst_pipeline_get_bus (GST_PIPELINE (priv->pipeline));
503 gst_bus_add_watch (bus, empathy_call_window_bus_message, self);
505 priv->video_output = empathy_video_widget_new (bus);
506 gtk_box_pack_start (GTK_BOX (hbox), priv->video_output, TRUE, TRUE, 3);
508 priv->video_tee = gst_element_factory_make ("tee", NULL);
509 gst_object_ref (priv->video_tee);
510 gst_object_sink (priv->video_tee);
512 vbox = gtk_vbox_new (FALSE, 3);
513 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 3);
515 priv->video_preview = empathy_video_widget_new_with_size (bus, 160, 120);
516 g_object_set (priv->video_preview, "sync", FALSE, "async", TRUE, NULL);
517 gtk_box_pack_start (GTK_BOX (vbox), priv->video_preview, FALSE, FALSE, 0);
519 priv->video_input = empathy_video_src_new ();
520 gst_object_ref (priv->video_input);
521 gst_object_sink (priv->video_input);
523 priv->audio_input = empathy_audio_src_new ();
524 gst_object_ref (priv->audio_input);
525 gst_object_sink (priv->audio_input);
527 priv->audio_output = empathy_audio_sink_new ();
528 gst_object_ref (priv->audio_output);
529 gst_object_sink (priv->audio_output);
531 g_object_unref (bus);
533 priv->sidebar_button = gtk_toggle_button_new_with_mnemonic (_("_Sidebar"));
534 arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
535 g_signal_connect (G_OBJECT (priv->sidebar_button), "toggled",
536 G_CALLBACK (empathy_call_window_sidebar_toggled_cb), self);
538 gtk_button_set_image (GTK_BUTTON (priv->sidebar_button), arrow);
540 h = gtk_hbox_new (FALSE, 3);
541 gtk_box_pack_end (GTK_BOX (vbox), h, FALSE, FALSE, 3);
542 gtk_box_pack_end (GTK_BOX (h), priv->sidebar_button, FALSE, FALSE, 3);
544 priv->sidebar = empathy_sidebar_new ();
545 g_signal_connect (G_OBJECT (priv->sidebar),
546 "hide", G_CALLBACK (empathy_call_window_sidebar_hidden_cb),
548 gtk_paned_pack2 (GTK_PANED (priv->pane), priv->sidebar, FALSE, FALSE);
550 priv->dtmf_panel = empathy_call_window_create_dtmf (self);
551 empathy_sidebar_add_page (EMPATHY_SIDEBAR (priv->sidebar), _("Dialpad"),
554 gtk_widget_set_sensitive (priv->dtmf_panel, FALSE);
556 page = empathy_call_window_create_audio_input (self);
557 empathy_sidebar_add_page (EMPATHY_SIDEBAR (priv->sidebar), _("Audio input"),
560 page = empathy_call_window_create_video_input (self);
561 empathy_sidebar_add_page (EMPATHY_SIDEBAR (priv->sidebar), _("Video input"),
564 gtk_widget_show_all (top_vbox);
566 gtk_widget_hide (priv->sidebar);
568 g_signal_connect (G_OBJECT (self), "realize",
569 G_CALLBACK (empathy_call_window_realized_cb), self);
571 g_signal_connect (G_OBJECT (self), "delete-event",
572 G_CALLBACK (empathy_call_window_delete_cb), self);
574 empathy_call_window_status_message (self, _("Connecting..."));
576 priv->timer = g_timer_new ();
578 g_object_ref (priv->ui_manager);
579 g_object_unref (gui);
582 static void empathy_call_window_dispose (GObject *object);
583 static void empathy_call_window_finalize (GObject *object);
586 empathy_call_window_set_property (GObject *object,
587 guint property_id, const GValue *value, GParamSpec *pspec)
589 EmpathyCallWindowPriv *priv = GET_PRIV (object);
593 case PROP_CALL_HANDLER:
594 priv->handler = g_value_dup_object (value);
597 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
602 empathy_call_window_get_property (GObject *object,
603 guint property_id, GValue *value, GParamSpec *pspec)
605 EmpathyCallWindowPriv *priv = GET_PRIV (object);
609 case PROP_CALL_HANDLER:
610 g_value_set_object (value, priv->handler);
613 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
618 empathy_call_window_class_init (
619 EmpathyCallWindowClass *empathy_call_window_class)
621 GObjectClass *object_class = G_OBJECT_CLASS (empathy_call_window_class);
622 GParamSpec *param_spec;
624 g_type_class_add_private (empathy_call_window_class,
625 sizeof (EmpathyCallWindowPriv));
627 object_class->set_property = empathy_call_window_set_property;
628 object_class->get_property = empathy_call_window_get_property;
630 object_class->dispose = empathy_call_window_dispose;
631 object_class->finalize = empathy_call_window_finalize;
633 param_spec = g_param_spec_object ("handler",
634 "handler", "The call handler",
635 EMPATHY_TYPE_CALL_HANDLER,
636 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
637 g_object_class_install_property (object_class,
638 PROP_CALL_HANDLER, param_spec);
643 empathy_call_window_dispose (GObject *object)
645 EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (object);
646 EmpathyCallWindowPriv *priv = GET_PRIV (self);
648 if (priv->dispose_has_run)
651 priv->dispose_has_run = TRUE;
653 if (priv->handler != NULL)
654 g_object_unref (priv->handler);
656 priv->handler = NULL;
658 if (priv->pipeline != NULL)
659 g_object_unref (priv->pipeline);
660 priv->pipeline = NULL;
662 if (priv->video_input != NULL)
663 g_object_unref (priv->video_input);
664 priv->video_input = NULL;
666 if (priv->audio_input != NULL)
667 g_object_unref (priv->audio_input);
668 priv->audio_input = NULL;
670 if (priv->audio_output != NULL)
671 g_object_unref (priv->audio_output);
672 priv->audio_output = NULL;
674 if (priv->video_tee != NULL)
675 g_object_unref (priv->video_tee);
676 priv->video_tee = NULL;
678 if (priv->timer_id != 0)
679 g_source_remove (priv->timer_id);
682 if (priv->ui_manager != NULL)
683 g_object_unref (priv->ui_manager);
684 priv->ui_manager = NULL;
686 /* release any references held by the object here */
687 if (G_OBJECT_CLASS (empathy_call_window_parent_class)->dispose)
688 G_OBJECT_CLASS (empathy_call_window_parent_class)->dispose (object);
692 empathy_call_window_finalize (GObject *object)
694 EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (object);
695 EmpathyCallWindowPriv *priv = GET_PRIV (self);
697 /* free any data held directly by the object here */
698 g_mutex_free (priv->lock);
700 g_timer_destroy (priv->timer);
702 G_OBJECT_CLASS (empathy_call_window_parent_class)->finalize (object);
707 empathy_call_window_new (EmpathyCallHandler *handler)
709 return EMPATHY_CALL_WINDOW (
710 g_object_new (EMPATHY_TYPE_CALL_WINDOW, "handler", handler, NULL));
714 empathy_call_window_conference_added_cb (EmpathyCallHandler *handler,
715 GstElement *conference, gpointer user_data)
717 EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (user_data);
718 EmpathyCallWindowPriv *priv = GET_PRIV (self);
720 gst_bin_add (GST_BIN (priv->pipeline), conference);
722 gst_element_set_state (conference, GST_STATE_PLAYING);
726 empathy_call_window_request_resource_cb (EmpathyCallHandler *handler,
727 FsMediaType type, FsStreamDirection direction, gpointer user_data)
729 EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (user_data);
730 EmpathyCallWindowPriv *priv = GET_PRIV (self);
732 if (type != TP_MEDIA_STREAM_TYPE_VIDEO)
735 if (direction == FS_DIRECTION_RECV)
738 /* video and direction is send */
739 return priv->video_input != NULL;
743 empathy_call_window_disconnected (EmpathyCallWindow *self)
745 EmpathyCallWindowPriv *priv = GET_PRIV (self);
747 g_mutex_lock (priv->lock);
749 g_timer_stop (priv->timer);
751 if (priv->timer_id != 0)
752 g_source_remove (priv->timer_id);
755 g_mutex_unlock (priv->lock);
757 empathy_call_window_status_message (self, _("Disconnected"));
759 gtk_widget_set_sensitive (priv->camera_button, FALSE);
760 gtk_action_set_sensitive (priv->send_video, FALSE);
761 priv->sending_video = FALSE;
766 empathy_call_window_channel_closed_cb (TfChannel *channel, gpointer user_data)
768 EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (user_data);
770 empathy_call_window_disconnected (self);
773 /* Called with global lock held */
775 empathy_call_window_get_video_sink_pad (EmpathyCallWindow *self)
777 EmpathyCallWindowPriv *priv = GET_PRIV (self);
780 if (priv->funnel == NULL)
784 output = empathy_video_widget_get_element (EMPATHY_VIDEO_WIDGET
785 (priv->video_output));
787 priv->funnel = gst_element_factory_make ("fsfunnel", NULL);
789 gst_bin_add (GST_BIN (priv->pipeline), priv->funnel);
790 gst_bin_add (GST_BIN (priv->pipeline), output);
792 gst_element_link (priv->funnel, output);
794 gst_element_set_state (priv->funnel, GST_STATE_PLAYING);
795 gst_element_set_state (output, GST_STATE_PLAYING);
798 pad = gst_element_get_request_pad (priv->funnel, "sink%d");
803 /* Called with global lock held */
805 empathy_call_window_get_audio_sink_pad (EmpathyCallWindow *self)
807 EmpathyCallWindowPriv *priv = GET_PRIV (self);
810 if (priv->liveadder == NULL)
812 priv->liveadder = gst_element_factory_make ("liveadder", NULL);
814 gst_bin_add (GST_BIN (priv->pipeline), priv->liveadder);
815 gst_bin_add (GST_BIN (priv->pipeline), priv->audio_output);
817 gst_element_link (priv->liveadder, priv->audio_output);
819 gst_element_set_state (priv->liveadder, GST_STATE_PLAYING);
820 gst_element_set_state (priv->audio_output, GST_STATE_PLAYING);
823 pad = gst_element_get_request_pad (priv->liveadder, "sink%d");
829 empathy_call_window_update_timer (gpointer user_data)
831 EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (user_data);
832 EmpathyCallWindowPriv *priv = GET_PRIV (self);
836 time = g_timer_elapsed (priv->timer, NULL);
838 /* Translators: number of minutes:seconds the caller has been connected */
839 str = g_strdup_printf (_("Connected — %d:%02dm"), (int) time / 60,
841 empathy_call_window_status_message (self, str);
848 empathy_call_window_connected (gpointer user_data)
850 EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (user_data);
851 EmpathyCallWindowPriv *priv = GET_PRIV (self);
854 g_object_get (priv->handler, "tp-call", &call, NULL);
856 if (empathy_tp_call_has_dtmf (call))
857 gtk_widget_set_sensitive (priv->dtmf_panel, TRUE);
859 if (priv->video_input != NULL)
861 gtk_widget_set_sensitive (priv->camera_button, TRUE);
862 gtk_action_set_sensitive (priv->send_video, TRUE);
865 g_object_unref (call);
867 g_mutex_lock (priv->lock);
869 priv->timer_id = g_timeout_add_seconds (1,
870 empathy_call_window_update_timer, self);
872 g_mutex_unlock (priv->lock);
874 empathy_call_window_update_timer (self);
880 /* Called from the streaming thread */
882 empathy_call_window_src_added_cb (EmpathyCallHandler *handler,
883 GstPad *src, guint media_type, gpointer user_data)
885 EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (user_data);
886 EmpathyCallWindowPriv *priv = GET_PRIV (self);
890 g_mutex_lock (priv->lock);
892 if (priv->connected == FALSE)
894 g_timer_start (priv->timer);
895 priv->timer_id = g_idle_add (empathy_call_window_connected, self);
896 priv->connected = TRUE;
901 case TP_MEDIA_STREAM_TYPE_AUDIO:
902 pad = empathy_call_window_get_audio_sink_pad (self);
904 case TP_MEDIA_STREAM_TYPE_VIDEO:
905 pad = empathy_call_window_get_video_sink_pad (self);
908 g_assert_not_reached ();
911 gst_pad_link (src, pad);
912 gst_object_unref (pad);
914 g_mutex_unlock (priv->lock);
917 /* Called from the streaming thread */
919 empathy_call_window_sink_added_cb (EmpathyCallHandler *handler,
920 GstPad *sink, guint media_type, gpointer user_data)
922 EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (user_data);
923 EmpathyCallWindowPriv *priv = GET_PRIV (self);
928 case TP_MEDIA_STREAM_TYPE_AUDIO:
929 gst_bin_add (GST_BIN (priv->pipeline), priv->audio_input);
931 pad = gst_element_get_static_pad (priv->audio_input, "src");
932 gst_pad_link (pad, sink);
934 gst_element_set_state (priv->audio_input, GST_STATE_PLAYING);
936 case TP_MEDIA_STREAM_TYPE_VIDEO:
937 if (priv->video_input != NULL)
939 pad = gst_element_get_request_pad (priv->video_tee, "src%d");
940 gst_pad_link (pad, sink);
944 g_assert_not_reached ();
950 empathy_gst_bin_has_child (GstBin *bin, GstElement *element)
953 gboolean ret = FALSE;
956 it = gst_bin_iterate_recurse (bin);
960 switch (gst_iterator_next (it, (gpointer *)&item))
962 case GST_ITERATOR_OK:
965 gst_object_unref (GST_OBJECT (item));
969 gst_object_unref (GST_OBJECT (item));
971 case GST_ITERATOR_RESYNC:
972 gst_iterator_resync (it);
974 case GST_ITERATOR_ERROR:
975 g_assert_not_reached ();
977 case GST_ITERATOR_DONE:
982 gst_iterator_free (it);
989 empathy_call_window_remove_video_input (EmpathyCallWindow *self)
991 EmpathyCallWindowPriv *priv = GET_PRIV (self);
994 preview = empathy_video_widget_get_element (
995 EMPATHY_VIDEO_WIDGET (priv->video_preview));
997 gst_element_set_state (priv->video_input, GST_STATE_NULL);
998 gst_element_set_state (priv->video_tee, GST_STATE_NULL);
999 gst_element_set_state (preview, GST_STATE_NULL);
1001 gst_bin_remove_many (GST_BIN (priv->pipeline), priv->video_input,
1002 priv->video_tee, preview, NULL);
1004 g_object_unref (priv->video_input);
1005 priv->video_input = NULL;
1006 g_object_unref (priv->video_tee);
1007 priv->video_tee = NULL;
1012 empathy_call_window_bus_message (GstBus *bus, GstMessage *message,
1015 EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (user_data);
1016 EmpathyCallWindowPriv *priv = GET_PRIV (self);
1019 empathy_call_handler_bus_message (priv->handler, bus, message);
1021 switch (GST_MESSAGE_TYPE (message))
1023 case GST_MESSAGE_STATE_CHANGED:
1024 if (GST_MESSAGE_SRC (message) == GST_OBJECT (priv->video_input))
1026 gst_message_parse_state_changed (message, NULL, &newstate, NULL);
1027 if (newstate == GST_STATE_PAUSED)
1028 empathy_call_window_setup_video_input (self);
1030 if (GST_MESSAGE_SRC (message) == GST_OBJECT (priv->pipeline) &&
1031 !priv->call_started)
1033 gst_message_parse_state_changed (message, NULL, &newstate, NULL);
1034 if (newstate == GST_STATE_PAUSED)
1036 priv->call_started = TRUE;
1037 empathy_call_handler_start_call (priv->handler);
1038 gst_element_set_state (priv->pipeline, GST_STATE_PLAYING);
1042 case GST_MESSAGE_ERROR:
1047 gst_message_parse_error (message, &error, &debug);
1049 g_message ("Element error: %s -- %s\n", error->message, debug);
1051 if (priv->video_input != NULL &&
1052 empathy_gst_bin_has_child (GST_BIN (priv->video_input),
1053 GST_ELEMENT (GST_MESSAGE_SRC (message))))
1055 /* Remove the video input and continue */
1056 empathy_call_window_remove_video_input (self);
1057 gst_element_set_state (priv->pipeline, GST_STATE_PAUSED);
1061 gst_element_set_state (priv->pipeline, GST_STATE_NULL);
1062 empathy_call_window_disconnected (self);
1064 g_error_free (error);
1075 empathy_call_window_realized_cb (GtkWidget *widget, EmpathyCallWindow *window)
1077 EmpathyCallWindowPriv *priv = GET_PRIV (window);
1078 GstElement *preview;
1080 g_signal_connect (priv->handler, "conference-added",
1081 G_CALLBACK (empathy_call_window_conference_added_cb), window);
1082 g_signal_connect (priv->handler, "request-resource",
1083 G_CALLBACK (empathy_call_window_request_resource_cb), window);
1084 g_signal_connect (priv->handler, "closed",
1085 G_CALLBACK (empathy_call_window_channel_closed_cb), window);
1086 g_signal_connect (priv->handler, "src-pad-added",
1087 G_CALLBACK (empathy_call_window_src_added_cb), window);
1088 g_signal_connect (priv->handler, "sink-pad-added",
1089 G_CALLBACK (empathy_call_window_sink_added_cb), window);
1092 preview = empathy_video_widget_get_element (
1093 EMPATHY_VIDEO_WIDGET (priv->video_preview));
1095 gst_bin_add_many (GST_BIN (priv->pipeline), priv->video_input,
1096 priv->video_tee, preview, NULL);
1097 gst_element_link_many (priv->video_input, priv->video_tee,
1100 gst_element_set_state (priv->pipeline, GST_STATE_PAUSED);
1104 empathy_call_window_delete_cb (GtkWidget *widget, GdkEvent*event,
1105 EmpathyCallWindow *window)
1107 EmpathyCallWindowPriv *priv = GET_PRIV (window);
1109 gst_element_set_state (priv->pipeline, GST_STATE_NULL);
1115 empathy_call_window_sidebar_toggled_cb (GtkToggleButton *toggle,
1116 EmpathyCallWindow *window)
1118 EmpathyCallWindowPriv *priv = GET_PRIV (window);
1120 int w,h, handle_size;
1122 w = GTK_WIDGET (window)->allocation.width;
1123 h = GTK_WIDGET (window)->allocation.height;
1125 gtk_widget_style_get (priv->pane, "handle_size", &handle_size, NULL);
1127 if (gtk_toggle_button_get_active (toggle))
1129 arrow = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_NONE);
1130 gtk_widget_show (priv->sidebar);
1131 w += priv->sidebar->allocation.width + handle_size;
1135 arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
1136 w -= priv->sidebar->allocation.width + handle_size;
1137 gtk_widget_hide (priv->sidebar);
1140 gtk_button_set_image (GTK_BUTTON (priv->sidebar_button), arrow);
1143 gtk_window_resize (GTK_WINDOW (window), w, h);
1147 empathy_call_window_set_send_video (EmpathyCallWindow *window,
1150 EmpathyCallWindowPriv *priv = GET_PRIV (window);
1151 EmpathyTpCall *call;
1153 g_object_get (priv->handler, "tp-call", &call, NULL);
1154 empathy_tp_call_request_video_stream_direction (call, send);
1155 g_object_unref (call);
1159 empathy_call_window_camera_toggled_cb (GtkToggleToolButton *toggle,
1160 EmpathyCallWindow *window)
1162 EmpathyCallWindowPriv *priv = GET_PRIV (window);
1165 active = (gtk_toggle_tool_button_get_active (toggle));
1167 if (priv->sending_video == active)
1169 priv->sending_video = active;
1171 empathy_call_window_set_send_video (window, active);
1172 gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (priv->send_video), active);
1176 empathy_call_window_send_video_toggled_cb (GtkToggleAction *toggle,
1177 EmpathyCallWindow *window)
1179 EmpathyCallWindowPriv *priv = GET_PRIV (window);
1182 active = (gtk_toggle_action_get_active (toggle));
1184 if (priv->sending_video == active)
1186 priv->sending_video = active;
1188 empathy_call_window_set_send_video (window, active);
1189 gtk_toggle_tool_button_set_active (
1190 GTK_TOGGLE_TOOL_BUTTON (priv->camera_button), active);
1194 empathy_call_window_show_preview_toggled_cb (GtkToggleAction *toggle,
1195 EmpathyCallWindow *window)
1197 /* FIXME: Not implemented */
1201 empathy_call_window_mic_toggled_cb (GtkToggleToolButton *toggle,
1202 EmpathyCallWindow *window)
1204 EmpathyCallWindowPriv *priv = GET_PRIV (window);
1207 active = (gtk_toggle_tool_button_get_active (toggle));
1211 empathy_audio_src_set_volume (EMPATHY_GST_AUDIO_SRC (priv->audio_input),
1213 gtk_adjustment_set_value (priv->audio_input_adj, priv->volume * 100);
1217 /* TODO, Instead of setting the input volume to 0 we should probably
1218 * stop sending but this would cause the audio call to drop if both
1219 * sides mute at the same time on certain CMs AFAIK. Need to revisit this
1220 * in the future. GNOME #574574
1222 empathy_audio_src_set_volume (EMPATHY_GST_AUDIO_SRC (priv->audio_input),
1224 gtk_adjustment_set_value (priv->audio_input_adj, 0);
1229 empathy_call_window_sidebar_hidden_cb (EmpathySidebar *sidebar,
1230 EmpathyCallWindow *window)
1232 EmpathyCallWindowPriv *priv = GET_PRIV (window);
1234 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->sidebar_button),
1239 empathy_call_window_hangup_cb (gpointer object,
1240 EmpathyCallWindow *window)
1242 EmpathyCallWindowPriv *priv = GET_PRIV (window);
1244 gst_element_set_state (priv->pipeline, GST_STATE_NULL);
1245 gtk_widget_destroy (GTK_WIDGET (window));
1249 empathy_call_window_status_message (EmpathyCallWindow *window,
1252 EmpathyCallWindowPriv *priv = GET_PRIV (window);
1254 if (priv->context_id == 0)
1256 priv->context_id = gtk_statusbar_get_context_id (
1257 GTK_STATUSBAR (priv->statusbar), "voip call status messages");
1261 gtk_statusbar_pop (GTK_STATUSBAR (priv->statusbar), priv->context_id);
1264 gtk_statusbar_push (GTK_STATUSBAR (priv->statusbar), priv->context_id,
1269 empathy_call_window_volume_changed_cb (GtkScaleButton *button,
1270 gdouble value, EmpathyCallWindow *window)
1272 EmpathyCallWindowPriv *priv = GET_PRIV (window);
1274 empathy_audio_sink_set_volume (EMPATHY_GST_AUDIO_SINK (priv->audio_output),