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();
}
static
void cb_filter_mask_changed(GtkWidget *widget, gpointer data)
{
const char *text = gtk_entry_get_text(GTK_ENTRY(widget));
if (strlen(text) == 1)
purple_prefs_set_string(PREF_MASK, gtk_entry_get_text(GTK_ENTRY(widget)));
}
void ggp_servconn_add_server(const gchar *server)
{
GList *old_entry;
gchar *joined;
old_entry = g_list_find_custom(global_data.server_history, server,
(GCompareFunc)g_strcmp0);
if (old_entry) {
g_free(old_entry->data);
global_data.server_history = g_list_delete_link(
global_data.server_history, old_entry);
}
global_data.server_history = g_list_prepend(global_data.server_history,
g_strdup(server));
global_data.server_history = ggp_list_truncate(
global_data.server_history, GGP_SERVCONN_HISTORY_MAXLEN,
g_free);
joined = ggp_strjoin_list(";", global_data.server_history);
purple_prefs_set_string(GGP_SERVCONN_HISTORY_PREF, joined);
g_free(joined);
purple_account_option_string_set_hints(global_data.server_option,
ggp_servconn_get_servers());
}
static void cb_apply_button(GtkWidget *widget, gpointer data)
{
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeSelection *sel;
struct mood_dialog *s_diag = (struct mood_dialog *)data;
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(s_diag->list_view));
if(gtk_tree_selection_get_selected(sel, &model, &iter)) {
const gchar *mood;
gchar *name;
gtk_tree_model_get(model, &iter, MOOD_COLUMN, &name, -1);
mood = g_hash_table_lookup(s_diag->global_moods, name);
if(mood) { /* mood found */
gchar *path;
destroy_mood_dialog(s_diag); /* destroy dialog first */
set_status_with_mood_all(mood);
purple_prefs_set_string(PREF "/mood", mood);
path = get_mood_icon_path(mood);
set_widget_mood(path);
g_free(path);
purple_debug_info(NAME, "mood changed to \"%s\" by user\n", mood);
} else
purple_debug_info(NAME, "selected mood \"%s\" doesn't exists\n", name);
g_free(name);
} else
purple_debug_info(NAME, "no row selected\n");
}
static gboolean logstat_format (GtkWidget *widget, GdkEventFocus *event,
gpointer data)
{
purple_prefs_set_string (
"/plugins/gtk/autoprofile/components/logstat/format",
gtk_entry_get_text (GTK_ENTRY (widget)));
return FALSE;
}
/* Update string arguments */
static gboolean update_behavior_string (GtkWidget *widget, GdkEventFocus *evt,
gpointer data)
{
ap_debug ("preferences", "behavior string preference modified");
if (!strcmp (data, "text_trigger")) {
purple_prefs_set_string ("/plugins/gtk/autoprofile/autorespond/trigger",
gtk_entry_get_text (GTK_ENTRY (widget)));
} else if (!strcmp (data, "text_respond")) {
purple_prefs_set_string ("/plugins/gtk/autoprofile/autorespond/text",
gtk_entry_get_text (GTK_ENTRY (widget)));
} else {
ap_debug_error ("preferences", "invalid data argument to string update");
}
return FALSE;
}
void cb_squeezecenter_changed(GtkWidget *entry, gpointer data)
{
const char *pref = (const char*) data;
purple_prefs_set_string(pref, gtk_entry_get_text(GTK_ENTRY(entry)));
if (strcmp(PREF_SQUEEZECENTER_SERVER,pref) == 0) {
squeezecenter_disconnect(&squeezecenter);
}
}
static void reset_sort_method() {
if(purple_utf8_strcasecmp(
purple_prefs_get_string(PIDGIN_PREFS_ROOT "/blist/sort_type"),
"ext_blist_sort"
) == 0) {
if(purple_utf8_strcasecmp(
purple_prefs_get_string(PLUGIN_PREFS_PREFIX "/old_sort_method"),
""
) != 0) {
purple_prefs_set_string(
PIDGIN_PREFS_ROOT "/blist/sort_type",
purple_prefs_get_string(PLUGIN_PREFS_PREFIX "/old_sort_method")
);
} else {
purple_prefs_set_string(PIDGIN_PREFS_ROOT "/blist/sort_type", "none");
}
}
}
static void set_preferred_voice(const char *voice) {
if (voice) {
purple_prefs_set_string("/plugins/gtk/festival/speaker/voice", voice);
if (festival_pf) {
fprintf(festival_pf,"(voice_%s)\n", voice);
fflush(festival_pf);
}
}
}
// Set Functions
static void set_stretch_duration(float duration) {
if(festival_pf) {
char sd[8];
sprintf(sd,"%2.1f",duration);
purple_prefs_set_string("/plugins/gtk/festival/speaker/duration", sd);
fprintf(festival_pf,"(Parameter.set 'Duration_Stretch %s)\n", sd);
fflush(festival_pf);
}
}
void
action_off_status(PurplePluginAction *action)
{
char buf[STRLEN];
strncpy(buf, purple_prefs_get_string("/plugins/core/musictracker/string_off"), STRLEN);
if (input_dialog("Status to Set When Player is OFF:", buf, STRLEN)) {
purple_prefs_set_string("/plugins/core/musictracker/string_off",
buf);
}
}
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 );
}
void finch_prefs_update_old()
{
const char *str = NULL;
purple_prefs_rename("/gaim/gnt", "/finch");
purple_prefs_rename("/purple/gnt", "/finch");
if ((str = purple_prefs_get_string("/purple/away/idle_reporting")) &&
strcmp(str, "gaim") == 0)
purple_prefs_set_string("/purple/away/idle_reporting", "purple");
}
void finch_request_save_in_prefs(gpointer null, PurpleRequestFields *allfields)
{
GList *list;
for (list = purple_request_fields_get_groups(allfields); list; list = list->next) {
PurpleRequestFieldGroup *group = list->data;
GList *fields = purple_request_field_group_get_fields(group);
for (; fields ; fields = fields->next) {
PurpleRequestField *field = fields->data;
PurpleRequestFieldType type = purple_request_field_get_type(field);
PurplePrefType pt;
gpointer val = NULL;
const char *id = purple_request_field_get_id(field);
switch (type) {
case PURPLE_REQUEST_FIELD_LIST:
val = purple_request_field_list_get_selected(field)->data;
break;
case PURPLE_REQUEST_FIELD_BOOLEAN:
val = GINT_TO_POINTER(purple_request_field_bool_get_value(field));
break;
case PURPLE_REQUEST_FIELD_INTEGER:
val = GINT_TO_POINTER(purple_request_field_int_get_value(field));
break;
case PURPLE_REQUEST_FIELD_STRING:
val = (gpointer)purple_request_field_string_get_value(field);
break;
default:
break;
}
pt = purple_prefs_get_type(id);
switch (pt) {
case PURPLE_PREF_INT:
{
long int tmp = GPOINTER_TO_INT(val);
if (type == PURPLE_REQUEST_FIELD_LIST) /* Lists always return string */
sscanf(val, "%ld", &tmp);
purple_prefs_set_int(id, (gint)tmp);
break;
}
case PURPLE_PREF_BOOLEAN:
purple_prefs_set_bool(id, GPOINTER_TO_INT(val));
break;
case PURPLE_PREF_STRING:
purple_prefs_set_string(id, val);
break;
default:
break;
}
}
}
}
static gboolean
options_entry_cb(GtkWidget *widget, GdkEventFocus *evt, gpointer data)
{
if (data == NULL)
return FALSE;
if (!strcmp(data, "method_string")) {
purple_prefs_set_string("/plugins/gtk/X11/notify/title_string",
gtk_entry_get_text(GTK_ENTRY(widget)));
}
apply_method();
return FALSE;
}
static void
purple_keyring_set_inuse_drop_cb(gpointer _tracker)
{
PurpleKeyringChangeTracker *tracker = _tracker;
g_return_if_fail(tracker != NULL);
if (tracker->succeeded) {
purple_keyring_close(tracker->old_kr);
purple_debug_info("keyring", "Successfully changed keyring.\n");
purple_keyring_inuse = tracker->new_kr;
current_change_tracker = NULL;
if (tracker->cb != NULL)
tracker->cb(NULL, tracker->cb_data);
purple_keyring_change_tracker_free(tracker);
return;
}
purple_debug_error("keyring", "Failed to change keyring, aborting.\n");
purple_keyring_close(tracker->new_kr);
purple_keyring_pref_disconnect();
purple_prefs_set_string("/purple/keyring/active",
purple_keyring_get_id(tracker->old_kr));
purple_keyring_pref_connect();
current_change_tracker = NULL;
if (tracker->error == NULL) {
tracker->error = g_error_new(PURPLE_KEYRING_ERROR,
PURPLE_KEYRING_ERROR_UNKNOWN,
_("An unknown error has occured."));
}
if (tracker->cb != NULL)
tracker->cb(tracker->error, tracker->cb_data);
purple_keyring_change_tracker_free(tracker);
}
static void
method_toggle_cb(GtkWidget *widget, gpointer data)
{
gboolean on = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
gchar pref[256];
g_snprintf(pref, sizeof(pref), "/plugins/gtk/X11/notify/%s",
(char *)data);
purple_prefs_set_bool(pref, on);
if (!strcmp(data, "method_string")) {
GtkWidget *entry = g_object_get_data(G_OBJECT(widget), "title-entry");
gtk_widget_set_sensitive(entry, on);
purple_prefs_set_string("/plugins/gtk/X11/notify/title_string",
gtk_entry_get_text(GTK_ENTRY(entry)));
}
apply_method();
}
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
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));
}
void pidgin_themes_remove_smiley_theme(const char *file)
{
char *theme_dir = NULL, *last_slash = NULL;
g_return_if_fail(NULL != file);
if (!g_file_test(file, G_FILE_TEST_EXISTS)) return;
if ((theme_dir = g_strdup(file)) == NULL) return ;
if ((last_slash = g_strrstr(theme_dir, G_DIR_SEPARATOR_S)) != NULL) {
GSList *iter = NULL;
struct smiley_theme *theme = NULL, *new_theme = NULL;
*last_slash = 0;
/* Delete files on disk */
pidgin_themes_remove_theme_dir(theme_dir);
/* Find theme in themes list and remove it */
for (iter = smiley_themes ; iter ; iter = iter->next) {
theme = ((struct smiley_theme *)(iter->data));
if (!strcmp(theme->path, file))
break ;
}
if (iter) {
if (theme == current_smiley_theme) {
new_theme = ((struct smiley_theme *)(NULL == iter->next ? (smiley_themes == iter ? NULL : smiley_themes->data) : iter->next->data));
if (new_theme)
purple_prefs_set_string(PIDGIN_PREFS_ROOT "/smileys/theme", new_theme->name);
else
current_smiley_theme = NULL;
}
smiley_themes = g_slist_delete_link(smiley_themes, iter);
/* Destroy theme structure */
pidgin_themes_destroy_smiley_theme(theme);
}
}
g_free(theme_dir);
}
static void
purplerc_font_response(GtkDialog *font_dialog, gint response, gpointer data)
{
const gchar *prefpath;
gint subscript = GPOINTER_TO_INT(data);
if (response == GTK_RESPONSE_OK) {
gchar *fontname = NULL;
if (subscript == -1) {
prefpath = "/plugins/gtk/purplerc/gtk-font-name";
} else {
prefpath = font_prefs[subscript];
}
fontname = gtk_font_selection_dialog_get_font_name(GTK_FONT_SELECTION_DIALOG(font_dialog));
purple_prefs_set_string(prefpath, fontname);
g_free(fontname);
}
gtk_widget_destroy(GTK_WIDGET(font_dialog));
}
static void
purplerc_color_response(GtkDialog *color_dialog, gint response, gpointer data)
{
gint subscript = GPOINTER_TO_INT(data);
if (response == GTK_RESPONSE_OK) {
GdkColor color;
gchar colorstr[8];
#if GTK_CHECK_VERSION(2,14,0)
GtkWidget *colorsel =
gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(color_dialog));
#else
GtkWidget *colorsel = GTK_COLOR_SELECTION_DIALOG(color_dialog)->colorsel;
#endif
gtk_color_selection_get_current_color(GTK_COLOR_SELECTION(colorsel), &color);
g_snprintf(colorstr, sizeof(colorstr), "#%02X%02X%02X",
color.red/256, color.green/256, color.blue/256);
purple_prefs_set_string(color_prefs[subscript], colorstr);
}
gtk_widget_destroy(GTK_WIDGET(color_dialog));
}
static void
get_plugin_frame(GtkWidget *parent, GtkSizeGroup *sg,
const gchar *name, const gchar *plugin_label,
const gchar **plugin_strs, const gchar *plugin_pref,
const gchar *device_label, const gchar *device_pref)
{
GtkWidget *vbox, *widget;
GList *plugins, *devices;
vbox = pidgin_make_frame(parent, name);
/* Setup plugin preference */
plugins = get_element_plugins(plugin_strs);
widget = pidgin_prefs_dropdown_from_list(vbox, plugin_label,
PURPLE_PREF_STRING, plugin_pref, plugins);
g_list_free(plugins);
gtk_size_group_add_widget(sg, widget);
gtk_misc_set_alignment(GTK_MISC(widget), 0, 0.5);
/* Setup device preference */
devices = get_element_devices(purple_prefs_get_string(plugin_pref));
if (g_list_find_custom(devices, purple_prefs_get_string(device_pref),
(GCompareFunc) strcmp) == NULL)
purple_prefs_set_string(device_pref, g_list_next(devices)->data);
widget = pidgin_prefs_dropdown_from_list(vbox, device_label,
PURPLE_PREF_STRING, device_pref, devices);
g_list_free(devices);
gtk_widget_set_name(widget, plugin_pref);
gtk_size_group_add_widget(sg, widget);
gtk_misc_set_alignment(GTK_MISC(widget), 0, 0.5);
purple_prefs_connect_callback(vbox, plugin_pref,
device_changed_cb, sg);
g_signal_connect_swapped(vbox, "destroy",
G_CALLBACK(purple_prefs_disconnect_by_handle), vbox);
}
void cb_xmms_sep_changed(GtkEditable *editable, gpointer data)
{
const char *text = gtk_entry_get_text(GTK_ENTRY(editable));
if (strlen(text) == 1)
purple_prefs_set_string(PREF_XMMS_SEP, text);
}
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
device_changed_cb(const gchar *name, PurplePrefType type,
gconstpointer value, gpointer data)
{
GtkSizeGroup *sg = data;
GtkWidget *parent, *widget;
GSList *widgets;
GList *devices;
GValue gvalue;
gint position;
gchar *label, *pref;
widgets = gtk_size_group_get_widgets(GTK_SIZE_GROUP(sg));
for (; widgets; widgets = g_slist_next(widgets)) {
const gchar *widget_name =
gtk_widget_get_name(GTK_WIDGET(widgets->data));
if (!strcmp(widget_name, name)) {
gchar *temp_str;
gchar delimiters[3] = {0, 0, 0};
const gchar *text;
gint keyval, pos;
widget = widgets->data;
/* Get label with _ from the GtkLabel */
text = gtk_label_get_text(GTK_LABEL(widget));
keyval = gtk_label_get_mnemonic_keyval(GTK_LABEL(widget));
delimiters[0] = g_ascii_tolower(keyval);
delimiters[1] = g_ascii_toupper(keyval);
pos = strcspn(text, delimiters);
if (pos != -1) {
temp_str = g_strndup(text, pos);
label = g_strconcat(temp_str, "_",
text + pos, NULL);
g_free(temp_str);
} else {
label = g_strdup(text);
}
break;
}
}
if (widgets == NULL)
return;
parent = gtk_widget_get_parent(widget);
widget = parent;
parent = gtk_widget_get_parent(GTK_WIDGET(widget));
gvalue.g_type = 0;
g_value_init(&gvalue, G_TYPE_INT);
gtk_container_child_get_property(GTK_CONTAINER(parent),
GTK_WIDGET(widget), "position", &gvalue);
position = g_value_get_int(&gvalue);
g_value_unset(&gvalue);
gtk_widget_destroy(widget);
pref = g_strdup(name);
strcpy(pref + strlen(pref) - strlen("plugin"), "device");
devices = get_element_devices(value);
if (g_list_find_custom(devices, purple_prefs_get_string(pref),
(GCompareFunc)strcmp) == NULL)
purple_prefs_set_string(pref, g_list_next(devices)->data);
widget = pidgin_prefs_dropdown_from_list(parent,
label, PURPLE_PREF_STRING,
pref, devices);
g_list_free(devices);
g_signal_connect_swapped(widget, "destroy",
G_CALLBACK(g_free), pref);
g_free(label);
gtk_misc_set_alignment(GTK_MISC(widget), 0, 0.5);
gtk_widget_set_name(widget, name);
gtk_size_group_add_widget(sg, widget);
gtk_box_reorder_child(GTK_BOX(parent),
gtk_widget_get_parent(GTK_WIDGET(widget)), position);
}
static void set_editor_path (GtkWidget *button, GtkWidget *text_field)
{
const char * path = gtk_entry_get_text((GtkEntry*)text_field);
purple_prefs_set_string("/plugins/gtk/musicmessaging/editor_path", path);
}
/* This will also create it if it doesn't exist */
void
finch_sound_set_active_profile(const char *name)
{
purple_prefs_set_string(FINCH_PREFS_ROOT "/sound/actprofile", name);
}
void IM::setPassword(const string& password)
{
purple_prefs_set_string("/minbif/password", password.c_str());
}
static void
ggzpurple_entry_change_cb(GtkObject *obj, gchar *pref)
{
purple_prefs_set_string(pref,gtk_entry_get_text(GTK_ENTRY(obj)));
}