/**
* A callback for when the position of a GtkPaned slider changes
*
* This function is responsible for storing the width or height of the Buddy
* List as a preference after the user changes it by dragging the slider.
*
* @param[in] gobject Pointer to the GtkPaned structure that was resized
* @param[in] pspec Unused
* @param[in] data Pointer to the Buddy List that is a parent of gobject
**/
static void notify_position_cb(GObject *gobject, U GParamSpec *pspec,
gpointer data)
{
PidginBuddyList *
gtkblist; /*< Buddy List window containing these panes */
gint max_position; /*< The "max-position" property of gobject */
gint size; /*< Current size of the Buddy List pane */
gtkblist = data;
size = gtk_paned_get_position(GTK_PANED(gobject));
/* If the Buddy List is not the first pane, invert the size preference.
*/
if (gtk_paned_get_child1(GTK_PANED(gobject)) != gtkblist->notebook) {
g_object_get(gobject, "max-position", &max_position, NULL);
size = max_position - size;
}
/* Store this size as a user preference (depending on paned
* orientation). */
if (GTK_IS_VPANED(gobject))
purple_prefs_set_int(PREF_HEIGHT, size);
else
purple_prefs_set_int(PREF_WIDTH, size);
}
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);
}
static void
size_changed_cb(GntWidget *widget, int oldw, int oldh)
{
int w, h;
gnt_widget_get_size(widget, &w, &h);
purple_prefs_set_int(PREF_ROOT "/size/width", w);
purple_prefs_set_int(PREF_ROOT "/size/height", h);
}
static void blist_save_state() {
if(blist_ab) {
if(purple_prefs_get_bool(PREF_DBLIST_DOCKABLE) && blist_ab->docked) {
purple_prefs_set_int(PREF_DBLIST_HEIGHT, blist_ab->undocked_height);
purple_prefs_set_int(PREF_DBLIST_SIDE, blist_ab->side);
purple_prefs_set_bool(PREF_DBLIST_DOCKED, blist_ab->docked);
} else
purple_prefs_set_bool(PREF_DBLIST_DOCKED, FALSE);
}
}
/* Update value returned from spinner for auto-respond delay */
static gboolean update_delay_respond (GtkWidget *widget, GdkEventFocus *evt,
gpointer data)
{
purple_prefs_set_int ("/plugins/gtk/autoprofile/delay_respond",
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (widget)));
return FALSE;
}
static void
pref_update(GtkWidget *widget, char *pref)
{
if (purple_prefs_get_type(pref) == PURPLE_PREF_INT)
purple_prefs_set_int(pref, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget)));
if (purple_prefs_get_type(pref) == PURPLE_PREF_BOOLEAN)
purple_prefs_set_bool(pref, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)));
}
static void change_alpha(GtkWidget *w, gpointer data) {
int alpha = gtk_range_get_value(GTK_RANGE(w));
purple_prefs_set_int(OPT_WINTRANS_IM_ALPHA, alpha);
/* If we're in no-transparency on focus mode,
* don't take effect immediately */
if (!purple_prefs_get_bool(OPT_WINTRANS_IM_ONFOCUS))
set_wintrans(GTK_WIDGET(data), alpha, TRUE,
purple_prefs_get_bool(OPT_WINTRANS_IM_ONTOP));
}
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
messaging_menu_config_cb(GtkWidget *widget, gpointer data)
{
gint option = GPOINTER_TO_INT(data);
if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
return;
purple_prefs_set_int("/plugins/gtk/unity/messaging_menu_text", option);
messaging_menu_text = option;
refill_messaging_menu();
}
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 void
set_timestamp(GtkWidget *spinner, void *null)
{
int tm;
tm = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spinner));
purple_debug(PURPLE_DEBUG_MISC, "timestamp",
"setting interval to %d minutes\n", tm);
interval = tm * 60;
purple_prefs_set_int("/plugins/gtk/timestamp/interval", interval * 1000);
}
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))));
purple_prefs_set_int(make_pref("/volume"), gnt_slider_get_value(GNT_SLIDER(pref_dialog->volume)));
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 PurplePluginPrefFrame *
get_plugin_pref_frame (PurplePlugin *plugin)
{
PurplePluginPrefFrame *frame;
PurplePluginPref *ppref;
frame = purple_plugin_pref_frame_new ();
ppref = purple_plugin_pref_new_with_name_and_label (
"/plugins/gtk/libnotify/newmsg",
_("New messages"));
purple_plugin_pref_frame_add (frame, ppref);
ppref = purple_plugin_pref_new_with_name_and_label (
"/plugins/gtk/libnotify/newmsgtxt",
_("Show new messages text"));
purple_plugin_pref_frame_add (frame, ppref);
if (purple_prefs_get_int("/plugins/gtk/libnotify/timeout") == 0) {
/* 3 seconds is the default timeout */
purple_prefs_set_int("/plugins/gtk/libnotify/timeout", 3000);
}
ppref = purple_plugin_pref_new_with_name_and_label (
"/plugins/gtk/libnotify/timeout",
_("Display timeout (msec)"));
purple_plugin_pref_set_bounds(ppref, 100, 100000);
purple_plugin_pref_frame_add (frame, ppref);
ppref = purple_plugin_pref_new_with_name_and_label (
"/plugins/gtk/libnotify/blocked",
_("Ignore events from blocked users"));
purple_plugin_pref_frame_add (frame, ppref);
ppref = purple_plugin_pref_new_with_name_and_label (
"/plugins/gtk/libnotify/signon",
_("Buddy signs on"));
purple_plugin_pref_frame_add (frame, ppref);
ppref = purple_plugin_pref_new_with_name_and_label (
"/plugins/gtk/libnotify/signoff",
_("Buddy signs off"));
purple_plugin_pref_frame_add (frame, ppref);
ppref = purple_plugin_pref_new_with_name_and_label (
"/plugins/gtk/libnotify/only_available",
_("Only when available"));
purple_plugin_pref_frame_add (frame, ppref);
return frame;
}
static void
launcher_config_cb(GtkWidget *widget, gpointer data)
{
gint option = GPOINTER_TO_INT(data);
if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
return;
purple_prefs_set_int("/plugins/gtk/unity/launcher_count", option);
launcher_count = option;
if (option == LAUNCHER_COUNT_DISABLE)
unity_launcher_entry_set_count_visible(launcher, FALSE);
else
update_launcher();
}
static
void cb_player_changed(GtkWidget *widget, gpointer data)
{
int active = gtk_combo_box_get_active(GTK_COMBO_BOX(widget));
if (active != -1) {
active -= 1;
purple_prefs_set_int(PREF_PLAYER, active);
}
// Enable/disable properties button depending on whether player has pref_func
if (active == -1)
gtk_widget_set_sensitive((GtkWidget*) data, FALSE);
else
gtk_widget_set_sensitive((GtkWidget*) data, g_players[active].pref_func != 0);
}
void
purple_prefs_update_old()
{
purple_prefs_rename("/core", "/purple");
/* Remove some no-longer-used prefs */
purple_prefs_remove("/purple/away/auto_response/enabled");
purple_prefs_remove("/purple/away/auto_response/idle_only");
purple_prefs_remove("/purple/away/auto_response/in_active_conv");
purple_prefs_remove("/purple/away/auto_response/sec_before_resend");
purple_prefs_remove("/purple/away/auto_response");
purple_prefs_remove("/purple/away/default_message");
purple_prefs_remove("/purple/buddies/use_server_alias");
purple_prefs_remove("/purple/conversations/away_back_on_send");
purple_prefs_remove("/purple/conversations/send_urls_as_links");
purple_prefs_remove("/purple/conversations/im/show_login");
purple_prefs_remove("/purple/conversations/chat/show_join");
purple_prefs_remove("/purple/conversations/chat/show_leave");
purple_prefs_remove("/purple/conversations/combine_chat_im");
purple_prefs_remove("/purple/conversations/use_alias_for_title");
purple_prefs_remove("/purple/logging/log_signon_signoff");
purple_prefs_remove("/purple/logging/log_idle_state");
purple_prefs_remove("/purple/logging/log_away_state");
purple_prefs_remove("/purple/logging/log_own_states");
purple_prefs_remove("/purple/status/scores/hidden");
purple_prefs_remove("/plugins/core/autorecon/hide_connected_error");
purple_prefs_remove("/plugins/core/autorecon/hide_connecting_error");
purple_prefs_remove("/plugins/core/autorecon/hide_reconnecting_dialog");
purple_prefs_remove("/plugins/core/autorecon/restore_state");
purple_prefs_remove("/plugins/core/autorecon");
/* Convert old sounds while_away pref to new 3-way pref. */
if (purple_prefs_exists("/purple/sound/while_away") &&
purple_prefs_get_bool("/purple/sound/while_away"))
{
purple_prefs_set_int("/purple/sound/while_status", 3);
}
purple_prefs_remove("/purple/sound/while_away");
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
/* migrate the old pref (we should only care if the plugin is actually *used*) */
/*
* TODO: We should eventually call purple_prefs_remove(PREFS_STRANGER_OLD)
* to clean up after ourselves, but we don't want to do it yet
* so that we don't break users who share a .purple directory
* between old libpurple clients and new libpurple clients.
* --Mark Doliner, 2011-01-03
*/
if (!purple_prefs_exists(PREF_STRANGER)) {
if (purple_prefs_get_bool(PREF_STRANGER_OLD))
purple_prefs_add_int(PREF_STRANGER, FT_REJECT);
else
purple_prefs_set_int(PREF_STRANGER, FT_ASK);
}
purple_signal_connect(purple_xfers_get_handle(), "file-recv-request", plugin,
PURPLE_CALLBACK(file_recv_request_cb), plugin);
purple_signal_connect(purple_blist_get_handle(), "blist-node-extended-menu", plugin,
PURPLE_CALLBACK(context_menu), plugin);
return TRUE;
}
static void
do_check(void)
{
int last_check = purple_prefs_get_int("/plugins/gtk/relnot/last_check");
if(!last_check || time(NULL) - last_check > MIN_CHECK_INTERVAL) {
gchar *url, *request;
const char *host = "pidgin.im";
url = g_strdup_printf("https://%s/version.php?version=%s&build=%s",
host,
purple_core_get_version(),
#ifdef _WIN32
"purple-win32"
#else
"purple"
#endif
);
request = g_strdup_printf(
"GET %s HTTP/1.0\r\n"
"Connection: close\r\n"
"Accept: */*\r\n"
"Host: %s\r\n\r\n",
url,
host);
purple_util_fetch_url_request_len(url, TRUE, NULL, FALSE,
request, TRUE, -1, version_fetch_cb, NULL);
g_free(request);
g_free(url);
purple_prefs_set_int("/plugins/gtk/relnot/last_check", time(NULL));
}
}
static void on_maxlength_spinbutton_changed(GtkWidget *widget) {
purple_prefs_set_int("/plugins/gtk/festival/speaker/maxlength",gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget)));
}
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
threshold_scale_destroy_cb(GtkRange *threshold, gpointer nul)
{
purple_prefs_set_int("/purple/media/audio/silence_threshold",
gtk_range_get_value(threshold));
}
static void
volume_scale_destroy_cb(GtkRange *volume, gpointer nul)
{
purple_prefs_set_int("/purple/media/audio/volume/input",
gtk_range_get_value(volume));
}
static void numeric_spinner_prefs_cb(GtkSpinButton *spinbutton, gpointer user_data) {
purple_prefs_set_int(user_data, gtk_spin_button_get_value_as_int(spinbutton));
}
static void
set_idle_away(PurpleSavedStatus *status)
{
purple_prefs_set_int("/core/savedstatus/idleaway",
purple_savedstatus_get_creation_time(status));
}
void IM::setSendDelay(int delay)
{
purple_prefs_set_int("/minbif/send_delay", delay);
}
void IM::setTypingNotice(bool enabled)
{
purple_prefs_set_int("/minbif/typing_notice", enabled ? 1 : 0);
}
static
void cb_lastfm_ws_interval_changed(GtkSpinButton *widget, gpointer data)
{
purple_prefs_set_int((const char*)data, gtk_spin_button_get_value_as_int(widget));
}
static void alpha_pref_set_int (GtkWidget *w, GdkEventFocus *e, const char *pref)
{
int alpha = gtk_range_get_value(GTK_RANGE(w));
purple_prefs_set_int(pref, alpha);
}
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);
}
