* Purple is the legal property of its developers, whose names are too numerous * to list here. Please refer to the COPYRIGHT file distributed with this * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA #include "savedstatuses.h" PURPLE_IDLE_NOT_AWAY = 0, PURPLE_IDLE_AWAY_BUT_NOT_AUTO_AWAY static PurpleIdleUiOps *idle_ui_ops = NULL; * This is needed for the I'dle Mak'er plugin to work correctly. We * use it to determine if we're the ones who set our accounts idle * or if someone else did it (the I'dle Mak'er plugin, for example). * Basically we just keep track of which accounts were set idle by us, * and then we'll only set these specific accounts unidle when the static GList *idled_accts = NULL; static guint idle_timer = 0; static time_t last_active_time = 0; set_account_idle(PurpleAccount *account, int time_idle) PurplePresence *presence; presence = purple_account_get_presence(account); if (purple_presence_is_idle(presence)) /* This account is already idle! */ purple_debug_info("idle", "Setting %s idle %d seconds\n", purple_account_get_username(account), time_idle); purple_presence_set_idle(presence, TRUE, time(NULL) - time_idle); idled_accts = g_list_prepend(idled_accts, account); set_account_unidle(PurpleAccount *account) PurplePresence *presence; presence = purple_account_get_presence(account); idled_accts = g_list_remove(idled_accts, account); if (!purple_presence_is_idle(presence)) /* This account is already unidle! */ purple_debug_info("idle", "Setting %s unidle\n", purple_account_get_username(account)); purple_presence_set_idle(presence, FALSE, 0); static gboolean no_away = FALSE; static gint time_until_next_idle_event; * This function should be called when you think your idle state * may have changed. Maybe you're over the 10-minute mark and * Purple should start reporting idle time to the server. Maybe * you've returned from being idle. Maybe your auto-away message * There is no harm to calling this many many times, other than * it will be kinda slow. This is called by a timer set when * Purple starts. It is also called when you send an IM, a chat, etc. * This function has 3 sections. * 1. Get your idle time. It will query XScreenSaver or Windows * or use the Purple idle time. Whatever. * 2. Set or unset your auto-away message. * 3. Report your current idle time to the IM server. const gchar *idle_reporting; gboolean report_idle = TRUE; gint idle_recheck_interval = 0; gint idle_poll_seconds = purple_prefs_get_int("/purple/away/mins_before_away") * 60; purple_signal_emit(purple_blist_get_handle(), "update-idle"); idle_reporting = purple_prefs_get_string("/purple/away/idle_reporting"); auto_away = purple_prefs_get_bool("/purple/away/away_when_idle"); if (purple_strequal(idle_reporting, "system") && (idle_ui_ops != NULL) && (idle_ui_ops->get_time_idle != NULL)) /* Use system idle time (mouse or keyboard movement, etc.) */ time_idle = idle_ui_ops->get_time_idle(); idle_recheck_interval = 1; else if (purple_strequal(idle_reporting, "purple")) time_idle = time(NULL) - last_active_time; idle_recheck_interval = 0; /* Don't report idle time */ /* If we're not reporting idle, we can still do auto-away. * First try "system" and if that isn't possible, use "purple" */ if ((idle_ui_ops != NULL) && (idle_ui_ops->get_time_idle != NULL)) time_idle = idle_ui_ops->get_time_idle(); idle_recheck_interval = 1; time_idle = time(NULL) - last_active_time; idle_recheck_interval = 0; purple_savedstatus_set_idleaway(FALSE); time_until_next_idle_event = 0; time_until_next_idle_event = idle_poll_seconds - time_idle; if (time_until_next_idle_event < 0) /* If we're already idle, check again as appropriate. */ time_until_next_idle_event = idle_recheck_interval; if (auto_away || !no_away) away_seconds = 60 * purple_prefs_get_int("/purple/away/mins_before_away"); if (auto_away && time_idle > away_seconds) purple_savedstatus_set_idleaway(TRUE); else if (purple_savedstatus_is_idleaway() && time_idle < away_seconds) purple_savedstatus_set_idleaway(FALSE); if (time_until_next_idle_event == 0 || (away_seconds - time_idle) < time_until_next_idle_event) time_until_next_idle_event = away_seconds - time_idle; /* Idle reporting stuff */ if (report_idle && (time_idle >= idle_poll_seconds)) for (l = purple_connections_get_all(); l != NULL; l = l->next) PurpleConnection *gc = l->data; set_account_idle(purple_connection_get_account(gc), time_idle); else if (!report_idle || (time_idle < idle_poll_seconds )) while (idled_accts != NULL) set_account_unidle(idled_accts->data); * Check idle and set the timer to fire at the next idle-worth event check_idleness_timer(void) if (time_until_next_idle_event == 0) * +1 more for g_timeout_add_seconds rounding. */ idle_timer = g_timeout_add_seconds(time_until_next_idle_event + 2, (GSourceFunc)check_idleness_timer, NULL); im_msg_sent_cb(PurpleAccount *account, PurpleMessage *msg, void *data) /* Check our idle time after an IM is sent */ signing_on_cb(PurpleConnection *gc, void *data) /* When signing on a new account, check if the account should be idle */ signing_off_cb(PurpleConnection *gc, void *data) account = purple_connection_get_account(gc); set_account_unidle(account); idle_reporting_cb(const char *name, PurplePrefType type, gconstpointer val, gpointer data) g_source_remove(idle_timer); g_source_remove(idle_timer); purple_idle_set(time_t time) purple_idle_ui_ops_copy(PurpleIdleUiOps *ops) PurpleIdleUiOps *ops_new; g_return_val_if_fail(ops != NULL, NULL); ops_new = g_new(PurpleIdleUiOps, 1); purple_idle_ui_ops_get_type(void) type = g_boxed_type_register_static("PurpleIdleUiOps", (GBoxedCopyFunc)purple_idle_ui_ops_copy, purple_idle_set_ui_ops(PurpleIdleUiOps *ops) purple_idle_get_ui_ops(void) purple_idle_get_handle(void) static gboolean _do_purple_idle_touch_cb(gpointer data) int idle_poll_minutes = purple_prefs_get_int("/purple/away/mins_before_away"); /* +1 more for g_timeout_add_seconds rounding. */ idle_timer = g_timeout_add_seconds((idle_poll_minutes * 60) + 2, (GSourceFunc)check_idleness_timer, NULL); purple_signal_connect(purple_conversations_get_handle(), "sent-im-msg", purple_idle_get_handle(), PURPLE_CALLBACK(im_msg_sent_cb), NULL); purple_signal_connect(purple_connections_get_handle(), "signing-on", purple_idle_get_handle(), PURPLE_CALLBACK(signing_on_cb), NULL); purple_signal_connect(purple_connections_get_handle(), "signing-off", purple_idle_get_handle(), PURPLE_CALLBACK(signing_off_cb), NULL); purple_prefs_connect_callback(purple_idle_get_handle(), "/purple/away/idle_reporting", idle_reporting_cb, NULL); /* Initialize the idleness asynchronously so it doesn't check idleness, * and potentially try to change the status before the UI is initialized */ g_timeout_add(0, _do_purple_idle_touch_cb, NULL); purple_signals_disconnect_by_handle(purple_idle_get_handle()); purple_prefs_disconnect_by_handle(purple_idle_get_handle()); /* Remove the idle timer */ g_source_remove(idle_timer);