* @file gtkprefs.c GTK+ Preferences * Pidgin is the legal property of its developers, whose names are too numerous * to list here. Please refer to the COPYRIGHT file distributed with this * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA #include "savedstatuses.h" #include "theme-manager.h" #include "gtkimhtmltoolbar.h" #include "gtksavedstatuses.h" #include "gtkstatus-icon-theme.h" #define PREFS_OPTIMAL_ICON_SIZE 32 static GtkWidget *prefs = NULL; static GtkWidget *prefsnotebook = NULL; static int notebook_page = 0; static GtkWidget *sample_imhtml = NULL; static GtkWidget *prefs_sound_themes_combo_box; static GtkWidget *prefs_blist_themes_combo_box; static GtkWidget *prefs_status_themes_combo_box; static GtkWidget *prefs_smiley_themes_combo_box; /* Sound theme specific */ static GtkWidget *sound_entry = NULL; static int sound_row_sel = 0; static gboolean prefs_sound_themes_loading; /* These exist outside the lifetime of the prefs dialog */ static GtkListStore *prefs_sound_themes; static GtkListStore *prefs_blist_themes; static GtkListStore *prefs_status_icon_themes; static GtkListStore *prefs_smiley_themes; static void delete_prefs(GtkWidget *, void *); update_spin_value(GtkWidget *w, GtkWidget *spin) const char *key = g_object_get_data(G_OBJECT(spin), "val"); value = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin)); purple_prefs_set_int(key, value); pidgin_prefs_labeled_spin_button(GtkWidget *box, const gchar *title, const char *key, int min, int max, GtkSizeGroup *sg) val = purple_prefs_get_int(key); adjust = gtk_adjustment_new(val, min, max, 1, 1, 0); spin = gtk_spin_button_new(GTK_ADJUSTMENT(adjust), 1, 0); g_object_set_data(G_OBJECT(spin), "val", (char *)key); gtk_widget_set_size_request(spin, 50, -1); gtk_widget_set_size_request(spin, 60, -1); g_signal_connect(G_OBJECT(adjust), "value-changed", G_CALLBACK(update_spin_value), GTK_WIDGET(spin)); return pidgin_add_widget_to_vbox(GTK_BOX(box), title, sg, spin, FALSE, NULL); entry_set(GtkEntry *entry, gpointer data) const char *key = (const char*)data; purple_prefs_set_string(key, gtk_entry_get_text(entry)); pidgin_prefs_labeled_entry(GtkWidget *page, const gchar *title, const char *key, GtkSizeGroup *sg) value = purple_prefs_get_string(key); gtk_entry_set_text(GTK_ENTRY(entry), value); g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(entry_set), (char*)key); return pidgin_add_widget_to_vbox(GTK_BOX(page), title, sg, entry, TRUE, NULL); pidgin_prefs_labeled_password(GtkWidget *page, const gchar *title, const char *key, GtkSizeGroup *sg) value = purple_prefs_get_string(key); gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE); gtk_entry_set_text(GTK_ENTRY(entry), value); g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(entry_set), (char*)key); return pidgin_add_widget_to_vbox(GTK_BOX(page), title, sg, entry, TRUE, NULL); dropdown_set(GObject *w, const char *key) type = GPOINTER_TO_INT(g_object_get_data(w, "type")); if (type == PURPLE_PREF_INT) { int_value = GPOINTER_TO_INT(g_object_get_data(w, "value")); purple_prefs_set_int(key, int_value); else if (type == PURPLE_PREF_STRING) { str_value = (const char *)g_object_get_data(w, "value"); purple_prefs_set_string(key, str_value); else if (type == PURPLE_PREF_BOOLEAN) { purple_prefs_set_bool(key, GPOINTER_TO_INT(g_object_get_data(w, "value"))); pidgin_prefs_dropdown_from_list(GtkWidget *box, const gchar *title, PurplePrefType type, const char *key, GList *menuitems) GtkWidget *dropdown, *opt, *menu; const char *stored_str = NULL; const char *str_value = NULL; g_return_val_if_fail(menuitems != NULL, NULL); dropdown = gtk_option_menu_new(); if (type == PURPLE_PREF_INT) stored_int = purple_prefs_get_int(key); else if (type == PURPLE_PREF_STRING) stored_str = purple_prefs_get_string(key); while (menuitems != NULL && (text = (char *) menuitems->data) != NULL) { menuitems = g_list_next(menuitems); g_return_val_if_fail(menuitems != NULL, NULL); opt = gtk_menu_item_new_with_label(text); g_object_set_data(G_OBJECT(opt), "type", GINT_TO_POINTER(type)); if (type == PURPLE_PREF_INT) { int_value = GPOINTER_TO_INT(menuitems->data); g_object_set_data(G_OBJECT(opt), "value", GINT_TO_POINTER(int_value)); else if (type == PURPLE_PREF_STRING) { str_value = (const char *)menuitems->data; g_object_set_data(G_OBJECT(opt), "value", (char *)str_value); else if (type == PURPLE_PREF_BOOLEAN) { g_object_set_data(G_OBJECT(opt), "value", g_signal_connect(G_OBJECT(opt), "activate", G_CALLBACK(dropdown_set), (char *)key); gtk_menu_shell_append(GTK_MENU_SHELL(menu), opt); if ((type == PURPLE_PREF_INT && stored_int == int_value) || (type == PURPLE_PREF_STRING && stored_str != NULL && !strcmp(stored_str, str_value)) || (type == PURPLE_PREF_BOOLEAN && (purple_prefs_get_bool(key) == GPOINTER_TO_INT(menuitems->data)))) { gtk_menu_set_active(GTK_MENU(menu), o); menuitems = g_list_next(menuitems); gtk_option_menu_set_menu(GTK_OPTION_MENU(dropdown), menu); pidgin_add_widget_to_vbox(GTK_BOX(box), title, NULL, dropdown, FALSE, &label); pidgin_prefs_dropdown(GtkWidget *box, const gchar *title, PurplePrefType type, GtkWidget *dropdown = NULL; g_return_val_if_fail(type == PURPLE_PREF_BOOLEAN || type == PURPLE_PREF_INT || type == PURPLE_PREF_STRING, NULL); while ((name = va_arg(ap, char *)) != NULL) { menuitems = g_list_prepend(menuitems, name); if (type == PURPLE_PREF_INT || type == PURPLE_PREF_BOOLEAN) { int_value = va_arg(ap, int); menuitems = g_list_prepend(menuitems, GINT_TO_POINTER(int_value)); str_value = va_arg(ap, const char *); menuitems = g_list_prepend(menuitems, (char *)str_value); g_return_val_if_fail(menuitems != NULL, NULL); menuitems = g_list_reverse(menuitems); dropdown = pidgin_prefs_dropdown_from_list(box, title, type, key, delete_prefs(GtkWidget *asdf, void *gdsa) /* Close any "select sound" request dialogs */ purple_request_close_with_handle(prefs); /* Unregister callbacks. */ purple_prefs_disconnect_by_handle(prefs); prefs_sound_themes_loading = FALSE; prefs_sound_themes_combo_box = NULL; prefs_blist_themes_combo_box = NULL; prefs_status_themes_combo_box = NULL; prefs_smiley_themes_combo_box = NULL; get_theme_markup(const char *name, gboolean custom, const char *author, return g_strdup_printf("<b>%s</b>%s%s%s%s\n<span foreground='dim grey'>%s</span>", name, custom ? " " : "", custom ? _("(Custom)") : "", author != NULL ? " - " : "", author != NULL ? author : "", description != NULL ? description : ""); smileys_refresh_theme_list(void) pidgin_themes_smiley_theme_probe(); if (!(themes = smiley_themes)) struct smiley_theme *theme = themes->data; char *description = get_theme_markup(_(theme->name), FALSE, _(theme->author), _(theme->desc)); gtk_list_store_append(prefs_smiley_themes, &iter); * LEAK - Gentoo memprof thinks pixbuf is leaking here... but it * looks like it should be ok to me. Anyone know what's up? --Mark pixbuf = (theme->icon ? pidgin_pixbuf_new_from_file(theme->icon) : NULL); gtk_list_store_set(prefs_smiley_themes, &iter, g_object_unref(G_OBJECT(pixbuf)); /* Rebuild the markup for the sound theme selection for "(Custom)" themes */ pref_sound_generate_markup(void) gboolean print_custom, customized; const gchar *author, *description, *current_theme; customized = pidgin_sound_is_customized(); current_theme = purple_prefs_get_string(PIDGIN_PREFS_ROOT "/sound/theme"); if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(prefs_sound_themes), &iter)) { gtk_tree_model_get(GTK_TREE_MODEL(prefs_sound_themes), &iter, 2, &name, -1); print_custom = customized && name && g_str_equal(current_theme, name); if (!name || *name == '\0') { name = g_strdup(_("Default")); author = _("Penguin Pimps"); description = _("The default Pidgin sound theme"); theme = PURPLE_SOUND_THEME(purple_theme_manager_find_theme(name, "sound")); author = purple_theme_get_author(PURPLE_THEME(theme)); description = purple_theme_get_description(PURPLE_THEME(theme)); markup = get_theme_markup(name, print_custom, author, description); gtk_list_store_set(prefs_sound_themes, &iter, 1, markup, -1); } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(prefs_sound_themes), &iter)); /* adds the themes to the theme list from the manager so they can be displayed in prefs */ prefs_themes_sort(PurpleTheme *theme) GdkPixbuf *pixbuf = NULL; gchar *image_full = NULL, *markup; const gchar *name, *author, *description; if (PURPLE_IS_SOUND_THEME(theme)){ image_full = purple_theme_get_image_full(theme); pixbuf = pidgin_pixbuf_new_from_file_at_scale(image_full, PREFS_OPTIMAL_ICON_SIZE, PREFS_OPTIMAL_ICON_SIZE, TRUE); gtk_list_store_append(prefs_sound_themes, &iter); gtk_list_store_set(prefs_sound_themes, &iter, 0, pixbuf, 2, purple_theme_get_name(theme), -1); g_object_unref(G_OBJECT(pixbuf)); } else if (PIDGIN_IS_BLIST_THEME(theme) || PIDGIN_IS_STATUS_ICON_THEME(theme)){ if (PIDGIN_IS_BLIST_THEME(theme)) store = prefs_blist_themes; store = prefs_status_icon_themes; image_full = purple_theme_get_image_full(theme); pixbuf = pidgin_pixbuf_new_from_file_at_scale(image_full, PREFS_OPTIMAL_ICON_SIZE, PREFS_OPTIMAL_ICON_SIZE, TRUE); name = purple_theme_get_name(theme); author = purple_theme_get_author(theme); description = purple_theme_get_description(theme); markup = get_theme_markup(name, FALSE, author, description); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, pixbuf, 1, markup, 2, name, -1); g_object_unref(G_OBJECT(pixbuf)); prefs_set_active_theme_combo(GtkWidget *combo_box, GtkListStore *store, const gchar *current_theme) if (current_theme && *current_theme && gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter)) { gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 2, &theme, -1); if (g_str_equal(current_theme, theme)) { gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo_box), &iter); } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter)); gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box), 0); prefs_themes_refresh(void) GdkPixbuf *pixbuf = NULL; prefs_sound_themes_loading = TRUE; /* refresh the list of themes in the manager */ purple_theme_manager_refresh(); tmp = g_build_filename(DATADIR, "icons", "hicolor", "32x32", "apps", "pidgin.png", NULL); pixbuf = pidgin_pixbuf_new_from_file_at_scale(tmp, PREFS_OPTIMAL_ICON_SIZE, PREFS_OPTIMAL_ICON_SIZE, TRUE); gtk_list_store_clear(prefs_sound_themes); gtk_list_store_append(prefs_sound_themes, &iter); gtk_list_store_set(prefs_sound_themes, &iter, 0, pixbuf, 2, "", -1); gtk_list_store_clear(prefs_blist_themes); gtk_list_store_append(prefs_blist_themes, &iter); tmp = get_theme_markup(_("Default"), FALSE, _("Penguin Pimps"), _("The default Pidgin buddy list theme")); gtk_list_store_set(prefs_blist_themes, &iter, 0, pixbuf, 1, tmp, 2, "", -1); gtk_list_store_clear(prefs_status_icon_themes); gtk_list_store_append(prefs_status_icon_themes, &iter); tmp = get_theme_markup(_("Default"), FALSE, _("Penguin Pimps"), _("The default Pidgin status icon theme")); gtk_list_store_set(prefs_status_icon_themes, &iter, 0, pixbuf, 1, tmp, 2, "", -1); g_object_unref(G_OBJECT(pixbuf)); gtk_list_store_clear(prefs_smiley_themes); purple_theme_manager_for_each_theme(prefs_themes_sort); pref_sound_generate_markup(); smileys_refresh_theme_list(); prefs_set_active_theme_combo(prefs_sound_themes_combo_box, prefs_sound_themes, purple_prefs_get_string(PIDGIN_PREFS_ROOT "/sound/theme")); prefs_set_active_theme_combo(prefs_blist_themes_combo_box, prefs_blist_themes, purple_prefs_get_string(PIDGIN_PREFS_ROOT "/blist/theme")); prefs_set_active_theme_combo(prefs_status_themes_combo_box, prefs_status_icon_themes, purple_prefs_get_string(PIDGIN_PREFS_ROOT "/status/icon-theme")); prefs_set_active_theme_combo(prefs_smiley_themes_combo_box, prefs_smiley_themes, purple_prefs_get_string(PIDGIN_PREFS_ROOT "/smileys/theme")); prefs_sound_themes_loading = FALSE; /* init all the theme variables so that the themes can be sorted later and used by pref pages */ prefs_sound_themes = gtk_list_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING); prefs_blist_themes = gtk_list_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING); prefs_status_icon_themes = gtk_list_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING); prefs_smiley_themes = gtk_list_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING); prefs_theme_find_theme(const gchar *path, const gchar *type) PurpleTheme *theme = purple_theme_manager_load_theme(path, type); GDir *dir = g_dir_open(path, 0, NULL); while (!PURPLE_IS_THEME(theme) && (next = g_dir_read_name(dir))) { gchar *next_path = g_build_filename(path, next, NULL); if (g_file_test(next_path, G_FILE_TEST_IS_DIR)) theme = prefs_theme_find_theme(next_path, type); /* Eww. Seriously ewww. But thanks, grim! This is taken from guifications2 */ purple_theme_file_copy(const gchar *source, const gchar *destination) if(!(src = g_fopen(source, "rb"))) if(!(dest = g_fopen(destination, "wb"))) { while((chr = fgetc(src)) != EOF) { free_theme_info(struct theme_info *info) g_free(info->original_name); /* installs a theme, info is freed by function */ theme_install_theme(char *path, struct theme_info *info) gboolean is_smiley_theme, is_archive; PurpleTheme *theme = NULL; /* check the extension */ tail = info->extension ? info->extension : strrchr(path, '.'); is_archive = !g_ascii_strcasecmp(tail, ".gz") || !g_ascii_strcasecmp(tail, ".tgz"); if ((is_smiley_theme = g_str_equal(info->type, "smiley"))) destdir = g_build_filename(purple_user_dir(), "smileys", NULL); destdir = g_build_filename(purple_user_dir(), "themes", "temp", NULL); /* We'll check this just to make sure. This also lets us do something different on * other platforms, if need be */ gchar *path_escaped = g_shell_quote(path); gchar *destdir_escaped = g_shell_quote(destdir); if (!g_file_test(destdir, G_FILE_TEST_IS_DIR)) purple_build_dir(destdir, S_IRUSR | S_IWUSR | S_IXUSR); command = g_strdup_printf("tar > /dev/null xzf %s -C %s", path_escaped, destdir_escaped); purple_notify_error(NULL, NULL, _("Theme failed to unpack."), NULL); if (!winpidgin_gz_untar(path, destdir)) { purple_notify_error(NULL, NULL, _("Theme failed to unpack."), NULL); /* just extract the folder to the smiley directory */ theme = prefs_theme_find_theme(destdir, info->type); if (PURPLE_IS_THEME(theme)) { /* create the location for the theme */ gchar *theme_dest = g_build_filename(purple_user_dir(), "themes", purple_theme_get_name(theme), "purple", info->type, NULL); if (!g_file_test(theme_dest, G_FILE_TEST_IS_DIR)) purple_build_dir(theme_dest, S_IRUSR | S_IWUSR | S_IXUSR); theme_dest = g_build_filename(purple_user_dir(), "themes", purple_theme_get_name(theme), "purple", info->type, NULL); /* move the entire directory to new location */ g_rename(purple_theme_get_dir(theme), theme_dest); /* something was wrong with the theme archive */ purple_notify_error(NULL, NULL, _("Theme failed to load."), NULL); } else { /* just a single file so copy it to a new temp directory and attempt to load it*/ gchar *temp_path, *temp_file; temp_path = g_build_filename(purple_user_dir(), "themes", "temp", "sub_folder", NULL); if (info->original_name != NULL) { /* name was changed from the original (probably a dnd) change it back before loading */ temp_file = g_build_filename(temp_path, info->original_name, NULL); gchar *source_name = g_path_get_basename(path); temp_file = g_build_filename(temp_path, source_name, NULL); if (!g_file_test(temp_path, G_FILE_TEST_IS_DIR)) purple_build_dir(temp_path, S_IRUSR | S_IWUSR | S_IXUSR); if (purple_theme_file_copy(path, temp_file)) { /* find the theme, could be in subfolder */ theme = prefs_theme_find_theme(temp_path, info->type); if (PURPLE_IS_THEME(theme)) { gchar *theme_dest = g_build_filename(purple_user_dir(), "themes", purple_theme_get_name(theme), "purple", info->type, NULL); if(!g_file_test(theme_dest, G_FILE_TEST_IS_DIR)) purple_build_dir(theme_dest, S_IRUSR | S_IWUSR | S_IXUSR); g_rename(purple_theme_get_dir(theme), theme_dest); purple_notify_error(NULL, NULL, _("Theme failed to load."), NULL); purple_notify_error(NULL, NULL, _("Theme failed to copy."), NULL); theme_got_url(PurpleUtilFetchUrlData *url_data, gpointer user_data, const gchar *themedata, size_t len, const gchar *error_message) if ((error_message != NULL) || (len == 0)) { free_theme_info(user_data); f = purple_mkstemp(&path, TRUE); wc = fwrite(themedata, len, 1, f); purple_debug_warning("theme_got_url", "Unable to write theme data.\n"); free_theme_info(user_data); theme_install_theme(path, user_data); theme_dnd_recv(GtkWidget *widget, GdkDragContext *dc, guint x, guint y, GtkSelectionData *sd, guint info, guint t, gpointer user_data) gchar *name = g_strchomp((gchar *)sd->data); if ((sd->length >= 0) && (sd->format == 8)) { /* Well, it looks like the drag event was cool. * Let's do something with it */ struct theme_info *info = g_new0(struct theme_info, 1); info->type = g_strdup((gchar *)user_data); info->extension = g_strdup(g_strrstr(name,".")); temp = g_strrstr(name, "/"); info->original_name = temp ? g_strdup(++temp) : NULL; if (!g_ascii_strncasecmp(name, "file://", 7)) { /* It looks like we're dealing with a local file. Let's * just untar it in the right place */ if(!(tmp = g_filename_from_uri(name, NULL, &converr))) { purple_debug(PURPLE_DEBUG_ERROR, "theme dnd", "%s\n", (converr ? converr->message : "g_filename_from_uri error")); theme_install_theme(tmp, info); } else if (!g_ascii_strncasecmp(name, "http://", 7)) { /* Oo, a web drag and drop. This is where things * will start to get interesting */ purple_util_fetch_url(name, TRUE, NULL, FALSE, theme_got_url, info); } else if (!g_ascii_strncasecmp(name, "https://", 8)) { /* purple_util_fetch_url() doesn't support HTTPS, but we want users * to be able to drag and drop links from the SF trackers, so * we'll try it as an HTTP URL. */ char *tmp = g_strdup(name + 1); purple_util_fetch_url(tmp, TRUE, NULL, FALSE, theme_got_url, info); gtk_drag_finish(dc, TRUE, FALSE, t); gtk_drag_finish(dc, FALSE, FALSE, t); /* builds a theme combo box from a list store with colums: icon preview, markup, theme name */ prefs_build_theme_combo_box(GtkListStore *store, const char *current_theme, const char *type) GtkCellRenderer *cell_rend; g_return_val_if_fail(store != NULL && current_theme != NULL, NULL); combo_box = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)); cell_rend = gtk_cell_renderer_pixbuf_new(); gtk_cell_renderer_set_fixed_size(cell_rend, PREFS_OPTIMAL_ICON_SIZE, PREFS_OPTIMAL_ICON_SIZE); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT (combo_box), cell_rend, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo_box), cell_rend, "pixbuf", 0, NULL); cell_rend = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT (combo_box), cell_rend, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo_box), cell_rend, "markup", 1, NULL); g_object_set(cell_rend, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_drag_dest_set(combo_box, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, te, sizeof(te) / sizeof(GtkTargetEntry) , GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect(G_OBJECT(combo_box), "drag_data_received", G_CALLBACK(theme_dnd_recv), (gpointer) type); /* sets the current sound theme */ prefs_set_sound_theme_cb(GtkComboBox *combo_box, gpointer user_data) if(gtk_combo_box_get_active_iter(combo_box, &new_iter) && !prefs_sound_themes_loading) { gtk_tree_model_get(GTK_TREE_MODEL(prefs_sound_themes), &new_iter, 2, &new_theme, -1); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/sound/theme", new_theme); /* New theme removes all customization */ for(i = 0; i < PURPLE_NUM_SOUNDS; i++){ pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/file/%s", pidgin_sound_get_event_option(i)); purple_prefs_set_path(pref, ""); /* gets rid of the "(Custom)" from the last selection */ pref_sound_generate_markup(); gtk_entry_set_text(GTK_ENTRY(sound_entry), _("(default)")); /* sets the current smiley theme */ prefs_set_smiley_theme_cb(GtkComboBox *combo_box, gpointer user_data) if (gtk_combo_box_get_active_iter(combo_box, &new_iter)) { gtk_tree_model_get(GTK_TREE_MODEL(prefs_smiley_themes), &new_iter, 2, &new_theme, -1); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/smileys/theme", new_theme); pidgin_themes_smiley_themeize(sample_imhtml); /* Does same as normal sort, except "none" is sorted first */ static gint pidgin_sort_smileys (GtkTreeModel *model, gchar *name1 = NULL, *name2 = NULL; gtk_tree_model_get(model, a, 2, &name1, -1); gtk_tree_model_get(model, b, 2, &name2, -1); if (name1 == NULL || name2 == NULL) { if (!(name1 == NULL && name2 == NULL)) ret = (name1 == NULL) ? -1: 1; } else if (!g_ascii_strcasecmp(name1, "none")) { if (!g_utf8_collate(name1, name2)) } else if (!g_ascii_strcasecmp(name2, "none")) { /* Neither string is "none", default to normal sort */ ret = purple_utf8_strcasecmp(name1, name2); /* sets the current buddy list theme */ prefs_set_blist_theme_cb(GtkComboBox *combo_box, gpointer user_data) PidginBlistTheme *theme = NULL; if(gtk_combo_box_get_active_iter(combo_box, &iter)) { gtk_tree_model_get(GTK_TREE_MODEL(prefs_blist_themes), &iter, 2, &name, -1); if(!name || !g_str_equal(name, "")) theme = PIDGIN_BLIST_THEME(purple_theme_manager_find_theme(name, "blist")); pidgin_blist_set_theme(theme); /* sets the current icon theme */ prefs_set_status_icon_theme_cb(GtkComboBox *combo_box, gpointer user_data) PidginStatusIconTheme *theme = NULL; if(gtk_combo_box_get_active_iter(combo_box, &iter)) { gtk_tree_model_get(GTK_TREE_MODEL(prefs_status_icon_themes), &iter, 2, &name, -1); if(!name || !g_str_equal(name, "")) theme = PIDGIN_STATUS_ICON_THEME(purple_theme_manager_find_theme(name, "status-icon")); pidgin_stock_load_status_icon_theme(theme); pidgin_blist_refresh(purple_get_blist()); add_theme_prefs_combo(GtkWidget *vbox, GtkSizeGroup *combo_sg, GtkSizeGroup *label_sg, GtkListStore *theme_store, GCallback combo_box_cb, gpointer combo_box_cb_user_data, const char *label_str, const char *prefs_path, GtkWidget *combo_box = NULL; GtkWidget *themesel_hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); label = gtk_label_new(label_str); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_size_group_add_widget(label_sg, label); gtk_box_pack_start(GTK_BOX(themesel_hbox), label, FALSE, FALSE, 0); combo_box = prefs_build_theme_combo_box(theme_store, purple_prefs_get_string(prefs_path), g_signal_connect(G_OBJECT(combo_box), "changed", (GCallback)combo_box_cb, combo_box_cb_user_data); gtk_size_group_add_widget(combo_sg, combo_box); gtk_box_pack_start(GTK_BOX(themesel_hbox), combo_box, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), themesel_hbox, FALSE, FALSE, 0); GtkSizeGroup *label_sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); GtkSizeGroup *combo_sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE); gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER); vbox = pidgin_make_frame(ret, _("Theme Selections")); label = gtk_label_new(_("Select a theme that you would like to use from " "the lists below.\nNew themes can be installed by " "dragging and dropping them onto the theme list.")); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, FALSE, 0); prefs_blist_themes_combo_box = add_theme_prefs_combo( vbox, combo_sg, label_sg, prefs_blist_themes, (GCallback)prefs_set_blist_theme_cb, NULL, _("Buddy List Theme:"), PIDGIN_PREFS_ROOT "/blist/theme", "blist"); prefs_status_themes_combo_box = add_theme_prefs_combo( vbox, combo_sg, label_sg, prefs_status_icon_themes, (GCallback)prefs_set_status_icon_theme_cb, NULL, _("Status Icon Theme:"), PIDGIN_PREFS_ROOT "/status/icon-theme", "icon"); prefs_sound_themes_combo_box = add_theme_prefs_combo( vbox, combo_sg, label_sg, prefs_sound_themes, (GCallback)prefs_set_sound_theme_cb, NULL, _("Sound Theme:"), PIDGIN_PREFS_ROOT "/sound/theme", "sound"); prefs_smiley_themes_combo_box = add_theme_prefs_combo( vbox, combo_sg, label_sg, prefs_smiley_themes, (GCallback)prefs_set_smiley_theme_cb, NULL, _("Smiley Theme:"), PIDGIN_PREFS_ROOT "/smileys/theme", "smiley"); /* Custom sort so "none" theme is at top of list */ gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(prefs_smiley_themes), 2, pidgin_sort_smileys, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(prefs_smiley_themes), gtk_widget_show_all(ret); formatting_toggle_cb(GtkIMHtml *imhtml, GtkIMHtmlButtons buttons, void *toolbar) gboolean bold, italic, uline; gtk_imhtml_get_current_format(GTK_IMHTML(imhtml), if (buttons & GTK_IMHTML_BOLD) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_bold", bold); if (buttons & GTK_IMHTML_ITALIC) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_italic", italic); if (buttons & GTK_IMHTML_UNDERLINE) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_underline", uline); if (buttons & GTK_IMHTML_GROW || buttons & GTK_IMHTML_SHRINK) purple_prefs_set_int(PIDGIN_PREFS_ROOT "/conversations/font_size", gtk_imhtml_get_current_fontsize(GTK_IMHTML(imhtml))); if (buttons & GTK_IMHTML_FACE) { char *face = gtk_imhtml_get_current_fontface(GTK_IMHTML(imhtml)); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/font_face", face); if (buttons & GTK_IMHTML_FORECOLOR) { char *color = gtk_imhtml_get_current_forecolor(GTK_IMHTML(imhtml)); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/fgcolor", color); if (buttons & GTK_IMHTML_BACKCOLOR) { color = gtk_imhtml_get_current_backcolor(GTK_IMHTML(imhtml)); /* Block the signal to prevent a loop. */ object = g_object_ref(G_OBJECT(imhtml)); g_signal_handlers_block_matched(object, G_SIGNAL_MATCH_DATA, 0, 0, NULL, /* Clear the backcolor. */ gtk_imhtml_toggle_backcolor(GTK_IMHTML(imhtml), ""); /* Unblock the signal. */ g_signal_handlers_unblock_matched(object, G_SIGNAL_MATCH_DATA, 0, 0, NULL, /* This will fire a toggle signal and get saved below. */ gtk_imhtml_toggle_background(GTK_IMHTML(imhtml), color); if (buttons & GTK_IMHTML_BACKGROUND) { char *color = gtk_imhtml_get_current_background(GTK_IMHTML(imhtml)); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/bgcolor", color); formatting_clear_cb(GtkIMHtml *imhtml, void *data) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_bold", FALSE); purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_italic", FALSE); purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_underline", FALSE); purple_prefs_set_int(PIDGIN_PREFS_ROOT "/conversations/font_size", 3); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/font_face", ""); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/fgcolor", ""); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/bgcolor", ""); conversation_usetabs_cb(const char *name, PurplePrefType type, gconstpointer value, gpointer data) gboolean usetabs = GPOINTER_TO_INT(value); gtk_widget_set_sensitive(GTK_WIDGET(data), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(data), FALSE); #define CONVERSATION_CLOSE_ACCEL_PATH "<main>/Conversation/Close" /* Filled in in keyboard_shortcuts(). */ static GtkAccelKey ctrl_w = { 0, 0, 0 }; static GtkAccelKey escape = { 0, 0, 0 }; static guint escape_closes_conversation_cb_id = 0; accel_is_escape(GtkAccelKey *k) return (k->accel_key == escape.accel_key && k->accel_mods == escape.accel_mods); /* Update the tickybox in Preferences when the keybinding for Conversation -> * Close is changed via Gtk. conversation_close_accel_changed_cb (GtkAccelMap *object, GdkModifierType accel_mods, GtkToggleButton *checkbox = GTK_TOGGLE_BUTTON(checkbox_); GtkAccelKey new = { accel_key, accel_mods, 0 }; g_signal_handler_block(checkbox, escape_closes_conversation_cb_id); gtk_toggle_button_set_active(checkbox, accel_is_escape(&new)); g_signal_handler_unblock(checkbox, escape_closes_conversation_cb_id); escape_closes_conversation_cb(GtkWidget *w, gboolean active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)); GtkAccelKey *new_key = active ? &escape : &ctrl_w; changed = gtk_accel_map_change_entry(CONVERSATION_CLOSE_ACCEL_PATH, new_key->accel_key, new_key->accel_mods, TRUE); /* If another path is already bound to the new accelerator, * _change_entry tries to delete that binding (because it was passed * replace=TRUE). If that other path is locked, then _change_entry * will fail. We don't ever lock any accelerator paths, so this case purple_debug_warning("gtkprefs", "Escape accel failed to change\n"); /* Creates preferences for keyboard shortcuts that it's hard to change with the * standard Gtk accelerator-changing mechanism. keyboard_shortcuts(GtkWidget *page) GtkWidget *vbox = pidgin_make_frame(page, _("Keyboard Shortcuts")); GtkAccelKey current = { 0, 0, 0 }; GtkAccelMap *map = gtk_accel_map_get(); /* Maybe it would be better just to hardcode the values? if (ctrl_w.accel_key == 0) gtk_accelerator_parse ("<Control>w", &(ctrl_w.accel_key), g_assert(ctrl_w.accel_key != 0); gtk_accelerator_parse ("Escape", &(escape.accel_key), g_assert(escape.accel_key != 0); checkbox = gtk_check_button_new_with_mnemonic( _("Cl_ose conversations with the Escape key")); gtk_accel_map_lookup_entry(CONVERSATION_CLOSE_ACCEL_PATH, ¤t); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), accel_is_escape(¤t)); escape_closes_conversation_cb_id = g_signal_connect(checkbox, "clicked", G_CALLBACK(escape_closes_conversation_cb), NULL); g_signal_connect_object(map, "changed::" CONVERSATION_CLOSE_ACCEL_PATH, G_CALLBACK(conversation_close_accel_changed_cb), checkbox, (GConnectFlags)0); gtk_box_pack_start(GTK_BOX(vbox), checkbox, FALSE, FALSE, 0); ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE); gtk_container_set_border_width(GTK_CONTAINER(ret), PIDGIN_HIG_BORDER); sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); vbox = pidgin_make_frame(ret, _("System Tray Icon")); label = pidgin_prefs_dropdown(vbox, _("_Show system tray icon:"), PURPLE_PREF_STRING, PIDGIN_PREFS_ROOT "/docklet/show", _("On unread messages"), "pending", gtk_size_group_add_widget(sg, label); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); vbox = pidgin_make_frame(ret, _("Conversation Window")); label = pidgin_prefs_dropdown(vbox, _("_Hide new IM conversations:"), PURPLE_PREF_STRING, PIDGIN_PREFS_ROOT "/conversations/im/hide_new", gtk_size_group_add_widget(sg, label); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); pidgin_prefs_checkbox(_("Minimi_ze new conversation windows"), PIDGIN_PREFS_ROOT "/win32/minimize_new_convs", vbox); /* All the tab options! */ vbox = pidgin_make_frame(ret, _("Tabs")); pidgin_prefs_checkbox(_("Show IMs and chats in _tabbed windows"), PIDGIN_PREFS_ROOT "/conversations/tabs", vbox); * Connect a signal to the above preference. When conversations are not * shown in a tabbed window then all tabbing options should be disabled. vbox2 = gtk_vbox_new(FALSE, 9); gtk_box_pack_start(GTK_BOX(vbox), vbox2, FALSE, FALSE, 0); purple_prefs_connect_callback(prefs, PIDGIN_PREFS_ROOT "/conversations/tabs", conversation_usetabs_cb, vbox2); if (!purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/tabs")) gtk_widget_set_sensitive(vbox2, FALSE); pidgin_prefs_checkbox(_("Show close b_utton on tabs"), PIDGIN_PREFS_ROOT "/conversations/close_on_tabs", vbox2); label = pidgin_prefs_dropdown(vbox2, _("_Placement:"), PURPLE_PREF_INT, PIDGIN_PREFS_ROOT "/conversations/tab_side", _("Bottom"), GTK_POS_BOTTOM, _("Right"), GTK_POS_RIGHT, _("Left Vertical"), GTK_POS_LEFT|8, _("Right Vertical"), GTK_POS_RIGHT|8, gtk_size_group_add_widget(sg, label); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); names = pidgin_conv_placement_get_options(); label = pidgin_prefs_dropdown_from_list(vbox2, _("N_ew conversations:"), PURPLE_PREF_STRING, PIDGIN_PREFS_ROOT "/conversations/placement", names); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_size_group_add_widget(sg, label); gtk_widget_show_all(ret); PangoFontDescription *desc = NULL; if (!purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/use_theme_font")) { const char *font = purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/custom_font"); desc = pango_font_description_from_string(font); gtk_widget_modify_font(sample_imhtml, desc); pango_font_description_free(desc); pidgin_custom_font_set(GtkFontButton *font_button, gpointer nul) purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/custom_font", gtk_font_button_get_font_name(font_button)); ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE); gtk_container_set_border_width(GTK_CONTAINER(ret), PIDGIN_HIG_BORDER); vbox = pidgin_make_frame(ret, _("Conversations")); pidgin_prefs_checkbox(_("Show _formatting on incoming messages"), PIDGIN_PREFS_ROOT "/conversations/show_incoming_formatting", vbox); pidgin_prefs_checkbox(_("Close IMs immediately when the tab is closed"), PIDGIN_PREFS_ROOT "/conversations/im/close_immediately", vbox); iconpref1 = pidgin_prefs_checkbox(_("Show _detailed information"), PIDGIN_PREFS_ROOT "/conversations/im/show_buddy_icons", vbox); iconpref2 = pidgin_prefs_checkbox(_("Enable buddy ic_on animation"), PIDGIN_PREFS_ROOT "/conversations/im/animate_buddy_icons", vbox); if (!purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/im/show_buddy_icons")) gtk_widget_set_sensitive(iconpref2, FALSE); g_signal_connect(G_OBJECT(iconpref1), "clicked", G_CALLBACK(pidgin_toggle_sensitive), iconpref2); pidgin_prefs_checkbox(_("_Notify buddies that you are typing to them"), "/purple/conversations/im/send_typing", vbox); pidgin_prefs_checkbox(_("Highlight _misspelled words"), PIDGIN_PREFS_ROOT "/conversations/spellcheck", vbox); pidgin_prefs_checkbox(_("Use smooth-scrolling"), PIDGIN_PREFS_ROOT "/conversations/use_smooth_scrolling", vbox); pidgin_prefs_checkbox(_("F_lash window when IMs are received"), PIDGIN_PREFS_ROOT "/win32/blink_im", vbox); hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); checkbox = pidgin_prefs_checkbox(_("Resize incoming custom smileys"), PIDGIN_PREFS_ROOT "/conversations/resize_custom_smileys", hbox); spin_button = pidgin_prefs_labeled_spin_button(hbox, PIDGIN_PREFS_ROOT "/conversations/custom_smileys_size", if (!purple_prefs_get_bool( PIDGIN_PREFS_ROOT "/conversations/resize_custom_smileys")) gtk_widget_set_sensitive(GTK_WIDGET(spin_button), FALSE); g_signal_connect(G_OBJECT(checkbox), "clicked", G_CALLBACK(pidgin_toggle_sensitive), spin_button); pidgin_add_widget_to_vbox(GTK_BOX(vbox), NULL, NULL, hbox, TRUE, NULL); pidgin_prefs_labeled_spin_button(vbox, _("Minimum input area height in lines:"), PIDGIN_PREFS_ROOT "/conversations/minimum_entry_lines", GtkWidget *fontpref, *font_button, *hbox; vbox = pidgin_make_frame(ret, _("Font")); fontpref = pidgin_prefs_checkbox(_("Use font from _theme"), PIDGIN_PREFS_ROOT "/conversations/use_theme_font", vbox); font_name = purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/custom_font"); if ((font_name == NULL) || (*font_name == '\0')) { font_button = gtk_font_button_new(); font_button = gtk_font_button_new_with_font(font_name); gtk_font_button_set_show_style(GTK_FONT_BUTTON(font_button), TRUE); hbox = pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("Conversation _font:"), NULL, font_button, FALSE, NULL); if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/use_theme_font")) gtk_widget_set_sensitive(hbox, FALSE); g_signal_connect(G_OBJECT(fontpref), "clicked", G_CALLBACK(pidgin_toggle_sensitive), hbox); g_signal_connect(G_OBJECT(fontpref), "clicked", G_CALLBACK(apply_custom_font), hbox); g_signal_connect(G_OBJECT(font_button), "font-set", G_CALLBACK(pidgin_custom_font_set), NULL); vbox = pidgin_make_frame(ret, _("Default Formatting")); frame = pidgin_create_imhtml(TRUE, &imhtml, &toolbar, NULL); gtk_widget_set_name(imhtml, "pidgin_prefs_font_imhtml"); gtk_widget_set_size_request(frame, 450, -1); gtk_imhtml_set_whole_buffer_formatting_only(GTK_IMHTML(imhtml), TRUE); gtk_imhtml_set_format_functions(GTK_IMHTML(imhtml), gtk_imhtml_append_text(GTK_IMHTML(imhtml), _("This is how your outgoing message text will appear when you use protocols that support formatting."), 0); gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0); gtk_imhtml_setup_entry(GTK_IMHTML(imhtml), PURPLE_CONNECTION_HTML | PURPLE_CONNECTION_FORMATTING_WBFO); g_signal_connect_after(G_OBJECT(imhtml), "format_function_toggle", G_CALLBACK(formatting_toggle_cb), toolbar); g_signal_connect_after(G_OBJECT(imhtml), "format_function_clear", G_CALLBACK(formatting_clear_cb), NULL); network_ip_changed(GtkEntry *entry, gpointer data) const gchar *text = gtk_entry_get_text(entry); if (purple_ip_address_is_valid(text)) { purple_network_set_public_ip(text); gtk_widget_modify_base(GTK_WIDGET(entry), GTK_STATE_NORMAL, &color); purple_network_set_public_ip(""); gtk_widget_modify_base(GTK_WIDGET(entry), GTK_STATE_NORMAL, NULL); network_stun_server_changed_cb(GtkWidget *widget, GdkEventFocus *event, gpointer data) GtkEntry *entry = GTK_ENTRY(widget); purple_prefs_set_string("/purple/network/stun_server", gtk_entry_get_text(entry)); purple_network_set_stun_server(gtk_entry_get_text(entry)); network_turn_server_changed_cb(GtkWidget *widget, GdkEventFocus *event, gpointer data) GtkEntry *entry = GTK_ENTRY(widget); purple_prefs_set_string("/purple/network/turn_server", gtk_entry_get_text(entry)); purple_network_set_turn_server(gtk_entry_get_text(entry)); proxy_changed_cb(const char *name, PurplePrefType type, gconstpointer value, gpointer data) const char *proxy = value; if (strcmp(proxy, "none") && strcmp(proxy, "envvar")) gtk_widget_show_all(frame); proxy_print_option(GtkEntry *entry, int entrynum) if (entrynum == PROXYHOST) purple_prefs_set_string("/purple/proxy/host", gtk_entry_get_text(entry)); else if (entrynum == PROXYPORT) purple_prefs_set_int("/purple/proxy/port", atoi(gtk_entry_get_text(entry))); else if (entrynum == PROXYUSER) purple_prefs_set_string("/purple/proxy/username", gtk_entry_get_text(entry)); else if (entrynum == PROXYPASS) purple_prefs_set_string("/purple/proxy/password", gtk_entry_get_text(entry)); proxy_button_clicked_cb(GtkWidget *button, gchar *program) if (g_spawn_command_line_async(program, &err)) purple_notify_error(NULL, NULL, _("Cannot start proxy configuration program."), err->message); browser_button_clicked_cb(GtkWidget *button, gchar *path) if (g_spawn_command_line_async(path, &err)) purple_notify_error(NULL, NULL, _("Cannot start browser configuration program."), err->message); auto_ip_button_clicked_cb(GtkWidget *button, gpointer null) PurpleStunNatDiscovery *stun; /* purple_network_get_my_ip will return the IP that was set by the user with purple_network_set_public_ip, so make a lookup for the auto-detected IP if (purple_prefs_get_bool("/purple/network/auto_ip")) { /* Check if STUN discovery was already done */ stun = purple_stun_discover(NULL); if ((stun != NULL) && (stun->status == PURPLE_STUN_STATUS_DISCOVERED)) { /* Attempt to get the IP from a NAT device using UPnP */ ip = purple_upnp_get_public_ip(); /* Attempt to get the IP from a NAT device using NAT-PMP */ ip = purple_pmp_get_public_ip(); /* Just fetch the IP of the local system */ ip = purple_network_get_local_system_ip(-1); auto_ip_text = g_strdup_printf(_("Use _automatically detected IP address: %s"), ip); gtk_button_set_label(GTK_BUTTON(button), auto_ip_text); GtkWidget *vbox, *hbox, *entry; GtkWidget *label, *auto_ip_checkbox, *ports_checkbox, *spin_button; ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE); gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER); vbox = pidgin_make_frame (ret, _("IP Address")); sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); gtk_entry_set_text(GTK_ENTRY(entry), purple_prefs_get_string( "/purple/network/stun_server")); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(network_stun_server_changed_cb), NULL); pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("ST_UN server:"), hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_container_add(GTK_CONTAINER(vbox), hbox); label = gtk_label_new(NULL); gtk_container_add(GTK_CONTAINER(hbox), label); gtk_size_group_add_widget(sg, label); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<span style=\"italic\">Example: stunserver.org</span>")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_container_add(GTK_CONTAINER(hbox), label); auto_ip_checkbox = pidgin_prefs_checkbox("Use _automatically detected IP address", "/purple/network/auto_ip", vbox); g_signal_connect(G_OBJECT(auto_ip_checkbox), "clicked", G_CALLBACK(auto_ip_button_clicked_cb), NULL); auto_ip_button_clicked_cb(auto_ip_checkbox, NULL); /* Update label */ gtk_entry_set_text(GTK_ENTRY(entry), purple_network_get_public_ip()); g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(network_ip_changed), NULL); hbox = pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("Public _IP:"), if (purple_prefs_get_bool("/purple/network/auto_ip")) { gtk_widget_set_sensitive(GTK_WIDGET(hbox), FALSE); g_signal_connect(G_OBJECT(auto_ip_checkbox), "clicked", G_CALLBACK(pidgin_toggle_sensitive), hbox); vbox = pidgin_make_frame (ret, _("Ports")); sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); pidgin_prefs_checkbox(_("_Enable automatic router port forwarding"), "/purple/network/map_ports", vbox); hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); ports_checkbox = pidgin_prefs_checkbox(_("_Manually specify range of ports to listen on:"), "/purple/network/ports_range_use", hbox); spin_button = pidgin_prefs_labeled_spin_button(hbox, _("_Start:"), "/purple/network/ports_range_start", 0, 65535, sg); if (!purple_prefs_get_bool("/purple/network/ports_range_use")) gtk_widget_set_sensitive(GTK_WIDGET(spin_button), FALSE); g_signal_connect(G_OBJECT(ports_checkbox), "clicked", G_CALLBACK(pidgin_toggle_sensitive), spin_button); spin_button = pidgin_prefs_labeled_spin_button(hbox, _("_End:"), "/purple/network/ports_range_end", 0, 65535, sg); if (!purple_prefs_get_bool("/purple/network/ports_range_use")) gtk_widget_set_sensitive(GTK_WIDGET(spin_button), FALSE); g_signal_connect(G_OBJECT(ports_checkbox), "clicked", G_CALLBACK(pidgin_toggle_sensitive), spin_button); pidgin_add_widget_to_vbox(GTK_BOX(vbox), NULL, NULL, hbox, TRUE, NULL); vbox = pidgin_make_frame(ret, _("Relay Server (TURN)")); sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); gtk_entry_set_text(GTK_ENTRY(entry), purple_prefs_get_string( "/purple/network/turn_server")); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(network_turn_server_changed_cb), NULL); hbox = pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("_TURN server:"), pidgin_prefs_labeled_spin_button(hbox, _("_UDP Port:"), "/purple/network/turn_port", 0, 65535, NULL); pidgin_prefs_labeled_spin_button(hbox, _("T_CP Port:"), "/purple/network/turn_port_tcp", 0, 65535, NULL); hbox = pidgin_prefs_labeled_entry(vbox, _("Use_rname:"), "/purple/network/turn_username", sg); pidgin_prefs_labeled_password(hbox, _("Pass_word:"), "/purple/network/turn_password", NULL); gtk_widget_show_all(ret); manual_browser_set(GtkWidget *entry, GdkEventFocus *event, gpointer data) const char *program = gtk_entry_get_text(GTK_ENTRY(entry)); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/browsers/manual_command", program); get_available_browsers(void) /* Sorted reverse alphabetically */ static const struct browser possible_browsers[] = { {N_("Seamonkey"), "seamonkey"}, {N_("Netscape"), "netscape"}, {N_("Mozilla"), "mozilla"}, {N_("Konqueror"), "kfmclient"}, {N_("Google Chrome"), "google-chrome"}, /* Do not move the line below. Code below expects gnome-open to be in * this list immediately after xdg-open! */ {N_("Desktop Default"), "xdg-open"}, {N_("GNOME Default"), "gnome-open"}, {N_("Galeon"), "galeon"}, {N_("Firefox"), "firefox"}, {N_("Firebird"), "mozilla-firebird"}, {N_("Epiphany"), "epiphany"}, /* Translators: please do not translate "chromium-browser" here! */ {N_("Chromium (chromium-browser)"), "chromium-browser"}, /* Translators: please do not translate "chrome" here! */ {N_("Chromium (chrome)"), "chrome"} static const int num_possible_browsers = G_N_ELEMENTS(possible_browsers); char *browser_setting = (char *)purple_prefs_get_string(PIDGIN_PREFS_ROOT "/browsers/browser"); browsers = g_list_prepend(browsers, (gpointer)"custom"); browsers = g_list_prepend(browsers, (gpointer)_("Manual")); for (i = 0; i < num_possible_browsers; i++) { if (purple_program_is_valid(possible_browsers[i].command)) { browsers = g_list_prepend(browsers, possible_browsers[i].command); browsers = g_list_prepend(browsers, (gpointer)_(possible_browsers[i].name)); if(browser_setting && !strcmp(possible_browsers[i].command, browser_setting)) /* If xdg-open is valid, prefer it over gnome-open and skip forward */ if(!strcmp(possible_browsers[i].command, "xdg-open")) { if (browser_setting && !strcmp("gnome-open", browser_setting)) { purple_prefs_set_string(PIDGIN_PREFS_ROOT "/browsers/browser", possible_browsers[i].command); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/browsers/browser", "custom"); browser_changed1_cb(const char *name, PurplePrefType type, gconstpointer value, gpointer data) const char *browser = value; gtk_widget_set_sensitive(hbox, strcmp(browser, "custom")); browser_changed2_cb(const char *name, PurplePrefType type, gconstpointer value, gpointer data) const char *browser = value; gtk_widget_set_sensitive(hbox, !strcmp(browser, "custom")); GtkWidget *ret, *vbox, *hbox, *label, *entry, *browser_button; ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE); gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER); vbox = pidgin_make_frame (ret, _("Browser Selection")); if (purple_running_gnome()) { hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); label = gtk_label_new(_("Browser preferences are configured in GNOME preferences")); gtk_container_add(GTK_CONTAINER(vbox), hbox); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_container_add(GTK_CONTAINER(vbox), hbox); path = g_find_program_in_path("gnome-control-center"); gchar *tmp = g_strdup_printf("%s info", path); path = g_find_program_in_path("gnome-default-applications-properties"); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<b>Browser configuration program was not found.</b>")); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); browser_button = gtk_button_new_with_mnemonic(_("Configure _Browser")); g_signal_connect_data(G_OBJECT(browser_button), "clicked", G_CALLBACK(browser_button_clicked_cb), path, (GClosureNotify)g_free, 0); gtk_box_pack_start(GTK_BOX(hbox), browser_button, FALSE, FALSE, 0); gtk_widget_show_all(ret); sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); browsers = get_available_browsers(); label = pidgin_prefs_dropdown_from_list(vbox,_("_Browser:"), PURPLE_PREF_STRING, PIDGIN_PREFS_ROOT "/browsers/browser", gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_size_group_add_widget(sg, label); hbox = gtk_hbox_new(FALSE, 0); label = pidgin_prefs_dropdown(hbox, _("_Open link in:"), PURPLE_PREF_INT, PIDGIN_PREFS_ROOT "/browsers/place", _("Browser default"), PIDGIN_BROWSER_DEFAULT, _("Existing window"), PIDGIN_BROWSER_CURRENT, _("New window"), PIDGIN_BROWSER_NEW_WINDOW, _("New tab"), PIDGIN_BROWSER_NEW_TAB, gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_size_group_add_widget(sg, label); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); if (!strcmp(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/browsers/browser"), "custom")) gtk_widget_set_sensitive(hbox, FALSE); purple_prefs_connect_callback(prefs, PIDGIN_PREFS_ROOT "/browsers/browser", browser_changed1_cb, hbox); gtk_entry_set_text(GTK_ENTRY(entry), purple_prefs_get_string(PIDGIN_PREFS_ROOT "/browsers/manual_command")); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(manual_browser_set), NULL); hbox = pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("_Manual:\n(%s for URL)"), sg, entry, TRUE, NULL); if (strcmp(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/browsers/browser"), "custom")) gtk_widget_set_sensitive(hbox, FALSE); purple_prefs_connect_callback(prefs, PIDGIN_PREFS_ROOT "/browsers/browser", browser_changed2_cb, hbox); gtk_widget_show_all(ret); GtkWidget *ret = NULL, *vbox = NULL, *hbox = NULL; GtkWidget *table = NULL, *entry = NULL, *label = NULL, *proxy_button = NULL; GtkWidget *prefs_proxy_frame = NULL; PurpleProxyInfo *proxy_info; ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE); gtk_container_set_border_width(GTK_CONTAINER(ret), PIDGIN_HIG_BORDER); vbox = pidgin_make_frame(ret, _("Proxy Server")); prefs_proxy_frame = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); if(purple_running_gnome()) { hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); label = gtk_label_new(_("Proxy preferences are configured in GNOME preferences")); gtk_container_add(GTK_CONTAINER(vbox), hbox); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_container_add(GTK_CONTAINER(vbox), hbox); path = g_find_program_in_path("gnome-network-properties"); path = g_find_program_in_path("gnome-network-preferences"); path = g_find_program_in_path("gnome-control-center"); char *tmp = g_strdup_printf("%s network", path); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<b>Proxy configuration program was not found.</b>")); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); proxy_button = gtk_button_new_with_mnemonic(_("Configure _Proxy")); g_signal_connect(G_OBJECT(proxy_button), "clicked", G_CALLBACK(proxy_button_clicked_cb), gtk_box_pack_start(GTK_BOX(hbox), proxy_button, FALSE, FALSE, 0); /* NOTE: path leaks, but only when the prefs window is destroyed, gtk_widget_show_all(ret); GtkWidget *prefs_proxy_subframe = gtk_vbox_new(FALSE, 0); /* This is a global option that affects SOCKS4 usage even with * account-specific proxy settings */ pidgin_prefs_checkbox(_("Use remote _DNS with SOCKS4 proxies"), "/purple/proxy/socks4_remotedns", prefs_proxy_frame); gtk_box_pack_start(GTK_BOX(vbox), prefs_proxy_frame, 0, 0, 0); pidgin_prefs_dropdown(prefs_proxy_frame, _("Proxy t_ype:"), PURPLE_PREF_STRING, _("Tor/Privacy (SOCKS5)"), "tor", _("Use Environmental Settings"), "envvar", gtk_box_pack_start(GTK_BOX(prefs_proxy_frame), prefs_proxy_subframe, 0, 0, 0); proxy_info = purple_global_proxy_get_info(); gtk_widget_show_all(ret); purple_prefs_connect_callback(prefs, "/purple/proxy/type", proxy_changed_cb, prefs_proxy_subframe); table = gtk_table_new(4, 2, FALSE); gtk_container_set_border_width(GTK_CONTAINER(table), 0); gtk_table_set_col_spacings(GTK_TABLE(table), 5); gtk_table_set_row_spacings(GTK_TABLE(table), 10); gtk_container_add(GTK_CONTAINER(prefs_proxy_subframe), table); label = gtk_label_new_with_mnemonic(_("_Host:")); gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0); gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry); gtk_table_attach(GTK_TABLE(table), entry, 1, 2, 0, 1, GTK_FILL, 0, 0, 0); g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(proxy_print_option), (void *)PROXYHOST); if (proxy_info != NULL && purple_proxy_info_get_host(proxy_info)) gtk_entry_set_text(GTK_ENTRY(entry), purple_proxy_info_get_host(proxy_info)); hbox = gtk_hbox_new(TRUE, 5); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); pidgin_set_accessible_label (entry, label); label = gtk_label_new_with_mnemonic(_("P_ort:")); gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 2, 3, 0, 1, GTK_FILL, 0, 0, 0); entry = gtk_spin_button_new_with_range(0, 65535, 1); gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry); gtk_table_attach(GTK_TABLE(table), entry, 3, 4, 0, 1, GTK_FILL, 0, 0, 0); g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(proxy_print_option), (void *)PROXYPORT); if (proxy_info != NULL && purple_proxy_info_get_port(proxy_info) != 0) { gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry), purple_proxy_info_get_port(proxy_info)); pidgin_set_accessible_label (entry, label); label = gtk_label_new_with_mnemonic(_("User_name:")); gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2, GTK_FILL, 0, 0, 0); gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry); gtk_table_attach(GTK_TABLE(table), entry, 1, 2, 1, 2, GTK_FILL, 0, 0, 0); g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(proxy_print_option), (void *)PROXYUSER); if (proxy_info != NULL && purple_proxy_info_get_username(proxy_info) != NULL) gtk_entry_set_text(GTK_ENTRY(entry), purple_proxy_info_get_username(proxy_info)); hbox = gtk_hbox_new(TRUE, 5); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); pidgin_set_accessible_label (entry, label); label = gtk_label_new_with_mnemonic(_("Pa_ssword:")); gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 2, 3, 1, 2, GTK_FILL, 0, 0, 0); gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry); gtk_table_attach(GTK_TABLE(table), entry, 3, 4, 1, 2, GTK_FILL , 0, 0, 0); gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE); #if !GTK_CHECK_VERSION(2,16,0) if (gtk_entry_get_invisible_char(GTK_ENTRY(entry)) == '*') gtk_entry_set_invisible_char(GTK_ENTRY(entry), PIDGIN_INVISIBLE_CHAR); #endif /* Less than GTK+ 2.16 */ g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(proxy_print_option), (void *)PROXYPASS); if (proxy_info != NULL && purple_proxy_info_get_password(proxy_info) != NULL) gtk_entry_set_text(GTK_ENTRY(entry), purple_proxy_info_get_password(proxy_info)); pidgin_set_accessible_label (entry, label); proxy_changed_cb("/purple/proxy/type", PURPLE_PREF_STRING, purple_prefs_get_string("/purple/proxy/type"), ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE); gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER); vbox = pidgin_make_frame (ret, _("Logging")); names = purple_log_logger_get_options(); pidgin_prefs_dropdown_from_list(vbox, _("Log _format:"), PURPLE_PREF_STRING, "/purple/logging/format", names); pidgin_prefs_checkbox(_("Log all _instant messages"), "/purple/logging/log_ims", vbox); pidgin_prefs_checkbox(_("Log all c_hats"), "/purple/logging/log_chats", vbox); pidgin_prefs_checkbox(_("Log all _status changes to system log"), "/purple/logging/log_system", vbox); gtk_widget_show_all(ret); sound_cmd_yeah(GtkEntry *entry, gpointer d) purple_prefs_set_path(PIDGIN_PREFS_ROOT "/sound/command", gtk_entry_get_text(GTK_ENTRY(entry))); sound_changed1_cb(const char *name, PurplePrefType type, gconstpointer value, gpointer data) const char *method = value; gtk_widget_set_sensitive(hbox, !strcmp(method, "custom")); sound_changed2_cb(const char *name, PurplePrefType type, gconstpointer value, gpointer data) const char *method = value; gtk_widget_set_sensitive(vbox, strcmp(method, "none")); sound_changed3_cb(const char *name, PurplePrefType type, gconstpointer value, gpointer data) const char *method = value; gtk_widget_set_sensitive(hbox, !strcmp(method, "automatic") || !strcmp(method, "alsa") || #endif /* USE_GSTREAMER */ event_toggled(GtkCellRendererToggle *cell, gchar *pth, gpointer data) GtkTreeModel *model = (GtkTreeModel *)data; GtkTreePath *path = gtk_tree_path_new_from_string(pth); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_model_get (model, &iter, purple_prefs_set_bool(pref, !gtk_cell_renderer_toggle_get_active(cell)); gtk_list_store_set(GTK_LIST_STORE (model), &iter, 0, !gtk_cell_renderer_toggle_get_active(cell), gtk_tree_path_free(path); test_sound(GtkWidget *button, gpointer i_am_NULL) pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/enabled/%s", pidgin_sound_get_event_option(sound_row_sel)); temp_enabled = purple_prefs_get_bool(pref); temp_mute = purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/sound/mute"); if (!temp_enabled) purple_prefs_set_bool(pref, TRUE); if (temp_mute) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/sound/mute", FALSE); purple_sound_play_event(sound_row_sel, NULL); if (!temp_enabled) purple_prefs_set_bool(pref, FALSE); if (temp_mute) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/sound/mute", TRUE); * Resets a sound file back to default. reset_sound(GtkWidget *button, gpointer i_am_also_NULL) pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/file/%s", pidgin_sound_get_event_option(sound_row_sel)); purple_prefs_set_path(pref, ""); gtk_entry_set_text(GTK_ENTRY(sound_entry), _("(default)")); pref_sound_generate_markup(); sound_chosen_cb(void *user_data, const char *filename) sound = GPOINTER_TO_INT(user_data); /* Set it -- and forget it */ pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/file/%s", pidgin_sound_get_event_option(sound)); purple_prefs_set_path(pref, filename); * If the sound we just changed is still the currently selected * sound, then update the box showing the file name. if (sound == sound_row_sel) gtk_entry_set_text(GTK_ENTRY(sound_entry), filename); pref_sound_generate_markup(); select_sound(GtkWidget *button, gpointer being_NULL_is_fun) pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/file/%s", pidgin_sound_get_event_option(sound_row_sel)); filename = purple_prefs_get_path(pref); purple_request_file(prefs, _("Sound Selection"), filename, FALSE, G_CALLBACK(sound_chosen_cb), NULL, GINT_TO_POINTER(sound_row_sel)); prefs_sound_volume_format(GtkScale *scale, gdouble val) return g_strdup_printf(_("Quietest")); return g_strdup_printf(_("Quieter")); return g_strdup_printf(_("Quiet")); return g_strdup_printf(_("Normal")); return g_strdup_printf(_("Loud")); return g_strdup_printf(_("Louder")); return g_strdup_printf(_("Loudest")); prefs_sound_volume_changed(GtkRange *range) int val = (int)gtk_range_get_value(GTK_RANGE(range)); purple_prefs_set_int(PIDGIN_PREFS_ROOT "/sound/volume", val); prefs_sound_sel(GtkTreeSelection *sel, GtkTreeModel *model) if (! gtk_tree_selection_get_selected (sel, &model, &iter)) gtk_tree_model_get_value (model, &iter, 3, &val); sound_row_sel = g_value_get_uint(&val); pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/file/%s", pidgin_sound_get_event_option(sound_row_sel)); file = purple_prefs_get_path(pref); gtk_entry_set_text(GTK_ENTRY(sound_entry), (file && *file != '\0') ? file : _("(default)")); pref_sound_generate_markup(); mute_changed_cb(const char *pref_name, PurplePrefType pref_type, GtkToggleButton *button = data; gboolean muted = GPOINTER_TO_INT(val); g_return_if_fail(!strcmp (pref_name, PIDGIN_PREFS_ROOT "/sound/mute")); /* Block the handler that re-sets the preference. */ g_signal_handlers_block_matched(button, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, (gpointer)pref_name); gtk_toggle_button_set_active (button, muted); g_signal_handlers_unblock_matched(button, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, (gpointer)pref_name); GtkWidget *vbox, *vbox2, *sw, *button; GtkListStore *event_store; ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE); gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER); sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); vbox2 = pidgin_make_frame(ret, _("Sound Options")); vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(vbox2), vbox, FALSE, FALSE, 0); dd = pidgin_prefs_dropdown(vbox2, _("_Method:"), PURPLE_PREF_STRING, PIDGIN_PREFS_ROOT "/sound/method", _("Console beep"), "beep", _("Automatic"), "automatic", gtk_size_group_add_widget(sg, dd); gtk_misc_set_alignment(GTK_MISC(dd), 0, 0.5); gtk_editable_set_editable(GTK_EDITABLE(entry), TRUE); cmd = purple_prefs_get_path(PIDGIN_PREFS_ROOT "/sound/command"); gtk_entry_set_text(GTK_ENTRY(entry), cmd); g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(sound_cmd_yeah), NULL); hbox = pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("Sound c_ommand:\n(%s for filename)"), sg, entry, TRUE, NULL); purple_prefs_connect_callback(prefs, PIDGIN_PREFS_ROOT "/sound/method", sound_changed1_cb, hbox); gtk_widget_set_sensitive(hbox, !strcmp(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/sound/method"), button = pidgin_prefs_checkbox(_("M_ute sounds"), PIDGIN_PREFS_ROOT "/sound/mute", vbox); purple_prefs_connect_callback(prefs, PIDGIN_PREFS_ROOT "/sound/mute", mute_changed_cb, button); pidgin_prefs_checkbox(_("Sounds when conversation has _focus"), PIDGIN_PREFS_ROOT "/sound/conv_focus", vbox); pidgin_prefs_dropdown(vbox, _("_Enable sounds:"), PURPLE_PREF_INT, "/purple/sound/while_status", _("Only when available"), 1, _("Only when not available"), 2, sw = gtk_hscale_new_with_range(0.0, 100.0, 5.0); gtk_range_set_increments(GTK_RANGE(sw), 5.0, 25.0); gtk_range_set_value(GTK_RANGE(sw), purple_prefs_get_int(PIDGIN_PREFS_ROOT "/sound/volume")); g_signal_connect (G_OBJECT (sw), "format-value", G_CALLBACK (prefs_sound_volume_format), g_signal_connect (G_OBJECT (sw), "value-changed", G_CALLBACK (prefs_sound_volume_changed), hbox = pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("V_olume:"), NULL, sw, TRUE, NULL); purple_prefs_connect_callback(prefs, PIDGIN_PREFS_ROOT "/sound/method", sound_changed3_cb, hbox); sound_changed3_cb(PIDGIN_PREFS_ROOT "/sound/method", PURPLE_PREF_STRING, purple_prefs_get_string(PIDGIN_PREFS_ROOT "/sound/method"), hbox); gtk_widget_set_sensitive(vbox, strcmp(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/sound/method"), "none")); purple_prefs_connect_callback(prefs, PIDGIN_PREFS_ROOT "/sound/method", sound_changed2_cb, vbox); vbox = pidgin_make_frame(ret, _("Sound Events")); /* The following is an ugly hack to make the frame expand so the * sound events list is big enough to be usable */ gtk_box_set_child_packing(GTK_BOX(vbox->parent), vbox, TRUE, TRUE, 0, gtk_box_set_child_packing(GTK_BOX(vbox->parent->parent), vbox->parent, TRUE, TRUE, 0, GTK_PACK_START); gtk_box_set_child_packing(GTK_BOX(vbox->parent->parent->parent), vbox->parent->parent, TRUE, TRUE, 0, GTK_PACK_START); event_store = gtk_list_store_new (4, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT); for (j=0; j < PURPLE_NUM_SOUNDS; j++) { char *pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/enabled/%s", pidgin_sound_get_event_option(j)); const char *label = pidgin_sound_get_event_label(j); gtk_list_store_append (event_store, &iter); gtk_list_store_set(event_store, &iter, 0, purple_prefs_get_bool(pref), event_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL(event_store)); rend = gtk_cell_renderer_toggle_new(); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (event_view)); g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (prefs_sound_sel), g_signal_connect (G_OBJECT(rend), "toggled", G_CALLBACK(event_toggled), event_store); path = gtk_tree_path_new_first(); gtk_tree_selection_select_path(sel, path); gtk_tree_path_free(path); col = gtk_tree_view_column_new_with_attributes (_("Play"), gtk_tree_view_append_column (GTK_TREE_VIEW(event_view), col); rend = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (_("Event"), gtk_tree_view_append_column (GTK_TREE_VIEW(event_view), col); g_object_unref(G_OBJECT(event_store)); gtk_box_pack_start(GTK_BOX(vbox), pidgin_make_scrollable(event_view, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC, GTK_SHADOW_IN, -1, 100), hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); sound_entry = gtk_entry_new(); pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/file/%s", pidgin_sound_get_event_option(0)); file = purple_prefs_get_path(pref); gtk_entry_set_text(GTK_ENTRY(sound_entry), (file && *file != '\0') ? file : _("(default)")); gtk_editable_set_editable(GTK_EDITABLE(sound_entry), FALSE); gtk_box_pack_start(GTK_BOX(hbox), sound_entry, FALSE, FALSE, PIDGIN_HIG_BOX_SPACE); button = gtk_button_new_with_mnemonic(_("_Browse...")); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(select_sound), NULL); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 1); button = gtk_button_new_with_mnemonic(_("Pre_view")); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(test_sound), NULL); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 1); button = gtk_button_new_with_mnemonic(_("_Reset")); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(reset_sound), NULL); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 1); gtk_widget_show_all(ret); set_idle_away(PurpleSavedStatus *status) purple_prefs_set_int("/purple/savedstatus/idleaway", purple_savedstatus_get_creation_time(status)); set_startupstatus(PurpleSavedStatus *status) purple_prefs_set_int("/purple/savedstatus/startup", purple_savedstatus_get_creation_time(status)); ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE); gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER); sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); vbox = pidgin_make_frame(ret, _("Idle")); dd = pidgin_prefs_dropdown(vbox, _("_Report idle time:"), PURPLE_PREF_STRING, "/purple/away/idle_reporting", _("From last sent message"), "purple", #if defined(USE_SCREENSAVER) || defined(HAVE_IOKIT) _("Based on keyboard or mouse use"), "system", gtk_size_group_add_widget(sg, dd); gtk_misc_set_alignment(GTK_MISC(dd), 0, 0.5); select = pidgin_prefs_labeled_spin_button(vbox, _("_Minutes before becoming idle:"), "/purple/away/mins_before_away", hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); button = pidgin_prefs_checkbox(_("Change to this status when _idle:"), "/purple/away/away_when_idle", hbox); gtk_size_group_add_widget(sg, button); /* TODO: Show something useful if we don't have any saved statuses. */ menu = pidgin_status_menu(purple_savedstatus_get_idleaway(), G_CALLBACK(set_idle_away)); gtk_size_group_add_widget(sg, menu); gtk_box_pack_start(GTK_BOX(hbox), menu, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(pidgin_toggle_sensitive), menu); if(!purple_prefs_get_bool("/purple/away/away_when_idle")) gtk_widget_set_sensitive(GTK_WIDGET(menu), FALSE); vbox = pidgin_make_frame(ret, _("Away")); dd = pidgin_prefs_dropdown(vbox, _("_Auto-reply:"), PURPLE_PREF_STRING, "/purple/away/auto_reply", _("When both away and idle"), "awayidle", gtk_size_group_add_widget(sg, dd); gtk_misc_set_alignment(GTK_MISC(dd), 0, 0.5); /* Signon status stuff */ vbox = pidgin_make_frame(ret, _("Status at Startup")); button = pidgin_prefs_checkbox(_("Use status from last _exit at startup"), "/purple/savedstatus/startup_current_status", vbox); gtk_size_group_add_widget(sg, button); /* TODO: Show something useful if we don't have any saved statuses. */ menu = pidgin_status_menu(purple_savedstatus_get_startup(), G_CALLBACK(set_startupstatus)); gtk_size_group_add_widget(sg, menu); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(pidgin_toggle_sensitive), menu); pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("Status to a_pply at startup:"), sg, menu, TRUE, &label); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(pidgin_toggle_sensitive), label); if(purple_prefs_get_bool("/purple/savedstatus/startup_current_status")) { gtk_widget_set_sensitive(GTK_WIDGET(menu), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(label), FALSE); gtk_widget_show_all(ret); prefs_notebook_add_page(const char *text, GtkWidget *page, int ind) return gtk_notebook_append_page(GTK_NOTEBOOK(prefsnotebook), page, gtk_label_new(text)); prefs_notebook_init(void) prefs_notebook_add_page(_("Interface"), interface_page(), notebook_page++); /* We use the registered default browser in windows */ /* if the user is running Mac OS X, hide the browsers tab */ if(purple_running_osx() == FALSE) prefs_notebook_add_page(_("Browser"), browser_page(), notebook_page++); prefs_notebook_add_page(_("Conversations"), conv_page(), notebook_page++); prefs_notebook_add_page(_("Logging"), logging_page(), notebook_page++); prefs_notebook_add_page(_("Network"), network_page(), notebook_page++); prefs_notebook_add_page(_("Proxy"), proxy_page(), notebook_page++); prefs_notebook_add_page(_("Sounds"), sound_page(), notebook_page++); prefs_notebook_add_page(_("Status / Idle"), away_page(), notebook_page++); prefs_notebook_add_page(_("Themes"), theme_page(), notebook_page++); gtk_window_present(GTK_WINDOW(prefs)); /* copy the preferences to tmp values... * I liked "take affect immediately" Oh well :-( */ /* (that should have been "effect," right?) */ /* Back to instant-apply! I win! BU-HAHAHA! */ prefs = pidgin_create_dialog(_("Preferences"), PIDGIN_HIG_BORDER, "preferences", FALSE); g_signal_connect(G_OBJECT(prefs), "destroy", G_CALLBACK(delete_prefs), NULL); vbox = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(prefs), FALSE, PIDGIN_HIG_BORDER); prefsnotebook = notebook = gtk_notebook_new (); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_LEFT); gtk_box_pack_start(GTK_BOX (vbox), notebook, FALSE, FALSE, 0); gtk_widget_show(prefsnotebook); button = pidgin_dialog_add_button(GTK_DIALOG(prefs), GTK_STOCK_CLOSE, NULL, NULL); g_signal_connect_swapped(G_OBJECT(button), "clicked", G_CALLBACK(gtk_widget_destroy), prefs); /* Refresh the list of themes before showing the preferences window */ set_bool_pref(GtkWidget *w, const char *key) purple_prefs_set_bool(key, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))); pidgin_prefs_checkbox(const char *text, const char *key, GtkWidget *page) button = gtk_check_button_new_with_mnemonic(text); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), purple_prefs_get_bool(key)); gtk_box_pack_start(GTK_BOX(page), button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(set_bool_pref), (char *)key); smiley_theme_pref_cb(const char *name, PurplePrefType type, gconstpointer value, gpointer data) const char *themename = value; for (themes = smiley_themes; themes; themes = themes->next) { struct smiley_theme *smile = themes->data; if (smile->name && strcmp(themename, smile->name) == 0) { pidgin_themes_load_smiley_theme(smile->path, TRUE); purple_prefs_add_none(PIDGIN_PREFS_ROOT ""); purple_prefs_add_none("/plugins/gtk"); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/browsers"); purple_prefs_add_int(PIDGIN_PREFS_ROOT "/browsers/place", PIDGIN_BROWSER_DEFAULT); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/browsers/manual_command", ""); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/browsers/browser", "xdg-open"); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/plugins"); purple_prefs_add_path_list(PIDGIN_PREFS_ROOT "/plugins/loaded", NULL); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/filelocations"); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/filelocations/last_save_folder", ""); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/filelocations/last_open_folder", ""); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/filelocations/last_icon_folder", ""); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/smileys"); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/smileys/theme", "Default"); purple_prefs_connect_callback(&prefs, PIDGIN_PREFS_ROOT "/smileys/theme", smiley_theme_pref_cb, NULL); pidgin_prefs_update_old(); pidgin_prefs_update_old(void) purple_prefs_rename("/gaim/gtk", PIDGIN_PREFS_ROOT); /* Rename some old prefs */ purple_prefs_rename(PIDGIN_PREFS_ROOT "/logging/log_ims", "/purple/logging/log_ims"); purple_prefs_rename(PIDGIN_PREFS_ROOT "/logging/log_chats", "/purple/logging/log_chats"); purple_prefs_rename("/purple/conversations/placement", PIDGIN_PREFS_ROOT "/conversations/placement"); purple_prefs_rename(PIDGIN_PREFS_ROOT "/debug/timestamps", "/purple/debug/timestamps"); purple_prefs_rename(PIDGIN_PREFS_ROOT "/conversations/im/raise_on_events", "/plugins/gtk/X11/notify/method_raise"); purple_prefs_rename_boolean_toggle(PIDGIN_PREFS_ROOT "/conversations/ignore_colors", PIDGIN_PREFS_ROOT "/conversations/show_incoming_formatting"); * this path pref changed to a string, so migrate. I know this will break * things for and confuse users that use multiple versions with the same * config directory, but I'm not inclined to want to deal with that at the if((str = purple_prefs_get_path(PIDGIN_PREFS_ROOT "/browsers/command")) != NULL) { purple_prefs_set_string(PIDGIN_PREFS_ROOT "/browsers/manual_command", str); purple_prefs_remove(PIDGIN_PREFS_ROOT "/browsers/command"); /* this string pref moved into the core, try to be friendly */ purple_prefs_rename(PIDGIN_PREFS_ROOT "/idle/reporting_method", "/purple/away/idle_reporting"); if ((str = purple_prefs_get_string("/purple/away/idle_reporting")) && strcmp(str, "gaim") == 0) purple_prefs_set_string("/purple/away/idle_reporting", "purple"); /* Remove some no-longer-used prefs */ purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/auto_expand_contacts"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/button_style"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/grey_idle_buddies"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/raise_on_events"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/show_group_count"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/show_warning_level"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/button_type"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/ctrl_enter_sends"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/enter_sends"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/escape_closes"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/html_shortcuts"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/icons_on_tabs"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/send_formatting"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/show_smileys"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/show_urls_as_links"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/smiley_shortcuts"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/use_custom_bgcolor"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/use_custom_fgcolor"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/use_custom_font"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/use_custom_size"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/chat/old_tab_complete"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/chat/tab_completion"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/im/hide_on_send"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/chat/color_nicks"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/chat/raise_on_events"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/ignore_fonts"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/ignore_font_sizes"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/passthrough_unknown_commands"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/idle"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/logging/individual_logs"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/sound/signon"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/sound/silent_signon"); /* Convert old queuing prefs to hide_new 3-way pref. */ if (purple_prefs_exists("/plugins/gtk/docklet/queue_messages") && purple_prefs_get_bool("/plugins/gtk/docklet/queue_messages")) purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/im/hide_new", "always"); else if (purple_prefs_exists(PIDGIN_PREFS_ROOT "/away/queue_messages") && purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/away/queue_messages")) purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/im/hide_new", "away"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/away/queue_messages"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/away"); purple_prefs_remove("/plugins/gtk/docklet/queue_messages"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/chat/default_width"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/chat/default_height"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/im/default_width"); purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/im/default_height"); purple_prefs_rename(PIDGIN_PREFS_ROOT "/conversations/x", PIDGIN_PREFS_ROOT "/conversations/im/x"); purple_prefs_rename(PIDGIN_PREFS_ROOT "/conversations/y", PIDGIN_PREFS_ROOT "/conversations/im/y");