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);
}
Exemplo n.º 2
0
const gchar *
empathy_account_get_error_message (TpAccount *account,
    gboolean *user_requested)
{
  const gchar *dbus_error;
  const gchar *message;
  const GHashTable *details = NULL;
  TpConnectionStatusReason reason;

  dbus_error = tp_account_get_detailed_error (account, &details);

  if (user_requested != NULL)
    {
      if (tp_asv_get_boolean (details, "user-requested", NULL))
        *user_requested = TRUE;
      else
        *user_requested = FALSE;
    }

  message = empathy_dbus_error_name_get_default_message (dbus_error);
  if (message != NULL)
    return message;

  tp_account_get_connection_status (account, &reason);

  DEBUG ("Don't understand error '%s'; fallback to the status reason (%u)",
    dbus_error, reason);

  return empathy_status_reason_get_default_message (reason);
}
static void
new_chatroom_dialog_select_last_account (GSettings             *gsettings,
                                         EmpathyAccountChooser *account_chooser)
{
	const gchar          *account_path;
	TpAccountManager      *manager;
	TpSimpleClientFactory *factory;
	TpAccount             *account;
	TpConnectionStatus    status;

	account_path = g_settings_get_string (gsettings, EMPATHY_PREFS_CHAT_ROOM_LAST_ACCOUNT);
	DEBUG ("Selecting account path '%s'", account_path);

	manager =  tp_account_manager_dup ();
	factory = tp_proxy_get_factory (manager);
	account = tp_simple_client_factory_ensure_account (factory,
	                                                   account_path,
	                                                   NULL,
	                                                   NULL);

	if (account != NULL) {
		status = tp_account_get_connection_status (account, NULL);
		if (status == TP_CONNECTION_STATUS_CONNECTED) {
			empathy_account_chooser_set_account (account_chooser,
			                                     account);
		}
		g_object_unref (account);
	}
	g_object_unref (manager);
}
/**
 * empathy_account_chooser_filter_supports_multichat:
 * @account: a #TpAccount
 * @user_data: user data or %NULL
 *
 * An #EmpathyAccountChooserFilterFunc that returns accounts that both
 * support multiuser text chat and are connected.
 *
 * Return value: TRUE if @account both supports muc and is connected
 */
static gboolean
empathy_account_chooser_filter_supports_multichat (TpAccount *account,
						   gpointer   user_data)
{
	TpConnection *connection;
	EmpathyDispatcher *dispatcher;
	GList *classes;

	if (tp_account_get_connection_status (account, NULL) !=
	    TP_CONNECTION_STATUS_CONNECTED)
	return FALSE;

	/* check if CM supports multiuser text chat */
	connection = tp_account_get_connection (account);
	if (connection == NULL)
		return FALSE;

	dispatcher = empathy_dispatcher_dup_singleton ();

	classes = empathy_dispatcher_find_requestable_channel_classes
		(dispatcher, connection, TP_IFACE_CHANNEL_TYPE_TEXT,
		TP_HANDLE_TYPE_ROOM, NULL);

	g_object_unref (dispatcher);

	if (classes == NULL)
		return FALSE;

	g_list_free (classes);
	return TRUE;
}
Exemplo n.º 5
0
/* This function returns %TRUE if EmpathyIdle considers the account
 * @account as having just connected recently. Otherwise, it returns
 * %FALSE. In doubt, %FALSE is returned. */
gboolean
empathy_idle_account_is_just_connected (EmpathyIdle *idle,
					TpAccount *account)
{
	EmpathyIdlePriv *priv = GET_PRIV (idle);
	GTimeVal val;
	gpointer ptr;
	glong t;

	if (tp_account_get_connection_status (account, NULL)
	    != TP_CONNECTION_STATUS_CONNECTED) {
		return FALSE;
	}

	ptr = g_hash_table_lookup (priv->connect_times, account);

	if (ptr == NULL) {
		return FALSE;
	}

	t = GPOINTER_TO_INT (ptr);

	g_get_current_time (&val);

	return (val.tv_sec - t) < ACCOUNT_IS_JUST_CONNECTED_SECONDS;
}
/**
 * empathy_account_chooser_filter_supports_multichat:
 * @account: a #TpAccount
 * @callback: an #EmpathyAccountChooserFilterResultCallback accepting the result
 * @callback_data: data passed to the @callback
 * @user_data: user data or %NULL
 *
 * An #EmpathyAccountChooserFilterFunc that returns accounts that both
 * support multiuser text chat and are connected.
 *
 * Returns (via the callback) TRUE if @account both supports muc and is connected
 */
void
empathy_account_chooser_filter_supports_chatrooms (
	TpAccount                                 *account,
	EmpathyAccountChooserFilterResultCallback  callback,
	gpointer                                   callback_data,
	gpointer                                   user_data)
{
	TpConnection       *connection;
	FilterCallbackData *cb_data;
	GQuark              features[] = { TP_CONNECTION_FEATURE_CAPABILITIES, 0 };

	if (tp_account_get_connection_status (account, NULL) !=
		TP_CONNECTION_STATUS_CONNECTED) {
		callback (FALSE, callback_data);
		return;
	}

	/* check if CM supports multiuser text chat */
	connection = tp_account_get_connection (account);
	if (connection == NULL) {
		callback (FALSE, callback_data);
		return;
	}

	cb_data = g_slice_new0 (FilterCallbackData);
	cb_data->callback = callback;
	cb_data->user_data = callback_data;

	tp_proxy_prepare_async (connection, features, conn_prepared_cb,
		cb_data);
}
static void
presence_chooser_constructed (GObject *self)
{
  PresenceChooserPrivate *priv = GET_PRIVATE (self);

  g_signal_connect_swapped (priv->account, "status-changed",
      G_CALLBACK (_status_changed), self);

  _status_changed (PRESENCE_CHOOSER (self), 0,
      tp_account_get_connection_status (priv->account, NULL),
      0, priv->account);
}
Exemplo n.º 8
0
/**
 * empathy_account_chooser_filter_is_connected:
 * @account: a #TpAccount
 * @callback: an #EmpathyAccountChooserFilterResultCallback accepting the result
 * @callback_data: data passed to the @callback
 * @user_data: user data or %NULL
 *
 * A useful #EmpathyAccountChooserFilterFunc that one could pass into
 * empathy_account_chooser_set_filter() and only show connected accounts.
 *
 * Returns (via the callback) TRUE is @account is connected
 */
void
empathy_account_chooser_filter_is_connected (TpAccount *account,
  EmpathyAccountChooserFilterResultCallback callback,
  gpointer callback_data,
  gpointer user_data)
{
  gboolean is_connected =
    tp_account_get_connection_status (account, NULL)
    == TP_CONNECTION_STATUS_CONNECTED;

  callback (is_connected, callback_data);
}
Exemplo n.º 9
0
gboolean
empathy_account_manager_get_accounts_connected (gboolean *connecting)
{
  TpAccountManager *manager;
  GList *accounts, *l;
  gboolean out_connecting = FALSE;
  gboolean out_connected = FALSE;

  manager = tp_account_manager_dup ();

  if (G_UNLIKELY (!tp_proxy_is_prepared (manager,
          TP_ACCOUNT_MANAGER_FEATURE_CORE)))
    g_critical (G_STRLOC ": %s called before AccountManager ready", G_STRFUNC);

  accounts = tp_account_manager_dup_valid_accounts (manager);

  for (l = accounts; l != NULL; l = l->next)
    {
      TpConnectionStatus s = tp_account_get_connection_status (
          TP_ACCOUNT (l->data), NULL);

      if (s == TP_CONNECTION_STATUS_CONNECTING)
        out_connecting = TRUE;
      else if (s == TP_CONNECTION_STATUS_CONNECTED)
        out_connected = TRUE;

      if (out_connecting && out_connected)
        break;
    }

  g_list_free_full (accounts, g_object_unref);
  g_object_unref (manager);

  if (connecting != NULL)
    *connecting = out_connecting;

  return out_connected;
}
Exemplo n.º 10
0
static void
update_join_button_sensitivity (EmpathyNewChatroomDialog *dialog)
{
	const gchar           *room;
	gboolean               sensitive = FALSE;


	room = gtk_entry_get_text (GTK_ENTRY (dialog->entry_room));
	if (EMP_STR_EMPTY (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);
}
/* This function returns %TRUE if EmpathyPresenceManager considers the account
 * @account as having just connected recently. Otherwise, it returns
 * %FALSE. In doubt, %FALSE is returned. */
gboolean
empathy_presence_manager_account_is_just_connected (
    EmpathyPresenceManager *self,
    TpAccount *account)
{
  GTimeVal val;
  gpointer ptr;
  glong t;

  if (tp_account_get_connection_status (account, NULL)
      != TP_CONNECTION_STATUS_CONNECTED)
    return FALSE;

  ptr = g_hash_table_lookup (self->priv->connect_times, account);

  if (ptr == NULL)
    return FALSE;

  t = GPOINTER_TO_INT (ptr);

  g_get_current_time (&val);

  return (val.tv_sec - t) < ACCOUNT_IS_JUST_CONNECTED_SECONDS;
}
Exemplo n.º 12
0
static void
_update_placeholder_state (MnbPeoplePanel *self)
{
  MnbPeoplePanelPrivate *priv = GET_PRIVATE (self);
  gint accounts_available = 0;
  gint accounts_online = 0;
  GList *accounts;

  for (accounts = tp_account_manager_get_valid_accounts (priv->am);
       accounts != NULL;
       accounts = g_list_delete_link (accounts, accounts))
  {
    TpAccount *account = accounts->data;

    if (!tp_account_is_enabled (account))
      continue;

    accounts_available++;

    if (tp_account_get_connection_status (account, NULL) ==
        TP_CONNECTION_STATUS_CONNECTED)
      accounts_online++;
  }

  /* There is something in the model, hide all placeholders */
  if (clutter_model_get_first_iter (CLUTTER_MODEL (priv->model)))
  {
    clutter_actor_hide (priv->no_people_tile);
    clutter_actor_hide (priv->everybody_offline_tile);

    /* Ensure content stuff is visible */
    clutter_actor_show (priv->main_scroll_view);

    if (accounts_available > 0 && accounts_online == 0)
    {
      clutter_actor_show (priv->offline_banner);
    } else {
      clutter_actor_hide (priv->offline_banner);
    }
  } else {
    /* Hide real content stuff */
    clutter_actor_hide (priv->main_scroll_view);

    if (accounts_online == 0)
    {
      if (accounts_available == 0)
      {
        clutter_actor_show (priv->no_people_tile);
        clutter_actor_hide (priv->everybody_offline_tile);
        clutter_actor_hide (priv->offline_banner);
      } else {
        clutter_actor_show (priv->offline_banner);
        clutter_actor_hide (priv->no_people_tile);
        clutter_actor_hide (priv->everybody_offline_tile);
      }
    } else {
      clutter_actor_show (priv->everybody_offline_tile);
      clutter_actor_hide (priv->no_people_tile);
      clutter_actor_hide (priv->offline_banner);
    }
  }
}