*/
#include "config.h"
+#include "empathy-call-window.h"
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <math.h>
-
-#include <gdk/gdkkeysyms.h>
-#include <gst/gst.h>
-#include <gtk/gtk.h>
#include <glib/gi18n.h>
-
-#include <clutter/clutter.h>
-#include <clutter-gtk/clutter-gtk.h>
-#include <clutter-gst/clutter-gst.h>
-
-#include <telepathy-glib/util.h>
#include <telepathy-farstream/telepathy-farstream.h>
-#include <telepathy-glib/util.h>
-
-#include <gst/farsight/fs-element-added-notifier.h>
-#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-request-util.h>
-#include <libempathy/empathy-utils.h>
-
-#include <libempathy-gtk/empathy-avatar-image.h>
-#include <libempathy-gtk/empathy-dialpad-widget.h>
-#include <libempathy-gtk/empathy-ui-utils.h>
-#include <libempathy-gtk/empathy-sound-manager.h>
-#include <libempathy-gtk/empathy-geometry.h>
-#include <libempathy-gtk/empathy-images.h>
+#include <farstream/fs-element-added-notifier.h>
+#include <farstream/fs-utils.h>
-#define DEBUG_FLAG EMPATHY_DEBUG_VOIP
-#include <libempathy/empathy-debug.h>
-
-#include "empathy-call-window.h"
-#include "empathy-call-window-fullscreen.h"
-#include "empathy-call-factory.h"
-#include "empathy-video-widget.h"
#include "empathy-about-dialog.h"
-#include "empathy-audio-src.h"
#include "empathy-audio-sink.h"
-#include "empathy-video-src.h"
+#include "empathy-call-utils.h"
+#include "empathy-call-window-fullscreen.h"
+#include "empathy-camera-menu.h"
+#include "empathy-camera-monitor.h"
+#include "empathy-dialpad-widget.h"
+#include "empathy-geometry.h"
+#include "empathy-gsettings.h"
+#include "empathy-images.h"
#include "empathy-mic-menu.h"
#include "empathy-preferences.h"
+#include "empathy-request-util.h"
#include "empathy-rounded-actor.h"
#include "empathy-rounded-rectangle.h"
#include "empathy-rounded-texture.h"
-#include "empathy-camera-menu.h"
+#include "empathy-sound-manager.h"
+#include "empathy-ui-utils.h"
+#include "empathy-utils.h"
+
+#define DEBUG_FLAG EMPATHY_DEBUG_VOIP
+#include "empathy-debug.h"
-#define CONTENT_HBOX_BORDER_WIDTH 6
#define CONTENT_HBOX_SPACING 3
-#define CONTENT_HBOX_CHILDREN_PACKING_PADDING 3
+#define CONTENT_HBOX_CHILDREN_PACKING_PADDING 0
+#define OVERLAY_MARGIN 6
+
+#define REMOTE_VIDEO_DEFAULT_WIDTH 320
+#define REMOTE_VIDEO_DEFAULT_HEIGHT 240
#define SELF_VIDEO_SECTION_WIDTH 120
#define SELF_VIDEO_SECTION_HEIGHT 90
-#define SELF_VIDEO_SECTION_MARGIN 10
-
-#define FLOATING_TOOLBAR_OPACITY 192
-#define FLOATING_TOOLBAR_WIDTH 280
-#define FLOATING_TOOLBAR_HEIGHT 36
-#define FLOATING_TOOLBAR_SPACING 20
+#define SELF_VIDEO_SECTION_MARGIN 2
+#define SELF_VIDEO_SECTION_BORDER SELF_VIDEO_SECTION_MARGIN*2
/* The avatar's default width and height are set to the same value because we
want a square icon. */
-#define REMOTE_CONTACT_AVATAR_DEFAULT_WIDTH EMPATHY_VIDEO_WIDGET_DEFAULT_HEIGHT
-#define REMOTE_CONTACT_AVATAR_DEFAULT_HEIGHT \
- EMPATHY_VIDEO_WIDGET_DEFAULT_HEIGHT
+#define REMOTE_CONTACT_AVATAR_DEFAULT_HEIGHT REMOTE_VIDEO_DEFAULT_HEIGHT
+#define REMOTE_CONTACT_AVATAR_DEFAULT_WIDTH REMOTE_VIDEO_DEFAULT_HEIGHT
#define SMALL_TOOLBAR_SIZE 36
/* The time interval in milliseconds between 2 outgoing rings */
#define MS_BETWEEN_RING 500
+/* The roundedness of preview box and placeholders */
+#define PREVIEW_ROUND_FACTOR 16
+
+#define PREVIEW_BUTTON_OPACITY 180
+
G_DEFINE_TYPE(EmpathyCallWindow, empathy_call_window, GTK_TYPE_WINDOW)
enum {
PROP_CALL_HANDLER = 1,
};
+enum {
+ SIG_INHIBIT,
+ LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL];
+
typedef enum {
RINGING, /* Incoming call */
CONNECTING, /* Outgoing call */
EmpathyCameraMonitor *camera_monitor;
- guint call_state;
+ CallState call_state;
gboolean outgoing;
GtkUIManager *ui_manager;
ClutterActor *preview_rectangle2;
ClutterActor *preview_rectangle3;
ClutterActor *preview_rectangle4;
- ClutterActor *preview_rectangle_box1;
- ClutterActor *preview_rectangle_box2;
- ClutterActor *preview_rectangle_box3;
- ClutterActor *preview_rectangle_box4;
ClutterActor *preview_spinner_actor;
GtkWidget *preview_spinner_widget;
GtkWidget *video_container;
GtkWidget *remote_user_avatar_widget;
GtkWidget *remote_user_avatar_toolbar;
GtkWidget *remote_user_name_toolbar;
+ GtkWidget *remote_user_status_toolbar;
GtkWidget *status_label;
GtkWidget *hangup_button;
GtkWidget *audio_call_button;
GtkWidget *video_call_button;
GtkWidget *mic_button;
+ GtkWidget *microphone_icon;
GtkWidget *volume_button;
GtkWidget *camera_button;
GtkWidget *dialpad_button;
ClutterState *transitions;
- /* The box that contains self and remote avatar and video
- input/output. When we redial, we destroy and re-create the box */
+ /* The main box covering all the stage, contaning remote avatar/video */
ClutterActor *video_box;
ClutterLayoutManager *video_layout;
+ /* A bin layout manager containing a bin for previews
+ * and the floating toolbar */
+ ClutterActor *overlay_bin;
+ ClutterLayoutManager *overlay_layout;
+
+ /* Bin layout for the previews */
+ ClutterActor *preview_box;
+ ClutterLayoutManager *preview_layout;
+
/* Coordinates of the preview drag event's start. */
PreviewPosition preview_pos;
/* These are used to accept or reject an incoming call when the status
is RINGING. */
GtkWidget *incoming_call_dialog;
- TpyCallChannel *pending_channel;
+ TpCallChannel *pending_channel;
TpChannelDispatchOperation *pending_cdo;
TpAddDispatchOperationContext *pending_context;
gulong video_output_motion_handler_id;
guint bus_message_source_id;
- /* String that contains the queued tones to send after the current ones
- are sent */
- GString *tones;
- gboolean sending_tones;
GtkWidget *dtmf_panel;
/* Details vbox */
GTimer *timer;
guint timer_id;
- GMutex *lock;
+ GMutex lock;
gboolean call_started;
gboolean sending_video;
CameraState camera_state;
GSettings *settings;
EmpathyMicMenu *mic_menu;
EmpathyCameraMenu *camera_menu;
+
+ gboolean muted;
};
#define GET_PRIV(o) (EMPATHY_CALL_WINDOW (o)->priv)
static gboolean empathy_call_window_bus_message (GstBus *bus,
GstMessage *message, gpointer user_data);
+static gboolean empathy_call_window_update_timer (gpointer user_data);
+
+static void
+make_background_transparent (GtkClutterActor *actor)
+{
+ GdkRGBA transparent = { 0., 0., 0., 0. };
+ GtkWidget *widget;
+
+ widget = gtk_clutter_actor_get_widget (actor);
+ gtk_widget_override_background_color (widget, GTK_STATE_FLAG_NORMAL, &transparent);
+}
+
static void
empathy_call_window_show_hangup_button (EmpathyCallWindow *self,
gboolean show)
empathy_call_window_restart_call (self);
}
-static void
-empathy_call_window_emit_tones (EmpathyCallWindow *self)
-{
- TpChannel *channel;
-
- if (tp_str_empty (self->priv->tones->str))
- return;
-
- g_object_get (self->priv->handler, "call-channel", &channel, NULL);
-
- DEBUG ("Emitting multiple tones: %s", self->priv->tones->str);
-
- tp_cli_channel_interface_dtmf_call_multiple_tones (channel, -1,
- self->priv->tones->str,
- NULL, NULL, NULL, NULL);
-
- self->priv->sending_tones = TRUE;
-
- g_string_set_size (self->priv->tones, 0);
-
- g_object_unref (channel);
-}
-
-static void
-empathy_call_window_maybe_emit_tones (EmpathyCallWindow *self)
-{
- if (self->priv->sending_tones)
- return;
-
- empathy_call_window_emit_tones (self);
-}
-
-static void
-empathy_call_window_tones_stopped_cb (TpChannel *proxy,
- gboolean arg_cancelled,
- gpointer user_data,
- GObject *weak_object)
-{
- EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (user_data);
-
- self->priv->sending_tones = FALSE;
-
- empathy_call_window_emit_tones (self);
-}
-
static void
dtmf_start_tone_cb (EmpathyDialpadWidget *dialpad,
TpDTMFEvent event,
EmpathyCallWindow *self)
{
- EmpathyCallWindowPriv *priv = GET_PRIV (self);
+ TpCallChannel *call;
+ gchar tones[2];
- g_string_append_c (priv->tones, tp_dtmf_event_to_char (event));
-
- empathy_call_window_maybe_emit_tones (self);
-}
+ g_object_get (self->priv->handler, "call-channel", &call, NULL);
-static void
-empathy_call_window_raise_actors (EmpathyCallWindow *self)
-{
- clutter_actor_raise_top (self->priv->floating_toolbar);
+ tones[0] = tp_dtmf_event_to_char (event);
+ tones[1] = '\0';
+ tp_call_channel_send_tones_async (call, tones, NULL, NULL, NULL);
- clutter_actor_raise_top (self->priv->preview_rectangle_box1);
- clutter_actor_raise_top (self->priv->preview_rectangle_box2);
- clutter_actor_raise_top (self->priv->preview_rectangle_box3);
- clutter_actor_raise_top (self->priv->preview_rectangle_box4);
+ g_object_unref (call);
}
static void
gtk_widget_set_visible (self->priv->remote_user_avatar_widget, !show);
- empathy_call_window_raise_actors (self);
+ clutter_actor_raise_top (self->priv->overlay_bin);
}
static void
clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (priv->video_output),
TRUE);
- priv->video_output_sink = clutter_gst_video_sink_new (
- CLUTTER_TEXTURE (priv->video_output));
+ priv->video_output_sink = gst_element_factory_make ("cluttersink", NULL);
+ if (priv->video_output_sink == NULL)
+ g_error ("Missing cluttersink");
+ else
+ g_object_set (priv->video_output_sink, "texture", priv->video_output, NULL);
clutter_container_add_actor (CLUTTER_CONTAINER (priv->video_box),
priv->video_output);
g_assert (priv->video_input == NULL);
priv->video_input = empathy_video_src_new ();
- gst_object_ref (priv->video_input);
- gst_object_sink (priv->video_input);
+ gst_object_ref_sink (priv->video_input);
}
static gboolean
return TRUE;
}
+static void
+audio_input_mute_notify_cb (GObject *obj, GParamSpec *spec,
+ EmpathyCallWindow *self)
+{
+ gboolean muted;
+ g_object_get (obj, "mute", &muted, NULL);
+
+ self->priv->muted = muted;
+ if (muted && self->priv->transitions)
+ clutter_state_set_state (self->priv->transitions, "fade-in");
+
+ if (muted)
+ {
+ gtk_image_set_from_icon_name (GTK_IMAGE (self->priv->microphone_icon),
+ EMPATHY_IMAGE_MIC_MUTED, GTK_ICON_SIZE_MENU);
+ }
+ else
+ {
+ gtk_image_set_from_icon_name (GTK_IMAGE (self->priv->microphone_icon),
+ EMPATHY_IMAGE_MIC, GTK_ICON_SIZE_MENU);
+ }
+
+ empathy_call_window_update_timer (self);
+}
+
static void
create_audio_input (EmpathyCallWindow *self)
{
g_assert (priv->audio_input == NULL);
priv->audio_input = empathy_audio_src_new ();
- gst_object_ref (priv->audio_input);
- gst_object_sink (priv->audio_input);
+ gst_object_ref_sink (priv->audio_input);
- g_object_bind_property (priv->mic_button, "active",
- priv->audio_input, "mute",
- G_BINDING_BIDIRECTIONAL |
- G_BINDING_INVERT_BOOLEAN | G_BINDING_SYNC_CREATE);
+ g_signal_connect (priv->audio_input, "notify::mute",
+ G_CALLBACK (audio_input_mute_notify_cb), self);
}
static void
{
clutter_actor_destroy (self->priv->preview_hidden_button);
- gtk_toggle_tool_button_set_active (
- GTK_TOGGLE_TOOL_BUTTON (self->priv->camera_button), FALSE);
+ gtk_toggle_button_set_active (
+ GTK_TOGGLE_BUTTON (self->priv->camera_button), FALSE);
}
static void
}
static void
-empathy_call_window_preview_button_clicked_cb (GtkButton *button,
+empathy_call_window_preview_button_clicked_cb (ClutterClickAction *action,
+ ClutterActor *actor,
EmpathyCallWindow *self)
{
GtkWidget *menu;
}
static void
-empathy_call_window_preview_hidden_button_clicked_cb (GtkButton *button,
+empathy_call_window_preview_hidden_button_clicked_cb (
+ ClutterClickAction *action,
+ ClutterActor *actor,
EmpathyCallWindow *self)
{
GtkWidget *menu;
static ClutterActor *
empathy_call_window_create_preview_rectangle (EmpathyCallWindow *self,
- ClutterActor **box,
ClutterBinAlignment x,
ClutterBinAlignment y)
{
- ClutterLayoutManager *layout1, *layout2;
ClutterActor *rectangle;
- ClutterActor *box1, *box2;
-
- layout1 = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
- CLUTTER_BIN_ALIGNMENT_START);
-
- box1 = clutter_box_new (layout1);
- *box = box1;
-
- rectangle = empathy_rounded_rectangle_new (
- SELF_VIDEO_SECTION_WIDTH + 5,
- SELF_VIDEO_SECTION_HEIGHT + 5);
-
- clutter_actor_set_size (box1,
- SELF_VIDEO_SECTION_WIDTH + 2 * SELF_VIDEO_SECTION_MARGIN,
- SELF_VIDEO_SECTION_HEIGHT + 2 * SELF_VIDEO_SECTION_MARGIN +
- FLOATING_TOOLBAR_HEIGHT + FLOATING_TOOLBAR_SPACING);
-
- layout2 = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
- CLUTTER_BIN_ALIGNMENT_CENTER);
-
- /* We have a box with the margins and the video in the middle inside
- * a bigger box with an extra bottom margin so we're not on top of
- * the floating toolbar. */
- box2 = clutter_box_new (layout2);
-
- clutter_actor_set_size (box2,
- SELF_VIDEO_SECTION_WIDTH + 2 * SELF_VIDEO_SECTION_MARGIN,
- SELF_VIDEO_SECTION_HEIGHT + 2 * SELF_VIDEO_SECTION_MARGIN);
-
- clutter_container_add_actor (CLUTTER_CONTAINER (box1), box2);
- clutter_container_add_actor (CLUTTER_CONTAINER (box2), rectangle);
-
- clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (self->priv->video_layout),
- box1, x, y);
+ rectangle = CLUTTER_ACTOR (empathy_rounded_rectangle_new (
+ SELF_VIDEO_SECTION_WIDTH, SELF_VIDEO_SECTION_HEIGHT,
+ PREVIEW_ROUND_FACTOR));
+ clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (self->priv->preview_layout),
+ rectangle, x, y);
clutter_actor_hide (rectangle);
return rectangle;
static void
empathy_call_window_create_preview_rectangles (EmpathyCallWindow *self)
{
+ ClutterActor *box;
+
+ self->priv->preview_layout = clutter_bin_layout_new (
+ CLUTTER_BIN_ALIGNMENT_CENTER, CLUTTER_BIN_ALIGNMENT_CENTER);
+ self->priv->preview_box = box = clutter_box_new (self->priv->preview_layout);
+
+ clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (self->priv->overlay_layout),
+ box,
+ CLUTTER_BIN_ALIGNMENT_FILL, CLUTTER_BIN_ALIGNMENT_FILL);
+
self->priv->preview_rectangle1 =
empathy_call_window_create_preview_rectangle (self,
- &self->priv->preview_rectangle_box1,
CLUTTER_BIN_ALIGNMENT_START, CLUTTER_BIN_ALIGNMENT_START);
self->priv->preview_rectangle2 =
empathy_call_window_create_preview_rectangle (self,
- &self->priv->preview_rectangle_box2,
CLUTTER_BIN_ALIGNMENT_START, CLUTTER_BIN_ALIGNMENT_END);
self->priv->preview_rectangle3 =
empathy_call_window_create_preview_rectangle (self,
- &self->priv->preview_rectangle_box3,
CLUTTER_BIN_ALIGNMENT_END, CLUTTER_BIN_ALIGNMENT_START);
self->priv->preview_rectangle4 =
empathy_call_window_create_preview_rectangle (self,
- &self->priv->preview_rectangle_box4,
CLUTTER_BIN_ALIGNMENT_END, CLUTTER_BIN_ALIGNMENT_END);
}
guint ret_x = 0, ret_y = 0;
ClutterGeometry box;
- if (!clutter_actor_has_allocation (self->priv->video_box))
+ if (!clutter_actor_has_allocation (self->priv->preview_box))
goto out;
- clutter_actor_get_geometry (self->priv->video_box, &box);
+ clutter_actor_get_geometry (self->priv->preview_box, &box);
switch (pos)
{
case PREVIEW_POS_BOTTOM_LEFT:
ret_x = SELF_VIDEO_SECTION_MARGIN;
ret_y = box.height - SELF_VIDEO_SECTION_MARGIN
- - SELF_VIDEO_SECTION_HEIGHT
- - FLOATING_TOOLBAR_HEIGHT - FLOATING_TOOLBAR_SPACING;
+ - SELF_VIDEO_SECTION_HEIGHT;
break;
case PREVIEW_POS_BOTTOM_RIGHT:
ret_x = box.width - SELF_VIDEO_SECTION_MARGIN
- SELF_VIDEO_SECTION_WIDTH;
ret_y = box.height - SELF_VIDEO_SECTION_MARGIN
- - SELF_VIDEO_SECTION_HEIGHT - FLOATING_TOOLBAR_HEIGHT
- - FLOATING_TOOLBAR_SPACING;
+ - SELF_VIDEO_SECTION_HEIGHT;
break;
default:
g_warn_if_reached ();
ClutterGeometry box;
PreviewPosition pos = PREVIEW_POS_NONE;
- if (!clutter_actor_has_allocation (self->priv->video_box))
+ if (!clutter_actor_has_allocation (self->priv->preview_box))
return pos;
- clutter_actor_get_geometry (self->priv->video_box, &box);
+ clutter_actor_get_geometry (self->priv->preview_box, &box);
if (0 + SELF_VIDEO_SECTION_MARGIN <= event_x &&
event_x <= (0 + SELF_VIDEO_SECTION_MARGIN + (gint) SELF_VIDEO_SECTION_WIDTH) &&
}
else if (0 + SELF_VIDEO_SECTION_MARGIN <= event_x &&
event_x <= (0 + SELF_VIDEO_SECTION_MARGIN + (gint) SELF_VIDEO_SECTION_WIDTH) &&
- box.height - SELF_VIDEO_SECTION_MARGIN - FLOATING_TOOLBAR_HEIGHT - FLOATING_TOOLBAR_SPACING >= event_y &&
- event_y >= (box.height - SELF_VIDEO_SECTION_MARGIN - FLOATING_TOOLBAR_HEIGHT - FLOATING_TOOLBAR_SPACING - (gint) SELF_VIDEO_SECTION_HEIGHT))
+ box.height - SELF_VIDEO_SECTION_MARGIN >= event_y &&
+ event_y >= (box.height - SELF_VIDEO_SECTION_MARGIN - (gint) SELF_VIDEO_SECTION_HEIGHT))
{
pos = PREVIEW_POS_BOTTOM_LEFT;
}
else if (box.width - SELF_VIDEO_SECTION_MARGIN >= event_x &&
event_x >= (box.width - SELF_VIDEO_SECTION_MARGIN - (gint) SELF_VIDEO_SECTION_WIDTH) &&
- box.height - SELF_VIDEO_SECTION_MARGIN - SELF_VIDEO_SECTION_MARGIN - FLOATING_TOOLBAR_HEIGHT - FLOATING_TOOLBAR_SPACING >= event_y &&
- event_y >= (box.height - SELF_VIDEO_SECTION_MARGIN - FLOATING_TOOLBAR_HEIGHT - FLOATING_TOOLBAR_SPACING - (gint) SELF_VIDEO_SECTION_HEIGHT))
+ box.height - 2 * SELF_VIDEO_SECTION_MARGIN >= event_y &&
+ event_y >= (box.height - SELF_VIDEO_SECTION_MARGIN - (gint) SELF_VIDEO_SECTION_HEIGHT))
{
pos = PREVIEW_POS_BOTTOM_RIGHT;
}
empathy_call_window_move_video_preview (EmpathyCallWindow *self,
PreviewPosition pos)
{
- ClutterBinLayout *layout = CLUTTER_BIN_LAYOUT (self->priv->video_layout);
+ ClutterBinLayout *layout = CLUTTER_BIN_LAYOUT (self->priv->preview_layout);
DEBUG ("moving the video preview to %d", pos);
PreviewPosition pos)
{
ClutterActor *rectangle;
+ ClutterColor white = { 0xff, 0xff, 0xff, 0xff};
rectangle = empathy_call_window_get_preview_rectangle (self, pos);
empathy_rounded_rectangle_set_border_width (
- EMPATHY_ROUNDED_RECTANGLE (rectangle), 5);
+ EMPATHY_ROUNDED_RECTANGLE (rectangle), 2 * SELF_VIDEO_SECTION_MARGIN);
empathy_rounded_rectangle_set_border_color (
- EMPATHY_ROUNDED_RECTANGLE (rectangle), CLUTTER_COLOR_Red);
+ EMPATHY_ROUNDED_RECTANGLE (rectangle), &white);
}
static void
empathy_call_window_darken_preview_rectangle (EmpathyCallWindow *self,
ClutterActor *rectangle)
{
+ ClutterColor white = { 0xff, 0xff, 0xff, 0xff}, darker;
+
+ clutter_color_shade (&white, 0.55, &darker);
+
empathy_rounded_rectangle_set_border_width (
EMPATHY_ROUNDED_RECTANGLE (rectangle), 1);
empathy_rounded_rectangle_set_border_color (
- EMPATHY_ROUNDED_RECTANGLE (rectangle), CLUTTER_COLOR_Black);
+ EMPATHY_ROUNDED_RECTANGLE (rectangle), &darker);
}
static void
create_video_preview (EmpathyCallWindow *self)
{
EmpathyCallWindowPriv *priv = GET_PRIV (self);
- ClutterLayoutManager *layout, *layout_center, *layout_end;
+ ClutterLayoutManager *layout;
ClutterActor *preview;
- ClutterActor *box;
ClutterActor *b;
ClutterAction *action;
- GtkWidget *button;
PreviewPosition pos;
- GdkRGBA transparent = { 0., 0., 0., 0. };
g_assert (priv->video_preview == NULL);
preview = empathy_rounded_texture_new ();
clutter_actor_set_size (preview,
SELF_VIDEO_SECTION_WIDTH, SELF_VIDEO_SECTION_HEIGHT);
- priv->video_preview_sink = clutter_gst_video_sink_new (
- CLUTTER_TEXTURE (preview));
+
+ priv->video_preview_sink = gst_element_factory_make ("cluttersink", NULL);
+ if (priv->video_preview_sink == NULL)
+ g_error ("Missing cluttersink, check your clutter-gst installation");
+ g_object_set (priv->video_preview_sink, "texture", preview, NULL);
+ g_object_add_weak_pointer (G_OBJECT (priv->video_preview_sink), (gpointer) &priv->video_preview_sink);
/* Add a little offset to the video preview */
layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
- CLUTTER_BIN_ALIGNMENT_START);
+ CLUTTER_BIN_ALIGNMENT_CENTER);
priv->video_preview = clutter_box_new (layout);
clutter_actor_set_size (priv->video_preview,
SELF_VIDEO_SECTION_WIDTH + 2 * SELF_VIDEO_SECTION_MARGIN,
- SELF_VIDEO_SECTION_HEIGHT + 2 * SELF_VIDEO_SECTION_MARGIN +
- FLOATING_TOOLBAR_HEIGHT + FLOATING_TOOLBAR_SPACING);
+ SELF_VIDEO_SECTION_HEIGHT + 2 * SELF_VIDEO_SECTION_MARGIN);
/* Spinner for when changing the camera device */
priv->preview_spinner_widget = gtk_spinner_new ();
- priv->preview_spinner_actor = empathy_rounded_actor_new ();
- empathy_rounded_actor_set_round_factor (
- EMPATHY_ROUNDED_ACTOR (priv->preview_spinner_actor), 16);
+ priv->preview_spinner_actor = empathy_rounded_actor_new (PREVIEW_ROUND_FACTOR);
g_object_set (priv->preview_spinner_widget, "expand", TRUE, NULL);
- gtk_widget_override_background_color (
- gtk_clutter_actor_get_widget (
- GTK_CLUTTER_ACTOR (priv->preview_spinner_actor)),
- GTK_STATE_FLAG_NORMAL, &transparent);
+ make_background_transparent (GTK_CLUTTER_ACTOR (priv->preview_spinner_actor));
gtk_widget_show (priv->preview_spinner_widget);
gtk_container_add (
clutter_actor_set_opacity (priv->preview_spinner_actor, 128);
clutter_actor_hide (priv->preview_spinner_actor);
- /* We have a box with the margins and the video in the middle inside
- * a bigger box with an extra bottom margin so we're not on top of
- * the floating toolbar. */
- layout_center = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
- CLUTTER_BIN_ALIGNMENT_CENTER);
- box = clutter_box_new (layout_center);
- clutter_actor_set_size (box,
- SELF_VIDEO_SECTION_WIDTH + 2 * SELF_VIDEO_SECTION_MARGIN,
- SELF_VIDEO_SECTION_HEIGHT + 2 * SELF_VIDEO_SECTION_MARGIN);
-
- clutter_container_add_actor (CLUTTER_CONTAINER (box), preview);
- clutter_container_add_actor (CLUTTER_CONTAINER (box),
+ clutter_container_add_actor (CLUTTER_CONTAINER (priv->video_preview),
+ preview);
+ clutter_container_add_actor (CLUTTER_CONTAINER (priv->video_preview),
priv->preview_spinner_actor);
- clutter_container_add_actor (CLUTTER_CONTAINER (priv->video_preview), box);
g_object_set (priv->video_preview_sink,
"sync", FALSE,
"async", FALSE,
NULL);
- /* Translators: this is an "Info" label. It should be as short
- * as possible. */
- button = gtk_button_new_with_label (_("i"));
- priv->preview_shown_button = b = empathy_rounded_actor_new ();
- gtk_container_add (
- GTK_CONTAINER (gtk_clutter_actor_get_widget (GTK_CLUTTER_ACTOR (b))),
- button);
- clutter_actor_set_size (b, 24, 24);
-
- layout_end = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_END,
- CLUTTER_BIN_ALIGNMENT_END);
- box = clutter_box_new (layout_end);
- clutter_actor_set_size (box,
- SELF_VIDEO_SECTION_WIDTH,
- SELF_VIDEO_SECTION_HEIGHT + SELF_VIDEO_SECTION_MARGIN);
-
- clutter_container_add_actor (CLUTTER_CONTAINER (box), b);
- clutter_container_add_actor (CLUTTER_CONTAINER (priv->video_preview), box);
-
- g_signal_connect (button, "clicked",
- G_CALLBACK (empathy_call_window_preview_button_clicked_cb),
- self);
-
- /* Translators: this is an "Info" label. It should be as short
- * as possible. */
- button = gtk_button_new_with_label (_("i"));
- b = empathy_rounded_actor_new ();
- gtk_container_add (
- GTK_CONTAINER (gtk_clutter_actor_get_widget (GTK_CLUTTER_ACTOR (b))),
- button);
- clutter_actor_set_size (b, 24, 24);
- priv->preview_hidden_button = b;
-
- clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (priv->video_layout),
+ /* Preview show */
+ priv->preview_shown_button = b = gtk_clutter_actor_new_with_contents (
+ gtk_image_new_from_icon_name ("emblem-system-symbolic",
+ GTK_ICON_SIZE_MENU));
+ clutter_actor_set_margin_right (b, 4);
+ clutter_actor_set_margin_bottom (b, 2);
+ clutter_actor_set_opacity (b, PREVIEW_BUTTON_OPACITY);
+ make_background_transparent (GTK_CLUTTER_ACTOR (b));
+
+ clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (layout), b,
+ CLUTTER_BIN_ALIGNMENT_END, CLUTTER_BIN_ALIGNMENT_END);
+
+ action = clutter_click_action_new ();
+ clutter_actor_add_action (b, action);
+ g_signal_connect (action, "clicked",
+ G_CALLBACK (empathy_call_window_preview_button_clicked_cb), self);
+
+ /* Preview hidden */
+ priv->preview_hidden_button = b = gtk_clutter_actor_new_with_contents (
+ gtk_image_new_from_icon_name ("emblem-system-symbolic",
+ GTK_ICON_SIZE_MENU));
+ make_background_transparent (GTK_CLUTTER_ACTOR (b));
+
+ clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (priv->preview_layout),
priv->preview_hidden_button,
CLUTTER_BIN_ALIGNMENT_START,
CLUTTER_BIN_ALIGNMENT_END);
clutter_actor_hide (priv->preview_hidden_button);
- g_signal_connect (button, "clicked",
- G_CALLBACK (empathy_call_window_preview_hidden_button_clicked_cb),
- self);
+ action = clutter_click_action_new ();
+ clutter_actor_add_action (b, action);
+ g_signal_connect (action, "clicked",
+ G_CALLBACK (empathy_call_window_preview_hidden_button_clicked_cb), self);
- clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (priv->video_layout),
+ clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (priv->preview_layout),
priv->video_preview,
CLUTTER_BIN_ALIGNMENT_START,
CLUTTER_BIN_ALIGNMENT_END);
}
static void
-empathy_call_window_camera_toggled_cb (GtkToggleToolButton *toggle,
+empathy_call_window_camera_toggled_cb (GtkToggleButton *toggle,
EmpathyCallWindow *self)
{
- if (gtk_toggle_tool_button_get_active (toggle))
+ if (gtk_toggle_button_get_active (toggle))
enable_camera (self);
else
disable_camera (self);
priv->pipeline_playing = FALSE;
priv->video_tee = gst_element_factory_make ("tee", NULL);
- gst_object_ref (priv->video_tee);
- gst_object_sink (priv->video_tee);
+ gst_object_ref_sink (priv->video_tee);
gst_bin_add (GST_BIN (priv->pipeline), priv->video_tee);
empathy_call_window_contents_cb (GtkAction *action,
EmpathyCallWindow *self)
{
- empathy_url_show (GTK_WIDGET (self), "ghelp:empathy?audio-video");
+ empathy_url_show (GTK_WIDGET (self), "help:empathy/audio-video");
+}
+
+static void
+show_png (GPid pid, gint status, gpointer user_data)
+{
+ gtk_show_uri (NULL, (gchar *) user_data, GDK_CURRENT_TIME, NULL);
+ g_spawn_close_pid (pid);
+ g_free (user_data);
+}
+
+static void
+empathy_call_window_debug_gst_cb (GtkAction *action,
+ EmpathyCallWindow *self)
+{
+ EmpathyCallWindowPriv *priv = GET_PRIV (self);
+ GDateTime *date_time;
+ GPid dot_pid;
+ const gchar *dot_dir;
+ const gchar *prgname;
+ gchar *dot_cmd;
+ gchar *filename;
+ gchar **argv;
+ gint argc;
+
+ if (priv->pipeline == NULL)
+ DEBUG ("No pipeline");
+
+ date_time = g_date_time_new_now_utc ();
+ prgname = g_get_prgname ();
+ filename = g_strdup_printf ("%s-%" G_GINT64_FORMAT, prgname,
+ g_date_time_to_unix (date_time));
+
+ GST_DEBUG_BIN_TO_DOT_FILE (GST_BIN (priv->pipeline),
+ GST_DEBUG_GRAPH_SHOW_ALL, filename);
+
+ dot_dir = g_getenv ("GST_DEBUG_DUMP_DOT_DIR");
+ dot_cmd = g_strdup_printf ("dot -Tpng -o %s.png %s.dot",
+ filename,
+ filename);
+ g_shell_parse_argv (dot_cmd, &argc, &argv, NULL);
+
+ if (g_spawn_async (dot_dir,
+ argv,
+ NULL,
+ G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_SEARCH_PATH,
+ NULL,
+ NULL,
+ &dot_pid,
+ NULL))
+ {
+ gchar *uri = g_strdup_printf ("file://%s/%s.png", dot_dir, filename);
+ g_child_watch_add (dot_pid, show_png, uri);
+ }
+
+ g_strfreev (argv);
+ g_free (dot_cmd);
+ g_free (filename);
+ g_date_time_unref (date_time);
}
static void
-empathy_call_window_debug_cb (GtkAction *action,
+empathy_call_window_debug_tp_cb (GtkAction *action,
EmpathyCallWindow *self)
{
empathy_launch_program (BIN_DIR, "empathy-debugger", "-s Empathy.Call");
EmpathyCallWindow *self = data;
/* We don't want to hide the toolbar if we're not in a call, as
- * to show the call status all the time. */
+ * to show the call status all the time. Also don't hide if we're muted
+ * to prevent the awkward, talking when muted situation */
if (self->priv->call_state != CONNECTING &&
- self->priv->call_state != DISCONNECTED)
+ self->priv->call_state != DISCONNECTED &&
+ !self->priv->muted)
clutter_state_set_state (self->priv->transitions, "fade-out");
return TRUE;
}
}
-static void
-empathy_call_window_stage_allocation_changed_cb (ClutterActor *stage,
- GParamSpec *pspec,
- ClutterBindConstraint *constraint)
-{
- ClutterActorBox allocation;
-
- clutter_actor_get_allocation_box (stage, &allocation);
-
- clutter_bind_constraint_set_offset (constraint,
- allocation.y2 - allocation.y1 -
- FLOATING_TOOLBAR_SPACING - FLOATING_TOOLBAR_HEIGHT);
-}
-
static void
empathy_call_window_incoming_call_response_cb (GtkDialog *dialog,
gint response_id,
g_assert (self->priv->call_state != CONNECTED);
- video = tpy_call_channel_has_initial_video (self->priv->pending_channel);
+ video = tp_call_channel_has_initial_video (self->priv->pending_channel, NULL);
empathy_call_window_status_message (self, _("Incoming call"));
self->priv->call_state = RINGING;
void
empathy_call_window_start_ringing (EmpathyCallWindow *self,
- TpyCallChannel *channel,
+ TpCallChannel *channel,
TpChannelDispatchOperation *dispatch_operation,
TpAddDispatchOperationContext *context)
{
tp_add_dispatch_operation_context_accept (context);
}
+static void
+mic_button_clicked (GtkWidget *button,
+ EmpathyCallWindow *self)
+{
+ /* Toggle the muted state. We rely on audio_input_mute_notify_cb to update
+ * the icon. */
+ empathy_audio_src_set_mute (EMPATHY_GST_AUDIO_SRC (self->priv->audio_input),
+ !self->priv->muted);
+}
+
static void
empathy_call_window_init (EmpathyCallWindow *self)
{
gchar *filename;
ClutterConstraint *constraint;
ClutterActor *remote_avatar;
- GtkStyleContext *context;
- GdkRGBA rgba;
- ClutterColor bg;
+ ClutterColor black = { 0, 0, 0, 0 };
+ ClutterMargin overlay_margin = { OVERLAY_MARGIN, OVERLAY_MARGIN,
+ OVERLAY_MARGIN, OVERLAY_MARGIN };
priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
EMPATHY_TYPE_CALL_WINDOW, EmpathyCallWindowPriv);
priv->settings = g_settings_new (EMPATHY_PREFS_CALL_SCHEMA);
+ priv->timer = g_timer_new ();
filename = empathy_file_lookup ("empathy-call-window.ui", "src");
gui = empathy_builder_get_file (filename,
"errors_vbox", &priv->errors_vbox,
"pane", &priv->pane,
"remote_user_name_toolbar", &priv->remote_user_name_toolbar,
+ "remote_user_status_toolbar", &priv->remote_user_status_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,
+ "microphone_icon", &priv->microphone_icon,
"volume", &priv->volume_button,
"camera", &priv->camera_button,
"hangup", &priv->hangup_button,
"menufullscreen", "activate", empathy_call_window_fullscreen_cb,
"menusettings", "activate", empathy_call_window_settings_cb,
"menucontents", "activate", empathy_call_window_contents_cb,
- "menudebug", "activate", empathy_call_window_debug_cb,
+ "menudebuggst", "activate", empathy_call_window_debug_gst_cb,
+ "menudebugtp", "activate", empathy_call_window_debug_tp_cb,
"menuabout", "activate", empathy_call_window_about_cb,
"menupreviewdisable", "activate", empathy_call_window_disable_camera_cb,
"menupreviewminimise", "activate", empathy_call_window_minimise_camera_cb,
"menupreviewswap", "activate", empathy_call_window_swap_camera_cb,
NULL);
+ empathy_set_css_provider (GTK_WIDGET (self));
gtk_action_set_sensitive (priv->menu_fullscreen, FALSE);
priv->camera_monitor = empathy_camera_monitor_dup_singleton ();
g_signal_connect (priv->camera_monitor, "removed",
G_CALLBACK (empathy_call_window_camera_removed_cb), self);
- priv->lock = g_mutex_new ();
+ g_signal_connect (priv->mic_button, "clicked",
+ G_CALLBACK (mic_button_clicked), self);
+
+ g_mutex_init (&priv->lock);
gtk_container_add (GTK_CONTAINER (self), top_vbox);
- priv->content_hbox = gtk_hbox_new (FALSE, CONTENT_HBOX_SPACING);
- gtk_container_set_border_width (GTK_CONTAINER (priv->content_hbox),
- CONTENT_HBOX_BORDER_WIDTH);
+ priv->content_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL,
+ CONTENT_HBOX_SPACING);
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,
- CLUTTER_BIN_ALIGNMENT_CENTER);
+ /* main contents remote avatar/video box */
+ priv->video_layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_FILL,
+ CLUTTER_BIN_ALIGNMENT_FILL);
priv->video_box = clutter_box_new (priv->video_layout);
priv->video_container = gtk_clutter_embed_new ();
- /* Set the background color to that of the rest of the window */
- context = gtk_widget_get_style_context (priv->content_hbox);
- gtk_style_context_get_background_color (context,
- GTK_STATE_FLAG_NORMAL, &rgba);
- bg.red = CLAMP (rgba.red * 255.0, 0, 255);
- bg.green = CLAMP (rgba.green * 255.0, 0, 255);
- bg.blue = CLAMP (rgba.blue * 255.0, 0, 255);
- bg.alpha = CLAMP (rgba.alpha * 255.0, 0, 255);
+ gtk_widget_set_size_request (priv->video_container,
+ REMOTE_VIDEO_DEFAULT_WIDTH, REMOTE_VIDEO_DEFAULT_HEIGHT);
+
+ /* Set the background black */
clutter_stage_set_color (
CLUTTER_STAGE (gtk_clutter_embed_get_stage (
GTK_CLUTTER_EMBED (priv->video_container))),
- &bg);
+ &black);
clutter_container_add (
CLUTTER_CONTAINER (gtk_clutter_embed_get_stage (
priv->remote_user_avatar_widget = gtk_image_new ();
remote_avatar = gtk_clutter_actor_new_with_contents (
priv->remote_user_avatar_widget);
+ make_background_transparent (GTK_CLUTTER_ACTOR (remote_avatar));
clutter_container_add_actor (CLUTTER_CONTAINER (priv->video_box),
remote_avatar);
+ /* create the overlay bin */
+ priv->overlay_layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
+ CLUTTER_BIN_ALIGNMENT_CENTER);
+ priv->overlay_bin = clutter_actor_new ();
+ clutter_actor_set_layout_manager (priv->overlay_bin, priv->overlay_layout);
+
+ clutter_actor_set_margin (priv->overlay_bin, &overlay_margin);
+
+ clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (priv->video_layout),
+ priv->overlay_bin,
+ CLUTTER_BIN_ALIGNMENT_FILL, CLUTTER_BIN_ALIGNMENT_FILL);
+
empathy_call_window_create_preview_rectangles (self);
gtk_box_pack_start (GTK_BOX (priv->content_hbox),
create_audio_input (self);
create_video_input (self);
- priv->floating_toolbar = empathy_rounded_actor_new ();
+ priv->floating_toolbar = gtk_clutter_actor_new ();
+ clutter_actor_set_reactive (priv->floating_toolbar, TRUE);
+ make_background_transparent (GTK_CLUTTER_ACTOR (priv->floating_toolbar));
+ gtk_style_context_add_class (
+ gtk_widget_get_style_context (GTK_WIDGET (priv->bottom_toolbar)),
+ GTK_STYLE_CLASS_OSD);
gtk_widget_reparent (priv->bottom_toolbar,
gtk_clutter_actor_get_widget (GTK_CLUTTER_ACTOR (priv->floating_toolbar)));
- constraint = clutter_bind_constraint_new (
- gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (priv->video_container)),
- CLUTTER_BIND_Y, 0);
-
- clutter_actor_add_constraint (priv->floating_toolbar, constraint);
-
- g_signal_connect (
- gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (priv->video_container)),
- "notify::allocation",
- G_CALLBACK (empathy_call_window_stage_allocation_changed_cb),
- constraint);
-
- clutter_actor_set_size (priv->floating_toolbar,
- FLOATING_TOOLBAR_WIDTH, FLOATING_TOOLBAR_HEIGHT);
- clutter_actor_set_opacity (priv->floating_toolbar, FLOATING_TOOLBAR_OPACITY);
-
- clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (priv->video_layout),
+ clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (priv->overlay_layout),
priv->floating_toolbar,
- CLUTTER_BIN_ALIGNMENT_CENTER,
- CLUTTER_BIN_ALIGNMENT_END);
+ CLUTTER_BIN_ALIGNMENT_CENTER, CLUTTER_BIN_ALIGNMENT_END);
clutter_actor_raise_top (priv->floating_toolbar);
/* transition from any state to "fade-in" state */
clutter_state_set (priv->transitions, NULL, "fade-in",
priv->floating_toolbar,
- "opacity", CLUTTER_EASE_OUT_QUAD, FLOATING_TOOLBAR_OPACITY,
+ "opacity", CLUTTER_EASE_OUT_QUAD, 255,
NULL);
/* put the actor into the "fade-in" state with no animation */
g_signal_connect (priv->dtmf_panel, "start-tone",
G_CALLBACK (dtmf_start_tone_cb), self);
- priv->tones = g_string_new ("");
-
gtk_box_pack_start (GTK_BOX (priv->pane), priv->dtmf_panel,
FALSE, FALSE, 6);
g_signal_connect (self, "motion-notify-event",
G_CALLBACK (empathy_call_window_motion_notify_cb), self);
- priv->timer = g_timer_new ();
-
g_object_ref (priv->ui_manager);
g_object_unref (gui);
empathy_call_window_show_hangup_button (self, TRUE);
+ gtk_window_set_default_size (GTK_WINDOW (self), 580, 480);
+
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
{
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);
+ gtk_label_set_text (GTK_LABEL (self->priv->remote_user_name_toolbar), alias);
+
+ if (status != NULL) {
+ gchar *markup;
+
+ markup = g_markup_printf_escaped ("<small>%s</small>", status);
+ gtk_label_set_markup (GTK_LABEL (self->priv->remote_user_status_toolbar),
+ markup);
+ g_free (markup);
+ } else {
+ gtk_label_set_markup (GTK_LABEL (self->priv->remote_user_status_toolbar),
+ "");
+ }
}
static void
{
EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (object);
EmpathyCallWindowPriv *priv = GET_PRIV (self);
- TpyCallChannel *call;
- TpyCallState state;
+ TpCallChannel *call;
+ TpCallState state;
g_assert (priv->handler != NULL);
g_object_get (priv->handler, "call-channel", &call, NULL);
- state = tpy_call_channel_get_state (call, NULL, NULL);
- priv->outgoing = (state == TPY_CALL_STATE_PENDING_INITIATOR);
+ state = tp_call_channel_get_state (call, NULL, NULL, NULL);
+ priv->outgoing = (state == TP_CALL_STATE_PENDING_INITIATOR);
tp_clear_object (&call);
- g_object_get (priv->handler, "target-contact", &priv->contact, NULL);
+ priv->contact = empathy_call_handler_get_contact (priv->handler);
g_assert (priv->contact != NULL);
+ g_object_ref (priv->contact);
if (!empathy_contact_can_voip_video (priv->contact))
{
if (!empathy_call_handler_has_initial_video (priv->handler))
{
- gtk_toggle_tool_button_set_active (
- GTK_TOGGLE_TOOL_BUTTON (priv->camera_button), FALSE);
+ gtk_toggle_button_set_active (
+ GTK_TOGGLE_BUTTON (priv->camera_button), FALSE);
}
/* If call has InitialVideo, the preview will be started once the call has
* been started (start_call()). */
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class,
PROP_CALL_HANDLER, param_spec);
+
+ signals[SIG_INHIBIT] = g_signal_new ("inhibit",
+ G_OBJECT_CLASS_TYPE (empathy_call_window_class),
+ G_SIGNAL_RUN_LAST,
+ 0, NULL, NULL, NULL,
+ G_TYPE_NONE,
+ 1, G_TYPE_BOOLEAN);
}
void
tp_clear_object (&priv->sound_mgr);
tp_clear_object (&priv->mic_menu);
tp_clear_object (&priv->camera_menu);
+ tp_clear_object (&priv->transitions);
g_list_free_full (priv->notifiers, g_object_unref);
g_source_remove (priv->timer_id);
priv->timer_id = 0;
- if (priv->contact != NULL)
- {
- g_signal_handlers_disconnect_by_func (priv->contact,
- contact_name_changed_cb, self);
- priv->contact = NULL;
- }
+ tp_clear_object (&priv->contact);
G_OBJECT_CLASS (empathy_call_window_parent_class)->dispose (object);
}
disconnect_video_output_motion_handler (self);
/* free any data held directly by the object here */
- g_mutex_free (priv->lock);
+ g_mutex_clear (&priv->lock);
g_timer_destroy (priv->timer);
- g_string_free (priv->tones, TRUE);
-
G_OBJECT_CLASS (empathy_call_window_parent_class)->finalize (object);
}
{
g_return_if_fail (EMPATHY_IS_CALL_HANDLER (handler));
- tp_clear_object (&self->priv->handler);
- self->priv->handler = g_object_ref (handler);
- empathy_call_window_connect_handler (self);
-
empathy_window_present (GTK_WINDOW (self));
- empathy_call_window_restart_call (self);
+
+ if (self->priv->call_state == DISCONNECTED)
+ {
+ /* start a new call if one is not already in progress */
+ tp_clear_object (&self->priv->handler);
+ self->priv->handler = g_object_ref (handler);
+ empathy_call_window_connect_handler (self);
+
+ empathy_call_window_restart_call (self);
+ }
}
static void
EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (user_data);
EmpathyCallWindowPriv *priv = GET_PRIV (self);
+ g_list_free_full (priv->notifiers, g_object_unref);
+ priv->notifiers = NULL;
+
gst_bin_remove (GST_BIN (priv->pipeline), conference);
gst_element_set_state (conference, GST_STATE_NULL);
}
/* Leave full screen mode if needed */
gtk_window_unfullscreen (GTK_WINDOW (self));
+ g_signal_emit (self, signals[SIG_INHIBIT], 0, FALSE);
+
gtk_action_set_sensitive (priv->menu_fullscreen, FALSE);
gtk_widget_set_sensitive (priv->dtmf_panel, FALSE);
- priv->sending_tones = FALSE;
- g_string_set_size (priv->tones, 0);
+ /* Create the video input and then turn on the camera
+ * menu, so that the active camera gets marked as such.
+ */
+ if (priv->video_input == NULL)
+ create_video_input (self);
+ empathy_camera_menu_set_sensitive (priv->camera_menu, TRUE);
could_reset_pipeline = empathy_call_window_reset_pipeline (self);
if (could_reset_pipeline)
{
- g_mutex_lock (priv->lock);
+ g_mutex_lock (&priv->lock);
g_timer_stop (priv->timer);
g_source_remove (priv->timer_id);
priv->timer_id = 0;
- g_mutex_unlock (priv->lock);
+ g_mutex_unlock (&priv->lock);
if (!restart)
/* We are about to destroy the window, no need to update it or create
gtk_widget_set_sensitive (priv->mic_button, FALSE);
/* Be sure that the mic button is enabled */
- gtk_toggle_tool_button_set_active (
- GTK_TOGGLE_TOOL_BUTTON (priv->mic_button), TRUE);
+ empathy_audio_src_set_mute (
+ EMPATHY_GST_AUDIO_SRC (self->priv->audio_input), FALSE);
if (priv->camera_state == CAMERA_STATE_ON)
{
if (priv->funnel == NULL)
{
output = priv->video_output_sink;
-
+#ifdef HAVE_GST1
+ priv->funnel = gst_element_factory_make ("funnel", NULL);
+#else
priv->funnel = gst_element_factory_make ("fsfunnel", NULL);
+#endif
if (!priv->funnel)
{
- g_warning ("Could not create fsfunnel");
+ g_warning ("Could not create video funnel");
return NULL;
}
goto error_output_added;
}
}
-
+#ifdef HAVE_GST1
+ pad = gst_element_get_request_pad (priv->funnel, "sink_%u");
+#else
pad = gst_element_get_request_pad (priv->funnel, "sink%d");
+#endif
if (!pad)
g_warning ("Could not get request pad from funnel");
g_warning ("Could not start audio sink");
goto error;
}
+ priv->audio_output_added = TRUE;
}
template = gst_element_class_get_pad_template (
if (priv->call_state == HELD)
status = _("On hold");
- else if (!gtk_toggle_tool_button_get_active (
- GTK_TOGGLE_TOOL_BUTTON (priv->mic_button)))
+ else if (priv->call_state == DISCONNECTED)
+ status = _("Disconnected");
+ else if (priv->muted)
status = _("Mute");
else
status = _("Duration");
content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (info_bar));
/* hbox containing the image and the messages vbox */
- hbox = gtk_hbox_new (FALSE, 3);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
gtk_container_add (GTK_CONTAINER (content_area), hbox);
/* Add image */
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
/* vbox containing the main message and the details expander */
- vbox = gtk_vbox_new (FALSE, 3);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
/* Add text */
#if 0
static gchar *
media_stream_error_to_txt (EmpathyCallWindow *self,
- TpyCallChannel *call,
+ TpCallChannel *call,
gboolean audio,
TpMediaStreamError error)
{
case TP_MEDIA_STREAM_ERROR_INVALID_CM_BEHAVIOR:
tp_connection_parse_object_path (
- tp_channel_borrow_connection (TP_CHANNEL (call)),
+ tp_channel_get_connection (TP_CHANNEL (call)),
NULL, &cm);
url = g_strdup_printf ("http://bugs.freedesktop.org/enter_bug.cgi?"
static void
empathy_call_window_stream_error (EmpathyCallWindow *self,
- TpyCallChannel *call,
+ TpCallChannel *call,
gboolean audio,
guint code,
const gchar *msg,
}
static void
-empathy_call_window_audio_stream_error (TpyCallChannel *call,
+empathy_call_window_audio_stream_error (TpCallChannel *call,
guint code,
const gchar *msg,
EmpathyCallWindow *self)
}
static void
-empathy_call_window_video_stream_error (TpyCallChannel *call,
+empathy_call_window_video_stream_error (TpCallChannel *call,
guint code,
const gchar *msg,
EmpathyCallWindow *self)
"call-channel", &call,
NULL);
- conn = tp_channel_borrow_connection (call);
+ conn = tp_channel_get_connection (call);
g_object_unref (call);
uri = tp_connection_get_balance_uri (conn);
static void
empathy_call_window_state_changed_cb (EmpathyCallHandler *handler,
- TpyCallState state,
+ TpCallState state,
gchar *reason,
EmpathyCallWindow *self)
{
EmpathyCallWindowPriv *priv = GET_PRIV (self);
- TpyCallChannel *call;
+ TpCallChannel *call;
gboolean can_send_video;
- if (state == TPY_CALL_STATE_ENDED &&
- !tp_strdiff (reason, TP_ERROR_STR_INSUFFICIENT_BALANCE))
+ if (state == TP_CALL_STATE_ENDED)
{
- show_balance_error (self);
+ DEBUG ("Call ended: %s", (reason != NULL && reason[0] != '\0') ? reason : "unspecified reason");
+ empathy_call_window_disconnected (self, TRUE);
+ if (!tp_strdiff (reason, TP_ERROR_STR_INSUFFICIENT_BALANCE))
+ show_balance_error (self);
return;
}
- if (state != TPY_CALL_STATE_ACCEPTED)
+ if (state != TP_CALL_STATE_ACCEPTED)
return;
if (priv->call_state == CONNECTED)
g_object_get (priv->handler, "call-channel", &call, NULL);
- if (tpy_call_channel_has_dtmf (call))
+ if (tp_call_channel_has_dtmf (call))
gtk_widget_set_sensitive (priv->dtmf_panel, TRUE);
if (priv->video_input == NULL)
g_object_unref (call);
- g_mutex_lock (priv->lock);
+ g_mutex_lock (&priv->lock);
priv->timer_id = g_timeout_add_seconds (1,
empathy_call_window_update_timer, self);
- g_mutex_unlock (priv->lock);
+ g_mutex_unlock (&priv->lock);
empathy_call_window_update_timer (self);
{
gtk_widget_hide (self->priv->remote_user_avatar_widget);
clutter_actor_show (self->priv->video_output);
- empathy_call_window_raise_actors (self);
+ clutter_actor_raise_top (self->priv->overlay_bin);
}
return FALSE;
}
/* Called from the streaming thread */
+#ifdef HAVE_GST1
+static GstPadProbeReturn
+empathy_call_window_video_probe_cb (GstPad *pad,
+ GstPadProbeInfo *info,
+ gpointer user_data)
+{
+ EmpathyCallWindow *self = user_data;
+
+ if (G_UNLIKELY (!self->priv->got_video))
+ {
+ /* show the remote video */
+ g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
+ empathy_call_window_show_video_output_cb,
+ g_object_ref (self), g_object_unref);
+
+ self->priv->got_video = TRUE;
+ }
+
+ return GST_PAD_PROBE_OK;
+}
+#else
static gboolean
empathy_call_window_video_probe_cb (GstPad *pad,
GstMiniObject *mini_obj,
return TRUE;
}
+#endif
/* Called from the streaming thread */
static gboolean
GstPad *pad;
- g_mutex_lock (priv->lock);
+ g_mutex_lock (&priv->lock);
g_object_get (content, "media-type", &media_type, NULL);
g_idle_add (empathy_call_window_show_video_output_cb, self);
pad = empathy_call_window_get_video_sink_pad (self);
+#ifdef HAVE_GST1
+ gst_pad_add_probe (src,
+ GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_BUFFER_LIST,
+ empathy_call_window_video_probe_cb, self, NULL);
+#else
gst_pad_add_data_probe (src,
G_CALLBACK (empathy_call_window_video_probe_cb), self);
+#endif
if (priv->got_video_src > 0)
g_source_remove (priv->got_video_src);
- priv->got_video_src = g_timeout_add_seconds (5,
+ priv->got_video_src = g_timeout_add_seconds (1,
empathy_call_window_check_video_cb, self);
break;
default:
}
- g_mutex_unlock (priv->lock);
+ g_mutex_unlock (&priv->lock);
return TRUE;
}
if (GST_PAD_LINK_FAILED (gst_pad_link (pad, sink)))
{
gst_bin_remove (GST_BIN (priv->pipeline), priv->audio_input);
+ gst_object_unref (pad);
g_warning ("Could not link audio source to farsight");
break;
}
+ gst_object_unref (pad);
if (gst_element_set_state (priv->audio_input, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE)
{
case FS_MEDIA_TYPE_VIDEO:
if (priv->video_tee != NULL)
{
+#ifdef HAVE_GST1
+ pad = gst_element_get_request_pad (priv->video_tee, "src_%u");
+#else
pad = gst_element_get_request_pad (priv->video_tee, "src%d");
+#endif
if (GST_PAD_LINK_FAILED (gst_pad_link (pad, sink)))
{
g_warning ("Could not link video source input pipeline");
priv->video_preview = NULL;
gtk_widget_set_sensitive (priv->camera_button, FALSE);
+ empathy_camera_menu_set_sensitive (priv->camera_menu, FALSE);
}
static void
{
EmpathyCallWindowPriv *priv = GET_PRIV (self);
+ g_signal_emit (self, signals[SIG_INHIBIT], 0, TRUE);
+
priv->call_started = TRUE;
empathy_call_handler_start_call (priv->handler,
gtk_get_current_event_time ());
if (empathy_call_handler_has_initial_video (priv->handler))
{
- TpyCallChannel *call;
- TpySendingState s;
+ TpCallChannel *call;
+ TpSendingState s;
g_object_get (priv->handler, "call-channel", &call, NULL);
/* If the call channel isn't set yet we're requesting it, if we're
* requesting it with initial video it should be PENDING_SEND when we get
* it */
if (call == NULL)
- s = TPY_SENDING_STATE_PENDING_SEND;
+ s = TP_SENDING_STATE_PENDING_SEND;
else
- s = tpy_call_channel_get_video_state (call);
+ s = empathy_call_channel_get_video_state (call);
- if (s == TPY_SENDING_STATE_PENDING_SEND ||
- s == TPY_SENDING_STATE_SENDING)
+ if (s == TP_SENDING_STATE_PENDING_SEND ||
+ s == TP_SENDING_STATE_SENDING)
{
/* Enable 'send video' buttons and display the preview */
- gtk_toggle_tool_button_set_active (
- GTK_TOGGLE_TOOL_BUTTON (priv->camera_button), TRUE);
+ gtk_toggle_button_set_active (
+ GTK_TOGGLE_BUTTON (priv->camera_button), TRUE);
}
else
{
- gtk_toggle_tool_button_set_active (
- GTK_TOGGLE_TOOL_BUTTON (priv->camera_button), FALSE);
+ gtk_toggle_button_set_active (
+ GTK_TOGGLE_BUTTON (priv->camera_button), FALSE);
if (priv->video_preview == NULL)
{
start_call (self);
}
}
- if (GST_MESSAGE_SRC (message) == GST_OBJECT (priv->video_preview_sink))
+ if (priv->video_preview_sink != NULL &&
+ GST_MESSAGE_SRC (message) == GST_OBJECT (priv->video_preview_sink))
{
gst_message_parse_state_changed (message, NULL, &newstate,
&pending);
GError *error = NULL;
GstElement *gst_error;
gchar *debug;
+ gchar *name;
gst_message_parse_error (message, &error, &debug);
gst_error = GST_ELEMENT (GST_MESSAGE_SRC (message));
g_message ("Element error: %s -- %s\n", error->message, debug);
- if (g_str_has_prefix (gst_element_get_name (gst_error),
- VIDEO_INPUT_ERROR_PREFIX))
+ name = gst_element_get_name (gst_error);
+ if (g_str_has_prefix (name, VIDEO_INPUT_ERROR_PREFIX))
{
/* Remove the video input and continue */
if (priv->video_input != NULL)
{
empathy_call_window_disconnected (self, TRUE);
}
+ g_free (name);
g_error_free (error);
g_free (debug);
}
}
static void
-empathy_call_window_members_changed_cb (TpyCallChannel *call,
- GHashTable *members,
+empathy_call_window_members_changed_cb (TpCallChannel *call,
+ GHashTable *updates,
+ GPtrArray *removed,
+ TpCallStateReason *reason,
EmpathyCallWindow *self)
{
EmpathyCallWindowPriv *priv = GET_PRIV (self);
gpointer key, value;
gboolean held = FALSE;
- g_hash_table_iter_init (&iter, members);
+ g_hash_table_iter_init (&iter, updates);
while (g_hash_table_iter_next (&iter, &key, &value))
{
- if (GPOINTER_TO_INT (value) & TPY_CALL_MEMBER_FLAG_HELD)
+ if (GPOINTER_TO_INT (value) & TP_CALL_MEMBER_FLAG_HELD)
{
/* This assumes this is a 1-1 call, otherwise one participant
* putting the call on hold wouldn't mean the call is on hold
EmpathyCallWindow *self)
{
EmpathyCallWindowPriv *priv = GET_PRIV (self);
- TpyCallChannel *call;
+ TpCallChannel *call;
g_object_get (priv->handler, "call-channel", &call, NULL);
if (call == NULL)
tp_g_signal_connect_object (call, "members-changed",
G_CALLBACK (empathy_call_window_members_changed_cb), self, 0);
- tp_cli_channel_interface_dtmf_connect_to_stopped_tones (TP_CHANNEL (call),
- empathy_call_window_tones_stopped_cb, self, NULL,
- G_OBJECT (call), NULL);
-
g_object_unref (call);
}
empathy_call_window_connect_handler (EmpathyCallWindow *self)
{
EmpathyCallWindowPriv *priv = GET_PRIV (self);
- TpyCallChannel *call;
+ TpCallChannel *call;
g_signal_connect (priv->handler, "state-changed",
G_CALLBACK (empathy_call_window_state_changed_cb), self);
{
EmpathyCallWindowPriv *priv = GET_PRIV (window);
- gtk_container_set_border_width (GTK_CONTAINER (priv->content_hbox),
- set_fullscreen ? 0 : CONTENT_HBOX_BORDER_WIDTH);
gtk_box_set_spacing (GTK_BOX (priv->content_hbox),
set_fullscreen ? 0 : CONTENT_HBOX_SPACING);
show_controls (window, set_fullscreen);
show_borders (window, set_fullscreen);
gtk_action_set_stock_id (priv->menu_fullscreen,
- (set_fullscreen ? "gtk-leave-fullscreen" : "gtk-fullscreen"));
+ (set_fullscreen ? "view-restore" : "view-fullscreen"));
priv->is_fullscreen = set_fullscreen;
}
CameraState state)
{
EmpathyCallWindowPriv *priv = GET_PRIV (window);
- TpyCallChannel *call;
+ TpCallChannel *call;
priv->sending_video = (state == CAMERA_STATE_ON);
g_object_get (priv->handler, "call-channel", &call, NULL);
DEBUG ("%s sending video", priv->sending_video ? "start": "stop");
- tpy_call_channel_send_video (call, priv->sending_video);
+ empathy_call_channel_send_video (call, priv->sending_video);
g_object_unref (call);
}
empathy_call_window_hangup_cb (gpointer object,
EmpathyCallWindow *self)
{
+ /* stopping the call will put it the ENDED state and
+ * from state_changed_cb we'll reconfigure the window
+ */
empathy_call_handler_stop_call (self->priv->handler);
-
- empathy_call_window_disconnected (self, TRUE);
}
static void
GdkEventKey *event, EmpathyCallWindow *window)
{
EmpathyCallWindowPriv *priv = GET_PRIV (window);
+ gchar key;
if (priv->is_fullscreen && event->keyval == GDK_KEY_Escape)
{
return TRUE;
}
- return FALSE;
+ key = gdk_keyval_to_unicode (event->keyval);
+ switch (key)
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case '*':
+ case '#':
+ break;
+ default:
+ return TRUE;
+ break;
+ }
+
+ gtk_toggle_tool_button_set_active (
+ GTK_TOGGLE_TOOL_BUTTON (priv->dialpad_button), TRUE);
+
+ empathy_dialpad_widget_press_key (
+ EMPATHY_DIALPAD_WIDGET (priv->dtmf_panel), key);
+
+ return TRUE;
}
static gboolean
{
return EMPATHY_GST_VIDEO_SRC (self->priv->video_input);
}
+
+void
+empathy_call_window_change_webcam (EmpathyCallWindow *self,
+ const gchar *device)
+{
+ EmpathyGstVideoSrc *video;
+ gboolean running;
+
+ /* Restart the camera only if it's already running */
+ running = (self->priv->video_preview != NULL);
+ video = empathy_call_window_get_video_src (self);
+
+ if (running)
+ empathy_call_window_play_camera (self, FALSE);
+
+ empathy_video_src_change_device (video, device);
+
+ if (running)
+ empathy_call_window_play_camera (self, TRUE);
+}