* @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 "gtkconv-theme.h" #include "gtksavedstatuses.h" #include "gtkstatus-icon-theme.h" #if GST_CHECK_VERSION(1,0,0) #include <gst/video/videooverlay.h> #include <gst/interfaces/xoverlay.h> #include <gst/interfaces/propertyprobe.h> #ifdef GDK_WINDOWING_WIN32 #include <gdk/gdkwin32.h> #ifdef GDK_WINDOWING_QUARTZ #include <gdk/gdkquartz.h> #define PREFS_OPTIMAL_ICON_SIZE 32 #define PREFS_MAX_DOWNLOADED_THEME_SIZE 26214400 static GtkWidget *prefs = NULL; static GtkWidget *prefsnotebook = NULL; static int notebook_page = 0; static GtkWidget *sample_webview = NULL; static GtkWidget *prefs_sound_themes_combo_box; static GtkWidget *prefs_blist_themes_combo_box; static GtkWidget *prefs_conv_themes_combo_box; static GtkWidget *prefs_conv_variants_combo_box; static GtkWidget *prefs_status_themes_combo_box; static GtkWidget *prefs_smiley_themes_combo_box; static PurpleHttpConnection *prefs_conv_themes_running_request = NULL; static GtkWidget *keyring_page_instance = NULL; static GtkComboBox *keyring_combo = NULL; static GtkBox *keyring_vbox = NULL; static PurpleRequestFields *keyring_settings = NULL; static GList *keyring_settings_fields = NULL; static GtkWidget *keyring_apply = NULL; /* 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_conv_themes; static GtkListStore *prefs_conv_variants; static GtkListStore *prefs_status_icon_themes; static GtkListStore *prefs_smiley_themes; static const gchar *AUDIO_SRC_PLUGINS[] = { "directsoundsrc", "DirectSound", "pulsesrc", "PulseAudio", /* "audiotestsrc wave=silence", "Silence", */ "audiotestsrc", N_("Test Sound"), static const gchar *AUDIO_SINK_PLUGINS[] = { "directsoundsink", "DirectSound", /* "gconfaudiosink", "GConf", */ "pulsesink", "PulseAudio", static const gchar *VIDEO_SRC_PLUGINS[] = { "videodisabledsrc", N_("Disabled"), "videotestsrc", N_("Test Input"), "dshowvideosrc","DirectDraw", "ksvideosrc", "KS Video", "v4l2src", "Video4Linux2", "v4lmjpegsrc", "Video4Linux MJPEG", static const gchar *VIDEO_SINK_PLUGINS[] = { /* "aasink", "AALib", Didn't work for me */ "directdrawsink", "DirectDraw", /* "gconfvideosink", "GConf", */ "ximagesink", "X Window System", "xvimagesink", "X Window System (Xv)", static GstElement *voice_pipeline; static GstElement *video_pipeline; 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(gtk_adjustment_new(val, min, max, 1, 1, 0)); spin = gtk_spin_button_new(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); /* TODO: Maybe move this up somewheres... */ typedef void (*PidginPrefsDropdownCallback)(GtkComboBox *combo_box, dropdown_set(GtkComboBox *combo_box, gpointer _cb) PidginPrefsDropdownCallback cb = _cb; GtkTreeModel *tree_model; tree_model = gtk_combo_box_get_model(combo_box); if (!gtk_combo_box_get_active_iter(combo_box, &iter)) active.type = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(combo_box), g_object_set_data(G_OBJECT(combo_box), "previously_active", g_object_get_data(G_OBJECT(combo_box), "current_active")); g_object_set_data(G_OBJECT(combo_box), "current_active", GINT_TO_POINTER(gtk_combo_box_get_active(combo_box))); if (active.type == PURPLE_PREF_INT) { gtk_tree_model_get(tree_model, &iter, PREF_DROPDOWN_VALUE, &active.value.integer, -1); else if (active.type == PURPLE_PREF_STRING) { gtk_tree_model_get(tree_model, &iter, PREF_DROPDOWN_VALUE, &active.value.string, -1); else if (active.type == PURPLE_PREF_BOOLEAN) { gtk_tree_model_get(tree_model, &iter, PREF_DROPDOWN_VALUE, &active.value.boolean, -1); static void pidgin_prefs_dropdown_revert_active(GtkComboBox *combo_box) g_return_if_fail(combo_box != NULL); previously_active = GPOINTER_TO_INT(g_object_get_data( G_OBJECT(combo_box), "previously_active")); g_object_set_data(G_OBJECT(combo_box), "current_active", GINT_TO_POINTER(previously_active)); gtk_combo_box_set_active(combo_box, previously_active); pidgin_prefs_dropdown_from_list_with_cb(GtkWidget *box, const gchar *title, GtkComboBox **dropdown_out, GList *menuitems, PidginPrefValue initial, PidginPrefsDropdownCallback cb) GtkListStore *store = NULL; GtkCellRenderer *renderer; g_return_val_if_fail(menuitems != NULL, NULL); if (initial.type == PURPLE_PREF_INT) { store = gtk_list_store_new(PREF_DROPDOWN_COUNT, G_TYPE_STRING, G_TYPE_INT); } else if (initial.type == PURPLE_PREF_STRING) { store = gtk_list_store_new(PREF_DROPDOWN_COUNT, G_TYPE_STRING, G_TYPE_STRING); } else if (initial.type == PURPLE_PREF_BOOLEAN) { store = gtk_list_store_new(PREF_DROPDOWN_COUNT, G_TYPE_STRING, G_TYPE_BOOLEAN); dropdown = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)); if (dropdown_out != NULL) *dropdown_out = GTK_COMBO_BOX(dropdown); g_object_set_data(G_OBJECT(dropdown), "type", GINT_TO_POINTER(initial.type)); while (menuitems != NULL && (text = (char *)menuitems->data) != NULL) { const char *str_value = NULL; gboolean bool_value = FALSE; menuitems = g_list_next(menuitems); g_return_val_if_fail(menuitems != NULL, NULL); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, PREF_DROPDOWN_TEXT, text, if (initial.type == PURPLE_PREF_INT) { int_value = GPOINTER_TO_INT(menuitems->data); gtk_list_store_set(store, &iter, PREF_DROPDOWN_VALUE, int_value, else if (initial.type == PURPLE_PREF_STRING) { str_value = (const char *)menuitems->data; gtk_list_store_set(store, &iter, PREF_DROPDOWN_VALUE, str_value, else if (initial.type == PURPLE_PREF_BOOLEAN) { bool_value = (gboolean)GPOINTER_TO_INT(menuitems->data); gtk_list_store_set(store, &iter, PREF_DROPDOWN_VALUE, bool_value, if ((initial.type == PURPLE_PREF_INT && initial.value.integer == int_value) || (initial.type == PURPLE_PREF_STRING && !g_strcmp0(initial.value.string, str_value)) || (initial.type == PURPLE_PREF_BOOLEAN && (initial.value.boolean == bool_value))) { menuitems = g_list_next(menuitems); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(dropdown), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(dropdown), renderer, gtk_combo_box_set_active_iter(GTK_COMBO_BOX(dropdown), &active); current_active = GINT_TO_POINTER(gtk_combo_box_get_active(GTK_COMBO_BOX( g_object_set_data(G_OBJECT(dropdown), "current_active", current_active); g_object_set_data(G_OBJECT(dropdown), "previously_active", current_active); g_signal_connect(G_OBJECT(dropdown), "changed", G_CALLBACK(dropdown_set), cb); pidgin_add_widget_to_vbox(GTK_BOX(box), title, NULL, dropdown, FALSE, &label); pidgin_prefs_dropdown_from_list_cb(GtkComboBox *combo_box, key = g_object_get_data(G_OBJECT(combo_box), "key"); if (value.type == PURPLE_PREF_INT) { purple_prefs_set_int(key, value.value.integer); } else if (value.type == PURPLE_PREF_STRING) { purple_prefs_set_string(key, value.value.string); } else if (value.type == PURPLE_PREF_BOOLEAN) { purple_prefs_set_bool(key, value.value.boolean); pidgin_prefs_dropdown_from_list(GtkWidget *box, const gchar *title, PurplePrefType type, const char *key, GList *menuitems) GtkComboBox *dropdown = NULL; if (type == PURPLE_PREF_INT) { initial.value.integer = purple_prefs_get_int(key); } else if (type == PURPLE_PREF_STRING) { initial.value.string = purple_prefs_get_string(key); } else if (type == PURPLE_PREF_BOOLEAN) { initial.value.boolean = purple_prefs_get_bool(key); g_return_val_if_reached(NULL); label = pidgin_prefs_dropdown_from_list_with_cb(box, title, &dropdown, menuitems, initial, pidgin_prefs_dropdown_from_list_cb); g_object_set_data(G_OBJECT(dropdown), "key", (gpointer)key); 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, static void keyring_page_cleanup(void); delete_prefs(GtkWidget *asdf, void *gdsa) /* Cancel HTTP requests */ purple_http_conn_cancel(prefs_conv_themes_running_request); prefs_conv_themes_running_request = NULL; /* Close any "select sound" request dialogs */ purple_request_close_with_handle(prefs); purple_notify_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_conv_themes_combo_box = NULL; prefs_conv_variants_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)); } else if (PIDGIN_IS_CONV_THEME(theme)) { /* No image available? */ name = purple_theme_get_name(theme); /* No author available */ /* No description available */ markup = get_theme_markup(name, FALSE, NULL, NULL); gtk_list_store_append(prefs_conv_themes, &iter); gtk_list_store_set(prefs_conv_themes, &iter, 1, markup, 2, name, -1); 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); /* conversation themes */ gtk_list_store_clear(prefs_conv_themes); gtk_list_store_append(prefs_conv_themes, &iter); tmp = get_theme_markup(_("Default"), FALSE, _("Penguin Pimps"), _("The default Pidgin conversation theme")); gtk_list_store_set(prefs_conv_themes, &iter, 0, pixbuf, 1, tmp, 2, "", -1); /* conversation theme variants */ gtk_list_store_clear(prefs_conv_variants); 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_conv_themes_combo_box, prefs_conv_themes, purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/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_conv_themes = gtk_list_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING); prefs_conv_variants = gtk_list_store_new(1, 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); * Attempt to load the given directory as a theme. If we are unable to * open the path as a theme then we recurse into path and attempt to * load each subdirectory that we encounter. * @param path A directory containing a theme. The theme could be at the * top level of this directory or in any subdirectory thereof. * @param type The type of theme to load. The loader for this theme type * will be used and this loader will determine what constitutes a * @return A new reference to a PurpleTheme. 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, NULL); if (!winpidgin_gz_untar(path, destdir)) { purple_notify_error(NULL, NULL, _("Theme failed to unpack."), NULL, 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 */ if (g_rename(purple_theme_get_dir(theme), theme_dest)) { purple_debug_error("gtkprefs", "Error renaming %s to %s: " "%s\n", purple_theme_get_dir(theme), theme_dest, /* something was wrong with the theme archive */ purple_notify_error(NULL, NULL, _("Theme failed to load."), NULL, 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); if (g_rename(purple_theme_get_dir(theme), theme_dest)) { purple_debug_error("gtkprefs", "Error renaming %s to %s: " "%s\n", purple_theme_get_dir(theme), theme_dest, if (g_remove(temp_path)) { purple_debug_error("gtkprefs", "Error removing %s: %s\n", temp_path, g_strerror(errno)); purple_notify_error(NULL, NULL, _("Theme failed to load."), NULL, NULL); purple_notify_error(NULL, NULL, _("Theme failed to copy."), NULL, NULL); theme_got_url(PurpleHttpConnection *http_conn, PurpleHttpResponse *response, struct theme_info *info = _info; g_assert(http_conn == prefs_conv_themes_running_request); prefs_conv_themes_running_request = NULL; if (!purple_http_response_is_successful(response)) { themedata = purple_http_response_get_data(response, &len); f = purple_mkstemp(&path, TRUE); wc = fwrite(themedata, len, 1, f); purple_debug_warning("theme_got_url", "Unable to write theme data.\n"); theme_install_theme(path, info); 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 *)gtk_selection_data_get_data(sd)); if ((gtk_selection_data_get_length(sd) >= 0) && (gtk_selection_data_get_format(sd) == 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) || !g_ascii_strncasecmp(name, "https://", 8)) { /* Oo, a web drag and drop. This is where things * will start to get interesting */ purple_http_conn_cancel(prefs_conv_themes_running_request); hr = purple_http_request_new(name); purple_http_request_set_max_len(hr, PREFS_MAX_DOWNLOADED_THEME_SIZE); prefs_conv_themes_running_request = purple_http_request( NULL, hr, theme_got_url, info); purple_http_request_unref(hr); 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); /* TODO: WebKit-ify smileys */ pidgin_themes_smiley_themeize(sample_webview); /* 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 conversation theme variant */ prefs_set_conv_variant_cb(GtkComboBox *combo_box, gpointer user_data) PidginConvTheme *theme = NULL; if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(prefs_conv_themes_combo_box), &iter)) { gtk_tree_model_get(GTK_TREE_MODEL(prefs_conv_themes), &iter, 2, &name, -1); theme = PIDGIN_CONV_THEME(purple_theme_manager_find_theme(name, "conversation")); theme = PIDGIN_CONV_THEME(pidgin_conversations_get_default_theme()); if (gtk_combo_box_get_active_iter(combo_box, &iter)) { gtk_tree_model_get(GTK_TREE_MODEL(prefs_conv_variants), &iter, 0, &name, -1); pidgin_conversation_theme_set_variant(theme, name); /* sets the current conversation theme */ prefs_set_conv_theme_cb(GtkComboBox *combo_box, gpointer user_data) if (gtk_combo_box_get_active_iter(combo_box, &iter)) { const char *current_variant; gtk_tree_model_get(GTK_TREE_MODEL(prefs_conv_themes), &iter, 2, &name, -1); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/theme", name); g_signal_handlers_block_by_func(prefs_conv_variants_combo_box, prefs_set_conv_variant_cb, NULL); /* Update list of variants */ gtk_list_store_clear(prefs_conv_variants); theme = PIDGIN_CONV_THEME(purple_theme_manager_find_theme(name, "conversation")); theme = PIDGIN_CONV_THEME(pidgin_conversations_get_default_theme()); current_variant = pidgin_conversation_theme_get_variant(theme); variants = pidgin_conversation_theme_get_variants(theme); for (; variants && current_variant; variants = g_list_next(variants)) { gtk_list_store_append(prefs_conv_variants, &iter); gtk_list_store_set(prefs_conv_variants, &iter, 0, variants->data, -1); if (g_str_equal(variants->data, current_variant)) { gtk_combo_box_set_active_iter(GTK_COMBO_BOX(prefs_conv_variants_combo_box), &iter); gtk_combo_box_set_active(GTK_COMBO_BOX(prefs_conv_variants_combo_box), 0); g_signal_handlers_unblock_by_func(prefs_conv_variants_combo_box, prefs_set_conv_variant_cb, NULL); /* 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_blist_get_buddy_list()); 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); add_child_theme_prefs_combo(GtkWidget *vbox, GtkSizeGroup *combo_sg, GtkSizeGroup *label_sg, GtkListStore *theme_store, GCallback combo_box_cb, gpointer combo_box_cb_user_data, GtkWidget *themesel_hbox; GtkCellRenderer *cell_rend; themesel_hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(vbox), themesel_hbox, FALSE, FALSE, 0); label = gtk_label_new(label_str); gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5); gtk_size_group_add_widget(label_sg, label); gtk_box_pack_start(GTK_BOX(themesel_hbox), label, FALSE, FALSE, 0); combo_box = gtk_combo_box_new_with_model(GTK_TREE_MODEL(theme_store)); 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, "text", 0, NULL); g_object_set(cell_rend, "ellipsize", PANGO_ELLIPSIZE_END, NULL); 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); 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"); /* Conversation Themes */ prefs_conv_themes_combo_box = add_theme_prefs_combo( vbox, combo_sg, label_sg, prefs_conv_themes, (GCallback)prefs_set_conv_theme_cb, NULL, _("Conversation Theme:"), PIDGIN_PREFS_ROOT "/conversations/theme", "conversation"); /* Conversation Theme Variants */ prefs_conv_variants_combo_box = add_child_theme_prefs_combo( vbox, combo_sg, label_sg, prefs_conv_variants, (GCallback)prefs_set_conv_variant_cb, NULL, _("\tVariant:")); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(prefs_conv_variants), 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(GtkWebView *webview, GtkWebViewButtons buttons, void *data) gboolean bold, italic, uline, strike; gtk_webview_get_current_format(webview, &bold, &italic, &uline, &strike); if (buttons & GTK_WEBVIEW_BOLD) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_bold", if (buttons & GTK_WEBVIEW_ITALIC) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_italic", if (buttons & GTK_WEBVIEW_UNDERLINE) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_underline", if (buttons & GTK_WEBVIEW_STRIKE) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_strike", if (buttons & GTK_WEBVIEW_GROW || buttons & GTK_WEBVIEW_SHRINK) purple_prefs_set_int(PIDGIN_PREFS_ROOT "/conversations/font_size", gtk_webview_get_current_fontsize(webview)); if (buttons & GTK_WEBVIEW_FACE) { char *face = gtk_webview_get_current_fontface(webview); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/font_face", face); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/font_face", ""); if (buttons & GTK_WEBVIEW_FORECOLOR) { char *color = gtk_webview_get_current_forecolor(webview); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/fgcolor", color); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/fgcolor", ""); if (buttons & GTK_WEBVIEW_BACKCOLOR) { char *color = gtk_webview_get_current_backcolor(webview); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/bgcolor", color); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/bgcolor", ""); formatting_clear_cb(GtkWebView *webview, 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_bool(PIDGIN_PREFS_ROOT "/conversations/send_strike", 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 "<Actions>/ConversationActions/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_webview, 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_dropdown(vbox, _("Chat notification:"), PURPLE_PREF_INT, PIDGIN_PREFS_ROOT "/conversations/notification_chat", _("On unseen events"), PIDGIN_UNSEEN_EVENT, _("On unseen text"), PIDGIN_UNSEEN_TEXT, _("On unseen text and the nick was said"), PIDGIN_UNSEEN_NICK, 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_webview(TRUE, &webview, NULL); gtk_widget_set_name(webview, "pidgin_prefs_font_webview"); gtk_widget_set_size_request(frame, 450, -1); gtk_webview_set_whole_buffer_formatting_only(GTK_WEBVIEW(webview), TRUE); gtk_webview_set_format_functions(GTK_WEBVIEW(webview), gtk_webview_append_html(GTK_WEBVIEW(webview), _("This is how your outgoing message text will " "appear when you use protocols that support " gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0); gtk_webview_setup_entry(GTK_WEBVIEW(webview), PURPLE_CONNECTION_FLAG_HTML | PURPLE_CONNECTION_FLAG_FORMATTING_WBFO); g_signal_connect_after(G_OBJECT(webview), "format-toggled", G_CALLBACK(formatting_toggle_cb), NULL); g_signal_connect_after(G_OBJECT(webview), "format-cleared", G_CALLBACK(formatting_clear_cb), NULL); sample_webview = webview; network_ip_changed(GtkEntry *entry, gpointer data) #if GTK_CHECK_VERSION(3,0,0) const gchar *text = gtk_entry_get_text(entry); GtkStyleContext *context = gtk_widget_get_style_context(GTK_WIDGET(entry)); if (purple_ip_address_is_valid(text)) { purple_network_set_public_ip(text); gtk_style_context_add_class(context, "good-ip"); gtk_style_context_remove_class(context, "bad-ip"); gtk_style_context_add_class(context, "bad-ip"); gtk_style_context_remove_class(context, "good-ip"); purple_network_set_public_ip(""); gtk_style_context_remove_class(context, "bad-ip"); gtk_style_context_remove_class(context, "good-ip"); 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, NULL); 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, NULL); 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; #if GTK_CHECK_VERSION(3,0,0) GtkStyleContext *context; "color: @error_fg_color;" "text-shadow: 0 1px @error_text_shadow;" "background-image: none;" "background-color: @error_bg_color;" "color: @question_fg_color;" "text-shadow: 0 1px @question_text_shadow;" "background-image: none;" "background-color: @success_color;" 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); #if GTK_CHECK_VERSION(3,0,0) ip_css = gtk_css_provider_new(); gtk_css_provider_load_from_data(ip_css, ip_style, -1, NULL); context = gtk_widget_get_style_context(entry); gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER(ip_css), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); 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_("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, _("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); 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); /*** keyring page *******************************************************/ keyring_page_settings_changed(GtkWidget *widget, gpointer _setting) PurpleRequestField *setting = _setting; PurpleRequestFieldType field_type; gtk_widget_set_sensitive(keyring_apply, TRUE); field_type = purple_request_field_get_type(setting); if (field_type == PURPLE_REQUEST_FIELD_BOOLEAN) { purple_request_field_bool_set_value(setting, gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(widget))); } else if (field_type == PURPLE_REQUEST_FIELD_STRING) { purple_request_field_string_set_value(setting, gtk_entry_get_text(GTK_ENTRY(widget))); } else if (field_type == PURPLE_REQUEST_FIELD_INTEGER) { purple_request_field_int_set_value(setting, gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(widget))); keyring_page_add_settings_field(GtkBox *vbox, PurpleRequestField *setting, GtkWidget *widget, *hbox; PurpleRequestFieldType field_type; label = purple_request_field_get_label(setting); field_type = purple_request_field_get_type(setting); if (field_type == PURPLE_REQUEST_FIELD_BOOLEAN) { widget = gtk_check_button_new_with_label(label); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), purple_request_field_bool_get_value(setting)); g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(keyring_page_settings_changed), setting); } else if (field_type == PURPLE_REQUEST_FIELD_STRING) { widget = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(widget), purple_request_field_string_get_value(setting)); if (purple_request_field_string_is_masked(setting)) gtk_entry_set_visibility(GTK_ENTRY(widget), FALSE); g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(keyring_page_settings_changed), setting); } else if (field_type == PURPLE_REQUEST_FIELD_INTEGER) { widget = gtk_spin_button_new_with_range( purple_request_field_int_get_lower_bound(setting), purple_request_field_int_get_upper_bound(setting), 1); gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), purple_request_field_int_get_value(setting)); g_signal_connect(G_OBJECT(widget), "value-changed", G_CALLBACK(keyring_page_settings_changed), setting); purple_debug_error("gtkprefs", "Unsupported field type\n"); hbox = pidgin_add_widget_to_vbox(vbox, label, sg, widget, return ((void*)hbox == (void*)vbox) ? widget : hbox; /* XXX: it could be available for all plugins, not keyrings only */ keyring_page_add_settings(PurpleRequestFields *settings) GList *it, *groups, *added_fields; sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); groups = purple_request_fields_get_groups(settings); for (it = g_list_first(groups); it != NULL; it = g_list_next(it)) { PurpleRequestFieldGroup *group; const gchar *group_title; group_title = purple_request_field_group_get_title(group); vbox = GTK_BOX(pidgin_make_frame( GTK_WIDGET(keyring_vbox), group_title)); added_fields = g_list_prepend(added_fields, g_object_get_data(G_OBJECT(vbox), "main-vbox")); fields = purple_request_field_group_get_fields(group); for (it2 = g_list_first(fields); it2 != NULL; it2 = g_list_next(it2)) { GtkWidget *added = keyring_page_add_settings_field(vbox, if (added == NULL || vbox != keyring_vbox) added_fields = g_list_prepend(added_fields, added); keyring_page_settings_apply(GtkButton *button, gpointer _unused) if (!purple_keyring_apply_settings(prefs, keyring_settings)) gtk_widget_set_sensitive(keyring_apply, FALSE); keyring_page_update_settings() if (keyring_settings != NULL) purple_request_fields_destroy(keyring_settings); keyring_settings = purple_keyring_read_settings(); keyring_settings_fields = keyring_page_add_settings(keyring_settings); keyring_apply = gtk_button_new_with_mnemonic(_("_Apply")); gtk_box_pack_start(keyring_vbox, keyring_apply, FALSE, FALSE, 1); gtk_widget_set_sensitive(keyring_apply, FALSE); keyring_settings_fields = g_list_prepend(keyring_settings_fields, g_signal_connect(G_OBJECT(keyring_apply), "clicked", G_CALLBACK(keyring_page_settings_apply), NULL); gtk_widget_show_all(keyring_page_instance); keyring_page_pref_set_inuse(GError *error, gpointer _keyring_page_instance) PurpleKeyring *in_use = purple_keyring_get_inuse(); if (_keyring_page_instance != keyring_page_instance) { purple_debug_info("gtkprefs", "pref window already closed\n"); gtk_widget_set_sensitive(GTK_WIDGET(keyring_combo), TRUE); pidgin_prefs_dropdown_revert_active(keyring_combo); purple_notify_error(NULL, _("Keyring"), _("Failed to set new keyring"), error->message, NULL); g_return_if_fail(in_use != NULL); purple_prefs_set_string("/purple/keyring/active", purple_keyring_get_id(in_use)); keyring_page_update_settings(); keyring_page_pref_changed(GtkComboBox *combo_box, PidginPrefValue value) g_return_if_fail(combo_box != NULL); g_return_if_fail(value.type == PURPLE_PREF_STRING); keyring_id = value.value.string; keyring = purple_keyring_find_keyring_by_id(keyring_id); pidgin_prefs_dropdown_revert_active(keyring_combo); purple_notify_error(NULL, _("Keyring"), _("Selected keyring is disabled"), NULL, NULL); gtk_widget_set_sensitive(GTK_WIDGET(combo_box), FALSE); for (it = keyring_settings_fields; it != NULL; it = g_list_next(it)) GtkWidget *widget = it->data; GTK_CONTAINER(gtk_widget_get_parent(widget)), widget); gtk_widget_show_all(keyring_page_instance); g_list_free(keyring_settings_fields); keyring_settings_fields = NULL; purple_request_fields_destroy(keyring_settings); purple_keyring_set_inuse(keyring, FALSE, keyring_page_pref_set_inuse, keyring_page_cleanup(void) keyring_page_instance = NULL; g_list_free(keyring_settings_fields); keyring_settings_fields = NULL; purple_request_fields_destroy(keyring_settings); g_return_val_if_fail(keyring_page_instance == NULL, keyring_page_instance = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE); gtk_container_set_border_width(GTK_CONTAINER(keyring_page_instance), keyring_vbox = GTK_BOX(pidgin_make_frame(keyring_page_instance, names = purple_keyring_get_options(); initial.type = PURPLE_PREF_STRING; initial.value.string = purple_prefs_get_string("/purple/keyring/active"); pidgin_prefs_dropdown_from_list_with_cb(GTK_WIDGET(keyring_vbox), _("Keyring:"), &keyring_combo, names, initial, keyring_page_pref_changed); keyring_page_update_settings(); gtk_widget_show_all(keyring_page_instance); return keyring_page_instance; /*** keyring page - end *************************************************/ 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") || !strcmp(method, "esd") || !strcmp(method, "waveform") || !strcmp(method, "directsound")); #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, 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, *button, *parent, *parent_parent, *parent_parent_parent; 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", _("Automatic"), "automatic", /* "WaveForm", "waveform", */ "DirectSound", "directsound", #endif /* USE_GSTREAMER */ "PlaySound", "playsoundw", _("Console beep"), "beep", 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 */ parent = gtk_widget_get_parent(vbox); parent_parent = gtk_widget_get_parent(parent); parent_parent_parent = gtk_widget_get_parent(parent_parent); gtk_box_set_child_packing(GTK_BOX(parent), vbox, TRUE, TRUE, 0, gtk_box_set_child_packing(GTK_BOX(parent_parent), parent, TRUE, TRUE, 0, GTK_PACK_START); gtk_box_set_child_packing(GTK_BOX(parent_parent_parent), 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); 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); get_vv_element_devices(const gchar *element_name) #if !GST_CHECK_VERSION(1,0,0) ret = g_list_prepend(ret, g_strdup(_("Default"))); ret = g_list_prepend(ret, g_strdup("")); if (!strcmp(element_name, "<custom>") || (*element_name == '\0')) { return g_list_reverse(ret); if (g_strcmp0(element_name, "videodisabledsrc") == 0) { ret = g_list_prepend(ret, g_strdup(_("Random noise"))); ret = g_list_prepend(ret, g_strdup("snow")); return g_list_reverse(ret); element = gst_element_factory_make(element_name, "test"); purple_debug_info("vvconfig", "'%s' - unable to find element\n", return g_list_reverse(ret); klass = G_OBJECT_GET_CLASS (element); purple_debug_info("vvconfig", "'%s' - unable to find GObject " "Class\n", element_name); return g_list_reverse(ret); #if GST_CHECK_VERSION(1,0,0) purple_debug_info("vvconfig", "'%s' - gstreamer-1.0 doesn't suport " "property probing\n", element_name); if (g_object_class_find_property(klass, "device")) probe_attr = PROBE_DEVICE; else if (g_object_class_find_property(klass, "device-index") && g_object_class_find_property(klass, "device-name")) if (!GST_IS_PROPERTY_PROBE(element)) if (probe_attr == PROBE_NONE) purple_debug_info("vvconfig", "'%s' - no possibility to probe " "for devices\n", element_name); gst_object_unref(element); return g_list_reverse(ret); probe = GST_PROPERTY_PROBE(element); if (probe_attr == PROBE_DEVICE) pspec = gst_property_probe_get_property(probe, "device"); else /* probe_attr == PROBE_NAME */ pspec = gst_property_probe_get_property(probe, "device-name"); purple_debug_info("vvconfig", "'%s' - creating probe failed\n", gst_object_unref(element); return g_list_reverse(ret); /* Set autoprobe[-fps] to FALSE to avoid delays when probing. */ if (g_object_class_find_property(klass, "autoprobe")) g_object_set(G_OBJECT(element), "autoprobe", FALSE, NULL); if (g_object_class_find_property(klass, "autoprobe-fps")) g_object_set(G_OBJECT(element), "autoprobe-fps", FALSE, NULL); array = gst_property_probe_probe_and_get_values(probe, pspec); purple_debug_info("vvconfig", "'%s' has no devices\n", gst_object_unref(element); return g_list_reverse(ret); for (i = 0; i < array->n_values; i++) { const gchar *device_name; G_GNUC_BEGIN_IGNORE_DEPRECATIONS /* GValueArray is in gstreamer-0.10 API */ device = g_value_array_get_nth(array, i); G_GNUC_END_IGNORE_DEPRECATIONS if (probe_attr == PROBE_DEVICE) { g_object_set_property(G_OBJECT(element), "device", if (gst_element_set_state(element, GST_STATE_READY) != GST_STATE_CHANGE_SUCCESS) purple_debug_warning("vvconfig", "Error " "changing state of %s\n", element_name); g_object_get(G_OBJECT(element), "device-name", &name, device_name = g_strdup(g_value_get_string(device)); } else /* probe_attr == PROBE_NAME */ { name = g_strdup(g_value_get_string(device)); device_name = g_strdup_printf("%d", i); purple_debug_info("vvconfig", "Found device %s: %s for %s\n", device_name, name, element_name); ret = g_list_prepend(ret, (gpointer)name); ret = g_list_prepend(ret, (gpointer)device_name); gst_element_set_state(element, GST_STATE_NULL); G_GNUC_BEGIN_IGNORE_DEPRECATIONS /* GValueArray is in gstreamer-0.10 API */ g_value_array_free(array); G_GNUC_END_IGNORE_DEPRECATIONS gst_object_unref(element); return g_list_reverse(ret); get_vv_element_plugins(const gchar **plugins) ret = g_list_prepend(ret, (gpointer)_("Default")); ret = g_list_prepend(ret, ""); for (; plugins[0] && plugins[1]; plugins += 2) { #if GST_CHECK_VERSION(1,0,0) if (gst_registry_check_feature_version(gst_registry_get(), if (gst_default_registry_check_feature_version(plugins[0], 0, 0, 0) || g_strcmp0(plugins[0], "videodisabledsrc") == 0) ret = g_list_prepend(ret, (gpointer)_(plugins[1])); ret = g_list_prepend(ret, (gpointer)plugins[0]); return g_list_reverse(ret); vv_plugin_changed_cb(const gchar *name, PurplePrefType type, gconstpointer value, gpointer data) sg = g_object_get_data(G_OBJECT(vbox), "size-group"); widget = g_object_get_data(G_OBJECT(vbox), "device-hbox"); gtk_widget_destroy(widget); strcpy(pref + strlen(pref) - strlen("plugin"), "device"); devices = get_vv_element_devices(value); if (g_list_find_custom(devices, purple_prefs_get_string(pref), (GCompareFunc)strcmp) == NULL) purple_prefs_set_string(pref, g_list_next(devices)->data); widget = pidgin_prefs_dropdown_from_list(vbox, _("_Device"), PURPLE_PREF_STRING, pref, devices); g_list_free_full(devices, g_free); gtk_size_group_add_widget(sg, widget); gtk_misc_set_alignment(GTK_MISC(widget), 0, 0.5); g_object_set_data(G_OBJECT(vbox), "device-hbox", gtk_widget_get_parent(widget)); g_signal_connect_swapped(widget, "destroy", G_CALLBACK(g_free), pref); make_vv_frame(GtkWidget *parent, GtkSizeGroup *sg, const gchar *name, const gchar **plugin_strs, const gchar *plugin_pref, const gchar *device_pref) GtkWidget *vbox, *widget; GList *plugins, *devices; vbox = pidgin_make_frame(parent, name); /* Setup plugin preference */ plugins = get_vv_element_plugins(plugin_strs); widget = pidgin_prefs_dropdown_from_list(vbox, _("_Plugin"), PURPLE_PREF_STRING, plugin_pref, gtk_size_group_add_widget(sg, widget); gtk_misc_set_alignment(GTK_MISC(widget), 0, 0.5); /* Setup device preference */ devices = get_vv_element_devices(purple_prefs_get_string(plugin_pref)); if (g_list_find_custom(devices, purple_prefs_get_string(device_pref), (GCompareFunc)strcmp) == NULL) purple_prefs_set_string(device_pref, g_list_next(devices)->data); widget = pidgin_prefs_dropdown_from_list(vbox, _("_Device"), PURPLE_PREF_STRING, device_pref, g_list_free_full(devices, g_free); gtk_size_group_add_widget(sg, widget); gtk_misc_set_alignment(GTK_MISC(widget), 0, 0.5); widget = gtk_widget_get_parent(widget); g_object_set_data(G_OBJECT(vbox), "size-group", sg); g_object_set_data(G_OBJECT(vbox), "device-hbox", widget); purple_prefs_connect_callback(vbox, plugin_pref, vv_plugin_changed_cb, g_signal_connect_swapped(vbox, "destroy", G_CALLBACK(purple_prefs_disconnect_by_handle), vbox); create_test_element(PurpleMediaElementType type) PurpleMediaElementInfo *element_info; element_info = purple_media_manager_get_active_element(purple_media_manager_get(), type); g_return_val_if_fail(element_info, NULL); return purple_media_element_info_call_create(element_info, vv_test_switch_page_cb(GtkNotebook *notebook, GtkWidget *page, guint num, gpointer data) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(test), FALSE); create_voice_pipeline(void) pipeline = gst_pipeline_new("voicetest"); src = create_test_element(PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SRC); sink = create_test_element(PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SINK); volume = gst_element_factory_make("volume", "volume"); level = gst_element_factory_make("level", "level"); valve = gst_element_factory_make("valve", "valve"); gst_bin_add_many(GST_BIN(pipeline), src, volume, level, valve, sink, NULL); gst_element_link_many(src, volume, level, valve, sink, NULL); purple_debug_info("gtkprefs", "create_voice_pipeline: setting pipeline " "state to GST_STATE_PLAYING - it may hang here on win32\n"); gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_PLAYING); purple_debug_info("gtkprefs", "create_voice_pipeline: state is set\n"); on_volume_change_cb(GtkWidget *w, gdouble value, GstBin *pipeline) g_return_if_fail(pipeline != NULL); volume = gst_bin_get_by_name(pipeline, "volume"); g_object_set(volume, "volume", gtk_scale_button_get_value(GTK_SCALE_BUTTON(w)) * 10.0, NULL); gst_msg_db_to_percent(GstMessage *msg, gchar *value_name) list = gst_structure_get_value(gst_message_get_structure(msg), value_name); #if GST_CHECK_VERSION(1,0,0) G_GNUC_BEGIN_IGNORE_DEPRECATIONS value = g_value_array_get_nth(g_value_get_boxed(list), 0); G_GNUC_END_IGNORE_DEPRECATIONS value = gst_value_list_get_value(list, 0); value_db = g_value_get_double(value); percent = pow(10, value_db / 20); return (percent > 1.0) ? 1.0 : percent; gst_bus_cb(GstBus *bus, GstMessage *msg, BusCbCtx *ctx) if (GST_MESSAGE_TYPE(msg) == GST_MESSAGE_ELEMENT && gst_structure_has_name(gst_message_get_structure(msg), "level")) { GstElement *src = GST_ELEMENT(GST_MESSAGE_SRC(msg)); gchar *name = gst_element_get_name(src); if (!strcmp(name, "level")) { percent = gst_msg_db_to_percent(msg, "rms"); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ctx->level), percent); percent = gst_msg_db_to_percent(msg, "decay"); threshold = gtk_range_get_value(GTK_RANGE(ctx->threshold)) / 100.0; valve = gst_bin_get_by_name(GST_BIN(GST_ELEMENT_PARENT(src)), "valve"); g_object_set(valve, "drop", (percent < threshold), NULL); g_object_set(ctx->level, "text", (percent < threshold) ? _("DROP") : " ", NULL); voice_test_destroy_cb(GtkWidget *w, gpointer data) gst_element_set_state(voice_pipeline, GST_STATE_NULL); gst_object_unref(voice_pipeline); toggle_voice_test_cb(GtkToggleButton *test, gpointer data) if (gtk_toggle_button_get_active(test)) { gtk_widget_set_sensitive(ctx->level, TRUE); voice_pipeline = create_voice_pipeline(); bus = gst_pipeline_get_bus(GST_PIPELINE(voice_pipeline)); gst_bus_add_signal_watch(bus); g_signal_connect(bus, "message", G_CALLBACK(gst_bus_cb), ctx); g_signal_connect(ctx->volume, "value-changed", G_CALLBACK(on_volume_change_cb), voice_pipeline); g_signal_connect(test, "destroy", G_CALLBACK(voice_test_destroy_cb), NULL); g_signal_connect(prefsnotebook, "switch-page", G_CALLBACK(vv_test_switch_page_cb), test); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ctx->level), 0.0); gtk_widget_set_sensitive(ctx->level, FALSE); g_object_disconnect(ctx->volume, "any-signal::value-changed", G_CALLBACK(on_volume_change_cb), voice_pipeline, g_object_disconnect(test, "any-signal::destroy", G_CALLBACK(voice_test_destroy_cb), NULL, g_object_disconnect(prefsnotebook, "any-signal::switch-page", G_CALLBACK(vv_test_switch_page_cb), test, voice_test_destroy_cb(NULL, NULL); volume_changed_cb(GtkScaleButton *button, gdouble value, gpointer data) purple_prefs_set_int("/purple/media/audio/volume/input", value * 100); threshold_value_changed_cb(GtkScale *scale, GtkWidget *label) value = (int)gtk_range_get_value(GTK_RANGE(scale)); tmp = g_strdup_printf(_("Silence threshold: %d%%"), value); gtk_label_set_label(GTK_LABEL(label), tmp); purple_prefs_set_int("/purple/media/audio/silence_threshold", value); make_voice_test(GtkWidget *vbox) label = gtk_label_new(NULL); gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0); hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_CAT_SPACE); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Volume:")); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); volume = gtk_volume_button_new(); gtk_box_pack_start(GTK_BOX(hbox), volume, TRUE, TRUE, 0); gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume), purple_prefs_get_int("/purple/media/audio/volume/input") / 100.0); g_signal_connect(volume, "value-changed", G_CALLBACK(volume_changed_cb), NULL); tmp = g_strdup_printf(_("Silence threshold: %d%%"), purple_prefs_get_int("/purple/media/audio/silence_threshold")); label = gtk_label_new(tmp); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); threshold = gtk_hscale_new_with_range(0, 100, 1); gtk_box_pack_start(GTK_BOX(vbox), threshold, FALSE, FALSE, 0); gtk_range_set_value(GTK_RANGE(threshold), purple_prefs_get_int("/purple/media/audio/silence_threshold")); gtk_scale_set_draw_value(GTK_SCALE(threshold), FALSE); g_signal_connect(threshold, "value-changed", G_CALLBACK(threshold_value_changed_cb), label); test = gtk_toggle_button_new_with_label(_("Test Audio")); gtk_box_pack_start(GTK_BOX(vbox), test, FALSE, FALSE, 0); level = gtk_progress_bar_new(); gtk_box_pack_start(GTK_BOX(vbox), level, FALSE, FALSE, 0); gtk_widget_set_sensitive(level, FALSE); ctx = g_new(BusCbCtx, 1); ctx->threshold = threshold; g_signal_connect(test, "toggled", G_CALLBACK(toggle_voice_test_cb), ctx); create_video_pipeline(void) pipeline = gst_pipeline_new("videotest"); src = create_test_element(PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SRC); sink = create_test_element(PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SINK); g_object_set_data(G_OBJECT(pipeline), "sink", sink); gst_bin_add_many(GST_BIN(pipeline), src, sink, NULL); gst_element_link_many(src, sink, NULL); video_test_destroy_cb(GtkWidget *w, gpointer data) gst_element_set_state(video_pipeline, GST_STATE_NULL); gst_object_unref(video_pipeline); window_id_cb(GstBus *bus, GstMessage *msg, gulong window_id) if (GST_MESSAGE_TYPE(msg) != GST_MESSAGE_ELEMENT #if GST_CHECK_VERSION(1,0,0) || !gst_is_video_overlay_prepare_window_handle_message(msg)) /* there may be have-xwindow-id also, in case something went wrong */ || !gst_structure_has_name(msg->structure, "prepare-xwindow-id")) g_signal_handlers_disconnect_matched(bus, G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, window_id_cb, #if GST_CHECK_VERSION(1,0,0) gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(GST_MESSAGE_SRC(msg)), #elif GST_CHECK_VERSION(0,10,31) gst_x_overlay_set_window_handle(GST_X_OVERLAY(GST_MESSAGE_SRC(msg)), gst_x_overlay_set_xwindow_id(GST_X_OVERLAY(GST_MESSAGE_SRC(msg)), toggle_video_test_cb(GtkToggleButton *test, gpointer data) if (gtk_toggle_button_get_active(test)) { GdkWindow *window = gtk_widget_get_window(video); #ifdef GDK_WINDOWING_WIN32 if (GDK_IS_WIN32_WINDOW(window)) window_id = GPOINTER_TO_UINT(GDK_WINDOW_HWND(window)); if (GDK_IS_X11_WINDOW(window)) window_id = gdk_x11_window_get_xid(window); #ifdef GDK_WINDOWING_QUARTZ if (GDK_IS_QUARTZ_WINDOW(window)) window_id = (gulong)gdk_quartz_window_get_nsview(window); g_warning("Unsupported GDK backend"); #if !(defined(GDK_WINDOWING_WIN32) \ || defined(GDK_WINDOWING_X11) \ || defined(GDK_WINDOWING_QUARTZ)) # error "Unsupported GDK windowing system" video_pipeline = create_video_pipeline(); bus = gst_pipeline_get_bus(GST_PIPELINE(video_pipeline)); #if GST_CHECK_VERSION(1,0,0) gst_bus_set_sync_handler(bus, gst_bus_sync_signal_handler, NULL, NULL); gst_bus_set_sync_handler(bus, gst_bus_sync_signal_handler, NULL); g_signal_connect(bus, "sync-message::element", G_CALLBACK(window_id_cb), (gpointer)window_id); gst_element_set_state(GST_ELEMENT(video_pipeline), GST_STATE_PLAYING); g_signal_connect(test, "destroy", G_CALLBACK(video_test_destroy_cb), NULL); g_signal_connect(prefsnotebook, "switch-page", G_CALLBACK(vv_test_switch_page_cb), test); g_object_disconnect(test, "any-signal::destroy", G_CALLBACK(video_test_destroy_cb), NULL, g_object_disconnect(prefsnotebook, "any-signal::switch-page", G_CALLBACK(vv_test_switch_page_cb), test, video_test_destroy_cb(NULL, NULL); make_video_test(GtkWidget *vbox) GdkColor color = {0, 0, 0, 0}; video = gtk_drawing_area_new(); gtk_box_pack_start(GTK_BOX(vbox), video, TRUE, TRUE, 0); gtk_widget_modify_bg(video, GTK_STATE_NORMAL, &color); gtk_widget_set_size_request(GTK_WIDGET(video), 240, 180); test = gtk_toggle_button_new_with_label(_("Test Video")); gtk_box_pack_start(GTK_BOX(vbox), test, FALSE, FALSE, 0); g_signal_connect(test, "toggled", G_CALLBACK(toggle_video_test_cb), video); ret = gtk_hbox_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, _("Audio")); make_vv_frame(vbox, sg, _("Input"), AUDIO_SRC_PLUGINS, PIDGIN_PREFS_ROOT "/vvconfig/audio/src/plugin", PIDGIN_PREFS_ROOT "/vvconfig/audio/src/device"); make_vv_frame(vbox, sg, _("Output"), AUDIO_SINK_PLUGINS, PIDGIN_PREFS_ROOT "/vvconfig/audio/sink/plugin", PIDGIN_PREFS_ROOT "/vvconfig/audio/sink/device"); vbox = pidgin_make_frame(ret, _("Video")); make_vv_frame(vbox, sg, _("Input"), VIDEO_SRC_PLUGINS, PIDGIN_PREFS_ROOT "/vvconfig/video/src/plugin", PIDGIN_PREFS_ROOT "/vvconfig/video/src/device"); make_vv_frame(vbox, sg, _("Output"), VIDEO_SINK_PLUGINS, PIDGIN_PREFS_ROOT "/vvconfig/video/sink/plugin", PIDGIN_PREFS_ROOT "/vvconfig/video/sink/device"); 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(_("Password Storage"), keyring_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++); prefs_notebook_add_page(_("Voice/Video"), vv_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! */ #if GTK_CHECK_VERSION(3,0,0) prefs = pidgin_create_dialog(_("Preferences"), 0, "preferences", FALSE); 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", ""); /* Conversation Themes */ purple_prefs_add_none(PIDGIN_PREFS_ROOT "/conversations"); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/conversations/theme", "Default"); 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); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig"); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig/audio"); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig/audio/src"); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/vvconfig/audio/src/plugin", ""); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/vvconfig/audio/src/device", ""); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig/audio/sink"); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/vvconfig/audio/sink/plugin", ""); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/vvconfig/audio/sink/device", ""); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig/video"); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig/video/src"); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/vvconfig/video/src/plugin", ""); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/vvconfig/video/src/device", ""); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig/video"); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig/video/sink"); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/vvconfig/video/sink/plugin", ""); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/vvconfig/video/sink/device", ""); pidgin_prefs_update_old(); pidgin_prefs_update_old(void) /* 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 "/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 moment. -- rekkanoryo if (purple_prefs_exists(PIDGIN_PREFS_ROOT "/browsers/command") && purple_prefs_get_type(PIDGIN_PREFS_ROOT "/browsers/command") == const char *str = purple_prefs_get_path( PIDGIN_PREFS_ROOT "/browsers/command"); PIDGIN_PREFS_ROOT "/browsers/manual_command", str); purple_prefs_remove(PIDGIN_PREFS_ROOT "/browsers/command"); /* 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 "/blist/tooltip_delay"); 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 "/debug/timestamps"); 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"); /* Fixup vvconfig plugin prefs */ if (purple_prefs_exists("/plugins/core/vvconfig/audio/src/plugin")) { purple_prefs_set_string(PIDGIN_PREFS_ROOT "/vvconfig/audio/src/plugin", purple_prefs_get_string("/plugins/core/vvconfig/audio/src/plugin")); if (purple_prefs_exists("/plugins/core/vvconfig/audio/src/device")) { purple_prefs_set_string(PIDGIN_PREFS_ROOT "/vvconfig/audio/src/device", purple_prefs_get_string("/plugins/core/vvconfig/audio/src/device")); if (purple_prefs_exists("/plugins/core/vvconfig/audio/sink/plugin")) { purple_prefs_set_string(PIDGIN_PREFS_ROOT "/vvconfig/audio/sink/plugin", purple_prefs_get_string("/plugins/core/vvconfig/audio/sink/plugin")); if (purple_prefs_exists("/plugins/core/vvconfig/audio/sink/device")) { purple_prefs_set_string(PIDGIN_PREFS_ROOT "/vvconfig/audio/sink/device", purple_prefs_get_string("/plugins/core/vvconfig/audio/sink/device")); if (purple_prefs_exists("/plugins/core/vvconfig/video/src/plugin")) { purple_prefs_set_string(PIDGIN_PREFS_ROOT "/vvconfig/video/src/plugin", purple_prefs_get_string("/plugins/core/vvconfig/video/src/plugin")); if (purple_prefs_exists("/plugins/core/vvconfig/video/src/device")) { purple_prefs_set_string(PIDGIN_PREFS_ROOT "/vvconfig/video/src/device", purple_prefs_get_string("/plugins/core/vvconfig/video/src/device")); if (purple_prefs_exists("/plugins/gtk/vvconfig/video/sink/plugin")) { purple_prefs_set_string(PIDGIN_PREFS_ROOT "/vvconfig/video/sink/plugin", purple_prefs_get_string("/plugins/gtk/vvconfig/video/sink/plugin")); if (purple_prefs_exists("/plugins/gtk/vvconfig/video/sink/device")) { purple_prefs_set_string(PIDGIN_PREFS_ROOT "/vvconfig/video/sink/device", purple_prefs_get_string("/plugins/gtk/vvconfig/video/sink/device")); purple_prefs_remove("/plugins/core/vvconfig"); purple_prefs_remove("/plugins/gtk/vvconfig"); if (purple_prefs_get_int(PIDGIN_PREFS_ROOT "/browsers/place") == 1) { /* If the "open link in" pref is set to the old value for "existing window" then change it to "default." */ purple_prefs_set_int(PIDGIN_PREFS_ROOT "/browsers/place", purple_prefs_get_string(PIDGIN_PREFS_ROOT "/browsers/browser"), purple_prefs_set_string(PIDGIN_PREFS_ROOT "/browsers/browser", "xdg-open");