static void
adc_error(MsnCmdProc *cmdproc, MsnTransaction *trans, int error)
{
MsnSession *session;
PurpleAccount *account;
PurpleConnection *gc;
const char *list, *passport;
const char *reason;
char *msg = NULL;
char **params;
session = cmdproc->session;
account = session->account;
gc = purple_account_get_connection(account);
params = g_strsplit(trans->params, " ", 0);
list = params[0];
passport = params[1];
if (!strcmp(list, "FL"))
msg = pecan_strdup_printf(_("Unable to add user on %s (%s)"),
purple_account_get_username(account),
purple_account_get_protocol_name(account));
else if (!strcmp(list, "BL"))
msg = pecan_strdup_printf(_("Unable to block user on %s (%s)"),
purple_account_get_username(account),
purple_account_get_protocol_name(account));
else if (!strcmp(list, "AL"))
msg = pecan_strdup_printf(_("Unable to permit user on %s (%s)"),
purple_account_get_username(account),
purple_account_get_protocol_name(account));
reason = pecan_error_to_string (error);
if (msg != NULL)
{
purple_notify_error(gc, NULL, msg, reason);
g_free(msg);
}
if (!strcmp(list, "FL"))
{
PurpleBuddy *buddy;
buddy = purple_find_buddy(account, passport);
if (buddy != NULL)
purple_blist_remove_buddy(buddy);
}
g_strfreev(params);
}
static void *
finch_notify_emails(PurpleConnection *gc, size_t count, gboolean detailed,
const char **subjects, const char **froms, const char **tos,
const char **urls)
{
PurpleAccount *account = purple_connection_get_account(gc);
GString *message = g_string_new(NULL);
void *ret;
static int key = 0;
if (count == 0)
return NULL;
if (!detailed)
{
g_string_append_printf(message,
ngettext("%s (%s) has %d new message.",
"%s (%s) has %d new messages.",
(int)count),
tos ? *tos : purple_account_get_username(account),
purple_account_get_protocol_name(account), (int)count);
}
else
{
char *to;
gboolean newwin = (emaildialog.window == NULL);
if (newwin)
setup_email_dialog();
to = g_strdup_printf("%s (%s)", tos ? *tos : purple_account_get_username(account),
purple_account_get_protocol_name(account));
gnt_tree_add_row_after(GNT_TREE(emaildialog.tree), GINT_TO_POINTER(++key),
gnt_tree_create_row(GNT_TREE(emaildialog.tree), to,
froms ? *froms : "[Unknown sender]",
*subjects),
NULL, NULL);
g_free(to);
if (newwin)
gnt_widget_show(emaildialog.window);
else
gnt_window_present(emaildialog.window);
return NULL;
}
ret = finch_notify_common(PURPLE_NOTIFY_EMAIL, PURPLE_NOTIFY_MSG_INFO,
_("New Mail"), _("You have mail!"), message->str);
g_string_free(message, TRUE);
return ret;
}
static void
add_substatus(EditStatus *edit, PurpleAccount *account)
{
char *name;
const char *type = NULL, *message = NULL;
PurpleSavedStatusSub *sub = NULL;
RowInfo *key;
if (!edit || !edit->tree)
return;
if (edit->saved)
sub = purple_savedstatus_get_substatus(edit->saved, account);
key = g_new0(RowInfo, 1);
key->account = account;
if (sub)
{
key->type = purple_savedstatus_substatus_get_type(sub);
type = purple_status_type_get_name(key->type);
message = purple_savedstatus_substatus_get_message(sub);
key->message = g_strdup(message);
}
name = g_strdup_printf("%s (%s)", purple_account_get_username(account),
purple_account_get_protocol_name(account));
gnt_tree_add_choice(GNT_TREE(edit->tree), key,
gnt_tree_create_row(GNT_TREE(edit->tree),
name, type ? type : "", message ? message : ""), NULL, NULL);
if (sub)
gnt_tree_set_choice(GNT_TREE(edit->tree), key, TRUE);
g_free(name);
}
static
void cb_custom_toggled(GtkCellRendererToggle *cell, char *path, gpointer data)
{
GtkTreeIter iter;
GtkTreeModel *model = (GtkTreeModel*) data;
if (gtk_tree_model_get_iter_from_string(model, &iter, path)) {
PurpleAccount *account;
GValue value;
memset(&value, 0, sizeof(value));
gtk_tree_model_get_value(model, &iter, 5, &value);
assert(G_VALUE_HOLDS_POINTER(&value));
account = g_value_get_pointer(&value);
g_value_unset(&value);
gboolean flag;
char pref[STRLEN];
build_pref(pref, PREF_CUSTOM_DISABLED, purple_account_get_username(account), purple_account_get_protocol_name(account));
memset(&value, 0, sizeof(value));
gtk_tree_model_get_value(model, &iter, 3, &value);
assert(G_VALUE_HOLDS_BOOLEAN(&value));
flag = !g_value_get_boolean(&value);
g_value_unset(&value);
gtk_list_store_set(GTK_LIST_STORE(model), &iter, 3, flag, -1);
purple_prefs_set_bool(pref, flag);
if (flag) {
set_status(account, "", 0);
}
}
}
static void
set_account(GtkListStore *store, GtkTreeIter *iter, PurpleAccount *account)
{
GdkPixbuf *pixbuf;
GdkPixbuf *scale;
scale = NULL;
pixbuf = pidgin_create_prpl_icon(account, 0.5);
if (pixbuf != NULL)
{
scale = gdk_pixbuf_scale_simple(pixbuf, 16, 16, GDK_INTERP_BILINEAR);
if (purple_account_is_disconnected(account))
gdk_pixbuf_saturate_and_pixelate(scale, scale, 0.0, FALSE);
}
gtk_list_store_set(store, iter,
COLUMN_ICON, scale,
COLUMN_SCREENNAME, purple_account_get_username(account),
COLUMN_ENABLED, ap_account_has_profile_enabled(account),
COLUMN_PROTOCOL, purple_account_get_protocol_name(account),
COLUMN_DATA, account,
-1);
if (pixbuf != NULL) g_object_unref(G_OBJECT(pixbuf));
if (scale != NULL) g_object_unref(G_OBJECT(scale));
}
void GeneralMenu::fields_ok_cb(PurpleRequestFields *fields)
{
LOG->debug(
"fields_ok_cb: text0=%s, text1=%s, int0=%d, bool0=%d, choice0=%d\n",
purple_request_fields_get_string(fields, "text0"),
purple_request_fields_get_string(fields, "text1"),
purple_request_fields_get_integer(fields, "int0"),
purple_request_fields_get_bool(fields, "bool0"),
purple_request_fields_get_choice(fields, "choice0"));
for (GList *list = purple_request_field_list_get_selected(
purple_request_fields_get_field(fields, "list0")); list;
list = list->next)
LOG->debug("fields_ok_cb: list0=%s",
reinterpret_cast<const char*>(list->data));
for (GList *list = purple_request_field_list_get_selected(
purple_request_fields_get_field(fields, "list1")); list;
list = list->next)
LOG->debug("fields_ok_cb: list1=%s",
reinterpret_cast<const char*>(list->data));
PurpleAccount *account = purple_request_fields_get_account(fields,
"account0");
LOG->debug("fields_ok_cb: account0=[%s] %s",
purple_account_get_protocol_name(account),
purple_account_get_username(account));
}
static void
group_error_helper(MsnSession *session, const char *msg, const gchar *group_guid, int error)
{
PurpleAccount *account;
PurpleConnection *gc;
char *reason = NULL;
char *title = NULL;
account = session->account;
gc = purple_account_get_connection(account);
if (error == 224)
{
const char *group_name;
group_name = pecan_contactlist_find_group_name(session->contactlist, group_guid);
reason = pecan_strdup_printf(_("%s is not a valid group."),
group_name);
}
else
{
reason = g_strdup(_("Unknown error."));
}
title = pecan_strdup_printf(_("%s on %s (%s)"), msg,
purple_account_get_username(account),
purple_account_get_protocol_name(account));
purple_notify_error(gc, NULL, title, reason);
g_free(title);
g_free(reason);
}
Request::FieldsDialog::AccountField::AccountField(PurpleRequestField *field)
: field(field)
{
g_assert(field);
// TODO filter (purple_request_field_account_get_filter())
// TODO signals (signed-on, signed-off, account-added, account-removed)
char *text = g_strdup_printf("%s%s",
purple_request_field_is_required(field) ? "*" : "",
purple_request_field_get_label(field));
SetText(text);
g_free(text);
gboolean show_all = purple_request_field_account_get_show_all(field);
for (GList *list = purple_accounts_get_all(); list; list = list->next) {
PurpleAccount *account = reinterpret_cast<PurpleAccount*>(list->data);
if (!show_all && !purple_account_is_connected(account))
continue;
char *label = g_strdup_printf("[%s] %s",
purple_account_get_protocol_name(account),
purple_account_get_username(account));
AddOptionPtr(label, account);
g_free(label);
}
SetSelectedByDataPtr(purple_request_field_account_get_default_value(field));
signal_selection_changed.connect(sigc::mem_fun(this,
&AccountField::OnAccountChanged));
}
void Accounts::status_changed(PurpleAccount *account, PurpleStatus *status)
{
if (!purple_account_get_enabled(account, PACKAGE_NAME))
return;
LOG->Message(_("+ [%s] %s: Status changed to: %s"),
purple_account_get_protocol_name(account),
purple_account_get_username(account),
purple_status_get_name(status));
}
static void log_select_cb(GtkTreeSelection *sel, PidginLogViewer *viewer) {
GtkTreeIter iter;
GValue val;
GtkTreeModel *model = GTK_TREE_MODEL(viewer->treestore);
PurpleLog *log = NULL;
PurpleLogReadFlags flags;
char *read = NULL;
if (!gtk_tree_selection_get_selected(sel, &model, &iter))
return;
val.g_type = 0;
gtk_tree_model_get_value (model, &iter, 1, &val);
log = g_value_get_pointer(&val);
g_value_unset(&val);
if (log == NULL)
return;
pidgin_set_cursor(viewer->window, GDK_WATCH);
if (log->type != PURPLE_LOG_SYSTEM) {
char *title;
if (log->type == PURPLE_LOG_CHAT)
title = g_strdup_printf(_("<span size='larger' weight='bold'>Conversation in %s on %s</span>"),
log->name, log_get_date(log));
else
title = g_strdup_printf(_("<span size='larger' weight='bold'>Conversation with %s on %s</span>"),
log->name, log_get_date(log));
gtk_label_set_markup(GTK_LABEL(viewer->label), title);
g_free(title);
}
read = purple_log_read(log, &flags);
viewer->flags = flags;
gtk_imhtml_clear(GTK_IMHTML(viewer->imhtml));
gtk_imhtml_set_protocol_name(GTK_IMHTML(viewer->imhtml),
purple_account_get_protocol_name(log->account));
purple_signal_emit(pidgin_log_get_handle(), "log-displaying", viewer, log);
gtk_imhtml_append_text(GTK_IMHTML(viewer->imhtml), read,
GTK_IMHTML_NO_COMMENTS | GTK_IMHTML_NO_TITLE | GTK_IMHTML_NO_SCROLL |
((flags & PURPLE_LOG_READ_NO_NEWLINE) ? GTK_IMHTML_NO_NEWLINE : 0));
g_free(read);
if (viewer->search != NULL) {
gtk_imhtml_search_clear(GTK_IMHTML(viewer->imhtml));
g_idle_add(search_find_cb, viewer);
}
pidgin_clear_cursor(viewer->window);
}
/*******************
* Signal Handlers *
*******************/
static void rc_at_conversation_event(PurpleConversation *conv)
{
PurpleAccount *acct = purple_conversation_get_account(conv);
const char * proto = purple_account_get_protocol_name(acct);
const char * proto_id = purple_account_get_protocol_id(acct);
const char * my_acct = purple_account_get_username(acct);
const char * recv_acct = purple_conversation_get_name(conv);
trace("Conversation event.. [%s: %s] account: %s to %s", proto_id,
proto, my_acct, recv_acct);
rc_push_contact(acct, recv_acct);
}
void
msn_show_sync_issue(MsnSession *session, const char *passport,
const char *group_name)
{
PurpleConnection *gc;
PurpleAccount *account;
MsnAddRemData *data;
char *msg, *reason;
account = session->account;
gc = purple_account_get_connection(account);
data = g_new0(MsnAddRemData, 1);
data->who = g_strdup(passport);
data->group = g_strdup(group_name);
data->gc = gc;
msg = g_strdup_printf(_("Buddy list synchronization issue in %s (%s)"),
purple_account_get_username(account),
purple_account_get_protocol_name(account));
if (group_name != NULL)
{
reason = g_strdup_printf(_("%s on the local list is "
"inside the group \"%s\" but not on "
"the server list. "
"Do you want this buddy to be added?"),
passport, group_name);
}
else
{
reason = g_strdup_printf(_("%s is on the local list but "
"not on the server list. "
"Do you want this buddy to be added?"),
passport);
}
purple_request_action(gc, NULL, msg, reason, PURPLE_DEFAULT_ACTION_NONE,
purple_connection_get_account(gc), data->who, NULL,
data, 2,
_("Yes"), G_CALLBACK(msn_add_cb),
_("No"), G_CALLBACK(msn_rem_cb));
g_free(reason);
g_free(msg);
}
PurpleSmileyList *
pidgin_smiley_theme_for_conv(PurpleConversation *conv)
{
PurpleAccount *acc = NULL;
PurpleSmileyTheme *theme;
const gchar *proto_name = NULL;
theme = purple_smiley_theme_get_current();
if (theme == NULL)
return NULL;
if (conv)
acc = purple_conversation_get_account(conv);
if (acc)
proto_name = purple_account_get_protocol_name(acc);
return purple_smiley_theme_get_smileys(theme, (gpointer)proto_name);
}
static
void cb_custom_edited(GtkCellRendererText *renderer, char *path, char *str, gpointer data)
{
GtkTreeIter iter;
GtkTreeModel *model = (GtkTreeModel*) data;
if (gtk_tree_model_get_iter_from_string(model, &iter, path)) {
PurpleAccount *account;
GValue value;
memset(&value, 0, sizeof(value));
gtk_tree_model_get_value(model, &iter, 5, &value);
assert(G_VALUE_HOLDS_POINTER(&value));
account = g_value_get_pointer(&value);
g_value_unset(&value);
char pref[STRLEN];
build_pref(pref, PREF_CUSTOM_FORMAT, purple_account_get_username(account), purple_account_get_protocol_name(account));
gtk_list_store_set(GTK_LIST_STORE(model), &iter, 2, str, -1);
purple_prefs_set_string(pref, str);
}
}
static void
reset_account_list(PurpleAccount *account)
{
GList *list;
GntComboBox *accounts = GNT_COMBO_BOX(froomlist.accounts);
gnt_combo_box_remove_all(accounts);
for (list = purple_connections_get_all(); list; list = list->next) {
PurplePluginProtocolInfo *prpl_info = NULL;
PurpleConnection *gc = list->data;
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(gc));
if (PURPLE_CONNECTION_IS_CONNECTED(gc) &&
prpl_info->roomlist_get_list != NULL) {
PurpleAccount *account = purple_connection_get_account(gc);
char *text = g_strdup_printf("%s (%s)",
purple_account_get_username(account),
purple_account_get_protocol_name(account));
gnt_combo_box_add_data(accounts, account, text);
g_free(text);
}
}
}
static GntWidget*
create_account_field(PurpleRequestField *field)
{
gboolean all;
PurpleAccount *def;
GList *list;
GntWidget *combo = gnt_combo_box_new();
all = purple_request_field_account_get_show_all(field);
def = purple_request_field_account_get_value(field);
if (!def)
def = purple_request_field_account_get_default_value(field);
if (all)
list = purple_accounts_get_all();
else
list = purple_connections_get_all();
for (; list; list = list->next)
{
PurpleAccount *account;
char *text;
if (all)
account = list->data;
else
account = purple_connection_get_account(list->data);
text = g_strdup_printf("%s (%s)",
purple_account_get_username(account),
purple_account_get_protocol_name(account));
gnt_combo_box_add_data(GNT_COMBO_BOX(combo), account, text);
g_free(text);
if (account == def)
gnt_combo_box_set_selected(GNT_COMBO_BOX(combo), account);
}
gnt_widget_set_size(combo, 20, 3); /* ew */
return combo;
}
static void historize(PurpleConversation *c)
{
PurpleAccount *account = NULL;
PurpleConversationType convtype;
PidginConversation *gtkconv = NULL;
GtkTextIter start;
GtkIMHtmlOptions options;
GList *logs = NULL, *logs_head = NULL;
struct tm *log_tm = NULL, *local_tm = NULL;
time_t t, log_time;
double limit_time = 0.0;
const char *name = NULL, *alias = NULL, *LOG_MODE = NULL;
char *header = NULL, *protocol = NULL, *history = NULL;
int conv_counter = 0;
int limit_offset = 0;
int byte_counter = 0;
int check_time = 0;
int log_size, overshoot;
account = purple_conversation_get_account(c);
name = purple_conversation_get_name(c);
alias = name;
LOG_MODE = purple_prefs_get_string("/purple/logging/format");
/* If logging isn't enabled, don't show any history */
if(!purple_prefs_get_bool("/purple/logging/log_ims") &&
!purple_prefs_get_bool("/purple/logging/log_chats"))
return;
/* If the user wants to show 0 logs, stop now */
if(PREF_NUMBER_VAL == 0) {
return;
}
/* If the logging mode is html, set the output options to include no newline.
* Otherwise, it's normal text, so we don't need extra lines */
if(strcasecmp(LOG_MODE, "html")==0) {
options = GTK_IMHTML_NO_NEWLINE;
} else {
options = GTK_IMHTML_NO_COLOURS;
}
/* Determine whether this is an IM or a chat. In either case, if the user has that
* particular log type disabled, the logs file doesnt not get specified */
convtype = purple_conversation_get_type(c);
if (convtype == PURPLE_CONV_TYPE_IM && PREF_IM_VAL) {
GSList *cur;
GSList *buddies = NULL;
/* Find buddies for this conversation. */
buddies = purple_find_buddies(account, name);
/* If we found at least one buddy, save the first buddy's alias. */
if (buddies != NULL)
alias = purple_buddy_get_contact_alias((PurpleBuddy *)buddies->data);
for(cur = buddies; cur; cur = cur->next) {
PurpleBlistNode *node = cur->data;
if(node && (node->prev || node->next)) {
PurpleBlistNode *node2;
for(node2 = node->parent->child; node2; node2 = node2->next) {
logs = g_list_concat(purple_log_get_logs(PURPLE_LOG_IM,
purple_buddy_get_name((PurpleBuddy *)node2),
purple_buddy_get_account((PurpleBuddy *)node2)), logs);
}
break;
}
}
g_slist_free(buddies);
if (logs)
logs = g_list_sort(logs, purple_log_compare);
else
logs = purple_log_get_logs(PURPLE_LOG_IM, name, account);
} else if (convtype == PURPLE_CONV_TYPE_CHAT && PREF_CHAT_VAL) {
logs = purple_log_get_logs(PURPLE_LOG_CHAT,
purple_conversation_get_name(c), purple_conversation_get_account(c));
}
gtkconv = PIDGIN_CONVERSATION(c);
/* The logs are non-existant or the user has disabled this type for log displaying. */
if (!logs) {
return;
}
/* Keep a pointer to the head of the logs for freeing later */
logs_head = logs;
/* If all time prefs are not 0, prepare to check times */
if (!(PREF_MINS_VAL == 0 && PREF_HOURS_VAL == 0 && PREF_DAYS_VAL == 0)) {
check_time = 1;
/* Grab current time and normalize it to UTC */
t = time(NULL);
local_tm = gmtime(&t);
t = mktime(local_tm);
limit_time = (PREF_MINS_VAL * 60.0) + (PREF_HOURS_VAL * 60.0 * 60.0) +
(PREF_DAYS_VAL * 60.0 * 60.0 * 24.0);
}
/* The protocol will need to be adjusted for each log for correct display,
so save the current imhtml protocol_name to restore it later */
protocol = g_strdup(gtk_imhtml_get_protocol_name(GTK_IMHTML(gtkconv->imhtml)));
/* Calculate time for the first log */
log_tm = gmtime(&((PurpleLog*)logs->data)->time);
log_time = mktime(log_tm);
/* Continue to add older logs until they run out or the conditions are no
longer met */
while (logs && conv_counter < PREF_NUMBER_VAL
&& byte_counter < PREF_BYTES_VAL
&& (!check_time || difftime(t, log_time) < limit_time)) {
guint flags;
/* Get the current log's contents as a char* */
history = purple_log_read((PurpleLog*)logs->data, &flags);
log_size = strlen(history);
if (flags & PURPLE_LOG_READ_NO_NEWLINE)
options |= GTK_IMHTML_NO_NEWLINE;
else
options &= ~GTK_IMHTML_NO_NEWLINE;
/* Update the overall byte count and determine if this log exceeds the limit */
byte_counter += log_size;
overshoot = byte_counter - PREF_BYTES_VAL;
if (overshoot > 0) {
/* Start looking at the maximum log size for a newline to break at */
limit_offset = overshoot;
/* Find the next \n, or stop if the end of the log is reached */
while (history[limit_offset] && history[limit_offset] != '\n') {
limit_offset++;
}
/* If we're at or very close to the end of the log, forget this log */
if (!history[limit_offset] || (log_size - limit_offset < 3)) {
limit_offset = -1;
}
else {
/* Start at the first character after the newline */
limit_offset++;
}
}
conv_counter++;
/* If this log won't fit at all, don't display it in the conversation */
if (limit_offset != -1) {
/* Set the correct protocol_name for this log */
gtk_imhtml_set_protocol_name(GTK_IMHTML(gtkconv->imhtml),
purple_account_get_protocol_name(((PurpleLog*)logs->data)->account));
/* Prepend the contents of the log starting at the calculated offset */
gtk_text_buffer_get_iter_at_offset(GTK_IMHTML(gtkconv->imhtml)->text_buffer,
&start, 0);
gtk_imhtml_insert_html_at_iter(GTK_IMHTML(gtkconv->imhtml),
history + limit_offset, options, &start);
/* Prepend the conversation header */
if (PREF_DATES_VAL) {
header = g_strdup_printf(_("<b>Conversation with %s on %s:</b><br>"), alias,
purple_date_format_full(localtime(&((PurpleLog *)logs->data)->time)));
gtk_text_buffer_get_iter_at_offset(GTK_IMHTML(gtkconv->imhtml)->text_buffer,
&start, 0);
gtk_imhtml_insert_html_at_iter(GTK_IMHTML(gtkconv->imhtml),
header, options, &start);
g_free(header);
}
}
g_free(history);
if (limit_offset > 0) {
/* This log had to be chopped to fit, so stop after this one */
break;
}
logs = logs->next;
/* Recalculate log time if we haven't run out of logs */
if (logs) {
log_tm = gmtime(&((PurpleLog*)logs->data)->time);
log_time = mktime(log_tm);
}
}
gtk_imhtml_append_text(GTK_IMHTML(gtkconv->imhtml), "<hr>", options);
/* Restore the original protocol_name */
gtk_imhtml_set_protocol_name(GTK_IMHTML(gtkconv->imhtml), protocol);
g_free(protocol);
g_object_ref(G_OBJECT(gtkconv->imhtml));
g_idle_add(_scroll_imhtml_to_end, gtkconv->imhtml);
/* Clear the allocated memory that the logs are using */
g_list_foreach(logs_head, (GFunc)purple_log_free, NULL);
g_list_free(logs_head);
}
static void
update_detailed_info(PidginXferDialog *dialog, PurpleXfer *xfer)
{
PidginXferUiData *data;
char *kbsec, *time_elapsed, *time_remaining;
char *status, *utf8;
if (dialog == NULL || xfer == NULL)
return;
data = PIDGINXFER(xfer);
get_xfer_info_strings(xfer, &kbsec, &time_elapsed, &time_remaining);
status = g_strdup_printf("%d%% (%" G_GSIZE_FORMAT " of %" G_GSIZE_FORMAT " bytes)",
(int)(purple_xfer_get_progress(xfer)*100),
purple_xfer_get_bytes_sent(xfer),
purple_xfer_get_size(xfer));
if (purple_xfer_is_completed(xfer)) {
GdkPixbuf *pixbuf = NULL;
pixbuf = gtk_widget_render_icon(xfer_dialog->window,
PIDGIN_STOCK_FILE_DONE,
GTK_ICON_SIZE_MENU, NULL);
gtk_list_store_set(GTK_LIST_STORE(xfer_dialog->model), &data->iter,
COLUMN_STATUS, pixbuf,
-1);
g_object_unref(pixbuf);
}
if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) {
gtk_label_set_markup(GTK_LABEL(dialog->local_user_desc_label),
_("<b>Receiving As:</b>"));
gtk_label_set_markup(GTK_LABEL(dialog->remote_user_desc_label),
_("<b>Receiving From:</b>"));
}
else {
gtk_label_set_markup(GTK_LABEL(dialog->remote_user_desc_label),
_("<b>Sending To:</b>"));
gtk_label_set_markup(GTK_LABEL(dialog->local_user_desc_label),
_("<b>Sending As:</b>"));
}
gtk_label_set_text(GTK_LABEL(dialog->local_user_label),
purple_account_get_username(xfer->account));
gtk_label_set_text(GTK_LABEL(dialog->remote_user_label), xfer->who);
gtk_label_set_text(GTK_LABEL(dialog->protocol_label),
purple_account_get_protocol_name(xfer->account));
if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) {
gtk_label_set_text(GTK_LABEL(dialog->filename_label),
purple_xfer_get_filename(xfer));
} else {
char *tmp;
tmp = g_path_get_basename(purple_xfer_get_local_filename(xfer));
utf8 = g_filename_to_utf8(tmp, -1, NULL, NULL, NULL);
g_free(tmp);
gtk_label_set_text(GTK_LABEL(dialog->filename_label), utf8);
g_free(utf8);
}
utf8 = g_filename_to_utf8((purple_xfer_get_local_filename(xfer)), -1, NULL, NULL, NULL);
gtk_label_set_text(GTK_LABEL(dialog->localfile_label), utf8);
g_free(utf8);
gtk_label_set_text(GTK_LABEL(dialog->status_label), status);
gtk_label_set_text(GTK_LABEL(dialog->speed_label), kbsec);
gtk_label_set_text(GTK_LABEL(dialog->time_elapsed_label), time_elapsed);
gtk_label_set_text(GTK_LABEL(dialog->time_remaining_label),
time_remaining);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dialog->progress),
purple_xfer_get_progress(xfer));
g_free(kbsec);
g_free(time_elapsed);
g_free(time_remaining);
g_free(status);
}
void AccountWindow::populateAccount(PurpleAccount *account)
{
if (account_entries.find(account) == account_entries.end()) {
// no entry for this account, so add one
AccountEntry entry;
entry.parent = NULL;
account_entries[account] = entry;
}
else {
// the account exists, so clear all data
clearAccount(account, false);
}
AccountEntry *account_entry = &account_entries[account];
if (!account_entry->parent) {
CppConsUI::TreeView::ToggleCollapseButton *button
= new CppConsUI::TreeView::ToggleCollapseButton;
CppConsUI::TreeView::NodeReference parent_reference
= treeview->appendNode(treeview->getRootNode(), *button);
treeview->setCollapsed(parent_reference, true);
account_entry->parent = button;
account_entry->parent_reference = parent_reference;
}
char *label = g_strdup_printf("[%s] %s",
purple_account_get_protocol_name(account),
purple_account_get_username(account));
account_entry->parent->setText(label);
g_free(label);
const char *protocol_id = purple_account_get_protocol_id(account);
PurplePlugin *prpl = purple_find_prpl(protocol_id);
if (!prpl) {
// we cannot change the settings of an unknown account
CppConsUI::Label *label = new CppConsUI::Label(
_("Invalid account or protocol plugin not loaded."));
treeview->appendNode(account_entry->parent_reference, *label);
}
else {
PurplePluginProtocolInfo *prplinfo = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
// protocols combobox
ProtocolOption *combobox = new ProtocolOption(account, *this);
CppConsUI::TreeView::NodeReference protocol_node
= treeview->appendNode(account_entry->parent_reference, *combobox);
combobox->grabFocus();
/* The username must be treated in a special way because it can contain
* multiple values (e.g. user@server:port/resource). */
char *username = g_strdup(purple_account_get_username(account));
for (GList *iter = g_list_last(prplinfo->user_splits); iter;
iter = iter->prev) {
PurpleAccountUserSplit *split
= reinterpret_cast<PurpleAccountUserSplit*>(iter->data);
char *s;
if (purple_account_user_split_get_reverse(split))
s = strrchr(username, purple_account_user_split_get_separator(split));
else
s = strchr(username, purple_account_user_split_get_separator(split));
const char *value;
if (s) {
*s = '\0';
value = s + 1;
}
else
value = purple_account_user_split_get_default_value(split);
// create widget for the username split and remember
SplitOption *widget_split = new SplitOption(account, split,
account_entry);
widget_split->setValue(value);
account_entry->split_widgets.push_front(widget_split);
treeview->appendNode(account_entry->parent_reference, *widget_split);
}
SplitOption *widget_split = new SplitOption(account, NULL, account_entry);
widget_split->setValue(username);
account_entry->split_widgets.push_front(widget_split);
treeview->insertNodeAfter(protocol_node, *widget_split);
g_free(username);
// password
Widget *widget = new StringOption(account, StringOption::TYPE_PASSWORD);
treeview->appendNode(account_entry->parent_reference, *widget);
// remember password
widget = new BoolOption(account, BoolOption::TYPE_REMEMBER_PASSWORD);
treeview->appendNode(account_entry->parent_reference, *widget);
// alias
widget = new StringOption(account, StringOption::TYPE_ALIAS);
treeview->appendNode(account_entry->parent_reference, *widget);
for (GList *pref = prplinfo->protocol_options; pref; pref = pref->next) {
PurpleAccountOption *option
= reinterpret_cast<PurpleAccountOption*>(pref->data);
PurplePrefType type = purple_account_option_get_type(option);
switch (type) {
case PURPLE_PREF_STRING:
widget = new StringOption(account, option);
treeview->appendNode(account_entry->parent_reference, *widget);
break;
case PURPLE_PREF_INT:
widget = new IntegerOption(account, option);
treeview->appendNode(account_entry->parent_reference, *widget);
break;
case PURPLE_PREF_BOOLEAN:
widget = new BoolOption(account, option);
treeview->appendNode(account_entry->parent_reference, *widget);
break;
case PURPLE_PREF_STRING_LIST:
widget = new StringListOption(account, option);
treeview->appendNode(account_entry->parent_reference, *widget);
break;
default:
LOG->error(_("Unhandled account option type '%d'."), type);
break;
}
}
// enable/disable account
widget = new BoolOption(account, BoolOption::TYPE_ENABLE_ACCOUNT);
treeview->appendNode(account_entry->parent_reference, *widget);
// coloring
widget = new ColorOption(account);
treeview->appendNode(account_entry->parent_reference, *widget);
}
// drop account
CppConsUI::Button *drop_button = new CppConsUI::Button(_("Drop account"));
drop_button->signal_activate.connect(sigc::bind(sigc::mem_fun(this,
&AccountWindow::dropAccount), account));
treeview->appendNode(account_entry->parent_reference, *drop_button);
}
static void historize(PurpleConversation *c)
{
PurpleAccount *account = purple_conversation_get_account(c);
const char *name = purple_conversation_get_name(c);
PurpleConversationType convtype;
GList *logs = NULL;
const char *alias = name;
guint flags;
char *history;
PidginConversation *gtkconv;
GtkIMHtmlOptions options = GTK_IMHTML_NO_COLOURS;
char *header;
char *protocol;
char *escaped_alias;
const char *header_date;
convtype = purple_conversation_get_type(c);
gtkconv = PIDGIN_CONVERSATION(c);
g_return_if_fail(gtkconv != NULL);
/* An IM which is the first active conversation. */
g_return_if_fail(gtkconv->convs != NULL);
if (convtype == PURPLE_CONV_TYPE_IM && !gtkconv->convs->next)
{
GSList *buddies;
GSList *cur;
/* If we're not logging, don't show anything.
* Otherwise, we might show a very old log. */
if (!purple_prefs_get_bool("/purple/logging/log_ims"))
return;
/* Find buddies for this conversation. */
buddies = purple_find_buddies(account, name);
/* If we found at least one buddy, save the first buddy's alias. */
if (buddies != NULL)
alias = purple_buddy_get_contact_alias((PurpleBuddy *)buddies->data);
for (cur = buddies; cur != NULL; cur = cur->next)
{
PurpleBlistNode *node = cur->data;
if ((node != NULL) && ((node->prev != NULL) || (node->next != NULL)))
{
PurpleBlistNode *node2;
alias = purple_buddy_get_contact_alias((PurpleBuddy *)node);
/* We've found a buddy that matches this conversation. It's part of a
* PurpleContact with more than one PurpleBuddy. Loop through the PurpleBuddies
* in the contact and get all the logs. */
for (node2 = node->parent->child ; node2 != NULL ; node2 = node2->next)
{
logs = g_list_concat(
purple_log_get_logs(PURPLE_LOG_IM,
purple_buddy_get_name((PurpleBuddy *)node2),
purple_buddy_get_account((PurpleBuddy *)node2)),
logs);
}
break;
}
}
g_slist_free(buddies);
if (logs == NULL)
logs = purple_log_get_logs(PURPLE_LOG_IM, name, account);
else
logs = g_list_sort(logs, purple_log_compare);
}
else if (convtype == PURPLE_CONV_TYPE_CHAT)
{
/* If we're not logging, don't show anything.
* Otherwise, we might show a very old log. */
if (!purple_prefs_get_bool("/purple/logging/log_chats"))
return;
logs = purple_log_get_logs(PURPLE_LOG_CHAT, name, account);
}
if (logs == NULL)
return;
history = purple_log_read((PurpleLog*)logs->data, &flags);
gtkconv = PIDGIN_CONVERSATION(c);
if (flags & PURPLE_LOG_READ_NO_NEWLINE)
options |= GTK_IMHTML_NO_NEWLINE;
protocol = g_strdup(gtk_imhtml_get_protocol_name(GTK_IMHTML(gtkconv->imhtml)));
gtk_imhtml_set_protocol_name(GTK_IMHTML(gtkconv->imhtml),
purple_account_get_protocol_name(((PurpleLog*)logs->data)->account));
if (gtk_text_buffer_get_char_count(gtk_text_view_get_buffer(GTK_TEXT_VIEW(gtkconv->imhtml))))
gtk_imhtml_append_text(GTK_IMHTML(gtkconv->imhtml), "<BR>", options);
escaped_alias = g_markup_escape_text(alias, -1);
if (((PurpleLog *)logs->data)->tm)
header_date = purple_date_format_full(((PurpleLog *)logs->data)->tm);
else
header_date = purple_date_format_full(localtime(&((PurpleLog *)logs->data)->time));
header = g_strdup_printf(_("<b>Conversation with %s on %s:</b><br>"), escaped_alias, header_date);
gtk_imhtml_append_text(GTK_IMHTML(gtkconv->imhtml), header, options);
g_free(header);
g_free(escaped_alias);
g_strchomp(history);
gtk_imhtml_append_text(GTK_IMHTML(gtkconv->imhtml), history, options);
g_free(history);
gtk_imhtml_append_text(GTK_IMHTML(gtkconv->imhtml), "<hr>", options);
gtk_imhtml_set_protocol_name(GTK_IMHTML(gtkconv->imhtml), protocol);
g_free(protocol);
g_object_ref(G_OBJECT(gtkconv->imhtml));
g_idle_add(_scroll_imhtml_to_end, gtkconv->imhtml);
g_list_foreach(logs, (GFunc)purple_log_free, NULL);
g_list_free(logs);
}
static void historize(PurpleConversation *c)
{
PurpleAccount *account = purple_conversation_get_account(c);
const char *name = purple_conversation_get_name(c);
GList *logs = NULL;
const char *alias = name;
guint flags;
char *history;
PidginConversation *gtkconv;
#if 0
/* FIXME: WebView has no options */
GtkIMHtmlOptions options = GTK_IMHTML_NO_COLOURS;
#endif
char *header;
#if 0
/* FIXME: WebView has no protocol setting */
char *protocol;
#endif
char *escaped_alias;
const char *header_date;
gtkconv = PIDGIN_CONVERSATION(c);
g_return_if_fail(gtkconv != NULL);
/* An IM which is the first active conversation. */
g_return_if_fail(gtkconv->convs != NULL);
if (PURPLE_IS_IM_CONVERSATION(c) && !gtkconv->convs->next)
{
GSList *buddies;
GSList *cur;
/* If we're not logging, don't show anything.
* Otherwise, we might show a very old log. */
if (!purple_prefs_get_bool("/purple/logging/log_ims"))
return;
/* Find buddies for this conversation. */
buddies = purple_blist_find_buddies(account, name);
/* If we found at least one buddy, save the first buddy's alias. */
if (buddies != NULL)
alias = purple_buddy_get_contact_alias(PURPLE_BUDDY(buddies->data));
for (cur = buddies; cur != NULL; cur = cur->next)
{
PurpleBlistNode *node = cur->data;
PurpleBlistNode *prev = purple_blist_node_get_sibling_prev(node);
PurpleBlistNode *next = purple_blist_node_get_sibling_next(node);
if ((node != NULL) && ((prev != NULL) || (next != NULL)))
{
PurpleBlistNode *node2;
PurpleBlistNode *parent = purple_blist_node_get_parent(node);
PurpleBlistNode *child = purple_blist_node_get_first_child(parent);
alias = purple_buddy_get_contact_alias(PURPLE_BUDDY(node));
/* We've found a buddy that matches this conversation. It's part of a
* PurpleContact with more than one PurpleBuddy. Loop through the PurpleBuddies
* in the contact and get all the logs. */
for (node2 = child ; node2 != NULL ; node2 = purple_blist_node_get_sibling_next(node2))
{
logs = g_list_concat(purple_log_get_logs(PURPLE_LOG_IM,
purple_buddy_get_name(PURPLE_BUDDY(node2)),
purple_buddy_get_account(PURPLE_BUDDY(node2))),
logs);
}
break;
}
}
g_slist_free(buddies);
if (logs == NULL)
logs = purple_log_get_logs(PURPLE_LOG_IM, name, account);
else
logs = g_list_sort(logs, purple_log_compare);
}
else if (PURPLE_IS_CHAT_CONVERSATION(c))
{
/* If we're not logging, don't show anything.
* Otherwise, we might show a very old log. */
if (!purple_prefs_get_bool("/purple/logging/log_chats"))
return;
logs = purple_log_get_logs(PURPLE_LOG_CHAT, name, account);
}
if (logs == NULL)
return;
history = purple_log_read((PurpleLog*)logs->data, &flags);
gtkconv = PIDGIN_CONVERSATION(c);
#if 0
/* FIXME: WebView has no options */
if (flags & PURPLE_LOG_READ_NO_NEWLINE)
options |= GTK_IMHTML_NO_NEWLINE;
#endif
#if 0
/* FIXME: WebView has no protocol setting */
protocol = g_strdup(gtk_imhtml_get_protocol_name(GTK_IMHTML(gtkconv->imhtml)));
gtk_imhtml_set_protocol_name(GTK_IMHTML(gtkconv->imhtml),
purple_account_get_protocol_name(((PurpleLog*)logs->data)->account));
#endif
#if 0
/* TODO WebKit: Do this properly... */
if (!pidgin_webview_is_empty(PIDGIN_WEBVIEW(gtkconv->webview)))
pidgin_webview_append_html(PIDGIN_WEBVIEW(gtkconv->webview), "<BR>");
#endif
escaped_alias = g_markup_escape_text(alias, -1);
if (((PurpleLog *)logs->data)->tm)
header_date = purple_date_format_full(((PurpleLog *)logs->data)->tm);
else
header_date = purple_date_format_full(localtime(&((PurpleLog *)logs->data)->time));
header = g_strdup_printf(_("<b>Conversation with %s on %s:</b><br>"), escaped_alias, header_date);
pidgin_webview_append_html(PIDGIN_WEBVIEW(gtkconv->webview), header);
g_free(header);
g_free(escaped_alias);
g_strchomp(history);
pidgin_webview_append_html(PIDGIN_WEBVIEW(gtkconv->webview), history);
g_free(history);
pidgin_webview_append_html(PIDGIN_WEBVIEW(gtkconv->webview), "<hr>");
#if 0
/* FIXME: WebView has no protocol setting */
gtk_imhtml_set_protocol_name(GTK_IMHTML(gtkconv->imhtml), protocol);
g_free(protocol);
#endif
g_object_ref(G_OBJECT(gtkconv->webview));
g_idle_add(_scroll_webview_to_end, gtkconv->webview);
g_list_foreach(logs, (GFunc)purple_log_free, NULL);
g_list_free(logs);
}
void init_acct_features_dialog(struct acct_features_dialog *f_diag)
{
GList *a = purple_accounts_get_all_active();
/* TODO: should be freed ? */
GdkPixbuf *yes = gtk_widget_render_icon(f_diag->window, GTK_STOCK_YES,
GTK_ICON_SIZE_MENU, NULL);
GdkPixbuf *no = gtk_widget_render_icon(f_diag->window, GTK_STOCK_NO,
GTK_ICON_SIZE_MENU, NULL);
/* last line summarize all available features */
GtkTreeIter e_iter;
GdkPixbuf *e_icon = gtk_widget_render_icon(f_diag->window,
PIDGIN_STOCK_INFO,
GTK_ICON_SIZE_MENU,
NULL);
GdkPixbuf *e_pm = no;
GdkPixbuf *e_buddyicon = no;
GdkPixbuf *e_nickname = no;
GdkPixbuf *e_mood = no;
GdkPixbuf *e_moodmsg = no;
GdkPixbuf *e_game = no;
GdkPixbuf *e_app = no;
GdkPixbuf *e_tune = no;
for(; a ; a = a->next) {
PurpleAccount *acct = (PurpleAccount *)a->data;
PurplePlugin *plugin = purple_find_prpl(acct->protocol_id);
PurplePluginProtocolInfo *protocol = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);
GtkTreeIter iter;
gchar *username = g_strdup_printf("%s (%s)",
purple_account_get_username(acct),
purple_account_get_protocol_name(acct));
GdkPixbuf *a_icon = pidgin_create_prpl_icon(acct, PIDGIN_PRPL_ICON_MEDIUM);
GHashTable *attrs = get_account_attrs(acct);
GdkPixbuf *nickname, *mood, *moodmsg, *game, *app, *tune, *pm, *buddyicon;
if(g_hash_table_lookup(attrs, "mood"))
e_mood = mood = yes;
else
mood = no;
if(g_hash_table_lookup(attrs, "moodtext"))
e_moodmsg = moodmsg = yes;
else
moodmsg = no;
if(g_hash_table_lookup(attrs, "game"))
e_game = game = yes;
else
game = no;
if(g_hash_table_lookup(attrs, "office"))
e_app = app = yes;
else
app = no;
if((g_hash_table_lookup(attrs, "tune_title") &&
g_hash_table_lookup(attrs, "tune_artist") &&
g_hash_table_lookup(attrs, "tune_album")))
e_tune = tune = yes;
else
tune = no;
g_hash_table_destroy(attrs);
if(protocol->set_status)
e_pm = pm = yes;
else
pm = no;
if(protocol->set_buddy_icon)
e_buddyicon = buddyicon = yes;
else
buddyicon = no;
/* exception for XMPP
nickname supported
manually
FIXME: however some XMPP account don't support nickname extension */
if(!strcmp(acct->protocol_id, "prpl-jabber") || protocol->set_public_alias)
e_nickname = nickname = yes;
else
nickname = no;
gtk_list_store_append(f_diag->list_store, &iter);
gtk_list_store_set(f_diag->list_store, &iter,
ACCT_COLUMN, username,
ACCTICON_COLUMN, a_icon,
NICKNAME_COLUMN, nickname,
PM_COLUMN, pm,
ICON_COLUMN, buddyicon,
MOOD_COLUMN, mood,
MOODMSG_COLUMN, moodmsg,
TUNE_COLUMN, tune,
GAME_COLUMN, game,
APP_COLUMN, app,
-1);
g_free(username);
}
/* last line summarize all available features */
gtk_list_store_append(f_diag->list_store, &e_iter);
gtk_list_store_set(f_diag->list_store, &e_iter,
ACCT_COLUMN, "Available features",
ACCTICON_COLUMN, e_icon,
NICKNAME_COLUMN, e_nickname,
PM_COLUMN, e_pm,
ICON_COLUMN, e_buddyicon,
MOOD_COLUMN, e_mood,
MOODMSG_COLUMN, e_moodmsg,
TUNE_COLUMN, e_tune,
GAME_COLUMN, e_game,
APP_COLUMN, e_app,
-1);
}
static void
pounce_cb(PurplePounce *pounce, PurplePounceEvent events, void *data)
{
PurpleConversation *conv;
PurpleAccount *account;
PurpleBuddy *buddy;
const char *pouncee;
const char *alias;
pouncee = purple_pounce_get_pouncee(pounce);
account = purple_pounce_get_pouncer(pounce);
buddy = purple_find_buddy(account, pouncee);
if (buddy != NULL)
{
alias = purple_buddy_get_alias(buddy);
if (alias == NULL)
alias = pouncee;
}
else
alias = pouncee;
if (purple_pounce_action_is_enabled(pounce, "open-window"))
{
if (!purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, pouncee, account))
purple_conversation_new(PURPLE_CONV_TYPE_IM, account, pouncee);
}
if (purple_pounce_action_is_enabled(pounce, "popup-notify"))
{
char *tmp = NULL;
const char *name_shown;
const char *reason;
struct {
PurplePounceEvent event;
const char *format;
} messages[] = {
{PURPLE_POUNCE_TYPING, _("%s has started typing to you (%s)")},
{PURPLE_POUNCE_TYPED, _("%s has paused while typing to you (%s)")},
{PURPLE_POUNCE_SIGNON, _("%s has signed on (%s)")},
{PURPLE_POUNCE_IDLE_RETURN, _("%s has returned from being idle (%s)")},
{PURPLE_POUNCE_AWAY_RETURN, _("%s has returned from being away (%s)")},
{PURPLE_POUNCE_TYPING_STOPPED, _("%s has stopped typing to you (%s)")},
{PURPLE_POUNCE_SIGNOFF, _("%s has signed off (%s)")},
{PURPLE_POUNCE_IDLE, _("%s has become idle (%s)")},
{PURPLE_POUNCE_AWAY, _("%s has gone away. (%s)")},
{PURPLE_POUNCE_MESSAGE_RECEIVED, _("%s has sent you a message. (%s)")},
{0, NULL}
};
int i;
reason = purple_pounce_action_get_attribute(pounce, "popup-notify",
"reason");
/*
* Here we place the protocol name in the pounce dialog to lessen
* confusion about what protocol a pounce is for.
*/
for (i = 0; messages[i].format != NULL; i++) {
if (messages[i].event & events) {
tmp = g_strdup_printf(messages[i].format, alias,
purple_account_get_protocol_name(account));
break;
}
}
if (tmp == NULL)
tmp = g_strdup(_("Unknown pounce event. Please report this!"));
/*
* Ok here is where I change the second argument, title, from
* NULL to the account alias if we have it or the account
* name if that's all we have
*/
if ((name_shown = purple_account_get_alias(account)) == NULL)
name_shown = purple_account_get_username(account);
if (reason == NULL)
{
purple_notify_info(NULL, name_shown, tmp, purple_date_format_full(NULL));
}
else
{
char *tmp2 = g_strdup_printf("%s\n\n%s", reason, purple_date_format_full(NULL));
purple_notify_info(NULL, name_shown, tmp, tmp2);
g_free(tmp2);
}
g_free(tmp);
}
if (purple_pounce_action_is_enabled(pounce, "send-message"))
{
const char *message;
message = purple_pounce_action_get_attribute(pounce, "send-message",
"message");
if (message != NULL)
{
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, pouncee, account);
if (conv == NULL)
conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, pouncee);
purple_conversation_write(conv, NULL, message,
PURPLE_MESSAGE_SEND, time(NULL));
serv_send_im(purple_account_get_connection(account), (char *)pouncee, (char *)message, 0);
}
}
if (purple_pounce_action_is_enabled(pounce, "execute-command"))
{
const char *command;
command = purple_pounce_action_get_attribute(pounce,
"execute-command", "command");
if (command != NULL)
{
char *localecmd = g_locale_from_utf8(command, -1, NULL,
NULL, NULL);
if (localecmd != NULL)
{
int pid = fork();
if (pid == 0) {
char *args[4];
args[0] = "sh";
args[1] = "-c";
args[2] = (char *)localecmd;
args[3] = NULL;
execvp(args[0], args);
_exit(0);
}
g_free(localecmd);
}
}
}
if (purple_pounce_action_is_enabled(pounce, "play-beep"))
{
beep();
}
}
GtkWidget* pref_frame(PurplePlugin *plugin)
{
GtkWidget *align, *frame, *align2, *vbox2;
GtkWidget *vbox, *hbox;
GtkWidget *widget, *widget2;
GtkWidget *expand;
GtkWidget *treeview;
GtkListStore *liststore;
GtkCellRenderer *renderer;
int i;
// Root container
vbox = gtk_vbox_new(FALSE, 10);
align = gtk_alignment_new(0, 0, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(align), 10, 10, 10, 10);
gtk_container_add(GTK_CONTAINER(align), vbox);
// Player selection
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new(_("Player:")), FALSE, FALSE, 0);
widget = gtk_combo_box_new_text();
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
widget2 = gtk_button_new_from_stock(GTK_STOCK_PROPERTIES);
gtk_box_pack_start(GTK_BOX(hbox), widget2, FALSE, FALSE, 0);
gtk_combo_box_append_text(GTK_COMBO_BOX(widget), _("Auto-detect"));
for (i=0; *g_players[i].name; ++i)
gtk_combo_box_append_text(GTK_COMBO_BOX(widget), g_players[i].name);
g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(cb_player_changed), (gpointer) widget2);
g_signal_connect(G_OBJECT(widget2), "clicked", G_CALLBACK(cb_player_properties), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(widget), purple_prefs_get_int(PREF_PLAYER) + 1);
// Popup menu for format
format_menu = gtk_menu_new();
char buf[100];
APPEND_FORMAT_MENU(_("Artist"), "%p");
APPEND_FORMAT_MENU(_("Album"), "%a");
APPEND_FORMAT_MENU(_("Title"), "%t");
APPEND_FORMAT_MENU(_("Track Duration"), "%d");
APPEND_FORMAT_MENU(_("Elapsed Track Time"), "%c");
APPEND_FORMAT_MENU(_("Progress Bar"), "%b");
APPEND_FORMAT_MENU(_("Player"), "%r");
APPEND_FORMAT_MENU(_("Music Symbol (may not display on some networks)"), "%m");
gtk_widget_show_all(format_menu);
// Format selection
frame = gtk_frame_new(_("Status Format"));
gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);
align2 = gtk_alignment_new(0, 0, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(align2), 5, 5, 5, 5);
gtk_container_add(GTK_CONTAINER(frame), align2);
vbox2 = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(align2), vbox2);
ADD_FORMAT_ENTRY(vbox2, _("Playing:"), PREF_FORMAT);
ADD_FORMAT_ENTRY(vbox2, _("Paused:"), PREF_PAUSED);
ADD_FORMAT_ENTRY(vbox2, _("Stopped/Off:"), PREF_OFF);
// Protocol-specific formats
liststore = gtk_list_store_new(6, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_POINTER);
GList *accounts = purple_accounts_get_all();
while (accounts) {
PurpleAccount *account = (PurpleAccount*) accounts->data;
GtkTreeIter iter;
const char *username = purple_account_get_username(account);
const char *protocolname = purple_account_get_protocol_name(account);
char buf1[100], buf2[100], buf3[100];
build_pref(buf1, PREF_CUSTOM_FORMAT, username, protocolname);
build_pref(buf2, PREF_CUSTOM_DISABLED, username, protocolname);
build_pref(buf3, PREF_BROKEN_NOWLISTENING, username, protocolname);
trace("%s %s", buf1, purple_prefs_get_string(buf1));
gtk_list_store_append(liststore, &iter);
gtk_list_store_set(liststore, &iter, 0, username, 1, purple_account_get_protocol_name(account),
2, purple_prefs_get_string(buf1), 3, purple_prefs_get_bool(buf2),
4, purple_prefs_get_bool(buf3), 5, account, -1);
accounts = accounts->next;
}
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(liststore));
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview), -1, _("Screen Name"),
gtk_cell_renderer_text_new(), "text", 0, NULL);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview), -1, _("Protocol"),
gtk_cell_renderer_text_new(), "text", 1, NULL);
renderer = gtk_cell_renderer_text_new();
g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(cb_custom_edited), (gpointer) GTK_TREE_MODEL(liststore));
g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview), -1, _("Playing Status Format"),
renderer, "text", 2, NULL);
renderer = gtk_cell_renderer_toggle_new();
g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(cb_custom_toggled), (gpointer) GTK_TREE_MODEL(liststore));
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview), -1, _("Disable"),
renderer, "active", 3, NULL);
renderer = gtk_cell_renderer_toggle_new();
g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(cb_broken_nowlistening_toggled), (gpointer) GTK_TREE_MODEL(liststore));
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview), -1, _("Broken 'now listening'"),
renderer, "active", 4, NULL);
expand = gtk_expander_new(_("Customize playing status format, or disable status changing altogether for specific accounts"));
gtk_expander_set_spacing(GTK_EXPANDER(expand), 5);
gtk_box_pack_start(GTK_BOX(vbox), expand, TRUE, TRUE, 0);
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(widget), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(expand), widget);
gtk_container_add(GTK_CONTAINER(widget), treeview);
// Misc settings
frame = gtk_frame_new(_("Other settings"));
gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);
align2 = gtk_alignment_new(0, 0, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(align2), 5, 5, 5, 5);
gtk_container_add(GTK_CONTAINER(frame), align2);
vbox2 = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(align2), vbox2);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox2), hbox, FALSE, FALSE, 0);
widget = gtk_check_button_new_with_label(_("Don't change status message when away"));
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), purple_prefs_get_bool(PREF_DISABLE_WHEN_AWAY));
g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(cb_misc_toggled), (gpointer) PREF_DISABLE_WHEN_AWAY);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox2), hbox, FALSE, FALSE, 0);
widget = gtk_check_button_new_with_label(_("Don't change status message if protocol has working 'now listening'"));
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), purple_prefs_get_bool(PREF_NOW_LISTENING_ONLY));
g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(cb_misc_toggled), (gpointer) PREF_NOW_LISTENING_ONLY);
// Filter
frame = gtk_frame_new(_("Status Filter"));
gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);
align2 = gtk_alignment_new(0, 0, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(align2), 5, 5, 5, 5);
gtk_container_add(GTK_CONTAINER(frame), align2);
vbox2 = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(align2), vbox2);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox2), hbox, FALSE, FALSE, 0);
widget = gtk_check_button_new_with_label(_("Enable status filter"));
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), purple_prefs_get_bool(PREF_FILTER_ENABLE));
g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(cb_filter_toggled), 0);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox2), hbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new(_("Blacklist (comma-delimited):")), FALSE, FALSE, 0);
widget = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(widget), purple_prefs_get_string(PREF_FILTER));
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(cb_filter_changed), 0);
filter_list = widget;
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox2), hbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new(_("Mask character:")), FALSE, FALSE, 0);
widget = gtk_entry_new_with_max_length(1);
gtk_entry_set_text(GTK_ENTRY(widget), purple_prefs_get_string(PREF_MASK));
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(cb_filter_mask_changed), 0);
filter_mask = widget;
gboolean state = purple_prefs_get_bool(PREF_FILTER_ENABLE);
gtk_widget_set_sensitive(filter_list, state);
gtk_widget_set_sensitive(filter_mask, state);
gtk_widget_show_all(align);
return align;
}
static void on_new_message(PurpleAccount *account, const char *remote,
const char *message)
{
const char *command = purple_prefs_get_path(PLUGIN_PREF_COMMAND);
// the command should be never NULL
g_return_if_fail(command);
if (!command[0]) {
// no command is set
return;
}
const char *protocol = purple_account_get_protocol_name(account);
char *local = g_strdup(purple_normalize(account,
purple_account_get_username(account)));
char *nohtml = purple_markup_strip_html(message);
PurpleBuddy *buddy = purple_find_buddy(account, remote);
char *icon_encoded = NULL;
if (buddy) {
// get buddy alias and icon
remote = purple_buddy_get_alias(buddy);
PurpleBuddyIcon *icon = purple_buddy_get_icon(buddy);
if (icon) {
size_t len;
gconstpointer data = purple_buddy_icon_get_data(icon, &len);
icon_encoded = g_base64_encode(data, len);
}
}
char *argv[2];
argv[0] = g_strdup(command);
argv[1] = NULL;
// prepare child's environment variables
char **envp = g_get_environ();
envp = g_environ_setenv(envp, "EVENT_TYPE", "msg", TRUE);
envp = g_environ_setenv(envp, "EVENT_NETWORK", protocol, TRUE);
envp = g_environ_setenv(envp, "EVENT_LOCAL_USER", local, TRUE);
envp = g_environ_setenv(envp, "EVENT_REMOTE_USER", remote, TRUE);
if (icon_encoded)
envp = g_environ_setenv(envp, "EVENT_REMOTE_USER_ICON", icon_encoded, TRUE);
envp = g_environ_setenv(envp, "EVENT_MESSAGE", nohtml, TRUE);
envp = g_environ_setenv(envp, "EVENT_MESSAGE_HTML", message, TRUE);
// spawn the command
GError *err = NULL;
if (!g_spawn_async(NULL, argv, envp, G_SPAWN_SEARCH_PATH
| G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL, NULL, NULL,
NULL, &err)) {
purple_debug_error("extaction", "%s", err->message);
g_clear_error(&err);
}
// free all resources
g_free(argv[0]);
g_strfreev(envp);
g_free(local);
g_free(nohtml);
g_free(icon_encoded);
}
static VALUE protocol_name(VALUE self)
{
PurpleAccount *account;
Data_Get_Struct(self, PurpleAccount, account);
return rb_str_new2(purple_account_get_protocol_name(account));
}
void
finch_pounce_editor_show(PurpleAccount *account, const char *name,
PurplePounce *cur_pounce)
{
PurpleGntPounceDialog *dialog;
GntWidget *window;
GntWidget *bbox;
GntWidget *hbox, *vbox;
GntWidget *button;
GntWidget *combo;
GList *list;
g_return_if_fail((cur_pounce != NULL) ||
(account != NULL) ||
(purple_accounts_get_all() != NULL));
dialog = g_new0(PurpleGntPounceDialog, 1);
if (cur_pounce != NULL) {
dialog->pounce = cur_pounce;
dialog->account = purple_pounce_get_pouncer(cur_pounce);
} else if (account != NULL) {
dialog->pounce = NULL;
dialog->account = account;
} else {
GList *connections = purple_connections_get_all();
PurpleConnection *gc;
if (connections != NULL) {
gc = (PurpleConnection *)connections->data;
dialog->account = purple_connection_get_account(gc);
} else
dialog->account = purple_accounts_get_all()->data;
dialog->pounce = NULL;
}
/* Create the window. */
dialog->window = window = gnt_vbox_new(FALSE);
gnt_box_set_pad(GNT_BOX(window), 0);
gnt_box_set_toplevel(GNT_BOX(window), TRUE);
gnt_box_set_alignment(GNT_BOX(window), GNT_ALIGN_LEFT);
gnt_box_set_title(GNT_BOX(window),
(cur_pounce == NULL
? _("New Buddy Pounce") : _("Edit Buddy Pounce")));
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(delete_win_cb), dialog);
gnt_box_add_widget(GNT_BOX(window), gnt_label_new_with_format(_("Pounce on Whom"), GNT_TEXT_FLAG_BOLD));
/* Account: */
gnt_box_add_widget(GNT_BOX(window), gnt_label_new(_("Account:")));
dialog->account_menu = combo = gnt_combo_box_new();
list = purple_accounts_get_all();
for (; list; list = list->next)
{
PurpleAccount *account;
char *text;
account = list->data;
text = g_strdup_printf("%s (%s)",
purple_account_get_username(account),
purple_account_get_protocol_name(account));
gnt_combo_box_add_data(GNT_COMBO_BOX(combo), account, text);
g_free(text);
}
if (dialog->account)
gnt_combo_box_set_selected(GNT_COMBO_BOX(combo), dialog->account);
gnt_box_add_widget(GNT_BOX(window), combo);
/* Buddy: */
hbox = gnt_hbox_new(FALSE);
gnt_box_add_widget(GNT_BOX(hbox), gnt_label_new(_("Buddy name:")));
dialog->buddy_entry = gnt_entry_new(NULL);
gnt_box_add_widget(GNT_BOX(hbox), dialog->buddy_entry);
setup_buddy_list_suggestion(GNT_ENTRY(dialog->buddy_entry), TRUE);
gnt_box_add_widget(GNT_BOX(window), hbox);
if (cur_pounce != NULL) {
gnt_entry_set_text(GNT_ENTRY(dialog->buddy_entry),
purple_pounce_get_pouncee(cur_pounce));
} else if (name != NULL) {
gnt_entry_set_text(GNT_ENTRY(dialog->buddy_entry), name);
}
/* Create the event frame */
gnt_box_add_widget(GNT_BOX(window), gnt_line_new(FALSE));
gnt_box_add_widget(GNT_BOX(window), gnt_label_new_with_format(_("Pounce When Buddy..."), GNT_TEXT_FLAG_BOLD));
dialog->signon = gnt_check_box_new(_("Signs on"));
dialog->signoff = gnt_check_box_new(_("Signs off"));
dialog->away = gnt_check_box_new(_("Goes away"));
dialog->away_return = gnt_check_box_new(_("Returns from away"));
dialog->idle = gnt_check_box_new(_("Becomes idle"));
dialog->idle_return = gnt_check_box_new(_("Is no longer idle"));
dialog->typing = gnt_check_box_new(_("Starts typing"));
dialog->typed = gnt_check_box_new(_("Pauses while typing"));
dialog->stop_typing = gnt_check_box_new(_("Stops typing"));
dialog->message_recv = gnt_check_box_new(_("Sends a message"));
hbox = gnt_hbox_new(TRUE);
gnt_box_set_pad(GNT_BOX(hbox), 2);
vbox = gnt_vbox_new(FALSE);
gnt_box_set_pad(GNT_BOX(vbox), 0);
gnt_box_add_widget(GNT_BOX(hbox), vbox);
gnt_box_add_widget(GNT_BOX(vbox), dialog->signon);
gnt_box_add_widget(GNT_BOX(vbox), dialog->away);
gnt_box_add_widget(GNT_BOX(vbox), dialog->idle);
gnt_box_add_widget(GNT_BOX(vbox), dialog->typing);
gnt_box_add_widget(GNT_BOX(vbox), dialog->stop_typing);
vbox = gnt_vbox_new(FALSE);
gnt_box_set_pad(GNT_BOX(vbox), 0);
gnt_box_add_widget(GNT_BOX(hbox), vbox);
gnt_box_add_widget(GNT_BOX(vbox), dialog->signoff);
gnt_box_add_widget(GNT_BOX(vbox), dialog->away_return);
gnt_box_add_widget(GNT_BOX(vbox), dialog->idle_return);
gnt_box_add_widget(GNT_BOX(vbox), dialog->typed);
gnt_box_add_widget(GNT_BOX(vbox), dialog->message_recv);
gnt_box_add_widget(GNT_BOX(window), hbox);
/* Create the "Action" frame. */
gnt_box_add_widget(GNT_BOX(window), gnt_line_new(FALSE));
gnt_box_add_widget(GNT_BOX(window), gnt_label_new_with_format(_("Action"), GNT_TEXT_FLAG_BOLD));
dialog->open_win = gnt_check_box_new(_("Open an IM window"));
dialog->popup = gnt_check_box_new(_("Pop up a notification"));
dialog->send_msg = gnt_check_box_new(_("Send a message"));
dialog->exec_cmd = gnt_check_box_new(_("Execute a command"));
dialog->play_sound = gnt_check_box_new(_("Play a sound"));
dialog->send_msg_entry = gnt_entry_new(NULL);
dialog->exec_cmd_entry = gnt_entry_new(NULL);
dialog->popup_entry = gnt_entry_new(NULL);
dialog->exec_cmd_entry = gnt_entry_new(NULL);
hbox = gnt_hbox_new(FALSE);
gnt_box_add_widget(GNT_BOX(hbox), dialog->open_win);
gnt_box_add_widget(GNT_BOX(window), hbox);
hbox = gnt_hbox_new(FALSE);
gnt_box_add_widget(GNT_BOX(hbox), dialog->popup);
gnt_box_add_widget(GNT_BOX(hbox), dialog->popup_entry);
gnt_box_add_widget(GNT_BOX(window), hbox);
hbox = gnt_hbox_new(FALSE);
gnt_box_add_widget(GNT_BOX(hbox), dialog->send_msg);
gnt_box_add_widget(GNT_BOX(hbox), dialog->send_msg_entry);
gnt_box_add_widget(GNT_BOX(window), hbox);
hbox = gnt_hbox_new(FALSE);
gnt_box_add_widget(GNT_BOX(hbox), dialog->exec_cmd);
gnt_box_add_widget(GNT_BOX(hbox), dialog->exec_cmd_entry);
gnt_box_add_widget(GNT_BOX(window), hbox);
hbox = gnt_hbox_new(FALSE);
gnt_box_add_widget(GNT_BOX(hbox), dialog->play_sound);
gnt_box_add_widget(GNT_BOX(window), hbox);
gnt_box_add_widget(GNT_BOX(window), gnt_line_new(FALSE));
gnt_box_add_widget(GNT_BOX(window), gnt_label_new_with_format(_("Options"), GNT_TEXT_FLAG_BOLD));
dialog->on_away = gnt_check_box_new(_("Pounce only when my status is not Available"));
gnt_box_add_widget(GNT_BOX(window), dialog->on_away);
dialog->save_pounce = gnt_check_box_new(_("Recurring"));
gnt_box_add_widget(GNT_BOX(window), dialog->save_pounce);
gnt_box_add_widget(GNT_BOX(window), gnt_line_new(FALSE));
/* Now the button box! */
bbox = gnt_hbox_new(FALSE);
/* Cancel button */
button = gnt_button_new(_("Cancel"));
gnt_box_add_widget(GNT_BOX(bbox), button);
g_signal_connect(G_OBJECT(button), "activate",
G_CALLBACK(cancel_cb), dialog);
/* Save button */
dialog->save_button = button = gnt_button_new(_("Save"));
gnt_box_add_widget(GNT_BOX(bbox), button);
g_signal_connect(G_OBJECT(button), "activate",
G_CALLBACK(save_pounce_cb), dialog);
gnt_box_add_widget(GNT_BOX(window), bbox);
/* Set the values of stuff. */
if (cur_pounce != NULL)
{
PurplePounceEvent events = purple_pounce_get_events(cur_pounce);
PurplePounceOption options = purple_pounce_get_options(cur_pounce);
const char *value;
/* Options */
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->on_away),
(options & PURPLE_POUNCE_OPTION_AWAY));
/* Events */
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->signon),
(events & PURPLE_POUNCE_SIGNON));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->signoff),
(events & PURPLE_POUNCE_SIGNOFF));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->away),
(events & PURPLE_POUNCE_AWAY));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->away_return),
(events & PURPLE_POUNCE_AWAY_RETURN));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->idle),
(events & PURPLE_POUNCE_IDLE));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->idle_return),
(events & PURPLE_POUNCE_IDLE_RETURN));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->typing),
(events & PURPLE_POUNCE_TYPING));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->typed),
(events & PURPLE_POUNCE_TYPED));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->stop_typing),
(events & PURPLE_POUNCE_TYPING_STOPPED));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->message_recv),
(events & PURPLE_POUNCE_MESSAGE_RECEIVED));
/* Actions */
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->open_win),
purple_pounce_action_is_enabled(cur_pounce, "open-window"));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->popup),
purple_pounce_action_is_enabled(cur_pounce, "popup-notify"));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->send_msg),
purple_pounce_action_is_enabled(cur_pounce, "send-message"));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->exec_cmd),
purple_pounce_action_is_enabled(cur_pounce, "execute-command"));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->play_sound),
purple_pounce_action_is_enabled(cur_pounce, "play-beep"));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->save_pounce),
purple_pounce_get_save(cur_pounce));
if ((value = purple_pounce_action_get_attribute(cur_pounce,
"send-message",
"message")) != NULL)
{
gnt_entry_set_text(GNT_ENTRY(dialog->send_msg_entry), value);
}
if ((value = purple_pounce_action_get_attribute(cur_pounce,
"popup-notify",
"reason")) != NULL)
{
gnt_entry_set_text(GNT_ENTRY(dialog->popup_entry), value);
}
if ((value = purple_pounce_action_get_attribute(cur_pounce,
"execute-command",
"command")) != NULL)
{
gnt_entry_set_text(GNT_ENTRY(dialog->exec_cmd_entry), value);
}
}
else
{
PurpleBuddy *buddy = NULL;
if (name != NULL)
buddy = purple_find_buddy(account, name);
/* Set some defaults */
if (buddy == NULL) {
gnt_check_box_set_checked(
GNT_CHECK_BOX(dialog->signon), TRUE);
} else {
if (!PURPLE_BUDDY_IS_ONLINE(buddy)) {
gnt_check_box_set_checked(
GNT_CHECK_BOX(dialog->signon), TRUE);
} else {
gboolean default_set = FALSE;
PurplePresence *presence = purple_buddy_get_presence(buddy);
if (purple_presence_is_idle(presence))
{
gnt_check_box_set_checked(
GNT_CHECK_BOX(dialog->idle_return), TRUE);
default_set = TRUE;
}
if (!purple_presence_is_available(presence))
{
gnt_check_box_set_checked(
GNT_CHECK_BOX(dialog->away_return), TRUE);
default_set = TRUE;
}
if (!default_set)
{
gnt_check_box_set_checked(
GNT_CHECK_BOX(dialog->signon), TRUE);
}
}
}
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->open_win),
purple_prefs_get_bool("/finch/pounces/default_actions/open-window"));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->popup),
purple_prefs_get_bool("/finch/pounces/default_actions/popup-notify"));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->send_msg),
purple_prefs_get_bool("/finch/pounces/default_actions/send-message"));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->exec_cmd),
purple_prefs_get_bool("/finch/pounces/default_actions/execute-command"));
gnt_check_box_set_checked(GNT_CHECK_BOX(dialog->play_sound),
purple_prefs_get_bool("/finch/pounces/default_actions/play-beep"));
}
gnt_widget_show(window);
}
static gboolean
popup_substatus(GntTree *tree, const char *key, EditStatus *edit)
{
if (key[0] == ' ' && key[1] == 0)
{
EditSubStatus *sub;
GntWidget *window, *combo, *entry, *box, *button, *l;
PurpleSavedStatusSub *substatus = NULL;
GList *iter;
char *name;
RowInfo *selected = gnt_tree_get_selection_data(tree);
PurpleAccount *account = selected->account;
if (gnt_tree_get_choice(tree, selected))
{
/* There was a savedstatus for this account. Now remove it. */
g_free(selected->message);
selected->type = NULL;
selected->message = NULL;
/* XXX: should we really be saving it right now? */
purple_savedstatus_unset_substatus(edit->saved, account);
gnt_tree_change_text(tree, account, 1, NULL);
gnt_tree_change_text(tree, account, 2, NULL);
return FALSE;
}
if (g_hash_table_lookup(edit->hash, account))
return TRUE;
if (edit->saved)
substatus = purple_savedstatus_get_substatus(edit->saved, account);
sub = g_new0(EditSubStatus, 1);
sub->parent = edit;
sub->key = selected;
sub->window = window = gnt_vbox_new(FALSE);
gnt_box_set_toplevel(GNT_BOX(window), TRUE);
gnt_box_set_title(GNT_BOX(window), _("Substatus")); /* XXX: a better title */
gnt_box_set_alignment(GNT_BOX(window), GNT_ALIGN_MID);
box = gnt_hbox_new(FALSE);
gnt_box_add_widget(GNT_BOX(box), gnt_label_new(_("Account:")));
name = g_strdup_printf("%s (%s)", purple_account_get_username(account),
purple_account_get_protocol_name(account));
gnt_box_add_widget(GNT_BOX(box), gnt_label_new(name));
g_free(name);
gnt_box_add_widget(GNT_BOX(window), box);
box = gnt_hbox_new(FALSE);
gnt_box_add_widget(GNT_BOX(box), (l = gnt_label_new(_("Status:"))));
gnt_widget_set_size(l, 0, 1); /* I don't like having to do this */
sub->type = combo = gnt_combo_box_new();
gnt_box_add_widget(GNT_BOX(box), combo);
gnt_box_add_widget(GNT_BOX(window), box);
for (iter = purple_account_get_status_types(account); iter; iter = iter->next)
{
PurpleStatusType *type = iter->data;
if (!purple_status_type_is_user_settable(type))
continue;
gnt_combo_box_add_data(GNT_COMBO_BOX(combo), type, purple_status_type_get_name(type));
}
box = gnt_hbox_new(FALSE);
gnt_box_add_widget(GNT_BOX(box), gnt_label_new(_("Message:")));
sub->message = entry = gnt_entry_new(substatus ? purple_savedstatus_substatus_get_message(substatus) : NULL);
gnt_box_add_widget(GNT_BOX(box), entry);
gnt_box_add_widget(GNT_BOX(window), box);
box = gnt_hbox_new(FALSE);
button = gnt_button_new(_("Cancel"));
g_signal_connect_swapped(G_OBJECT(button), "activate", G_CALLBACK(gnt_widget_destroy), window);
gnt_box_add_widget(GNT_BOX(box), button);
button = gnt_button_new(_("Save"));
g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(save_substatus_cb), sub);
gnt_box_add_widget(GNT_BOX(box), button);
gnt_box_add_widget(GNT_BOX(window), box);
gnt_widget_show(window);
g_hash_table_insert(edit->hash, account, sub);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(substatus_window_destroy_cb), sub);
return TRUE;
}
return FALSE;
}
static PurplePluginPrefFrame *
get_plugin_pref_frame(PurplePlugin *plugin)
{
PurplePluginPrefFrame *frame;
PurplePluginPref *ppref;
PurpleAccount *account;
char *name, *id, *path;
int len;
GList *l, *listed_protocols;
DEBUG_MSG("get_plugin_pref_frame");
frame = purple_plugin_pref_frame_new();
ppref = purple_plugin_pref_new_with_name_and_label(
"/plugins/core/pidgin-gntp/on_focus", "show message when window is focused");
purple_plugin_pref_frame_add(frame, ppref);
ppref = purple_plugin_pref_new_with_label("Send notifications when status is:");
purple_plugin_pref_frame_add(frame, ppref);
ppref = purple_plugin_pref_new_with_name_and_label(
"/plugins/core/pidgin-gntp/on_available", "available");
purple_plugin_pref_frame_add(frame, ppref);
ppref = purple_plugin_pref_new_with_name_and_label(
"/plugins/core/pidgin-gntp/on_unavailable", "unavailable");
purple_plugin_pref_frame_add(frame, ppref);
ppref = purple_plugin_pref_new_with_name_and_label(
"/plugins/core/pidgin-gntp/on_invisible", "invisible");
purple_plugin_pref_frame_add(frame, ppref);
ppref = purple_plugin_pref_new_with_name_and_label(
"/plugins/core/pidgin-gntp/on_away", "away");
purple_plugin_pref_frame_add(frame, ppref);
ppref = purple_plugin_pref_new_with_label("Starting delay (to prevent spam while connecting):");
purple_plugin_pref_frame_add(frame, ppref);
ppref = purple_plugin_pref_new_with_name_and_label(
"/plugins/core/pidgin-gntp/hack_ms", "value in milliseconds (1000ms = 1 sec)");
purple_plugin_pref_set_bounds(ppref, 0, 30000);
purple_plugin_pref_frame_add(frame, ppref);
ppref = purple_plugin_pref_new_with_label("Following protocols sends notifications:");
purple_plugin_pref_frame_add(frame, ppref);
listed_protocols = NULL;
for (l = purple_accounts_get_all(); l != NULL; l = l->next)
{
account = (PurpleAccount *)l->data;
name = (char*)purple_account_get_protocol_name (account);
id = (char*)purple_account_get_protocol_id (account);
if( !g_list_find_custom(listed_protocols, id, (GCompareFunc)strcmp) )
{
listed_protocols = g_list_prepend (listed_protocols, id);
len = s_strlen("/plugins/core/pidgin-gntp/") + s_strlen(id) + 1;
path = malloc( len );
g_snprintf(path, len, "%s%s", "/plugins/core/pidgin-gntp/", id );
if(!purple_prefs_exists(path))
purple_prefs_add_bool(path, TRUE);
ppref = purple_plugin_pref_new_with_name_and_label(path, name);
purple_plugin_pref_frame_add(frame, ppref);
free(path);
}
}
g_list_free(listed_protocols);
ppref = purple_plugin_pref_new_with_label(REV);
purple_plugin_pref_frame_add(frame, ppref);
return frame;
}