#include <gst/farsight/fs-utils.h>
#include <libempathy/empathy-camera-monitor.h>
+#include <libempathy/empathy-gsettings.h>
#include <libempathy/empathy-tp-contact-factory.h>
#include <libempathy/empathy-utils.h>
+
#include <libempathy-gtk/empathy-avatar-image.h>
#include <libempathy-gtk/empathy-ui-utils.h>
#include <libempathy-gtk/empathy-sound-manager.h>
#include "empathy-audio-src.h"
#include "empathy-audio-sink.h"
#include "empathy-video-src.h"
-#include "ev-sidebar.h"
#define CONTENT_HBOX_BORDER_WIDTH 6
#define CONTENT_HBOX_SPACING 3
#define REMOTE_CONTACT_AVATAR_DEFAULT_HEIGHT \
EMPATHY_VIDEO_WIDGET_DEFAULT_HEIGHT
+#define SMALL_TOOLBAR_SIZE 36
+
/* If an video input error occurs, the error message will start with "v4l" */
#define VIDEO_INPUT_ERROR_PREFIX "v4l"
ClutterActor *preview_hidden_button;
GtkWidget *video_container;
GtkWidget *remote_user_avatar_widget;
- GtkWidget *sidebar;
- GtkWidget *statusbar;
- GtkWidget *volume_button;
- GtkWidget *redial_button;
+ GtkWidget *remote_user_avatar_toolbar;
+ GtkWidget *remote_user_name_toolbar;
+ GtkWidget *status_label;
+ GtkWidget *hangup_button;
+ GtkWidget *audio_call_button;
+ GtkWidget *video_call_button;
GtkWidget *mic_button;
GtkWidget *camera_button;
GtkWidget *dialpad_button;
GtkWidget *toolbar;
+ GtkWidget *bottom_toolbar;
GtkWidget *pane;
- GtkAction *redial;
- GtkAction *menu_sidebar;
GtkAction *menu_fullscreen;
/* The box that contains self and remote avatar and video
guint bus_message_source_id;
gdouble volume;
- GtkWidget *volume_scale;
- GtkWidget *volume_progress_bar;
- GtkAdjustment *audio_input_adj;
GtkWidget *dtmf_panel;
GList *notifiers;
- guint context_id;
-
GTimer *timer;
guint timer_id;
- GtkWidget *video_contrast;
- GtkWidget *video_brightness;
- GtkWidget *video_gamma;
-
GMutex *lock;
gboolean call_started;
gboolean sending_video;
/* Those fields represent the state of the window before it actually was in
fullscreen mode. */
- gboolean sidebar_was_visible_before_fs;
+ gboolean dialpad_was_visible_before_fs;
gint original_width_before_fs;
gint original_height_before_fs;
- gint x, y, w, h, sidebar_width;
+ gint x, y, w, h, dialpad_width;
gboolean maximized;
/* TRUE if the call should be started when the pipeline is playing */
gboolean pipeline_playing;
EmpathySoundManager *sound_mgr;
+
+ GSettings *settings;
};
#define GET_PRIV(o) (EMPATHY_CALL_WINDOW (o)->priv)
static void empathy_call_window_mic_toggled_cb (
GtkToggleToolButton *toggle, EmpathyCallWindow *window);
-static void empathy_call_window_sidebar_cb (GtkToggleAction *menu,
- EmpathyCallWindow *self);
-
-static void empathy_call_window_sidebar_hidden_cb (EvSidebar *sidebar,
- EmpathyCallWindow *window);
-
-static void empathy_call_window_sidebar_shown_cb (EvSidebar *sidebar,
- EmpathyCallWindow *window);
-
-static void empathy_call_window_sidebar_changed_cb (EvSidebar *sidebar,
- const gchar *page,
- EmpathyCallWindow *window);
-
static void empathy_call_window_hangup_cb (gpointer object,
EmpathyCallWindow *window);
static void empathy_call_window_video_menu_popup (EmpathyCallWindow *window,
guint button);
-static void empathy_call_window_redial_cb (gpointer object,
- EmpathyCallWindow *window);
-
static void empathy_call_window_dialpad_cb (GtkToggleToolButton *button,
EmpathyCallWindow *window);
gdouble value, EmpathyCallWindow *window);
static void
-empathy_call_window_setup_toolbar (EmpathyCallWindow *self)
+empathy_call_window_show_hangup_button (EmpathyCallWindow *self,
+ gboolean show)
{
- EmpathyCallWindowPriv *priv = GET_PRIV (self);
- GtkToolItem *tool_item;
-
- /* Add an empty expanded GtkToolItem so the volume button is at the end of
- * the toolbar. */
- tool_item = gtk_tool_item_new ();
- gtk_tool_item_set_expand (tool_item, TRUE);
- gtk_widget_show (GTK_WIDGET (tool_item));
- gtk_toolbar_insert (GTK_TOOLBAR (priv->toolbar), tool_item, -1);
+ gtk_widget_set_visible (self->priv->hangup_button, show);
+ gtk_widget_set_visible (self->priv->audio_call_button, !show);
+ gtk_widget_set_visible (self->priv->video_call_button, !show);
+}
- priv->volume_button = gtk_volume_button_new ();
- /* FIXME listen to the audiosinks signals and update the button according to
- * that, for now starting out at 1.0 and assuming only the app changes the
- * volume will do */
- gtk_scale_button_set_value (GTK_SCALE_BUTTON (priv->volume_button), 1.0);
- g_signal_connect (G_OBJECT (priv->volume_button), "value-changed",
- G_CALLBACK (empathy_call_window_volume_changed_cb), self);
+static void
+empathy_call_window_audio_call_cb (GtkToggleToolButton *button,
+ EmpathyCallWindow *self)
+{
+ g_object_set (self->priv->handler, "initial-video", FALSE, NULL);
+ empathy_call_window_restart_call (self);
+}
- tool_item = gtk_tool_item_new ();
- gtk_container_add (GTK_CONTAINER (tool_item), priv->volume_button);
- gtk_widget_show_all (GTK_WIDGET (tool_item));
- gtk_toolbar_insert (GTK_TOOLBAR (priv->toolbar), tool_item, -1);
+static void
+empathy_call_window_video_call_cb (GtkToggleToolButton *button,
+ EmpathyCallWindow *self)
+{
+ empathy_call_window_set_send_video (self, CAMERA_STATE_ON);
+ g_object_set (self->priv->handler, "initial-video", TRUE, NULL);
+ empathy_call_window_restart_call (self);
}
static void
g_object_unref (call);
}
-static GtkWidget *
-empathy_call_window_create_video_input_add_slider (EmpathyCallWindow *self,
- gchar *label_text, GtkWidget *bin)
-{
- GtkWidget *vbox = gtk_vbox_new (FALSE, 2);
- GtkWidget *scale = gtk_vscale_new_with_range (0, 100, 10);
- GtkWidget *label = gtk_label_new (label_text);
-
- gtk_widget_set_sensitive (scale, FALSE);
-
- gtk_container_add (GTK_CONTAINER (bin), vbox);
-
- gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
- gtk_box_pack_start (GTK_BOX (vbox), scale, TRUE, TRUE, 0);
- gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
-
- return scale;
-}
-
-static void
-empathy_call_window_video_contrast_changed_cb (GtkAdjustment *adj,
- EmpathyCallWindow *self)
-
-{
- EmpathyCallWindowPriv *priv = GET_PRIV (self);
-
- empathy_video_src_set_channel (priv->video_input,
- EMPATHY_GST_VIDEO_SRC_CHANNEL_CONTRAST, gtk_adjustment_get_value (adj));
-}
-
-static void
-empathy_call_window_video_brightness_changed_cb (GtkAdjustment *adj,
- EmpathyCallWindow *self)
-
-{
- EmpathyCallWindowPriv *priv = GET_PRIV (self);
-
- empathy_video_src_set_channel (priv->video_input,
- EMPATHY_GST_VIDEO_SRC_CHANNEL_BRIGHTNESS, gtk_adjustment_get_value (adj));
-}
-
-static void
-empathy_call_window_video_gamma_changed_cb (GtkAdjustment *adj,
- EmpathyCallWindow *self)
-
-{
- EmpathyCallWindowPriv *priv = GET_PRIV (self);
-
- empathy_video_src_set_channel (priv->video_input,
- EMPATHY_GST_VIDEO_SRC_CHANNEL_GAMMA, gtk_adjustment_get_value (adj));
-}
-
-
-static GtkWidget *
-empathy_call_window_create_video_input (EmpathyCallWindow *self)
-{
- EmpathyCallWindowPriv *priv = GET_PRIV (self);
- GtkWidget *hbox;
-
- hbox = gtk_hbox_new (TRUE, 3);
-
- priv->video_contrast = empathy_call_window_create_video_input_add_slider (
- self, _("Contrast"), hbox);
-
- priv->video_brightness = empathy_call_window_create_video_input_add_slider (
- self, _("Brightness"), hbox);
-
- priv->video_gamma = empathy_call_window_create_video_input_add_slider (
- self, _("Gamma"), hbox);
-
- return hbox;
-}
-
-static void
-empathy_call_window_setup_video_input (EmpathyCallWindow *self)
-{
- EmpathyCallWindowPriv *priv = GET_PRIV (self);
- guint supported;
- GtkAdjustment *adj;
-
- supported = empathy_video_src_get_supported_channels (priv->video_input);
-
- if (supported & EMPATHY_GST_VIDEO_SRC_SUPPORTS_CONTRAST)
- {
- adj = gtk_range_get_adjustment (GTK_RANGE (priv->video_contrast));
-
- gtk_adjustment_set_value (adj,
- empathy_video_src_get_channel (priv->video_input,
- EMPATHY_GST_VIDEO_SRC_CHANNEL_CONTRAST));
-
- g_signal_connect (G_OBJECT (adj), "value-changed",
- G_CALLBACK (empathy_call_window_video_contrast_changed_cb), self);
-
- gtk_widget_set_sensitive (priv->video_contrast, TRUE);
- }
-
- if (supported & EMPATHY_GST_VIDEO_SRC_SUPPORTS_BRIGHTNESS)
- {
- adj = gtk_range_get_adjustment (GTK_RANGE (priv->video_brightness));
-
- gtk_adjustment_set_value (adj,
- empathy_video_src_get_channel (priv->video_input,
- EMPATHY_GST_VIDEO_SRC_CHANNEL_BRIGHTNESS));
-
- g_signal_connect (G_OBJECT (adj), "value-changed",
- G_CALLBACK (empathy_call_window_video_brightness_changed_cb), self);
- gtk_widget_set_sensitive (priv->video_brightness, TRUE);
- }
-
- if (supported & EMPATHY_GST_VIDEO_SRC_SUPPORTS_GAMMA)
- {
- adj = gtk_range_get_adjustment (GTK_RANGE (priv->video_gamma));
-
- gtk_adjustment_set_value (adj,
- empathy_video_src_get_channel (priv->video_input,
- EMPATHY_GST_VIDEO_SRC_CHANNEL_GAMMA));
-
- g_signal_connect (G_OBJECT (adj), "value-changed",
- G_CALLBACK (empathy_call_window_video_gamma_changed_cb), self);
- gtk_widget_set_sensitive (priv->video_gamma, TRUE);
- }
-}
-
static void
-empathy_call_window_mic_volume_changed_cb (GtkAdjustment *adj,
- EmpathyCallWindow *self)
+empathy_call_window_mic_volume_changed (EmpathyCallWindow *self)
{
EmpathyCallWindowPriv *priv = GET_PRIV (self);
gdouble volume;
- volume = gtk_adjustment_get_value (adj)/100.0;
+ volume = g_settings_get_double (priv->settings,
+ EMPATHY_PREFS_CALL_SOUND_VOLUME) / 100.0;
/* Don't store the volume because of muting */
if (volume > 0 || gtk_toggle_tool_button_get_active (
}
static void
-empathy_call_window_audio_input_level_changed_cb (EmpathyGstAudioSrc *src,
- gdouble level, EmpathyCallWindow *window)
-{
- gdouble value;
- EmpathyCallWindowPriv *priv = GET_PRIV (window);
-
- value = CLAMP (pow (10, level / 20), 0.0, 1.0);
- gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (priv->volume_progress_bar),
- value);
-}
-
-static GtkWidget *
-empathy_call_window_create_audio_input (EmpathyCallWindow *self)
+empathy_call_window_prefs_volume_changed_cb (GSettings *settings,
+ gchar *key,
+ EmpathyCallWindow *self)
{
- EmpathyCallWindowPriv *priv = GET_PRIV (self);
- GtkWidget *hbox, *vbox, *label;
-
- hbox = gtk_hbox_new (TRUE, 3);
-
- vbox = gtk_vbox_new (FALSE, 3);
- gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 3);
-
- priv->volume_scale = gtk_vscale_new_with_range (0, 150, 100);
- gtk_range_set_inverted (GTK_RANGE (priv->volume_scale), TRUE);
- label = gtk_label_new (_("Volume"));
-
- priv->audio_input_adj = gtk_range_get_adjustment (
- GTK_RANGE (priv->volume_scale));
- priv->volume = empathy_audio_src_get_volume (EMPATHY_GST_AUDIO_SRC
- (priv->audio_input));
- gtk_adjustment_set_value (priv->audio_input_adj, priv->volume * 100);
-
- g_signal_connect (G_OBJECT (priv->audio_input_adj), "value-changed",
- G_CALLBACK (empathy_call_window_mic_volume_changed_cb), self);
-
- gtk_box_pack_start (GTK_BOX (vbox), priv->volume_scale, TRUE, TRUE, 3);
- gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 3);
-
- priv->volume_progress_bar = gtk_progress_bar_new ();
-
- gtk_orientable_set_orientation (GTK_ORIENTABLE (priv->volume_progress_bar),
- GTK_ORIENTATION_VERTICAL);
-
- gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (priv->volume_progress_bar),
- 0);
-
- gtk_box_pack_start (GTK_BOX (hbox), priv->volume_progress_bar, FALSE, FALSE,
- 3);
-
- return hbox;
+ empathy_call_window_mic_volume_changed (self);
}
static void
priv->audio_input = empathy_audio_src_new ();
gst_object_ref (priv->audio_input);
gst_object_sink (priv->audio_input);
-
- tp_g_signal_connect_object (priv->audio_input, "peak-level-changed",
- G_CALLBACK (empathy_call_window_audio_input_level_changed_cb),
- self, 0);
}
static void
gtk_window_get_position (GTK_WINDOW (self), &self->priv->x, &self->priv->y);
gtk_window_get_size (GTK_WINDOW (self), &self->priv->w, &self->priv->h);
- gtk_widget_get_preferred_width (self->priv->sidebar,
- &self->priv->sidebar_width, NULL);
+ gtk_widget_get_preferred_width (self->priv->dtmf_panel,
+ &self->priv->dialpad_width, NULL);
gdk_window = gtk_widget_get_window (widget);
window_state = gdk_window_get_state (gdk_window);
empathy_call_window_destroyed_cb (GtkWidget *object,
EmpathyCallWindow *self)
{
- if (gtk_widget_get_visible (self->priv->sidebar))
+ if (gtk_widget_get_visible (self->priv->dtmf_panel))
{
- /* Save the geometry as if the sidebar was hidden. */
+ /* Save the geometry as if the dialpad was hidden. */
empathy_geometry_save_values (GTK_WINDOW (self),
self->priv->x, self->priv->y,
- self->priv->w - self->priv->sidebar_width, self->priv->h,
+ self->priv->w - self->priv->dialpad_width, self->priv->h,
self->priv->maximized);
}
}
EmpathyCallWindowPriv *priv;
GtkBuilder *gui;
GtkWidget *top_vbox;
- GtkWidget *page;
gchar *filename;
- GtkWidget *scroll;
ClutterConstraint *size_constraint;
ClutterActor *remote_avatar;
GtkStyleContext *context;
"call_window_vbox", &top_vbox,
"errors_vbox", &priv->errors_vbox,
"pane", &priv->pane,
- "statusbar", &priv->statusbar,
- "redial", &priv->redial_button,
+ "remote_user_name_toolbar", &priv->remote_user_name_toolbar,
+ "remote_user_avatar_toolbar", &priv->remote_user_avatar_toolbar,
+ "status_label", &priv->status_label,
+ "audiocall", &priv->audio_call_button,
+ "videocall", &priv->video_call_button,
"microphone", &priv->mic_button,
"camera", &priv->camera_button,
+ "hangup", &priv->hangup_button,
"dialpad", &priv->dialpad_button,
"toolbar", &priv->toolbar,
- "menuredial", &priv->redial,
- "menusidebar", &priv->menu_sidebar,
+ "bottom_toolbar", &priv->bottom_toolbar,
"ui_manager", &priv->ui_manager,
"menufullscreen", &priv->menu_fullscreen,
"details_vbox", &priv->details_vbox,
empathy_builder_connect (gui, self,
"menuhangup", "activate", empathy_call_window_hangup_cb,
"hangup", "clicked", empathy_call_window_hangup_cb,
- "menuredial", "activate", empathy_call_window_redial_cb,
- "redial", "clicked", empathy_call_window_redial_cb,
- "menusidebar", "toggled", empathy_call_window_sidebar_cb,
+ "audiocall", "clicked", empathy_call_window_audio_call_cb,
+ "videocall", "clicked", empathy_call_window_video_call_cb,
+ "volume", "value-changed", empathy_call_window_volume_changed_cb,
"microphone", "toggled", empathy_call_window_mic_toggled_cb,
"camera", "toggled", empathy_call_window_camera_toggled_cb,
"dialpad", "toggled", empathy_call_window_dialpad_cb,
priv->content_hbox = gtk_hbox_new (FALSE, CONTENT_HBOX_SPACING);
gtk_container_set_border_width (GTK_CONTAINER (priv->content_hbox),
CONTENT_HBOX_BORDER_WIDTH);
- gtk_paned_pack1 (GTK_PANED (priv->pane), priv->content_hbox, TRUE, FALSE);
+ gtk_box_pack_start (GTK_BOX (priv->pane), priv->content_hbox,
+ TRUE, TRUE, 0);
/* avatar/video box */
priv->video_layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
/* The call will be started as soon the pipeline is playing */
priv->start_call_when_playing = TRUE;
- empathy_call_window_setup_toolbar (self);
-
- priv->sidebar = ev_sidebar_new ();
- g_signal_connect (G_OBJECT (priv->sidebar),
- "hide", G_CALLBACK (empathy_call_window_sidebar_hidden_cb), self);
- g_signal_connect (G_OBJECT (priv->sidebar),
- "show", G_CALLBACK (empathy_call_window_sidebar_shown_cb), self);
- g_signal_connect (G_OBJECT (priv->sidebar), "changed",
- G_CALLBACK (empathy_call_window_sidebar_changed_cb), self);
- gtk_paned_pack2 (GTK_PANED (priv->pane), priv->sidebar, FALSE, FALSE);
-
- page = empathy_call_window_create_audio_input (self);
- ev_sidebar_add_page (EV_SIDEBAR (priv->sidebar), "audio-input",
- _("Audio input"), page);
-
- page = empathy_call_window_create_video_input (self);
- ev_sidebar_add_page (EV_SIDEBAR (priv->sidebar), "video-input",
- _("Video input"), page);
-
priv->dtmf_panel = empathy_create_dtmf_dialpad (G_OBJECT (self),
G_CALLBACK (dtmf_button_pressed_cb),
G_CALLBACK (dtmf_button_released_cb));
- ev_sidebar_add_page (EV_SIDEBAR (priv->sidebar), "dialpad",
- _("Dialpad"), priv->dtmf_panel);
- gtk_widget_set_sensitive (priv->dtmf_panel, FALSE);
+ gtk_box_pack_start (GTK_BOX (priv->pane), priv->dtmf_panel,
+ FALSE, FALSE, 0);
- /* Put the details vbox in a scroll window as it can require a lot of
- * horizontal space. */
- scroll = gtk_scrolled_window_new (NULL, NULL);
- gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scroll),
- priv->details_vbox);
+ gtk_box_pack_start (GTK_BOX (priv->pane), priv->details_vbox,
+ FALSE, FALSE, 0);
- ev_sidebar_add_page (EV_SIDEBAR (priv->sidebar), "details", _("Details"),
- scroll);
+ gtk_widget_set_sensitive (priv->dtmf_panel, FALSE);
gtk_widget_show_all (top_vbox);
- gtk_widget_hide (priv->sidebar);
+ gtk_widget_hide (priv->dtmf_panel);
+ gtk_widget_hide (priv->details_vbox);
priv->fullscreen = empathy_call_window_fullscreen_new (self);
priv->sound_mgr = empathy_sound_manager_dup_singleton ();
+ empathy_call_window_show_hangup_button (self, TRUE);
+
+ priv->settings = g_settings_new (EMPATHY_PREFS_CALL_SCHEMA);
+ g_signal_connect (priv->settings, "changed::"EMPATHY_PREFS_CALL_SOUND_VOLUME,
+ G_CALLBACK (empathy_call_window_prefs_volume_changed_cb), self);
+
empathy_geometry_bind (GTK_WINDOW (self), "call-window");
/* These signals are used to track the window position and save it
* when the window is destroyed. We need to do this as we don't want
- * the window geometry to be saved with the sidebar taken into account. */
+ * the window geometry to be saved with the dialpad taken into account. */
g_signal_connect (self, "destroy",
G_CALLBACK (empathy_call_window_destroyed_cb), self);
g_signal_connect (self, "configure-event",
}
}
+static void
+set_remote_user_name (EmpathyCallWindow *self,
+ EmpathyContact *contact)
+{
+ const gchar *alias = empathy_contact_get_alias (contact);
+ const gchar *status = empathy_contact_get_status (contact);
+ gchar *label;
+
+ label = g_strdup_printf ("%s\n<small>%s</small>", alias, status);
+ gtk_label_set_markup (GTK_LABEL (self->priv->remote_user_name_toolbar),
+ label);
+ g_free (label);
+}
+
static void
contact_name_changed_cb (EmpathyContact *contact,
- GParamSpec *pspec, EmpathyCallWindow *self)
+ GParamSpec *pspec,
+ EmpathyCallWindow *self)
{
set_window_title (self);
+ set_remote_user_name (self, contact);
+}
+
+static void
+contact_presence_changed_cb (EmpathyContact *contact,
+ GParamSpec *pspec,
+ EmpathyCallWindow *self)
+{
+ set_remote_user_name (self, contact);
}
static void
contact_avatar_changed_cb (EmpathyContact *contact,
- GParamSpec *pspec, GtkWidget *avatar_widget)
+ GParamSpec *pspec,
+ EmpathyCallWindow *self)
{
int size;
GtkAllocation allocation;
+ GtkWidget *avatar_widget;
+
+ avatar_widget = self->priv->remote_user_avatar_widget;
gtk_widget_get_allocation (avatar_widget, &allocation);
size = allocation.height;
}
init_contact_avatar_with_size (contact, avatar_widget, size);
+
+ avatar_widget = self->priv->remote_user_avatar_toolbar;
+
+ gtk_widget_get_allocation (avatar_widget, &allocation);
+ size = allocation.height;
+
+ if (size == 0)
+ {
+ /* the widget is not allocated yet, set a default size */
+ size = SMALL_TOOLBAR_SIZE;
+ }
+
+ init_contact_avatar_with_size (contact, avatar_widget, size);
}
static void
{
EmpathyCallWindowPriv *priv = GET_PRIV (self);
- g_signal_connect (priv->contact, "notify::name",
- G_CALLBACK (contact_name_changed_cb), self);
- g_signal_connect (priv->contact, "notify::avatar",
- G_CALLBACK (contact_avatar_changed_cb),
- priv->remote_user_avatar_widget);
+ tp_g_signal_connect_object (priv->contact, "notify::name",
+ G_CALLBACK (contact_name_changed_cb), self, 0);
+ tp_g_signal_connect_object (priv->contact, "notify::avatar",
+ G_CALLBACK (contact_avatar_changed_cb), self, 0);
+ tp_g_signal_connect_object (priv->contact, "notify::presence",
+ G_CALLBACK (contact_presence_changed_cb), self, 0);
set_window_title (self);
+ set_remote_user_name (self, priv->contact);
init_contact_avatar_with_size (priv->contact,
priv->remote_user_avatar_widget,
MIN (REMOTE_CONTACT_AVATAR_DEFAULT_WIDTH,
REMOTE_CONTACT_AVATAR_DEFAULT_HEIGHT));
+ init_contact_avatar_with_size (priv->contact,
+ priv->remote_user_avatar_toolbar,
+ SMALL_TOOLBAR_SIZE);
+
/* The remote avatar is shown by default and will be hidden when we receive
video from the remote side. */
clutter_actor_hide (priv->video_output);
tp_clear_object (&priv->ui_manager);
tp_clear_object (&priv->fullscreen);
tp_clear_object (&priv->camera_monitor);
+ tp_clear_object (&priv->settings);
g_list_free_full (priv->notifiers, g_object_unref);
g_object_unref (priv->pipeline);
priv->pipeline = NULL;
- g_signal_handlers_disconnect_by_func (priv->audio_input_adj,
- empathy_call_window_mic_volume_changed_cb, self);
-
if (priv->audio_output != NULL)
g_object_unref (priv->audio_output);
priv->audio_output = NULL;
empathy_call_window_status_message (self, _("Disconnected"));
- gtk_action_set_sensitive (priv->redial, TRUE);
- gtk_widget_set_sensitive (priv->redial_button, TRUE);
+ empathy_call_window_show_hangup_button (self, FALSE);
/* Unsensitive the camera and mic button */
gtk_widget_set_sensitive (priv->camera_button, FALSE);
display_video_preview (self, TRUE);
}
- gtk_progress_bar_set_fraction (
- GTK_PROGRESS_BAR (priv->volume_progress_bar), 0);
-
/* destroy the video output; it will be recreated when we'll redial */
disconnect_video_output_motion_handler (self);
if (priv->video_output != NULL)
gtk_widget_set_sensitive (priv->camera_button, can_send_video);
- gtk_action_set_sensitive (priv->redial, FALSE);
- gtk_widget_set_sensitive (priv->redial_button, FALSE);
+ empathy_call_window_show_hangup_button (self, TRUE);
gtk_widget_set_sensitive (priv->mic_button, TRUE);
if (GST_MESSAGE_SRC (message) == GST_OBJECT (priv->video_input))
{
gst_message_parse_state_changed (message, NULL, &newstate, NULL);
- if (newstate == GST_STATE_PAUSED)
- empathy_call_window_setup_video_input (self);
}
if (GST_MESSAGE_SRC (message) == GST_OBJECT (priv->pipeline) &&
!priv->call_started)
{
EmpathyCallWindowPriv *priv = GET_PRIV (window);
TpyCallChannel *call;
+ gint width;
+
+ /* Make the hangup button twice as wide */
+ width = gtk_widget_get_allocated_width (priv->hangup_button);
+ gtk_widget_set_size_request (priv->hangup_button, width * 2, -1);
g_signal_connect (priv->handler, "state-changed",
G_CALLBACK (empathy_call_window_state_changed_cb), window);
if (set_fullscreen)
{
- gtk_widget_hide (priv->sidebar);
+ gtk_widget_hide (priv->dtmf_panel);
gtk_widget_hide (menu);
- gtk_widget_hide (priv->statusbar);
gtk_widget_hide (priv->toolbar);
}
else
{
- if (priv->sidebar_was_visible_before_fs)
- gtk_widget_show (priv->sidebar);
+ if (priv->dialpad_was_visible_before_fs)
+ gtk_widget_show (priv->dtmf_panel);
gtk_widget_show (menu);
- gtk_widget_show (priv->statusbar);
gtk_widget_show (priv->toolbar);
gtk_window_resize (GTK_WINDOW (window), priv->original_width_before_fs,
if (set_fullscreen)
{
- gboolean sidebar_was_visible;
+ gboolean dialpad_was_visible;
GtkAllocation allocation;
gint original_width, original_height;
original_width = allocation.width;
original_height = allocation.height;
- g_object_get (priv->sidebar, "visible", &sidebar_was_visible, NULL);
+ g_object_get (priv->dtmf_panel,
+ "visible", &dialpad_was_visible,
+ NULL);
- priv->sidebar_was_visible_before_fs = sidebar_was_visible;
+ priv->dialpad_was_visible_before_fs = dialpad_was_visible;
priv->original_width_before_fs = original_width;
priv->original_height_before_fs = original_height;
}
static void
-empathy_call_window_update_sidebar_buttons (EmpathyCallWindow *window,
- gboolean toggled)
-{
- EmpathyCallWindowPriv *priv = GET_PRIV (window);
-
- /* Update dialpad button */
- g_signal_handlers_block_by_func (priv->dialpad_button,
- empathy_call_window_dialpad_cb, window);
- gtk_toggle_tool_button_set_active (
- GTK_TOGGLE_TOOL_BUTTON (priv->dialpad_button),
- toggled);
- g_signal_handlers_unblock_by_func (priv->dialpad_button,
- empathy_call_window_dialpad_cb, window);
-
- /* Update sidebar menu */
- g_signal_handlers_block_by_func (priv->menu_sidebar,
- empathy_call_window_sidebar_cb, window);
- gtk_toggle_action_set_active (
- GTK_TOGGLE_ACTION (priv->menu_sidebar),
- gtk_widget_get_visible (priv->sidebar));
- g_signal_handlers_unblock_by_func (priv->menu_sidebar,
- empathy_call_window_sidebar_cb, window);
-}
-
-static void
-empathy_call_window_show_sidebar (EmpathyCallWindow *window,
+empathy_call_window_show_dialpad (EmpathyCallWindow *window,
gboolean active)
{
EmpathyCallWindowPriv *priv = GET_PRIV (window);
- int w, h, sidebar_width, handle_size;
+ int w, h, dialpad_width;
GtkAllocation allocation;
- gchar *page;
- gboolean dialpad_shown;
gtk_widget_get_allocation (GTK_WIDGET (window), &allocation);
w = allocation.width;
h = allocation.height;
- gtk_widget_style_get (priv->pane, "handle_size", &handle_size, NULL);
-
- gtk_widget_get_preferred_width (priv->sidebar, &sidebar_width, NULL);
+ gtk_widget_get_preferred_width (priv->dtmf_panel, &dialpad_width, NULL);
if (active)
{
- gtk_widget_show (priv->sidebar);
- w += sidebar_width + handle_size;
+ gtk_widget_show (priv->dtmf_panel);
+ w += dialpad_width;
}
else
{
- w -= sidebar_width + handle_size;
- gtk_widget_hide (priv->sidebar);
+ w -= dialpad_width;
+ gtk_widget_hide (priv->dtmf_panel);
}
if (w > 0 && h > 0)
gtk_window_resize (GTK_WINDOW (window), w, h);
-
- /* Update the 'Dialpad' menu */
- page = ev_sidebar_get_current_page (EV_SIDEBAR (priv->sidebar));
- dialpad_shown = active && !tp_strdiff (page, "dialpad");
- g_free (page);
-
- empathy_call_window_update_sidebar_buttons (window, dialpad_shown);
}
static void
if (active)
{
- empathy_audio_src_set_volume (EMPATHY_GST_AUDIO_SRC (priv->audio_input),
- priv->volume);
- gtk_adjustment_set_value (priv->audio_input_adj, priv->volume * 100);
+ g_settings_set_double (priv->settings, EMPATHY_PREFS_CALL_SOUND_VOLUME,
+ priv->volume * 100);
}
else
{
* sides mute at the same time on certain CMs AFAIK. Need to revisit this
* in the future. GNOME #574574
*/
- empathy_audio_src_set_volume (EMPATHY_GST_AUDIO_SRC (priv->audio_input),
- 0);
- gtk_adjustment_set_value (priv->audio_input_adj, 0);
+ g_settings_set_double (priv->settings, EMPATHY_PREFS_CALL_SOUND_VOLUME,
+ 0);
}
}
-static void
-empathy_call_window_sidebar_hidden_cb (EvSidebar *sidebar,
- EmpathyCallWindow *window)
-{
- empathy_call_window_show_sidebar (window, FALSE);
-}
-
-static void
-empathy_call_window_sidebar_shown_cb (EvSidebar *sidebar,
- EmpathyCallWindow *window)
-{
- empathy_call_window_show_sidebar (window, TRUE);
-}
-
-static void
-empathy_call_window_sidebar_changed_cb (EvSidebar *sidebar,
- const gchar *page,
- EmpathyCallWindow *window)
-{
- empathy_call_window_update_sidebar_buttons (window,
- !tp_strdiff (page, "dialpad"));
-}
-
static void
empathy_call_window_hangup_cb (gpointer object,
EmpathyCallWindow *window)
create_video_output_widget (window);
- g_signal_connect (G_OBJECT (priv->audio_input_adj), "value-changed",
- G_CALLBACK (empathy_call_window_mic_volume_changed_cb), window);
-
/* While the call was disconnected, the input volume might have changed.
* However, since the audio_input source was destroyed, its volume has not
* been updated during that time. That's why we manually update it here */
- empathy_call_window_mic_volume_changed_cb (priv->audio_input_adj, window);
+ empathy_call_window_mic_volume_changed (window);
priv->outgoing = TRUE;
empathy_call_window_set_state_connecting (window);
/* call will be started when the pipeline is ready */
priv->start_call_when_playing = TRUE;
-
empathy_call_window_setup_avatars (window, priv->handler);
- gtk_action_set_sensitive (priv->redial, FALSE);
- gtk_widget_set_sensitive (priv->redial_button, FALSE);
-}
-
-static void
-empathy_call_window_redial_cb (gpointer object,
- EmpathyCallWindow *window)
-{
- EmpathyCallWindowPriv *priv = GET_PRIV (window);
-
- if (priv->call_state == CONNECTED)
- priv->call_state = REDIALING;
-
- empathy_call_handler_stop_call (priv->handler);
-
- if (priv->call_state != CONNECTED)
- empathy_call_window_restart_call (window);
+ empathy_call_window_show_hangup_button (window, TRUE);
}
static void
empathy_call_window_dialpad_cb (GtkToggleToolButton *button,
EmpathyCallWindow *window)
{
- EmpathyCallWindowPriv *priv = GET_PRIV (window);
gboolean active;
active = gtk_toggle_tool_button_get_active (button);
- if (active)
- ev_sidebar_set_current_page (EV_SIDEBAR (priv->sidebar), "dialpad");
-
- empathy_call_window_show_sidebar (window, active);
-}
-
-static void
-empathy_call_window_sidebar_cb (GtkToggleAction *menu,
- EmpathyCallWindow *self)
-{
- empathy_call_window_show_sidebar (self,
- gtk_toggle_action_get_active (menu));
+ empathy_call_window_show_dialpad (window, active);
}
static void
}
static void
-empathy_call_window_status_message (EmpathyCallWindow *window,
+empathy_call_window_status_message (EmpathyCallWindow *self,
gchar *message)
{
- EmpathyCallWindowPriv *priv = GET_PRIV (window);
-
- if (priv->context_id == 0)
- {
- priv->context_id = gtk_statusbar_get_context_id (
- GTK_STATUSBAR (priv->statusbar), "voip call status messages");
- }
- else
- {
- gtk_statusbar_pop (GTK_STATUSBAR (priv->statusbar), priv->context_id);
- }
-
- gtk_statusbar_push (GTK_STATUSBAR (priv->statusbar), priv->context_id,
- message);
+ gtk_label_set_label (GTK_LABEL (self->priv->status_label), message);
}
static void
projects / empathy.git / blobdiff