static void
menu_tree_add(GntMenu *menu, GntMenuItem *item, GntMenuItem *parent)
{
char trigger[] = "\0 )\0";
g_return_if_fail(item != NULL);
if ((trigger[1] = gnt_menuitem_get_trigger(item)) && trigger[1] != ' ')
trigger[0] = '(';
if (GNT_IS_MENU_ITEM_CHECK(item)) {
gnt_tree_add_choice(GNT_TREE(menu), item,
gnt_tree_create_row(GNT_TREE(menu), item->text, trigger, " "), parent, NULL);
gnt_tree_set_choice(GNT_TREE(menu), item, gnt_menuitem_check_get_checked(GNT_MENU_ITEM_CHECK(item)));
} else {
gnt_tree_add_row_last(GNT_TREE(menu), item,
gnt_tree_create_row(GNT_TREE(menu), item->text, trigger, item->submenu ? ">" : " "), parent);
if (!item->callback && !item->submenu)
gnt_tree_set_row_color(GNT_TREE(menu), item, GNT_COLOR_DISABLED);
}
if (0 && item->submenu) {
GntMenu *sub = GNT_MENU(item->submenu);
GList *iter;
for (iter = sub->list; iter; iter = iter->next) {
GntMenuItem *it = GNT_MENU_ITEM(iter->data);
menu_tree_add(menu, it, item);
}
}
}
static gboolean
location_changed(GntFileSel *sel, GError **err)
{
GList *files, *iter;
gboolean success;
if (!sel->dirs)
return TRUE;
gnt_tree_remove_all(GNT_TREE(sel->dirs));
if (sel->files)
gnt_tree_remove_all(GNT_TREE(sel->files));
gnt_entry_set_text(GNT_ENTRY(sel->location), NULL);
if (sel->current == NULL) {
if (GNT_WIDGET_IS_FLAG_SET(GNT_WIDGET(sel), GNT_WIDGET_MAPPED))
gnt_widget_draw(GNT_WIDGET(sel));
return TRUE;
}
/* XXX:\
* XXX: This is blocking.
* XXX:/
*/
files = NULL;
if (sel->read_fn)
success = sel->read_fn(sel->current, &files, err);
else
success = local_read_fn(sel->current, &files, err);
if (!success || *err) {
gnt_warning("error opening location %s (%s)",
sel->current, *err ? (*err)->message : "reason unknown");
return FALSE;
}
for (iter = files; iter; iter = iter->next) {
GntFile *file = iter->data;
char *str = file->basename;
if (file->type == GNT_FILE_DIR) {
gnt_tree_add_row_after(GNT_TREE(sel->dirs), g_strdup(str),
gnt_tree_create_row(GNT_TREE(sel->dirs), str), NULL, NULL);
if (sel->multiselect && sel->dirsonly && is_tagged(sel, str))
gnt_tree_set_row_flags(GNT_TREE(sel->dirs), (gpointer)str, GNT_TEXT_FLAG_BOLD);
} else if (!sel->dirsonly) {
char size[128];
snprintf(size, sizeof(size), "%ld", file->size);
gnt_tree_add_row_after(GNT_TREE(sel->files), g_strdup(str),
gnt_tree_create_row(GNT_TREE(sel->files), str, size, ""), NULL, NULL);
if (sel->multiselect && is_tagged(sel, str))
gnt_tree_set_row_flags(GNT_TREE(sel->files), (gpointer)str, GNT_TEXT_FLAG_BOLD);
}
}
g_list_foreach(files, (GFunc)gnt_file_free, NULL);
g_list_free(files);
if (GNT_WIDGET_IS_FLAG_SET(GNT_WIDGET(sel), GNT_WIDGET_MAPPED))
gnt_widget_draw(GNT_WIDGET(sel));
return TRUE;
}
static gboolean on_offline_init()
{
GntTree *tree = finch_blist_get_tree();
gnt_tree_add_row_after(tree, online,
gnt_tree_create_row(tree, _("Online")), NULL, NULL);
gnt_tree_add_row_after(tree, offline,
gnt_tree_create_row(tree, _("Offline")), NULL, online);
return TRUE;
}
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
save_savedstatus_cb(GntWidget *button, EditStatus *edit)
{
const char *title, *message;
PurpleStatusPrimitive prim;
PurpleSavedStatus *find;
title = gnt_entry_get_text(GNT_ENTRY(edit->title));
message = gnt_entry_get_text(GNT_ENTRY(edit->message));
if (!message || !*message)
message = NULL;
prim = GPOINTER_TO_INT(gnt_combo_box_get_selected_data(GNT_COMBO_BOX(edit->type)));
if (!title || !*title)
{
purple_notify_error(edit, _("Error"), _("Invalid title"),
_("Please enter a non-empty title for the status."));
gnt_box_give_focus_to_child(GNT_BOX(edit->window), edit->title);
return;
}
find = purple_savedstatus_find(title);
if (find && find != edit->saved)
{
purple_notify_error(edit, _("Error"), _("Duplicate title"),
_("Please enter a different title for the status."));
gnt_box_give_focus_to_child(GNT_BOX(edit->window), edit->title);
return;
}
if (edit->saved == NULL)
{
edit->saved = purple_savedstatus_new(title, prim);
purple_savedstatus_set_message(edit->saved, message);
set_substatuses(edit);
if (statuses.tree)
gnt_tree_add_row_last(GNT_TREE(statuses.tree), edit->saved,
gnt_tree_create_row(GNT_TREE(statuses.tree), title,
purple_primitive_get_name_from_type(prim), message), NULL);
}
else
{
purple_savedstatus_set_title(edit->saved, title);
purple_savedstatus_set_type(edit->saved, prim);
purple_savedstatus_set_message(edit->saved, message);
if (statuses.tree)
{
gnt_tree_change_text(GNT_TREE(statuses.tree), edit->saved, 0, title);
gnt_tree_change_text(GNT_TREE(statuses.tree), edit->saved, 1,
purple_primitive_get_name_from_type(prim));
gnt_tree_change_text(GNT_TREE(statuses.tree), edit->saved, 2, message);
}
}
if (g_object_get_data(G_OBJECT(button), "use"))
purple_savedstatus_activate(edit->saved);
gnt_widget_destroy(edit->window);
}
static gboolean meebo_init()
{
GntTree *tree = finch_blist_get_tree();
if (!g_list_find(gnt_tree_get_rows(tree), &meebo)) {
gnt_tree_add_row_last(tree, &meebo,
gnt_tree_create_row(tree, _("Offline")), NULL);
}
return TRUE;
}
static void
add_pounce_to_treeview(GntTree *tree, PurplePounce *pounce)
{
PurpleAccount *account;
const char *pouncer;
const char *pouncee;
account = purple_pounce_get_pouncer(pounce);
pouncer = purple_account_get_username(account);
pouncee = purple_pounce_get_pouncee(pounce);
gnt_tree_add_row_last(tree, pounce,
gnt_tree_create_row(tree, pouncer, pouncee), NULL);
}
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
fl_add_room(PurpleRoomlist *roomlist, PurpleRoomlistRoom *room)
{
gboolean category;
if (froomlist.roomlist != roomlist)
return;
category = (purple_roomlist_room_get_type(room) == PURPLE_ROOMLIST_ROOMTYPE_CATEGORY);
gnt_tree_remove(GNT_TREE(froomlist.tree), room);
gnt_tree_add_row_after(GNT_TREE(froomlist.tree), room,
gnt_tree_create_row(GNT_TREE(froomlist.tree),
purple_roomlist_room_get_name(room),
category ? "<" : ""),
purple_roomlist_room_get_parent(room), NULL);
gnt_tree_set_expanded(GNT_TREE(froomlist.tree), room, !category);
}
static void
prof_add_cb(GntButton *button, GntEntry * entry)
{
const char * profile = gnt_entry_get_text(entry);
GntTreeRow * row;
if (!finch_sound_profile_exists(profile)) {
gpointer key = g_strdup(profile);
row = gnt_tree_create_row(GNT_TREE(pref_dialog->profiles), profile);
gnt_tree_add_row_after(GNT_TREE(pref_dialog->profiles), key,
row,
NULL, NULL);
gnt_entry_set_text(entry, "");
gnt_tree_set_selected(GNT_TREE(pref_dialog->profiles), key);
finch_sound_set_active_profile(key);
} else
reload_pref_window(profile);
}
void
finch_xfer_dialog_add_xfer(PurpleXfer *xfer)
{
PurpleGntXferUiData *data;
PurpleXferType type;
char *size_str, *remaining_str;
char *lfilename, *utf8;
g_return_if_fail(xfer_dialog != NULL);
g_return_if_fail(xfer != NULL);
purple_xfer_ref(xfer);
data = FINCHXFER(xfer);
data->in_list = TRUE;
finch_xfer_dialog_show();
data->last_updated_time = 0;
type = purple_xfer_get_type(xfer);
size_str = purple_str_size_to_units(purple_xfer_get_size(xfer));
remaining_str = purple_str_size_to_units(purple_xfer_get_bytes_remaining(xfer));
lfilename = g_path_get_basename(purple_xfer_get_local_filename(xfer));
utf8 = g_filename_to_utf8(lfilename, -1, NULL, NULL, NULL);
g_free(lfilename);
lfilename = utf8;
gnt_tree_add_row_last(GNT_TREE(xfer_dialog->tree), xfer,
gnt_tree_create_row(GNT_TREE(xfer_dialog->tree),
"0.0", (type == PURPLE_XFER_RECEIVE) ? purple_xfer_get_filename(xfer) : lfilename,
size_str, "0.0", "",_("Waiting for transfer to begin")), NULL);
g_free(lfilename);
g_free(size_str);
g_free(remaining_str);
xfer_dialog->num_transfers++;
update_title_progress();
}
static gpointer
nested_group_find_parent(PurpleBlistNode *node)
{
char *name;
PurpleGroup *group;
char *sep;
PurpleBlistNode *ret, *parent;
GntTree *tree;
if (!PURPLE_IS_GROUP(node))
return default_manager->find_parent(node);
group = PURPLE_GROUP(node);
name = g_strdup(purple_group_get_name(group));
if (!(sep = strchr(name, '/'))) {
g_free(name);
return default_manager->find_parent(node);
}
tree = finch_blist_get_tree();
parent = NULL;
while (sep) {
*sep = 0;
if (*(sep + 1) && (ret = PURPLE_BLIST_NODE(purple_blist_find_group(name)))) {
finch_blist_manager_add_node(ret);
parent = ret;
} else if (!(ret = g_hash_table_lookup(groups, name))) {
ret = g_object_new(FINCH_TYPE_GROUPING_NODE, NULL);
g_hash_table_insert(groups, g_strdup(name), ret);
gnt_tree_add_row_last(tree, ret,
gnt_tree_create_row(tree, name), parent);
parent = ret;
}
*sep = '/';
sep = strchr(sep + 1, '/');
}
g_free(name);
return ret;
}
static GntWidget *
config_frame(void)
{
GntWidget *window, *tree, *check;
int i;
window = gnt_vbox_new(FALSE);
gnt_box_set_pad(GNT_BOX(window), 0);
gnt_box_set_alignment(GNT_BOX(window), GNT_ALIGN_MID);
gnt_box_set_fill(GNT_BOX(window), TRUE);
gnt_box_add_widget(GNT_BOX(window),
gnt_label_new(_("Notify with a toaster when")));
tree = gnt_tree_new();
gnt_box_add_widget(GNT_BOX(window), tree);
for (i = 0; prefs[i].pref; i++)
{
gnt_tree_add_choice(GNT_TREE(tree), prefs[i].pref,
gnt_tree_create_row(GNT_TREE(tree), prefs[i].display), NULL, NULL);
gnt_tree_set_choice(GNT_TREE(tree), prefs[i].pref,
purple_prefs_get_bool(prefs[i].pref));
}
gnt_tree_set_col_width(GNT_TREE(tree), 0, 40);
g_signal_connect(G_OBJECT(tree), "toggled", G_CALLBACK(pref_toggled), NULL);
check = gnt_check_box_new(_("Beep too!"));
gnt_check_box_set_checked(GNT_CHECK_BOX(check), purple_prefs_get_bool(PREFS_BEEP));
g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(toggle_option), PREFS_BEEP);
gnt_box_add_widget(GNT_BOX(window), check);
#ifdef HAVE_X11
check = gnt_check_box_new(_("Set URGENT for the terminal window."));
gnt_check_box_set_checked(GNT_CHECK_BOX(check), purple_prefs_get_bool(PREFS_URGENT));
g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(toggle_option), PREFS_URGENT);
gnt_box_add_widget(GNT_BOX(window), check);
#endif
return window;
}
static void
populate_statuses(GntTree *tree)
{
GList *list;
for (list = purple_savedstatuses_get_all(); list; list = list->next)
{
PurpleSavedStatus *saved = list->data;
const char *title, *type, *message;
if (purple_savedstatus_is_transient(saved))
continue;
title = purple_savedstatus_get_title(saved);
type = purple_primitive_get_name_from_type(purple_savedstatus_get_type(saved));
message = purple_savedstatus_get_message(saved); /* XXX: Strip possible markups */
gnt_tree_add_row_last(tree, saved,
gnt_tree_create_row(tree, title, type, message), NULL);
}
}
static GntWidget*
create_list_field(PurpleRequestField *field)
{
GntWidget *ret = NULL;
GList *list;
gboolean multi = purple_request_field_list_get_multi_select(field);
if (multi)
{
GntWidget *tree = gnt_tree_new();
list = purple_request_field_list_get_items(field);
for (; list; list = list->next)
{
const char *text = list->data;
gpointer key = purple_request_field_list_get_data(field, text);
gnt_tree_add_choice(GNT_TREE(tree), key,
gnt_tree_create_row(GNT_TREE(tree), text), NULL, NULL);
if (purple_request_field_list_is_selected(field, text))
gnt_tree_set_choice(GNT_TREE(tree), key, TRUE);
}
ret = tree;
}
else
{
GntWidget *combo = gnt_combo_box_new();
list = purple_request_field_list_get_items(field);
for (; list; list = list->next)
{
const char *text = list->data;
gpointer key = purple_request_field_list_get_data(field, text);
gnt_combo_box_add_data(GNT_COMBO_BOX(combo), key, text);
if (purple_request_field_list_is_selected(field, text))
gnt_combo_box_set_selected(GNT_COMBO_BOX(combo), key);
}
ret = combo;
}
return ret;
}
void finch_plugins_show_all(void)
{
GntWidget *window, *tree, *box, *aboot, *button;
GList *plugin_list, *iter;
GList *seen;
if (plugins.window) {
gnt_window_present(plugins.window);
return;
}
purple_plugins_refresh();
plugins.window = window = gnt_vbox_new(FALSE);
gnt_box_set_toplevel(GNT_BOX(window), TRUE);
gnt_box_set_title(GNT_BOX(window), _("Plugins"));
gnt_box_set_pad(GNT_BOX(window), 0);
gnt_box_set_alignment(GNT_BOX(window), GNT_ALIGN_MID);
gnt_box_add_widget(GNT_BOX(window),
gnt_label_new(_("You can (un)load plugins from the following list.")));
gnt_box_add_widget(GNT_BOX(window), gnt_hline_new());
box = gnt_hbox_new(FALSE);
gnt_box_add_widget(GNT_BOX(window), box);
gnt_box_add_widget(GNT_BOX(window), gnt_hline_new());
gnt_box_set_pad(GNT_BOX(box), 0);
plugins.tree = tree = gnt_tree_new();
gnt_tree_set_compare_func(GNT_TREE(tree), (GCompareFunc)plugin_compare);
GNT_WIDGET_SET_FLAGS(tree, GNT_WIDGET_NO_BORDER);
gnt_box_add_widget(GNT_BOX(box), tree);
gnt_box_add_widget(GNT_BOX(box), gnt_vline_new());
plugins.aboot = aboot = gnt_text_view_new();
gnt_text_view_set_flag(GNT_TEXT_VIEW(aboot), GNT_TEXT_VIEW_TOP_ALIGN);
gnt_widget_set_size(aboot, 40, 20);
gnt_box_add_widget(GNT_BOX(box), aboot);
seen = purple_prefs_get_path_list("/finch/plugins/seen");
plugin_list = purple_plugins_find_all();
for (iter = plugin_list; iter; iter = iter->next)
{
PurplePlugin *plug = PURPLE_PLUGIN(iter->data);
if (purple_plugin_is_internal(plug))
continue;
gnt_tree_add_choice(GNT_TREE(tree), plug,
gnt_tree_create_row(GNT_TREE(tree),
purple_plugin_info_get_name(purple_plugin_get_info(plug))),
NULL, NULL);
gnt_tree_set_choice(GNT_TREE(tree), plug, purple_plugin_is_loaded(plug));
if (!g_list_find_custom(seen, purple_plugin_get_filename(plug),
(GCompareFunc)strcmp))
gnt_tree_set_row_flags(GNT_TREE(tree), plug, GNT_TEXT_FLAG_BOLD);
}
g_list_free(plugin_list);
gnt_tree_set_col_width(GNT_TREE(tree), 0, 30);
g_signal_connect(G_OBJECT(tree), "toggled", G_CALLBACK(plugin_toggled_cb), NULL);
g_signal_connect(G_OBJECT(tree), "selection_changed", G_CALLBACK(selection_changed), NULL);
g_object_set_data(G_OBJECT(tree), "seen-list", seen);
box = gnt_hbox_new(FALSE);
gnt_box_add_widget(GNT_BOX(window), box);
#if 0
button = gnt_button_new(_("Install Plugin..."));
gnt_box_add_widget(GNT_BOX(box), button);
gnt_util_set_trigger_widget(GNT_WIDGET(tree), GNT_KEY_INS, button);
g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(install_plugin_cb), NULL);
#endif
button = gnt_button_new(_("Close"));
gnt_box_add_widget(GNT_BOX(box), button);
g_signal_connect_swapped(G_OBJECT(button), "activate",
G_CALLBACK(gnt_widget_destroy), window);
plugins.conf = button = gnt_button_new(_("Configure Plugin"));
gnt_box_add_widget(GNT_BOX(box), button);
g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(configure_plugin_cb), NULL);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(reset_plugin_window), NULL);
gnt_widget_show(window);
decide_conf_button(gnt_tree_get_selection_data(GNT_TREE(tree)));
}
static void
install_selected_file_cb(gpointer handle, const char *filename)
{
/* Try to init the selected file.
* If it succeeds, try to make a copy of the file in $USERDIR/plugins/.
* If the copy succeeds, unload and destroy the plugin in the original
* location and init+load the new one.
* Select the plugin in the plugin list.
*/
char *path;
PurplePlugin *plugin;
g_return_if_fail(plugins.window);
plugin = purple_plugin_probe(filename);
if (!plugin) {
purple_notify_error(handle, _("Error loading plugin"),
_("The selected file is not a valid plugin."),
_("Please open the debug window and try again to see the exact error message."), NULL);
return;
}
if (g_list_find(gnt_tree_get_rows(GNT_TREE(plugins.tree)), plugin)) {
purple_plugin_load(plugin);
gnt_tree_set_choice(GNT_TREE(plugins.tree), plugin, purple_plugin_is_loaded(plugin));
gnt_tree_set_selected(GNT_TREE(plugins.tree), plugin);
return;
}
path = g_build_filename(purple_user_dir(), "plugins", NULL);
if (purple_build_dir(path, S_IRUSR | S_IWUSR | S_IXUSR) == 0) {
char *content = NULL;
gsize length = 0;
if (g_file_get_contents(filename, &content, &length, NULL)) {
char *file = g_path_get_basename(filename);
g_free(path);
path = g_build_filename(purple_user_dir(), "plugins", file, NULL);
if (purple_util_write_data_to_file_absolute(path, content, length)) {
purple_plugin_destroy(plugin);
plugin = purple_plugin_probe(path);
if (!plugin) {
purple_debug_warning("gntplugin", "This is really strange. %s can be loaded, but %s can't!\n",
filename, path);
g_unlink(path);
plugin = purple_plugin_probe(filename);
}
} else {
}
}
g_free(content);
}
g_free(path);
purple_plugin_load(plugin);
if (plugin->info->type == PURPLE_PLUGIN_LOADER) {
GList *cur;
for (cur = PURPLE_PLUGIN_LOADER_INFO(plugin)->exts; cur != NULL;
cur = cur->next)
purple_plugins_probe(cur->data);
return;
}
if (plugin->info->type != PURPLE_PLUGIN_STANDARD ||
(plugin->info->flags & PURPLE_PLUGIN_FLAG_INVISIBLE) ||
plugin->error)
return;
gnt_tree_add_choice(GNT_TREE(plugins.tree), plugin,
gnt_tree_create_row(GNT_TREE(plugins.tree), plugin->info->name), NULL, NULL);
gnt_tree_set_choice(GNT_TREE(plugins.tree), plugin, purple_plugin_is_loaded(plugin));
gnt_tree_set_row_flags(GNT_TREE(plugins.tree), plugin, GNT_TEXT_FLAG_BOLD);
gnt_tree_set_selected(GNT_TREE(plugins.tree), plugin);
}
void
finch_sounds_show_all(void)
{
GntWidget *box, *tmpbox, *splitbox, *cmbox, *slider;
GntWidget *entry;
GntWidget *chkbox;
GntWidget *button;
GntWidget *label;
GntWidget *tree;
GntWidget *win;
gint i;
GList *itr, *list;
if (pref_dialog) {
gnt_window_present(pref_dialog->window);
return;
}
pref_dialog = g_new0(SoundPrefDialog, 1);
pref_dialog->original_profile = g_strdup(finch_sound_get_active_profile());
pref_dialog->window = win = gnt_window_box_new(FALSE, TRUE);
gnt_box_set_pad(GNT_BOX(win), 0);
gnt_box_set_toplevel(GNT_BOX(win), TRUE);
gnt_box_set_title(GNT_BOX(win), _("Sound Preferences"));
gnt_box_set_fill(GNT_BOX(win), TRUE);
gnt_box_set_alignment(GNT_BOX(win), GNT_ALIGN_MID);
/* Profiles */
splitbox = gnt_hbox_new(FALSE);
gnt_box_set_pad(GNT_BOX(splitbox), 0);
gnt_box_set_alignment(GNT_BOX(splitbox), GNT_ALIGN_TOP);
box = gnt_vbox_new(FALSE);
gnt_box_set_pad(GNT_BOX(box), 0);
gnt_box_add_widget(GNT_BOX(box), gnt_label_new_with_format(_("Profiles"), GNT_TEXT_FLAG_BOLD));
pref_dialog->profiles = tree = gnt_tree_new();
gnt_tree_set_hash_fns(GNT_TREE(tree), g_str_hash, g_str_equal, g_free);
gnt_tree_set_compare_func(GNT_TREE(tree), (GCompareFunc)g_ascii_strcasecmp);
g_signal_connect(G_OBJECT(tree), "selection-changed", G_CALLBACK(prof_load_cb), NULL);
itr = list = finch_sound_get_profiles();
for (; itr; itr = itr->next) {
/* Do not free itr->data. It's the stored as a key for the tree, and will
* be freed when the tree is destroyed. */
gnt_tree_add_row_after(GNT_TREE(tree), itr->data,
gnt_tree_create_row(GNT_TREE(tree), itr->data), NULL, NULL);
}
g_list_free(list);
gnt_box_add_widget(GNT_BOX(box), tree);
pref_dialog->new_profile = entry = gnt_entry_new("");
gnt_box_add_widget(GNT_BOX(box), entry);
tmpbox = gnt_hbox_new(FALSE);
button = gnt_button_new("Add");
g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(prof_add_cb), entry);
gnt_box_add_widget(GNT_BOX(tmpbox), button);
button = gnt_button_new("Delete");
g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(prof_del_cb), NULL);
gnt_box_add_widget(GNT_BOX(tmpbox), button);
gnt_box_add_widget(GNT_BOX(box), tmpbox);
gnt_box_add_widget(GNT_BOX(splitbox), box);
gnt_box_add_widget(GNT_BOX(splitbox), gnt_vline_new());
/* Sound method */
box = gnt_vbox_new(FALSE);
gnt_box_set_pad(GNT_BOX(box), 0);
pref_dialog->method = cmbox = gnt_combo_box_new();
gnt_tree_set_hash_fns(GNT_TREE(GNT_COMBO_BOX(cmbox)->dropdown), g_str_hash, g_str_equal, NULL);
gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), "automatic", _("Automatic"));
gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), "alsa", "ALSA");
gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), "esd", "ESD");
gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), "beep", _("Console Beep"));
gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), "custom", _("Command"));
gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), "nosound", _("No Sound"));
label = gnt_label_new_with_format(_("Sound Method"), GNT_TEXT_FLAG_BOLD);
gnt_box_add_widget(GNT_BOX(box), label);
tmpbox = gnt_hbox_new(TRUE);
gnt_box_set_fill(GNT_BOX(tmpbox), FALSE);
gnt_box_set_pad(GNT_BOX(tmpbox), 0);
gnt_box_add_widget(GNT_BOX(tmpbox), gnt_label_new(_("Method: ")));
gnt_box_add_widget(GNT_BOX(tmpbox), cmbox);
gnt_box_add_widget(GNT_BOX(box), tmpbox);
tmpbox = gnt_hbox_new(TRUE);
gnt_box_set_pad(GNT_BOX(tmpbox), 0);
gnt_box_set_fill(GNT_BOX(tmpbox), FALSE);
gnt_box_add_widget(GNT_BOX(tmpbox), gnt_label_new(_("Sound Command\n(%s for filename)")));
pref_dialog->command = entry = gnt_entry_new("");
gnt_box_add_widget(GNT_BOX(tmpbox), entry);
gnt_box_add_widget(GNT_BOX(box), tmpbox);
gnt_box_add_widget(GNT_BOX(box), gnt_line_new(FALSE));
/* Sound options */
gnt_box_add_widget(GNT_BOX(box), gnt_label_new_with_format(_("Sound Options"), GNT_TEXT_FLAG_BOLD));
pref_dialog->conv_focus = chkbox = gnt_check_box_new(_("Sounds when conversation has focus"));
gnt_box_add_widget(GNT_BOX(box), chkbox);
tmpbox = gnt_hbox_new(TRUE);
gnt_box_set_pad(GNT_BOX(tmpbox), 0);
gnt_box_set_fill(GNT_BOX(tmpbox), FALSE);
gnt_box_add_widget(GNT_BOX(tmpbox), gnt_label_new("Enable Sounds:"));
pref_dialog->while_status = cmbox = gnt_combo_box_new();
gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), GINT_TO_POINTER(3), _("Always"));
gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), GINT_TO_POINTER(1), _("Only when available"));
gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), GINT_TO_POINTER(2), _("Only when not available"));
gnt_box_add_widget(GNT_BOX(tmpbox), cmbox);
gnt_box_add_widget(GNT_BOX(box), tmpbox);
tmpbox = gnt_hbox_new(TRUE);
gnt_box_set_pad(GNT_BOX(tmpbox), 0);
gnt_box_set_fill(GNT_BOX(tmpbox), FALSE);
gnt_box_add_widget(GNT_BOX(tmpbox), gnt_label_new(_("Volume(0-100):")));
pref_dialog->volume = slider = gnt_slider_new(FALSE, 100, 0);
gnt_slider_set_step(GNT_SLIDER(slider), 5);
gnt_slider_set_small_step(GNT_SLIDER(slider), 1);
gnt_slider_set_large_step(GNT_SLIDER(slider), 20);
label = gnt_label_new("");
gnt_slider_reflect_label(GNT_SLIDER(slider), GNT_LABEL(label));
gnt_box_set_pad(GNT_BOX(tmpbox), 1);
gnt_box_add_widget(GNT_BOX(tmpbox), slider);
gnt_box_add_widget(GNT_BOX(tmpbox), label);
gnt_box_add_widget(GNT_BOX(box), tmpbox);
gnt_box_add_widget(GNT_BOX(splitbox), box);
gnt_box_add_widget(GNT_BOX(win), splitbox);
gnt_box_add_widget(GNT_BOX(win), gnt_hline_new());
/* Sound events */
gnt_box_add_widget(GNT_BOX(win), gnt_label_new_with_format(_("Sound Events"), GNT_TEXT_FLAG_BOLD));
pref_dialog->events = tree = gnt_tree_new_with_columns(2);
gnt_tree_set_column_titles(GNT_TREE(tree), _("Event"), _("File"));
gnt_tree_set_show_title(GNT_TREE(tree), TRUE);
for (i = 0; i < PURPLE_NUM_SOUNDS; i++) {
FinchSoundEvent * event = &sounds[i];
if (event->label == NULL) {
continue;
}
gnt_tree_add_choice(GNT_TREE(tree), GINT_TO_POINTER(i),
gnt_tree_create_row(GNT_TREE(tree), event->label, event->def),
NULL, NULL);
}
gnt_tree_adjust_columns(GNT_TREE(tree));
gnt_box_add_widget(GNT_BOX(win), tree);
box = gnt_hbox_new(FALSE);
button = gnt_button_new(_("Test"));
g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(test_cb), NULL);
gnt_box_add_widget(GNT_BOX(box), button);
button = gnt_button_new(_("Reset"));
g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(reset_cb), NULL);
gnt_box_add_widget(GNT_BOX(box), button);
button = gnt_button_new(_("Choose..."));
g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(choose_cb), NULL);
gnt_box_add_widget(GNT_BOX(box), button);
gnt_box_add_widget(GNT_BOX(win), box);
gnt_box_add_widget(GNT_BOX(win), gnt_line_new(FALSE));
/* Add new stuff before this */
box = gnt_hbox_new(FALSE);
gnt_box_set_fill(GNT_BOX(box), TRUE);
button = gnt_button_new(_("Save"));
g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(save_cb), win);
gnt_box_add_widget(GNT_BOX(box), button);
button = gnt_button_new(_("Cancel"));
g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(cancel_cb), win);
gnt_box_add_widget(GNT_BOX(box), button);
gnt_box_add_widget(GNT_BOX(win), box);
g_signal_connect(G_OBJECT(win), "destroy", G_CALLBACK(release_pref_dialog), NULL);
load_pref_window(finch_sound_get_active_profile());
gnt_widget_show(win);
}
static gboolean
location_key_pressed(GntTree *tree, const char *key, GntFileSel *sel)
{
char *path;
char *str;
#if 0
int count;
glob_t gl;
struct stat st;
int glob_ret;
#endif
if (strcmp(key, "\r") && strcmp(key, "\n"))
return FALSE;
str = (char*)gnt_entry_get_text(GNT_ENTRY(sel->location));
if (*str == G_DIR_SEPARATOR)
path = g_strdup(str);
else
path = g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s", sel->current, str);
str = process_path(path);
g_free(path);
path = str;
if (gnt_file_sel_set_current_location(sel, path))
goto success;
path = g_path_get_dirname(str);
g_free(str);
if (!gnt_file_sel_set_current_location(sel, path)) {
g_free(path);
return FALSE;
}
#if 0
/* XXX: there needs to be a way to allow other methods for globbing,
* like the read_fn stuff. */
glob_ret = glob(path, GLOB_MARK, NULL, &gl);
if (!glob_ret) { /* XXX: do something with the return value */
char *loc = g_path_get_dirname(gl.gl_pathv[0]);
stat(gl.gl_pathv[0], &st);
gnt_file_sel_set_current_location(sel, loc); /* XXX: check the return value */
g_free(loc);
if (!S_ISDIR(st.st_mode) && !sel->dirsonly) {
gnt_tree_remove_all(GNT_TREE(sel->files));
for (count = 0; count < gl.gl_pathc; count++) {
char *tmp = process_path(gl.gl_pathv[count]);
loc = g_path_get_dirname(tmp);
if (g_utf8_collate(sel->current, loc) == 0) {
char *base = g_path_get_basename(tmp);
char size[128];
snprintf(size, sizeof(size), "%ld", (long)st.st_size);
gnt_tree_add_row_after(GNT_TREE(sel->files), base,
gnt_tree_create_row(GNT_TREE(sel->files), base, size, ""), NULL, NULL);
}
g_free(loc);
g_free(tmp);
}
gnt_widget_draw(sel->files);
}
} else if (sel->files) {
gnt_tree_remove_all(GNT_TREE(sel->files));
gnt_widget_draw(sel->files);
}
globfree(&gl);
#endif
success:
g_free(path);
return TRUE;
}
static gboolean
show_suggest_dropdown(GntEntry *entry)
{
char *suggest = NULL;
int len;
int offset = 0, x, y;
int count = 0;
GList *iter;
const char *text = NULL;
const char *sgst = NULL;
int max = -1;
if (entry->word)
{
char *s = get_beginning_of_word(entry);
suggest = g_strndup(s, entry->cursor - s);
if (entry->scroll < s)
offset = gnt_util_onscreen_width(entry->scroll, s);
}
else
suggest = g_strdup(entry->start);
len = strlen(suggest); /* Don't need to use the utf8-function here */
if (entry->ddown == NULL)
{
GntWidget *box = gnt_vbox_new(FALSE);
entry->ddown = gnt_tree_new();
gnt_tree_set_compare_func(GNT_TREE(entry->ddown), (GCompareFunc)g_utf8_collate);
gnt_box_add_widget(GNT_BOX(box), entry->ddown);
GNT_WIDGET_SET_FLAGS(box, GNT_WIDGET_TRANSIENT);
gnt_widget_get_position(GNT_WIDGET(entry), &x, &y);
x += offset;
y++;
if (y + 10 >= getmaxy(stdscr))
y -= 11;
gnt_widget_set_position(box, x, y);
}
else
gnt_tree_remove_all(GNT_TREE(entry->ddown));
for (count = 0, iter = entry->suggests; iter; iter = iter->next)
{
text = iter->data;
if (g_ascii_strncasecmp(suggest, text, len) == 0 && strlen(text) >= len)
{
gnt_tree_add_row_after(GNT_TREE(entry->ddown), (gpointer)text,
gnt_tree_create_row(GNT_TREE(entry->ddown), text),
NULL, NULL);
count++;
if (max == -1)
max = strlen(text) - len;
else if (max)
max = MIN(max, max_common_prefix(sgst + len, text + len));
sgst = text;
}
}
g_free(suggest);
if (count == 0) {
destroy_suggest(entry);
return FALSE;
} else if (count == 1) {
char *store = g_strndup(entry->start, entry->end - entry->start);
gboolean ret;
destroy_suggest(entry);
complete_suggest(entry, sgst);
ret = (strncmp(store, entry->start, entry->end - entry->start) != 0);
g_free(store);
return ret;
} else {
if (max > 0) {
GntWidget *ddown = entry->ddown;
char *match = g_strndup(sgst + len, max);
entry->ddown = NULL;
gnt_entry_key_pressed(GNT_WIDGET(entry), match);
g_free(match);
if (entry->ddown)
gnt_widget_destroy(ddown);
else
entry->ddown = ddown;
}
gnt_widget_draw(entry->ddown->parent);
}
return TRUE;
}