static void
test_cb(GntWidget *button, gpointer null)
{
PurpleSoundEventID id = GPOINTER_TO_INT(gnt_tree_get_selection_data(GNT_TREE(pref_dialog->events)));
FinchSoundEvent * event = &sounds[id];
char *enabled, *file, *tmpfile, *volpref;
gboolean temp_value;
int volume;
enabled = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/enabled/%s",
finch_sound_get_active_profile(), event->pref);
file = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/file/%s",
finch_sound_get_active_profile(), event->pref);
volpref = g_strdup(make_pref("/volume"));
temp_value = purple_prefs_get_bool(enabled);
tmpfile = g_strdup(purple_prefs_get_path(file));
volume = purple_prefs_get_int(volpref);
purple_prefs_set_path(file, event->file);
if (!temp_value) purple_prefs_set_bool(enabled, TRUE);
purple_prefs_set_int(volpref, gnt_slider_get_value(GNT_SLIDER(pref_dialog->volume)));
purple_sound_play_event(id, NULL);
if (!temp_value) purple_prefs_set_bool(enabled, FALSE);
purple_prefs_set_path(file, tmpfile);
purple_prefs_set_int(volpref, volume);
g_free(enabled);
g_free(file);
g_free(tmpfile);
g_free(volpref);
}
void
pidgin_stock_load_status_icon_theme(PidginStatusIconTheme *theme)
{
GtkIconFactory *icon_factory;
gint i;
GtkIconSet *normal;
GtkIconSet *translucent = NULL;
GtkWidget *win;
if (theme != NULL) {
purple_prefs_set_string(PIDGIN_PREFS_ROOT "/status/icon-theme",
purple_theme_get_name(PURPLE_THEME(theme)));
purple_prefs_set_path(PIDGIN_PREFS_ROOT "/status/icon-theme-dir",
purple_theme_get_dir(PURPLE_THEME(theme)));
}
else {
purple_prefs_set_string(PIDGIN_PREFS_ROOT "/status/icon-theme", "");
purple_prefs_set_path(PIDGIN_PREFS_ROOT "/status/icon-theme-dir", "");
}
icon_factory = gtk_icon_factory_new();
gtk_icon_factory_add_default(icon_factory);
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_realize(win);
for (i = 0; i < G_N_ELEMENTS(sized_status_icons); i++)
{
normal = gtk_icon_set_new();
if (sized_status_icons[i].translucent_name)
translucent = gtk_icon_set_new();
#define ADD_SIZED_ICON(name, size) \
if (sized_status_icons[i].name) { \
add_sized_icon(normal, name, PIDGIN_ICON_THEME(theme), size, sized_status_icons[i], FALSE); \
if (sized_status_icons[i].translucent_name) \
add_sized_icon(translucent, name, PIDGIN_ICON_THEME(theme), size, sized_status_icons[i], TRUE); \
}
ADD_SIZED_ICON(microscopic, "11");
ADD_SIZED_ICON(extra_small, "16");
ADD_SIZED_ICON(small, "22");
ADD_SIZED_ICON(medium, "32");
ADD_SIZED_ICON(large, "48");
ADD_SIZED_ICON(huge, "64");
#undef ADD_SIZED_ICON
gtk_icon_factory_add(icon_factory, sized_status_icons[i].name, normal);
gtk_icon_set_unref(normal);
if (sized_status_icons[i].translucent_name) {
gtk_icon_factory_add(icon_factory, sized_status_icons[i].translucent_name, translucent);
gtk_icon_set_unref(translucent);
}
}
gtk_widget_destroy(win);
g_object_unref(G_OBJECT(icon_factory));
reload_settings();
}
xmlnode * _h_elim_set_prefs ( const char *name ,
const char *id ,
SEXP_VALUE *args ,
gpointer data )
{
ASSERT_ALISTP( args, id, name );
elim_ping();
xmlnode *rval = xnode_new( "alist" );
xmlnode *set = xnode_new( "alist" );
GHashTable *prefs = ALIST_VAL_ALIST( args, "prefs" );
SEXP_VALUE *PREFS = ALIST_VAL ( args, "prefs" );
AL_NODE( rval, "prefs", set );
fprintf( stderr, "hash: %p; sexp: %p\n", prefs, PREFS );
if( prefs )
{
GList *key = NULL;
GList *keys = g_hash_table_get_keys( prefs );
fprintf( stderr, "keys: %p", keys );
for( key = keys; key; key = key->next )
{
gboolean done = TRUE;
const char *pref = key->data;
PurplePrefType type = purple_prefs_get_type( pref );
switch( type )
{
case PURPLE_PREF_BOOLEAN:
purple_prefs_set_bool ( pref, ALIST_VAL_BOOL( PREFS, pref ) );
break;
case PURPLE_PREF_INT:
purple_prefs_set_int ( pref, ALIST_VAL_INT ( PREFS, pref ) );
break;
case PURPLE_PREF_STRING:
purple_prefs_set_string( pref, ALIST_VAL_STR ( PREFS, pref ) );
break;
case PURPLE_PREF_PATH:
purple_prefs_set_path ( pref, ALIST_VAL_STR ( PREFS, pref ) );
break;
default:
done = FALSE;
}
AL_BOOL( set, pref, done );
}
g_list_free( keys );
}
sexp_val_free( args );
return response_value( 0, id, name, rval );
}
static void
save_cb(GntWidget *button, gpointer win)
{
GList * itr;
purple_prefs_set_string(make_pref("/method"), gnt_combo_box_get_selected_data(GNT_COMBO_BOX(pref_dialog->method)));
purple_prefs_set_path(make_pref("/command"), gnt_entry_get_text(GNT_ENTRY(pref_dialog->command)));
purple_prefs_set_bool(make_pref("/conv_focus"), gnt_check_box_get_checked(GNT_CHECK_BOX(pref_dialog->conv_focus)));
purple_prefs_set_int("/purple/sound/while_status", GPOINTER_TO_INT(gnt_combo_box_get_selected_data(GNT_COMBO_BOX(pref_dialog->while_status))));
for (itr = gnt_tree_get_rows(GNT_TREE(pref_dialog->events)); itr; itr = itr->next) {
FinchSoundEvent * event = &sounds[GPOINTER_TO_INT(itr->data)];
char * filepref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/file/%s", finch_sound_get_active_profile(), event->pref);
char * boolpref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/enabled/%s", finch_sound_get_active_profile(), event->pref);
purple_prefs_set_bool(boolpref, gnt_tree_get_choice(GNT_TREE(pref_dialog->events), itr->data));
purple_prefs_set_path(filepref, event->file ? event->file : "");
g_free(filepref);
g_free(boolpref);
}
gnt_widget_destroy(GNT_WIDGET(win));
}
static void
file_ok_cb(gpointer fq, GntWidget *widget)
{
FinchFileRequest *data = fq;
char *file = gnt_file_sel_get_selected_file(GNT_FILE_SEL(data->dialog));
char *dir = g_path_get_dirname(file);
if (data->cbs[0] != NULL)
((PurpleRequestFileCb)data->cbs[0])(data->user_data, file);
g_free(file);
purple_prefs_set_path(data->save ? "/finch/filelocations/last_save_folder" :
"/finch/filelocations/last_open_folder", dir);
g_free(dir);
purple_request_close(PURPLE_REQUEST_FILE, data->dialog);
}
void
pidgin_stock_load_stock_icon_theme(PidginStockIconTheme *theme)
{
GtkIconFactory *icon_factory;
gint i;
GtkWidget *win;
if (theme != NULL) {
purple_prefs_set_string(PIDGIN_PREFS_ROOT "/stock/icon-theme",
purple_theme_get_name(PURPLE_THEME(theme)));
purple_prefs_set_path(PIDGIN_PREFS_ROOT "/stock/icon-theme-dir",
purple_theme_get_dir(PURPLE_THEME(theme)));
}
else {
purple_prefs_set_string(PIDGIN_PREFS_ROOT "/stock/icon-theme", "");
purple_prefs_set_path(PIDGIN_PREFS_ROOT "/stock/icon-theme-dir", "");
}
icon_factory = gtk_icon_factory_new();
gtk_icon_factory_add_default(icon_factory);
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_realize(win);
/* All non-sized icons */
for (i = 0; i < G_N_ELEMENTS(stock_icons); i++) {
GtkIconSource *source;
GtkIconSet *iconset;
gchar *filename;
if (stock_icons[i].dir == NULL) {
/* GTK+ Stock icon */
iconset = gtk_style_lookup_icon_set(gtk_widget_get_style(win),
stock_icons[i].filename);
} else {
filename = find_file(stock_icons[i].dir, stock_icons[i].filename);
if (filename == NULL)
continue;
source = gtk_icon_source_new();
gtk_icon_source_set_filename(source, filename);
gtk_icon_source_set_direction_wildcarded(source, TRUE);
gtk_icon_source_set_size_wildcarded(source, TRUE);
gtk_icon_source_set_state_wildcarded(source, TRUE);
iconset = gtk_icon_set_new();
gtk_icon_set_add_source(iconset, source);
gtk_icon_source_free(source);
g_free(filename);
}
gtk_icon_factory_add(icon_factory, stock_icons[i].name, iconset);
gtk_icon_set_unref(iconset);
}
/* All non-status sized icons */
for (i = 0; i < G_N_ELEMENTS(sized_stock_icons); i++)
{
GtkIconSet *iconset = gtk_icon_set_new();
#define ADD_SIZED_ICON(name, size) \
if (sized_stock_icons[i].name) \
add_sized_icon(iconset, name, PIDGIN_ICON_THEME(theme), size, sized_stock_icons[i], FALSE);
ADD_SIZED_ICON(microscopic, "11");
ADD_SIZED_ICON(extra_small, "16");
ADD_SIZED_ICON(small, "22");
ADD_SIZED_ICON(medium, "32");
ADD_SIZED_ICON(large, "48");
ADD_SIZED_ICON(huge, "64");
#undef ADD_SIZED_ICON
gtk_icon_factory_add(icon_factory, sized_stock_icons[i].name, iconset);
gtk_icon_set_unref(iconset);
}
gtk_widget_destroy(win);
g_object_unref(G_OBJECT(icon_factory));
reload_settings();
}
static void
prefs_start_element_handler (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
gpointer user_data,
GError **error)
{
PurplePrefType pref_type = PURPLE_PREF_NONE;
int i;
const char *pref_name = NULL, *pref_value = NULL;
GString *pref_name_full;
GList *tmp;
if(!purple_strequal(element_name, "pref") &&
!purple_strequal(element_name, "item"))
return;
for(i = 0; attribute_names[i]; i++) {
if(purple_strequal(attribute_names[i], "name")) {
pref_name = attribute_values[i];
} else if(purple_strequal(attribute_names[i], "type")) {
if(purple_strequal(attribute_values[i], "bool"))
pref_type = PURPLE_PREF_BOOLEAN;
else if(purple_strequal(attribute_values[i], "int"))
pref_type = PURPLE_PREF_INT;
else if(purple_strequal(attribute_values[i], "string"))
pref_type = PURPLE_PREF_STRING;
else if(purple_strequal(attribute_values[i], "stringlist"))
pref_type = PURPLE_PREF_STRING_LIST;
else if(purple_strequal(attribute_values[i], "path"))
pref_type = PURPLE_PREF_PATH;
else if(purple_strequal(attribute_values[i], "pathlist"))
pref_type = PURPLE_PREF_PATH_LIST;
else
return;
} else if(purple_strequal(attribute_names[i], "value")) {
pref_value = attribute_values[i];
}
}
if(purple_strequal(element_name, "item")) {
struct purple_pref *pref;
pref_name_full = g_string_new("");
for(tmp = prefs_stack; tmp; tmp = tmp->next) {
pref_name_full = g_string_prepend(pref_name_full, tmp->data);
pref_name_full = g_string_prepend_c(pref_name_full, '/');
}
pref = find_pref(pref_name_full->str);
if(pref) {
if(pref->type == PURPLE_PREF_STRING_LIST) {
pref->value.stringlist = g_list_append(pref->value.stringlist,
g_strdup(pref_value));
} else if(pref->type == PURPLE_PREF_PATH_LIST) {
pref->value.stringlist = g_list_append(pref->value.stringlist,
g_filename_from_utf8(pref_value, -1, NULL, NULL, NULL));
}
}
g_string_free(pref_name_full, TRUE);
} else {
char *decoded;
if(!pref_name || purple_strequal(pref_name, "/"))
return;
pref_name_full = g_string_new(pref_name);
for(tmp = prefs_stack; tmp; tmp = tmp->next) {
pref_name_full = g_string_prepend_c(pref_name_full, '/');
pref_name_full = g_string_prepend(pref_name_full, tmp->data);
}
pref_name_full = g_string_prepend_c(pref_name_full, '/');
switch(pref_type) {
case PURPLE_PREF_NONE:
purple_prefs_add_none(pref_name_full->str);
break;
case PURPLE_PREF_BOOLEAN:
purple_prefs_set_bool(pref_name_full->str, atoi(pref_value));
break;
case PURPLE_PREF_INT:
purple_prefs_set_int(pref_name_full->str, atoi(pref_value));
break;
case PURPLE_PREF_STRING:
purple_prefs_set_string(pref_name_full->str, pref_value);
break;
case PURPLE_PREF_STRING_LIST:
purple_prefs_set_string_list(pref_name_full->str, NULL);
break;
case PURPLE_PREF_PATH:
if (pref_value) {
decoded = g_filename_from_utf8(pref_value, -1, NULL, NULL, NULL);
purple_prefs_set_path(pref_name_full->str, decoded);
g_free(decoded);
} else {
purple_prefs_set_path(pref_name_full->str, NULL);
}
break;
case PURPLE_PREF_PATH_LIST:
purple_prefs_set_path_list(pref_name_full->str, NULL);
break;
}
prefs_stack = g_list_prepend(prefs_stack, g_strdup(pref_name));
g_string_free(pref_name_full, TRUE);
}
}
static void
purple_prefs_rename_node(struct purple_pref *oldpref, struct purple_pref *newpref)
{
struct purple_pref *child, *next;
char *oldname, *newname;
/* if we're a parent, rename the kids first */
for(child = oldpref->first_child; child != NULL; child = next)
{
struct purple_pref *newchild;
next = child->sibling;
for(newchild = newpref->first_child; newchild != NULL; newchild = newchild->sibling)
{
if(purple_strequal(child->name, newchild->name))
{
purple_prefs_rename_node(child, newchild);
break;
}
}
if(newchild == NULL) {
/* no rename happened, we weren't able to find the new pref */
char *tmpname = pref_full_name(child);
purple_debug_error("prefs", "Unable to find rename pref for %s\n", tmpname);
g_free(tmpname);
}
}
oldname = pref_full_name(oldpref);
newname = pref_full_name(newpref);
if (oldpref->type != newpref->type)
{
purple_debug_error("prefs", "Unable to rename %s to %s: differing types\n", oldname, newname);
g_free(oldname);
g_free(newname);
return;
}
purple_debug_info("prefs", "Renaming %s to %s\n", oldname, newname);
g_free(oldname);
switch(oldpref->type) {
case PURPLE_PREF_NONE:
break;
case PURPLE_PREF_BOOLEAN:
purple_prefs_set_bool(newname, oldpref->value.boolean);
break;
case PURPLE_PREF_INT:
purple_prefs_set_int(newname, oldpref->value.integer);
break;
case PURPLE_PREF_STRING:
purple_prefs_set_string(newname, oldpref->value.string);
break;
case PURPLE_PREF_STRING_LIST:
purple_prefs_set_string_list(newname, oldpref->value.stringlist);
break;
case PURPLE_PREF_PATH:
purple_prefs_set_path(newname, oldpref->value.string);
break;
case PURPLE_PREF_PATH_LIST:
purple_prefs_set_path_list(newname, oldpref->value.stringlist);
break;
}
g_free(newname);
remove_pref(oldpref);
}
