static EmpathyRosterGroup *
ensure_roster_group (EmpathyRosterView *self,
const gchar *group)
{
GtkWidget *roster_group;
roster_group = (GtkWidget *) lookup_roster_group (self, group);
if (roster_group != NULL)
return EMPATHY_ROSTER_GROUP (roster_group);
if (!tp_strdiff (group, EMPATHY_ROSTER_MODEL_GROUP_TOP_GROUP))
roster_group = empathy_roster_group_new (group, "emblem-favorite-symbolic");
else if (!tp_strdiff (group, EMPATHY_ROSTER_MODEL_GROUP_PEOPLE_NEARBY))
roster_group = empathy_roster_group_new (group, "im-local-xmpp");
else
roster_group = empathy_roster_group_new (group, NULL);
gtk_expander_set_expanded (EMPATHY_ROSTER_GROUP (roster_group)->expander,
empathy_contact_group_get_expanded (group));
g_signal_connect (EMPATHY_ROSTER_GROUP (roster_group)->expander,
"notify::expanded", G_CALLBACK (group_expanded_cb), roster_group);
gtk_widget_show (roster_group);
gtk_container_add (GTK_CONTAINER (self), roster_group);
g_hash_table_insert (self->priv->roster_groups, g_strdup (group),
roster_group);
return EMPATHY_ROSTER_GROUP (roster_group);
}
static void
empathy_irc_network_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
EmpathyIrcNetwork *self = EMPATHY_IRC_NETWORK (object);
EmpathyIrcNetworkPriv *priv = GET_PRIV (self);
switch (property_id)
{
case PROP_NAME:
if (tp_strdiff (priv->name, g_value_get_string (value)))
{
g_free (priv->name);
priv->name = g_value_dup_string (value);
g_signal_emit (object, signals[MODIFIED], 0);
}
break;
case PROP_CHARSET:
if (tp_strdiff (priv->charset, g_value_get_string (value)))
{
g_free (priv->charset);
priv->charset = g_value_dup_string (value);
g_signal_emit (object, signals[MODIFIED], 0);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
void
empathy_idle_set_presence (EmpathyIdle *idle,
TpConnectionPresenceType state,
const gchar *status)
{
EmpathyIdlePriv *priv;
const gchar *default_status;
priv = GET_PRIV (idle);
DEBUG ("Changing presence to %s (%d)", status, state);
/* Do not set translated default messages */
default_status = empathy_presence_get_default_message (state);
if (!tp_strdiff (status, default_status)) {
status = NULL;
}
if (state != TP_CONNECTION_PRESENCE_TYPE_OFFLINE &&
!empathy_connectivity_is_online (priv->connectivity)) {
DEBUG ("Empathy is not online");
priv->saved_state = state;
if (tp_strdiff (priv->status, status)) {
g_free (priv->saved_status);
priv->saved_status = NULL;
if (!EMP_STR_EMPTY (status)) {
priv->saved_status = g_strdup (status);
}
}
return;
}
empathy_idle_do_set_presence (idle, state, status);
}
static void
tp_contact_notify_cb (TpContact *tp_contact,
GParamSpec *param,
GObject *contact)
{
EmpathyContactPriv *priv = GET_PRIV (contact);
/* Forward property notifications */
if (!tp_strdiff (param->name, "alias"))
g_object_notify (contact, "name");
else if (!tp_strdiff (param->name, "presence-type")) {
McPresence presence;
presence = empathy_contact_get_presence (EMPATHY_CONTACT (contact));
g_signal_emit (contact, signals[PRESENCE_CHANGED], 0, presence, priv->presence);
priv->presence = presence;
g_object_notify (contact, "presence");
}
else if (!tp_strdiff (param->name, "presence-message"))
g_object_notify (contact, "presence-message");
else if (!tp_strdiff (param->name, "identifier"))
g_object_notify (contact, "id");
else if (!tp_strdiff (param->name, "handle"))
g_object_notify (contact, "handle");
}
static void
update_join_button_sensitivity (EmpathyNewChatroomDialog *dialog)
{
const gchar *room;
const gchar *protocol;
gboolean sensitive = FALSE;
room = gtk_entry_get_text (GTK_ENTRY (dialog->entry_room));
protocol = tp_account_get_protocol (dialog->account);
if (EMP_STR_EMPTY (room))
goto out;
if (!tp_strdiff (protocol, "irc") && (!tp_strdiff (room, "#") ||
!tp_strdiff (room, "&")))
{
goto out;
}
if (dialog->account == NULL)
goto out;
if (tp_account_get_connection_status (dialog->account, NULL) !=
TP_CONNECTION_STATUS_CONNECTED)
goto out;
sensitive = TRUE;
out:
gtk_widget_set_sensitive (dialog->button_join, sensitive);
}
static void
conference_element_added (FsElementAddedNotifier *notifier,
GstBin *bin,
GstElement *element,
gpointer user_data)
{
GstElementFactory *factory;
const gchar *name;
factory = gst_element_get_factory (element);
name = gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory));
if (!tp_strdiff (name, "x264enc"))
{
/* Ensure that the encoder creates the baseline profile */
g_object_set (element,
"byte-stream", TRUE,
"bframes", 0,
"b-adapt", FALSE,
"cabac", FALSE,
"dct8x8", FALSE,
NULL);
}
else if (!tp_strdiff (name, "gstrtpbin"))
{
/* Lower the jitterbuffer latency to make it more suitable for video
* conferencing */
g_object_set (element, "latency", 100, NULL);
}
}
static EmpathyContact *
contact_manager_lookup_contact (EmpathyContactManager *manager,
const gchar *account_name,
const gchar *contact_id)
{
EmpathyContact *retval = NULL;
GList *members, *l;
/* XXX: any more efficient way to do this (other than having to build
* and maintain a hash)? */
members = empathy_contact_list_get_members (
EMPATHY_CONTACT_LIST (manager));
for (l = members; l; l = l->next) {
EmpathyContact *contact = l->data;
TpAccount *account = empathy_contact_get_account (contact);
const gchar *id_cur;
const gchar *name_cur;
id_cur = empathy_contact_get_id (contact);
name_cur = tp_proxy_get_object_path (TP_PROXY (account));
if (!tp_strdiff (contact_id, id_cur) &&
!tp_strdiff (account_name, name_cur)) {
retval = contact;
}
g_object_unref (contact);
}
g_list_free (members);
return retval;
}
gboolean
_capabilities_has_stream_tube (TpCapabilities *caps)
{
GPtrArray *classes;
guint i;
if (caps == NULL)
return FALSE;
classes = tp_capabilities_get_channel_classes (caps);
for (i = 0; i < classes->len; i++)
{
GValueArray *arr = g_ptr_array_index (classes, i);
GHashTable *fixed;
const gchar *chan_type;
const gchar *service;
TpHandleType handle_type;
fixed = g_value_get_boxed (g_value_array_get_nth (arr, 0));
chan_type = tp_asv_get_string (fixed, TP_PROP_CHANNEL_CHANNEL_TYPE);
service = tp_asv_get_string (fixed,
TP_PROP_CHANNEL_TYPE_STREAM_TUBE_SERVICE);
handle_type = tp_asv_get_uint32 (fixed,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, NULL);
if (!tp_strdiff (chan_type, TP_IFACE_CHANNEL_TYPE_STREAM_TUBE) &&
handle_type == TP_HANDLE_TYPE_CONTACT &&
(!tp_capabilities_is_specific_to_contact (caps) ||
!tp_strdiff (service, TUBE_SERVICE)))
return TRUE;
}
return FALSE;
}
static void
got_list_channel (EmpathyTpContactList *list,
TpChannel *channel)
{
EmpathyTpContactListPriv *priv = GET_PRIV (list);
const gchar *id;
/* We requested that channel by providing TargetID property, so it's
* guaranteed that tp_channel_get_identifier will return it. */
id = tp_channel_get_identifier (channel);
/* TpChannel emits initial set of members just before being ready */
if (!tp_strdiff (id, "stored")) {
if (priv->stored != NULL)
return;
priv->stored = g_object_ref (channel);
g_signal_connect (priv->stored, "group-members-changed",
G_CALLBACK (tp_contact_list_store_group_members_changed_cb),
list);
} else if (!tp_strdiff (id, "publish")) {
if (priv->publish != NULL)
return;
priv->publish = g_object_ref (channel);
g_signal_connect (priv->publish, "group-members-changed",
G_CALLBACK (tp_contact_list_publish_group_members_changed_cb),
list);
} else if (!tp_strdiff (id, "subscribe")) {
if (priv->subscribe != NULL)
return;
priv->subscribe = g_object_ref (channel);
g_signal_connect (priv->subscribe, "group-members-changed",
G_CALLBACK (tp_contact_list_subscribe_group_members_changed_cb),
list);
}
}
void
conn_location_properties_getter (GObject *object,
GQuark interface,
GQuark name,
GValue *value,
gpointer getter_data)
{
GabbleConnection *conn = GABBLE_CONNECTION (object);
if (!tp_strdiff (g_quark_to_string (name), "LocationAccessControlTypes"))
{
guint access_control_type =
TP_RICH_PRESENCE_ACCESS_CONTROL_TYPE_PUBLISH_LIST;
GArray *access_control = g_array_sized_new (FALSE, FALSE,
sizeof (guint), 1);
g_array_append_val (access_control, access_control_type);
g_value_take_boxed (value, access_control);
}
else if (!tp_strdiff (g_quark_to_string (name), "LocationAccessControl"))
{
GValueArray *access_control = g_value_array_new (2);
GValue type = {0,};
GValue variant = {0,};
GValue *allocated_value;
/* G_TYPE_UINT is the D-Bus type of TpRichPresenceAccessControlType */
g_value_init (&type, G_TYPE_UINT);
g_value_set_uint (&type,
TP_RICH_PRESENCE_ACCESS_CONTROL_TYPE_PUBLISH_LIST);
g_value_array_append (access_control, &type);
g_value_unset (&type);
g_value_init (&variant, G_TYPE_VALUE);
/* For Publish_List, the variant isn't used, so we set a dummy value,
* (guint) 0 */
allocated_value = tp_g_value_slice_new (G_TYPE_UINT);
g_value_set_uint (allocated_value, 0);
g_value_set_boxed (&variant, allocated_value);
g_value_array_append (access_control, &variant);
g_value_unset (&variant);
tp_g_value_slice_free (allocated_value);
g_value_take_boxed (value, access_control);
}
else if (name == g_quark_from_static_string ("SupportedLocationFeatures"))
{
TpLocationFeatures flags = 0;
if (conn->features & GABBLE_CONNECTION_FEATURES_PEP)
flags |= TP_LOCATION_FEATURE_CAN_SET;
g_value_set_uint (value, flags);
}
else
{
g_assert_not_reached ();
}
}
static gboolean
set_own_status (GObject *object,
const TpPresenceStatus *status,
GError **error)
{
ExampleCallConnection *self =
EXAMPLE_CALL_CONNECTION (object);
TpBaseConnection *base = TP_BASE_CONNECTION (object);
GHashTable *presences;
const gchar *message = "";
if (status->optional_arguments != NULL)
{
GValue *v = g_hash_table_lookup (status->optional_arguments, "message");
if (v != NULL && G_VALUE_HOLDS_STRING (v))
{
message = g_value_get_string (v);
if (message == NULL)
message = "";
}
}
if (status->index == EXAMPLE_CALL_PRESENCE_AWAY)
{
if (self->priv->away && !tp_strdiff (message,
self->priv->presence_message))
return TRUE;
self->priv->away = TRUE;
}
else
{
if (!self->priv->away && !tp_strdiff (message,
self->priv->presence_message))
return TRUE;
self->priv->away = FALSE;
}
g_free (self->priv->presence_message);
self->priv->presence_message = g_strdup (message);
presences = g_hash_table_new_full (g_direct_hash, g_direct_equal,
NULL, NULL);
g_hash_table_insert (presences, GUINT_TO_POINTER (base->self_handle),
(gpointer) status);
tp_presence_mixin_emit_presence_update (object, presences);
g_hash_table_destroy (presences);
if (!self->priv->away)
{
g_signal_emit (self, signals[SIGNAL_AVAILABLE], 0, message);
}
return TRUE;
}
static void
empathy_tube_dispatch_constructed (GObject *object)
{
EmpathyTubeDispatch *self = EMPATHY_TUBE_DISPATCH (object);
EmpathyTubeDispatchPriv *priv = GET_PRIV (self);
TpChannel *channel;
GHashTable *properties;
const gchar *service;
const gchar *channel_type;
TpTubeType type;
priv->dbus = tp_dbus_daemon_new (tp_get_bus());
channel = empathy_dispatch_operation_get_channel (priv->operation);
properties = tp_channel_borrow_immutable_properties (channel);
channel_type = tp_asv_get_string (properties,
TP_IFACE_CHANNEL ".ChannelType");
if (channel_type == NULL)
goto failed;
if (!tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_STREAM_TUBE))
{
type = TP_TUBE_TYPE_STREAM;
service = tp_asv_get_string (properties,
EMP_IFACE_CHANNEL_TYPE_STREAM_TUBE ".Service");
}
else if (!tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_DBUS_TUBE))
{
type = TP_TUBE_TYPE_DBUS;
service = tp_asv_get_string (properties,
EMP_IFACE_CHANNEL_TYPE_DBUS_TUBE ".ServiceName");
}
else
{
goto failed;
}
if (service == NULL)
goto failed;
priv->bus_name = empathy_tube_handler_build_bus_name (type, service);
priv->object_path = empathy_tube_handler_build_object_path (type, service);
priv->service = g_strdup (service);
DEBUG ("Look for tube handler %s\n", priv->bus_name);
tp_cli_dbus_daemon_call_name_has_owner (priv->dbus, -1, priv->bus_name,
empathy_tube_dispatch_name_has_owner_cb, NULL, NULL, G_OBJECT (self));
return;
failed:
empathy_tube_dispatch_set_ability (self,
EMPATHY_TUBE_DISPATCHABILITY_IMPOSSIBLE);
}
static void
preferences_theme_notify_cb (GSettings *gsettings,
const gchar *key,
gpointer user_data)
{
EmpathyPreferences *preferences = user_data;
EmpathyPreferencesPriv *priv = GET_PRIV (preferences);
GtkComboBox *combo;
gchar *conf_name;
gchar *conf_path;
GtkTreeModel *model;
GtkTreeIter iter;
gboolean found = FALSE;
conf_name = g_settings_get_string (gsettings, EMPATHY_PREFS_CHAT_THEME);
conf_path = g_settings_get_string (gsettings, EMPATHY_PREFS_CHAT_ADIUM_PATH);
combo = GTK_COMBO_BOX (priv->combobox_chat_theme);
model = gtk_combo_box_get_model (combo);
if (gtk_tree_model_get_iter_first (model, &iter)) {
gboolean is_adium;
gchar *name;
gchar *path;
do {
gtk_tree_model_get (model, &iter,
COL_COMBO_IS_ADIUM, &is_adium,
COL_COMBO_NAME, &name,
COL_COMBO_PATH, &path,
-1);
if (!tp_strdiff (name, conf_name)) {
if (tp_strdiff (name, "adium") ||
!tp_strdiff (path, conf_path)) {
found = TRUE;
gtk_combo_box_set_active_iter (combo, &iter);
g_free (name);
g_free (path);
break;
}
}
g_free (name);
g_free (path);
} while (gtk_tree_model_iter_next (model, &iter));
}
/* Fallback to the first one. */
if (!found) {
if (gtk_tree_model_get_iter_first (model, &iter)) {
gtk_combo_box_set_active_iter (combo, &iter);
}
}
g_free (conf_name);
g_free (conf_path);
}
EmpathyAccountSettings *
empathy_protocol_chooser_create_account_settings (EmpathyProtocolChooser *self)
{
EmpathyAccountSettings *settings;
gchar *str;
const gchar *display_name;
TpConnectionManager *cm;
TpConnectionManagerProtocol *proto;
gchar *service;
cm = empathy_protocol_chooser_dup_selected (self, &proto, &service);
if (cm == NULL || proto == NULL)
return NULL;
if (service != NULL)
display_name = empathy_service_name_to_display_name (service);
else
display_name = empathy_protocol_name_to_display_name (proto->name);
/* Create account */
/* To translator: %s is the name of the protocol, such as "Google Talk" or
* "Yahoo!"
*/
str = g_strdup_printf (_("New %s account"), display_name);
settings = empathy_account_settings_new (cm->name, proto->name, service, str);
g_free (str);
if (!tp_strdiff (service, "google-talk"))
{
gchar *fallback_servers[] = {
"talkx.l.google.com",
"talkx.l.google.com:443,oldssl",
"talkx.l.google.com:80",
NULL};
empathy_account_settings_set_icon_name_async (settings, "im-google-talk",
NULL, NULL);
empathy_account_settings_set_strv (settings, "fallback-servers",
fallback_servers);
}
else if (!tp_strdiff (service, "facebook"))
{
empathy_account_settings_set_icon_name_async (settings, "im-facebook",
NULL, NULL);
empathy_account_settings_set_string (settings, "server",
"chat.facebook.com");
}
g_object_unref (cm);
g_free (service);
return settings;
}
static gboolean
account_assistant_chooser_enter_details_filter_func (
TpConnectionManager *cm,
TpConnectionManagerProtocol *protocol,
gpointer user_data)
{
if (!tp_strdiff (protocol->name, "local-xmpp") ||
!tp_strdiff (protocol->name, "irc"))
return FALSE;
return TRUE;
}
void
conn_location_properties_getter (GObject *object,
GQuark interface,
GQuark name,
GValue *value,
gpointer getter_data)
{
GabbleConnection *conn = GABBLE_CONNECTION (object);
if (!tp_strdiff (g_quark_to_string (name), "LocationAccessControlTypes"))
{
guint access_control_type =
TP_RICH_PRESENCE_ACCESS_CONTROL_TYPE_PUBLISH_LIST;
GArray *access_control = g_array_sized_new (FALSE, FALSE,
sizeof (guint), 1);
g_array_append_val (access_control, access_control_type);
g_value_take_boxed (value, access_control);
}
else if (!tp_strdiff (g_quark_to_string (name), "LocationAccessControl"))
{
GValueArray *access_control;
GValue dummy = G_VALUE_INIT;
/* For Publish_List, the variant isn't used, so we set a dummy value,
* (guint) 0 */
g_value_init (&dummy, G_TYPE_UINT);
g_value_set_uint (&dummy, 0);
access_control = tp_value_array_build (2,
G_TYPE_UINT,
(guint) TP_RICH_PRESENCE_ACCESS_CONTROL_TYPE_PUBLISH_LIST,
G_TYPE_VALUE, &dummy,
G_TYPE_INVALID);
g_value_unset (&dummy);
g_value_take_boxed (value, access_control);
}
else if (name == g_quark_from_static_string ("SupportedLocationFeatures"))
{
TpLocationFeatures flags = 0;
if (conn->features & GABBLE_CONNECTION_FEATURES_PEP)
flags |= TP_LOCATION_FEATURE_CAN_SET;
g_value_set_uint (value, flags);
}
else
{
g_assert_not_reached ();
}
}
gboolean
empathy_client_types_contains_mobile_device (const GStrv types) {
int i;
if (types == NULL)
return FALSE;
for (i = 0; types[i] != NULL; i++)
if (!tp_strdiff (types[i], "phone") || !tp_strdiff (types[i], "handheld"))
return TRUE;
return FALSE;
}
gchar *
empathy_protocol_icon_name (const gchar *protocol)
{
if (!tp_strdiff (protocol, "yahoojp"))
/* Yahoo Japan uses the same icon as Yahoo */
protocol = "yahoo";
else if (!tp_strdiff (protocol, "simple"))
/* SIMPLE uses the same icon as SIP */
protocol = "sip";
else if (!tp_strdiff (protocol, "sms"))
return g_strdup ("phone");
return g_strdup_printf ("im-%s", protocol);
}
static EmpathyCapabilities
channel_classes_to_capabilities (GPtrArray *classes,
gboolean audio_video)
{
EmpathyCapabilities capabilities = 0;
guint i;
for (i = 0; i < classes->len; i++) {
GValueArray *class_struct;
GHashTable *fixed_prop;
GStrv allowed_prop;
TpHandleType handle_type;
const gchar *chan_type;
class_struct = g_ptr_array_index (classes, i);
fixed_prop = g_value_get_boxed (g_value_array_get_nth (class_struct, 0));
allowed_prop = g_value_get_boxed (g_value_array_get_nth (class_struct, 1));
handle_type = tp_asv_get_uint32 (fixed_prop,
TP_IFACE_CHANNEL ".TargetHandleType", NULL);
if (handle_type != TP_HANDLE_TYPE_CONTACT)
continue;
chan_type = tp_asv_get_string (fixed_prop,
TP_IFACE_CHANNEL ".ChannelType");
if (!tp_strdiff (chan_type, TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER)) {
capabilities |= EMPATHY_CAPABILITIES_FT;
}
else if (!tp_strdiff (chan_type, TP_IFACE_CHANNEL_TYPE_STREAM_TUBE)) {
capabilities |= EMPATHY_CAPABILITIES_STREAM_TUBE;
}
else if (audio_video && !tp_strdiff (chan_type,
TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA)) {
guint j;
for (j = 0; allowed_prop[j] != NULL; j++) {
if (!tp_strdiff (allowed_prop[j],
TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA ".InitialAudio"))
capabilities |= EMPATHY_CAPABILITIES_AUDIO;
else if (!tp_strdiff (allowed_prop[j],
TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA ".InitialVideo"))
capabilities |= EMPATHY_CAPABILITIES_VIDEO;
}
}
}
return capabilities;
}
static void
check_chatroom (EmpathyChatroom *chatroom,
const gchar *name,
const gchar *room,
gboolean auto_connect,
gboolean favorite)
{
gboolean _favorite;
fail_if (tp_strdiff (empathy_chatroom_get_name (chatroom), name));
fail_if (tp_strdiff (empathy_chatroom_get_room (chatroom), room));
fail_if (empathy_chatroom_get_auto_connect (chatroom) != auto_connect);
g_object_get (chatroom, "favorite", &_favorite, NULL);
fail_if (favorite != _favorite);
}
GabbleCallMemberContent *
gabble_call_member_ensure_content (GabbleCallMember *self,
const gchar *name,
JingleMediaType mtype)
{
GabbleCallMemberPrivate *priv = self->priv;
GList *l;
GabbleCallMemberContent *content = NULL;
for (l = priv->contents ; l != NULL; l = g_list_next (l))
{
GabbleCallMemberContent *c = GABBLE_CALL_MEMBER_CONTENT (l->data);
if (gabble_call_member_content_get_media_type (c) == mtype &&
!tp_strdiff (gabble_call_member_content_get_name (c), name))
{
content = c;
break;
}
}
if (content == NULL)
{
content = gabble_call_member_content_new (name, mtype, self);
gabble_call_member_add_member_content (self, content);
}
return content;
}
EmpathyChat *
empathy_chat_window_find_chat (McAccount *account,
const gchar *id)
{
GList *l;
g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
g_return_val_if_fail (!G_STR_EMPTY (id), NULL);
for (l = chat_windows; l; l = l->next) {
EmpathyChatWindowPriv *priv;
EmpathyChatWindow *window;
GList *ll;
window = l->data;
priv = GET_PRIV (window);
for (ll = priv->chats; ll; ll = ll->next) {
EmpathyChat *chat;
chat = ll->data;
if (empathy_account_equal (account, empathy_chat_get_account (chat)) &&
!tp_strdiff (id, empathy_chat_get_id (chat))) {
return chat;
}
}
}
return NULL;
}
/* Return the TpContact on @conn associated with @individual, if any */
TpContact *
empathy_get_tp_contact_for_individual (FolksIndividual *individual,
TpConnection *conn)
{
TpContact *contact = NULL;
GeeSet *personas;
GeeIterator *iter;
personas = folks_individual_get_personas (individual);
iter = gee_iterable_iterator (GEE_ITERABLE (personas));
while (contact == NULL && gee_iterator_next (iter))
{
TpfPersona *persona = gee_iterator_get (iter);
TpConnection *contact_conn;
TpContact *contact_cur = NULL;
if (TPF_IS_PERSONA (persona))
{
contact_cur = tpf_persona_get_contact (persona);
if (contact_cur != NULL)
{
contact_conn = tp_contact_get_connection (contact_cur);
if (!tp_strdiff (tp_proxy_get_object_path (contact_conn),
tp_proxy_get_object_path (conn)))
contact = contact_cur;
}
}
g_clear_object (&persona);
}
g_clear_object (&iter);
return contact;
}
const char *
empathy_service_name_to_display_name (const gchar *service_name)
{
int i;
static struct {
const gchar *service;
const gchar *display;
gboolean translated;
} names[] = {
{ "google-talk", N_("Google Talk"), FALSE },
{ "facebook", N_("Facebook Chat"), TRUE },
{ NULL, NULL }
};
for (i = 0; names[i].service != NULL; i++)
{
if (!tp_strdiff (service_name, names[i].service))
{
if (names[i].translated)
return gettext (names[i].display);
else
return names[i].display;
}
}
return service_name;
}
gboolean
empathy_migrate_butterfly_logs (EmpathyContact *contact)
{
GSettings *gsettings = g_settings_new (EMPATHY_PREFS_SCHEMA);
gchar *cm;
/* Already in progress. */
if (butterfly_log_migration_id != 0)
return FALSE;
/* Already done. */
if (g_settings_get_boolean (gsettings, EMPATHY_PREFS_BUTTERFLY_LOGS_MIGRATED))
return FALSE;
tp_account_parse_object_path (
tp_proxy_get_object_path (empathy_contact_get_account (contact)),
&cm, NULL, NULL, NULL);
if (tp_strdiff (cm, "butterfly"))
{
g_free (cm);
return TRUE;
}
g_free (cm);
if (g_str_has_suffix (empathy_contact_get_id (contact), "#32")
|| g_str_has_suffix (empathy_contact_get_id (contact), "#1"))
return TRUE;
/* Okay, we know a new butterfly is being used, so we should migrate its logs */
butterfly_log_migration_id = g_idle_add_full (G_PRIORITY_LOW,
migrate_logs, NULL, NULL);
return FALSE;
}
static gboolean
contact_in_top (EmpathyRosterView *self,
EmpathyRosterContact *contact)
{
if (!self->priv->show_groups)
{
/* Always display top contacts in non-group mode. */
GList *groups;
FolksIndividual *individual;
gboolean result = FALSE;
individual = empathy_roster_contact_get_individual (contact);
groups = empathy_roster_model_dup_groups_for_individual (
self->priv->model, individual);
if (g_list_find_custom (groups, EMPATHY_ROSTER_MODEL_GROUP_TOP_GROUP,
(GCompareFunc) g_strcmp0) != NULL)
result = TRUE;
g_list_free_full (groups, g_free);
return result;
}
if (!tp_strdiff (empathy_roster_contact_get_group (contact),
EMPATHY_ROSTER_MODEL_GROUP_TOP_GROUP))
/* If we are displaying contacts, we only want to *always* display the
* RosterContact which is displayed at the top; not the ones displayed in
* the 'normal' group sections */
return TRUE;
return FALSE;
}
static gboolean
contact_list_store_get_group_foreach (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
FindGroup *fg)
{
gchar *str;
gboolean is_group;
/* Groups are only at the top level. */
if (gtk_tree_path_get_depth (path) != 1) {
return FALSE;
}
gtk_tree_model_get (model, iter,
EMPATHY_CONTACT_LIST_STORE_COL_NAME, &str,
EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group,
-1);
if (is_group && !tp_strdiff (str, fg->name)) {
fg->found = TRUE;
fg->iter = *iter;
}
g_free (str);
return fg->found;
}
static gboolean
tp_contact_factory_avatar_maybe_update (EmpathyTpContactFactory *tp_factory,
guint handle,
const gchar *token)
{
EmpathyContact *contact;
EmpathyAvatar *avatar;
contact = tp_contact_factory_find_by_handle (tp_factory, handle);
if (!contact) {
return TRUE;
}
/* Check if we have an avatar */
if (EMP_STR_EMPTY (token)) {
empathy_contact_set_avatar (contact, NULL);
return TRUE;
}
/* Check if the avatar changed */
avatar = empathy_contact_get_avatar (contact);
if (avatar && !tp_strdiff (avatar->token, token)) {
return TRUE;
}
/* The avatar changed, search the new one in the cache */
if (empathy_contact_load_avatar_cache (contact, token)) {
/* Got from cache, use it */
return TRUE;
}
/* Avatar is not up-to-date, we have to request it. */
return FALSE;
}
static gboolean
import_dialog_account_id_in_list (GList *accounts,
const gchar *account_id)
{
GList *l;
for (l = accounts; l; l = l->next)
{
McAccount *account = l->data;
gchar *value;
gboolean result;
if (mc_account_get_param_string (account, "account", &value)
== MC_ACCOUNT_SETTING_ABSENT)
continue;
result = tp_strdiff (value, account_id);
g_free (value);
if (!result)
return TRUE;
}
return FALSE;
}
static void
account_widget_entry_changed_common (EmpathyAccountWidget *self,
GtkEntry *entry, gboolean focus)
{
const gchar *str;
const gchar *param_name;
EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
str = gtk_entry_get_text (entry);
param_name = g_object_get_data (G_OBJECT (entry), "param_name");
if (EMP_STR_EMPTY (str))
{
const gchar *value = NULL;
empathy_account_settings_unset (priv->settings, param_name);
if (focus)
{
value = empathy_account_settings_get_string (priv->settings,
param_name);
DEBUG ("Unset %s and restore to %s", param_name, value);
gtk_entry_set_text (entry, value ? value : "");
}
}
else
{
DEBUG ("Setting %s to %s", param_name,
tp_strdiff (param_name, "password") ? str : "***");
empathy_account_settings_set_string (priv->settings, param_name, str);
}
}
