m4_define([empathy_major_version], [3])
m4_define([empathy_minor_version], [3])
-m4_define([empathy_micro_version], [4])
+m4_define([empathy_micro_version], [5])
m4_define([empathy_nano_version], [0])
dnl Display the nano_version only if it's not '0'
LIBCANBERRA_GTK_REQUIRED=0.25
LIBNOTIFY_REQUIRED=0.7.0
TELEPATHY_FARSIGHT_REQUIRED=0.0.18
-TELEPATHY_GLIB_REQUIRED=0.17.3
+TELEPATHY_GLIB_REQUIRED=0.17.5
TELEPATHY_LOGGER=0.2.10
WEBKIT_REQUIRED=1.3.13
GOA_REQUIRED=3.3.0
# those warnings later during the cycle (bgo #662662)
AC_DEFINE(GLIB_DISABLE_DEPRECATION_WARNINGS, 1, [Build with GLib deprecated])
- # telepathy-yell
- prev_top_build_prefix=$ac_top_build_prefix
- prev_ac_configure_args=$ac_configure_args
- ac_configure_args="$ac_configure_args --disable-shared-library"
- AX_CONFIG_DIR([telepathy-yell])
- ac_top_build_prefix=$prev_top_build_prefix
- ac_configure_args=$prev_ac_configure_args
- export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:"$ac_top_build_prefix"telepathy-yell/telepathy-yell
-
+# FIXME: bgo #669673
+AC_DEFINE(CLUTTER_DISABLE_DEPRECATION_WARNINGS, 1, [Build with Clutter deprecated])
+
AC_CONFIG_MACRO_DIR([m4])
AC_CONFIG_HEADERS([config.h])
AC_CONFIG_SRCDIR([configure.ac])
LT_PREREQ([2.2])
LT_INIT
-GNOME_DOC_INIT([0.17.3])
AC_PATH_PROG(DBUS_BINDING_TOOL, dbus-binding-tool)
GLIB_GSETTINGS
GLIB_GENMARSHAL=`$PKG_CONFIG glib-2.0 --variable=glib_genmarshal`
libsoup-2.4
])
- PKG_CHECK_MODULES(YELL, [telepathy-yell])
-
PKG_CHECK_MODULES(EMPATHY_AV,
[
farsight2-0.10
if test "x$enable_call" != "xno" ; then
PKG_CHECK_MODULES(EMPATHY_CALL,
[
- farsight2-0.10
- telepathy-farstream >= 0.1.2
+ farstream-0.1
+ telepathy-farstream >= 0.2.0
clutter-1.0 >= $CLUTTER_REQUIRED
clutter-gtk-1.0
clutter-gst-1.0
fi
AM_CONDITIONAL(BUILD_CHEESE, test x${have_cheese} = xyes)
+# Help documentation
+YELP_HELP_INIT
# -----------------------------------------------------------
# Coding style checks
#include <libempathy-gtk/empathy-sound-manager.h>
#include <libempathy-gtk/empathy-geometry.h>
#include <libempathy-gtk/empathy-images.h>
+ #include <libempathy-gtk/empathy-call-utils.h>
#define DEBUG_FLAG EMPATHY_DEBUG_VOIP
#include <libempathy/empathy-debug.h>
/* 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 */
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));
+ g_object_get (self->priv->handler, "call-channel", &call, NULL);
- empathy_call_window_maybe_emit_tones (self);
+ tones[0] = tp_dtmf_event_to_char (event);
+ tones[1] = '\0';
+ tp_call_channel_send_tones_async (call, tones, NULL, NULL, NULL);
+
+ g_object_unref (call);
}
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);
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");
+ else
+ g_object_set (priv->video_preview_sink, "texture", preview, NULL);
/* Add a little offset to the video preview */
layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
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)
{
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);
{
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);
g_timer_destroy (priv->timer);
- g_string_free (priv->tones, TRUE);
-
G_OBJECT_CLASS (empathy_call_window_parent_class)->finalize (object);
}
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);
-
could_reset_pipeline = empathy_call_window_reset_pipeline (self);
if (priv->call_state == CONNECTING)
#if 0
static gchar *
media_stream_error_to_txt (EmpathyCallWindow *self,
- TpyCallChannel *call,
+ TpCallChannel *call,
gboolean audio,
TpMediaStreamError error)
{
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)
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 &&
+ if (state == TP_CALL_STATE_ENDED &&
!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)
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 (
}
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);
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);
}