/** * 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); }