自学教程：C++ tp_strdiff函数代码示例

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 voidempathy_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;    }}

static voidtp_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 voidupdate_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 voidconference_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 voidgot_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);	}}

voidconn_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 gbooleanset_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 voidempathy_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);}

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;}

voidconn_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 ();    }}

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 EmpathyCapabilitieschannel_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 voidcheck_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;}

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;}

gbooleanempathy_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 gbooleancontact_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 gbooleancontact_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 gbooleantp_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 gbooleanimport_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 voidaccount_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);    }}