HGKeeper

* purple

* 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

* source distribution.

* 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 "internal.h"

#include "connection.h"

#include "debug.h"

#include "eventloop.h"

#include "idle.h"

#include "log.h"

#include "prefs.h"

#include "savedstatuses.h"

#include "signals.h"

typedef enum

{

PURPLE_IDLE_NOT_AWAY = 0,

PURPLE_IDLE_AUTO_AWAY,

PURPLE_IDLE_AWAY_BUT_NOT_AUTO_AWAY

} PurpleAutoAwayState;

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

* user returns.

static GList *idled_accts = NULL;

static guint idle_timer = 0;

static time_t last_active_time = 0;

static void

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! */

return;

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

}

static void

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! */

return;

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

* should be set.

* 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.

static void

check_idleness(void)

{

time_t time_idle = 0;

gboolean auto_away;

const gchar *idle_reporting;

gboolean report_idle = TRUE;

gint away_seconds = 0;

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"))

{

/* Use 'Purple idle' */

time_idle = time(NULL) - last_active_time;

idle_recheck_interval = 0;

}

else

{

/* Don't report idle time */

report_idle = FALSE;

/* If we're not reporting idle, we can still do auto-away.

* First try "system" and if that isn't possible, use "purple" */

if (auto_away)

{

if ((idle_ui_ops != NULL) && (idle_ui_ops->get_time_idle != NULL))

{

time_idle = idle_ui_ops->get_time_idle();

idle_recheck_interval = 1;

}

else

{

time_idle = time(NULL) - last_active_time;

idle_recheck_interval = 0;

}

else

{

if (!no_away)

{

no_away = TRUE;

purple_savedstatus_set_idleaway(FALSE);

}

time_until_next_idle_event = 0;

return;

}

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

no_away = FALSE;

}

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))

{

GList *l;

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

static gboolean

check_idleness_timer(void)

{

check_idleness();

if (time_until_next_idle_event == 0)

idle_timer = 0;

else

{

/* +1 for the boundary,

* +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);

}

return FALSE;

}

static void

im_msg_sent_cb(PurpleAccount *account, PurpleMessage *msg, void *data)

{

/* Check our idle time after an IM is sent */

check_idleness();

}

static void

signing_on_cb(PurpleConnection *gc, void *data)

{

/* When signing on a new account, check if the account should be idle */

check_idleness();

}

static void

signing_off_cb(PurpleConnection *gc, void *data)

{

PurpleAccount *account;

account = purple_connection_get_account(gc);

set_account_unidle(account);

}

static void

idle_reporting_cb(const char *name, PurplePrefType type, gconstpointer val, gpointer data)

{

if (idle_timer)

g_source_remove(idle_timer);

idle_timer = 0;

check_idleness_timer();

}

void

purple_idle_touch()

{

time(&last_active_time);

if (!no_away)

{

if (idle_timer)

g_source_remove(idle_timer);

idle_timer = 0;

check_idleness_timer();

}

void

purple_idle_set(time_t time)

{

last_active_time = time;

}

static PurpleIdleUiOps *

purple_idle_ui_ops_copy(PurpleIdleUiOps *ops)

{

PurpleIdleUiOps *ops_new;

g_return_val_if_fail(ops != NULL, NULL);

ops_new = g_new(PurpleIdleUiOps, 1);

*ops_new = *ops;

return ops_new;

}

GType

purple_idle_ui_ops_get_type(void)

{

static GType type = 0;

if (type == 0) {

type = g_boxed_type_register_static("PurpleIdleUiOps",

(GBoxedCopyFunc)purple_idle_ui_ops_copy,

(GBoxedFreeFunc)g_free);

}

return type;

}

void

purple_idle_set_ui_ops(PurpleIdleUiOps *ops)

{

idle_ui_ops = ops;

}

PurpleIdleUiOps *

purple_idle_get_ui_ops(void)

{

return idle_ui_ops;

}

static void *

purple_idle_get_handle(void)

{

static int handle;

return &handle;

}

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_idle_touch();

return FALSE;

}

void

purple_idle_init()

{

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

}

void

purple_idle_uninit()

{

purple_signals_disconnect_by_handle(purple_idle_get_handle());

purple_prefs_disconnect_by_handle(purple_idle_get_handle());

/* Remove the idle timer */

if (idle_timer > 0)

g_source_remove(idle_timer);

idle_timer = 0;

}

pidgin/pidgin