static void
idle_state_change_cb (EmpathyConnectivity *connectivity,
gboolean new_online,
EmpathyIdle *idle)
{
EmpathyIdlePriv *priv;
priv = GET_PRIV (idle);
if (!new_online) {
/* We are no longer connected */
DEBUG ("Disconnected: Save state %d (%s)",
priv->state, priv->status);
priv->saved_state = priv->state;
g_free (priv->saved_status);
priv->saved_status = g_strdup (priv->status);
empathy_idle_set_state (idle, TP_CONNECTION_PRESENCE_TYPE_OFFLINE);
}
else if (new_online
&& priv->saved_state != TP_CONNECTION_PRESENCE_TYPE_UNSET) {
/* We are now connected */
DEBUG ("Reconnected: Restore state %d (%s)",
priv->saved_state, priv->saved_status);
empathy_idle_set_presence (idle,
priv->saved_state,
priv->saved_status);
priv->saved_state = TP_CONNECTION_PRESENCE_TYPE_UNSET;
g_free (priv->saved_status);
priv->saved_status = NULL;
}
}
static void
presence_chooser_set_state (McPresence state,
const gchar *status)
{
EmpathyIdle *idle;
idle = empathy_idle_dup_singleton ();
empathy_idle_set_presence (idle, state, status);
g_object_unref (idle);
}
void
empathy_idle_set_status (EmpathyIdle *idle,
const gchar *status)
{
EmpathyIdlePriv *priv;
priv = GET_PRIV (idle);
empathy_idle_set_presence (idle, priv->state, status);
}
void
empathy_idle_set_state (EmpathyIdle *idle,
TpConnectionPresenceType state)
{
EmpathyIdlePriv *priv;
priv = GET_PRIV (idle);
empathy_idle_set_presence (idle, state, priv->status);
}
static void
mc_set_custom_state (EmpathyPresenceChooser *self)
{
EmpathyPresenceChooserPriv *priv = GET_PRIV (self);
GtkWidget *entry;
const char *status;
entry = gtk_bin_get_child (GTK_BIN (self));
/* update the status with MC */
status = gtk_entry_get_text (GTK_ENTRY (entry));
DEBUG ("Sending state to MC-> %d (%s)\n", priv->state, status);
empathy_idle_set_presence (priv->idle, priv->state, status);
}
static gboolean
presence_chooser_scroll_timeout_cb (EmpathyPresenceChooser *chooser)
{
EmpathyPresenceChooserPriv *priv;
priv = GET_PRIV (chooser);
priv->scroll_timeout_id = 0;
empathy_idle_set_presence (priv->idle,
priv->scroll_state,
priv->scroll_status);
g_free (priv->scroll_status);
priv->scroll_status = NULL;
return FALSE;
}
static gboolean
presence_chooser_scroll_event_cb (EmpathyPresenceChooser *chooser,
GdkEventScroll *event,
gpointer user_data)
{
EmpathyPresenceChooserPriv *priv;
GList *list, *l;
const gchar *current_status;
StateAndStatus *sas;
gboolean match;
priv = GET_PRIV (chooser);
switch (event->direction) {
case GDK_SCROLL_UP:
break;
case GDK_SCROLL_DOWN:
break;
default:
return FALSE;
}
current_status = gtk_label_get_text (GTK_LABEL (priv->label));
/* Get the list of presets, which in this context means all the items
* without a trailing "...".
*/
list = presence_chooser_get_presets (chooser);
sas = NULL;
match = FALSE;
for (l = list; l; l = l->next) {
sas = l->data;
if (sas->state == priv->last_state &&
strcmp (sas->status, current_status) == 0) {
sas = NULL;
match = TRUE;
if (event->direction == GDK_SCROLL_UP) {
if (l->prev) {
sas = l->prev->data;
}
}
else if (event->direction == GDK_SCROLL_DOWN) {
if (l->next) {
sas = l->next->data;
}
}
break;
}
sas = NULL;
}
if (sas) {
presence_chooser_reset_scroll_timeout (chooser);
priv->scroll_status = g_strdup (sas->status);
priv->scroll_state = sas->state;
priv->scroll_timeout_id =
g_timeout_add_seconds (1,
(GSourceFunc) presence_chooser_scroll_timeout_cb,
chooser);
presence_chooser_flash_stop (chooser, sas->state);
gtk_label_set_text (GTK_LABEL (priv->label), sas->status);
}
else if (!match) {
const gchar *status;
/* If we didn't get any match at all, it means the last state
* was a custom one. Just switch to the first one.
*/
status = empathy_presence_get_default_message (states[0]);
presence_chooser_reset_scroll_timeout (chooser);
empathy_idle_set_presence (priv->idle, states[0], status);
}
g_list_foreach (list, (GFunc) g_free, NULL);
g_list_free (list);
return TRUE;
}
static void
idle_session_status_changed_cb (DBusGProxy *gs_proxy,
SessionStatus status,
EmpathyIdle *idle)
{
EmpathyIdlePriv *priv;
gboolean is_idle;
priv = GET_PRIV (idle);
is_idle = (status == SESSION_STATUS_IDLE);
DEBUG ("Session idle state changed, %s -> %s",
priv->is_idle ? "yes" : "no",
is_idle ? "yes" : "no");
if (!priv->auto_away ||
(priv->saved_state == TP_CONNECTION_PRESENCE_TYPE_UNSET &&
(priv->state <= TP_CONNECTION_PRESENCE_TYPE_OFFLINE ||
priv->state == TP_CONNECTION_PRESENCE_TYPE_HIDDEN))) {
/* We don't want to go auto away OR we explicitely asked to be
* offline, nothing to do here */
priv->is_idle = is_idle;
return;
}
if (is_idle && !priv->is_idle) {
TpConnectionPresenceType new_state;
/* We are now idle */
idle_ext_away_start (idle);
if (priv->saved_state != TP_CONNECTION_PRESENCE_TYPE_UNSET) {
/* We are disconnected, when coming back from away
* we want to restore the presence before the
* disconnection. */
priv->away_saved_state = priv->saved_state;
} else {
priv->away_saved_state = priv->state;
}
new_state = TP_CONNECTION_PRESENCE_TYPE_AWAY;
if (priv->state == TP_CONNECTION_PRESENCE_TYPE_EXTENDED_AWAY) {
new_state = TP_CONNECTION_PRESENCE_TYPE_EXTENDED_AWAY;
}
DEBUG ("Going to autoaway. Saved state=%d, new state=%d",
priv->away_saved_state, new_state);
empathy_idle_set_state (idle, new_state);
} else if (!is_idle && priv->is_idle) {
const gchar *new_status;
/* We are no more idle, restore state */
idle_ext_away_stop (idle);
if (priv->away_saved_state == TP_CONNECTION_PRESENCE_TYPE_AWAY ||
priv->away_saved_state == TP_CONNECTION_PRESENCE_TYPE_EXTENDED_AWAY) {
priv->away_saved_state = TP_CONNECTION_PRESENCE_TYPE_AVAILABLE;
new_status = NULL;
} else {
new_status = priv->status;
}
/* Only try and set the presence if the away saved state is not
* unset. This is an odd case because it means that the session
* didn't notify us of the state change to idle, and as a
* result, we couldn't save the current state at that time.
*/
if (priv->away_saved_state != TP_CONNECTION_PRESENCE_TYPE_UNSET) {
DEBUG ("Restoring state to %d, reset status to %s",
priv->away_saved_state, new_status);
empathy_idle_set_presence (idle,
priv->away_saved_state,
new_status);
} else {
DEBUG ("Away saved state is unset. This means that we "
"weren't told when the session went idle. "
"As a result, I'm not trying to set presence");
}
priv->away_saved_state = TP_CONNECTION_PRESENCE_TYPE_UNSET;
}
priv->is_idle = is_idle;
}
static void
presence_chooser_changed_cb (GtkComboBox *self, gpointer user_data)
{
EmpathyPresenceChooserPriv *priv = GET_PRIV (self);
GtkTreeIter iter;
char *icon_name;
TpConnectionPresenceType new_state;
gboolean customisable = TRUE;
PresenceChooserEntryType type = -1;
GtkWidget *entry;
GtkTreeModel *model;
if (priv->block_changed ||
!gtk_combo_box_get_active_iter (self, &iter)) {
return;
}
model = gtk_combo_box_get_model (self);
gtk_tree_model_get (model, &iter,
COL_STATE_ICON_NAME, &icon_name,
COL_STATE, &new_state,
COL_STATUS_CUSTOMISABLE, &customisable,
COL_TYPE, &type,
-1);
entry = gtk_bin_get_child (GTK_BIN (self));
/* some types of status aren't editable, set the editability of the
* entry appropriately. Unless we're just about to reset it anyway,
* in which case, don't fiddle with it */
if (type != ENTRY_TYPE_EDIT_CUSTOM) {
gtk_editable_set_editable (GTK_EDITABLE (entry), customisable);
priv->state = new_state;
}
if (type == ENTRY_TYPE_EDIT_CUSTOM) {
GtkWidget *window, *dialog;
presence_chooser_reset_status (EMPATHY_PRESENCE_CHOOSER (self));
/* attempt to get the toplevel for this widget */
window = gtk_widget_get_toplevel (GTK_WIDGET (self));
if (!GTK_WIDGET_TOPLEVEL (window) || !GTK_IS_WINDOW (window)) {
window = NULL;
}
dialog = empathy_status_preset_dialog_new (GTK_WINDOW (window));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
else if (type == ENTRY_TYPE_CUSTOM) {
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
icon_name);
/* preseed the status */
if (priv->previous_type == ENTRY_TYPE_BUILTIN) {
/* if their previous entry was a builtin, don't
* preseed */
gtk_entry_set_text (GTK_ENTRY (entry), "");
} else {
/* else preseed the text of their currently entered
* status message */
const char *status;
status = empathy_idle_get_status (priv->idle);
gtk_entry_set_text (GTK_ENTRY (entry), status);
}
/* grab the focus */
gtk_widget_grab_focus (entry);
} else {
char *status;
/* just in case we were setting a new status when
* things were changed */
presence_chooser_set_status_editing (
EMPATHY_PRESENCE_CHOOSER (self),
FALSE);
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
icon_name);
gtk_tree_model_get (model, &iter,
COL_STATUS_TEXT, &status,
-1);
empathy_idle_set_presence (priv->idle, priv->state, status);
g_free (status);
}
if (type != ENTRY_TYPE_EDIT_CUSTOM) {
priv->previous_type = type;
}
g_free (icon_name);
}