transmission/gtk/tr-prefs.c

1273 lines
42 KiB
C

/*
* This file Copyright (C) 2007-2014 Mnemosyne LLC
*
* It may be used under the GNU GPL versions 2 or 3
* or any future license endorsed by Mnemosyne LLC.
*
*/
#include <ctype.h> /* isspace */
#include <limits.h> /* USHRT_MAX, INT_MAX */
#include <unistd.h>
#include <glib/gi18n.h>
#include <gtk/gtk.h>
#include <libtransmission/transmission.h>
#include <libtransmission/utils.h>
#include <libtransmission/version.h>
#include "conf.h"
#include "hig.h"
#include "tr-core.h"
#include "tr-prefs.h"
#include "util.h"
/**
***
**/
struct prefs_dialog_data
{
TrCore* core;
gulong core_prefs_tag;
GtkWidget* freespace_label;
GtkWidget* port_label;
GtkWidget* port_button;
GtkWidget* port_spin;
};
/**
***
**/
#define PREF_KEY "pref-key"
static void response_cb(GtkDialog* dialog, int response, gpointer unused UNUSED)
{
if (response == GTK_RESPONSE_HELP)
{
char* uri = g_strconcat(gtr_get_help_uri(), "/html/preferences.html", NULL);
gtr_open_uri(uri);
g_free(uri);
}
if (response == GTK_RESPONSE_CLOSE)
{
gtk_widget_destroy(GTK_WIDGET(dialog));
}
}
static void toggled_cb(GtkToggleButton* w, gpointer core)
{
tr_quark const key = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(w), PREF_KEY));
gboolean const flag = gtk_toggle_button_get_active(w);
gtr_core_set_pref_bool(TR_CORE(core), key, flag);
}
static GtkWidget* new_check_button(char const* mnemonic, tr_quark const key, gpointer core)
{
GtkWidget* w = gtk_check_button_new_with_mnemonic(mnemonic);
g_object_set_data(G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), gtr_pref_flag_get(key));
g_signal_connect(w, "toggled", G_CALLBACK(toggled_cb), core);
return w;
}
#define IDLE_DATA "idle-data"
struct spin_idle_data
{
gpointer core;
GTimer* last_change;
gboolean isDouble;
};
static void spin_idle_data_free(gpointer gdata)
{
struct spin_idle_data* data = gdata;
g_timer_destroy(data->last_change);
g_free(data);
}
static gboolean spun_cb_idle(gpointer spin)
{
gboolean keep_waiting = TRUE;
GObject* o = G_OBJECT(spin);
struct spin_idle_data* data = g_object_get_data(o, IDLE_DATA);
/* has the user stopped making changes? */
if (g_timer_elapsed(data->last_change, NULL) > 0.33f)
{
/* update the core */
tr_quark const key = GPOINTER_TO_INT(g_object_get_data(o, PREF_KEY));
if (data->isDouble)
{
double const value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin));
gtr_core_set_pref_double(TR_CORE(data->core), key, value);
}
else
{
int const value = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin));
gtr_core_set_pref_int(TR_CORE(data->core), key, value);
}
/* cleanup */
g_object_set_data(o, IDLE_DATA, NULL);
keep_waiting = FALSE;
g_object_unref(G_OBJECT(o));
}
return keep_waiting;
}
static void spun_cb(GtkSpinButton* w, gpointer core, gboolean isDouble)
{
/* user may be spinning through many values, so let's hold off
for a moment to keep from flooding the core with changes */
GObject* o = G_OBJECT(w);
struct spin_idle_data* data = g_object_get_data(o, IDLE_DATA);
if (data == NULL)
{
data = g_new(struct spin_idle_data, 1);
data->core = core;
data->last_change = g_timer_new();
data->isDouble = isDouble;
g_object_set_data_full(o, IDLE_DATA, data, spin_idle_data_free);
g_object_ref(G_OBJECT(o));
gdk_threads_add_timeout_seconds(1, spun_cb_idle, w);
}
g_timer_start(data->last_change);
}
static void spun_cb_int(GtkSpinButton* w, gpointer core)
{
spun_cb(w, core, FALSE);
}
static void spun_cb_double(GtkSpinButton* w, gpointer core)
{
spun_cb(w, core, TRUE);
}
static GtkWidget* new_spin_button(tr_quark const key, gpointer core, int low, int high, int step)
{
GtkWidget* w = gtk_spin_button_new_with_range(low, high, step);
g_object_set_data(G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(w), 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), gtr_pref_int_get(key));
g_signal_connect(w, "value-changed", G_CALLBACK(spun_cb_int), core);
return w;
}
static GtkWidget* new_spin_button_double(tr_quark const key, gpointer core, double low, double high, double step)
{
GtkWidget* w = gtk_spin_button_new_with_range(low, high, step);
g_object_set_data(G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(w), 2);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), gtr_pref_double_get(key));
g_signal_connect(w, "value-changed", G_CALLBACK(spun_cb_double), core);
return w;
}
static void entry_changed_cb(GtkEntry* w, gpointer core)
{
tr_quark const key = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(w), PREF_KEY));
char const* value = gtk_entry_get_text(w);
gtr_core_set_pref(TR_CORE(core), key, value);
}
static GtkWidget* new_entry(tr_quark const key, gpointer core)
{
GtkWidget* w = gtk_entry_new();
char const* value = gtr_pref_string_get(key);
if (value != NULL)
{
gtk_entry_set_text(GTK_ENTRY(w), value);
}
g_object_set_data(G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
g_signal_connect(w, "changed", G_CALLBACK(entry_changed_cb), core);
return w;
}
static void chosen_cb(GtkFileChooser* w, gpointer core)
{
tr_quark const key = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(w), PREF_KEY));
char* value = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(w));
gtr_core_set_pref(TR_CORE(core), key, value);
g_free(value);
}
static GtkWidget* new_path_chooser_button(tr_quark const key, gpointer core)
{
GtkWidget* w = gtk_file_chooser_button_new(NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
char const* path = gtr_pref_string_get(key);
g_object_set_data(G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
if (path != NULL)
{
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(w), path);
}
g_signal_connect(w, "selection-changed", G_CALLBACK(chosen_cb), core);
return w;
}
static GtkWidget* new_file_chooser_button(tr_quark const key, gpointer core)
{
GtkWidget* w = gtk_file_chooser_button_new(NULL, GTK_FILE_CHOOSER_ACTION_OPEN);
char const* path = gtr_pref_string_get(key);
g_object_set_data(G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
if (path != NULL)
{
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(w), path);
}
g_signal_connect(w, "selection-changed", G_CALLBACK(chosen_cb), core);
return w;
}
static void target_cb(GtkWidget* tb, gpointer target)
{
gboolean const b = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tb));
gtk_widget_set_sensitive(GTK_WIDGET(target), b);
}
/****
***** Download Tab
****/
static GtkWidget* downloadingPage(GObject* core, struct prefs_dialog_data* data)
{
GtkWidget* t;
GtkWidget* w;
GtkWidget* l;
char const* s;
guint row = 0;
t = hig_workarea_create();
hig_workarea_add_section_title(t, &row, C_("Gerund", "Adding"));
s = _("Automatically add .torrent files _from:");
l = new_check_button(s, TR_KEY_watch_dir_enabled, core);
w = new_path_chooser_button(TR_KEY_watch_dir, core);
gtk_widget_set_sensitive(GTK_WIDGET(w), gtr_pref_flag_get(TR_KEY_watch_dir_enabled));
g_signal_connect(l, "toggled", G_CALLBACK(target_cb), w);
hig_workarea_add_row_w(t, &row, l, w, NULL);
s = _("Show the Torrent Options _dialog");
w = new_check_button(s, TR_KEY_show_options_window, core);
hig_workarea_add_wide_control(t, &row, w);
s = _("_Start added torrents");
w = new_check_button(s, TR_KEY_start_added_torrents, core);
hig_workarea_add_wide_control(t, &row, w);
s = _("Mo_ve .torrent file to the trash");
w = new_check_button(s, TR_KEY_trash_original_torrent_files, core);
hig_workarea_add_wide_control(t, &row, w);
w = new_path_chooser_button(TR_KEY_download_dir, core);
hig_workarea_add_row(t, &row, _("Save to _Location:"), w, NULL);
l = data->freespace_label = gtr_freespace_label_new(TR_CORE(core), NULL);
gtk_misc_set_alignment(GTK_MISC(l), 1.0f, 0.5f);
hig_workarea_add_wide_control(t, &row, l);
hig_workarea_add_section_divider(t, &row);
hig_workarea_add_section_title(t, &row, _("Download Queue"));
s = _("Ma_ximum active downloads:");
w = new_spin_button(TR_KEY_download_queue_size, core, 0, INT_MAX, 1);
hig_workarea_add_row(t, &row, s, w, NULL);
s = _("Downloads sharing data in the last _N minutes are active:");
w = new_spin_button(TR_KEY_queue_stalled_minutes, core, 1, INT_MAX, 15);
hig_workarea_add_row(t, &row, s, w, NULL);
hig_workarea_add_section_divider(t, &row);
hig_workarea_add_section_title(t, &row, _("Incomplete"));
s = _("Append \"._part\" to incomplete files' names");
w = new_check_button(s, TR_KEY_rename_partial_files, core);
hig_workarea_add_wide_control(t, &row, w);
s = _("Keep _incomplete torrents in:");
l = new_check_button(s, TR_KEY_incomplete_dir_enabled, core);
w = new_path_chooser_button(TR_KEY_incomplete_dir, core);
gtk_widget_set_sensitive(GTK_WIDGET(w), gtr_pref_flag_get(TR_KEY_incomplete_dir_enabled));
g_signal_connect(l, "toggled", G_CALLBACK(target_cb), w);
hig_workarea_add_row_w(t, &row, l, w, NULL);
s = _("Call scrip_t when torrent is completed:");
l = new_check_button(s, TR_KEY_script_torrent_done_enabled, core);
w = new_file_chooser_button(TR_KEY_script_torrent_done_filename, core);
gtk_widget_set_sensitive(GTK_WIDGET(w), gtr_pref_flag_get(TR_KEY_script_torrent_done_enabled));
g_signal_connect(l, "toggled", G_CALLBACK(target_cb), w);
hig_workarea_add_row_w(t, &row, l, w, NULL);
return t;
}
/****
***** Torrent Tab
****/
static GtkWidget* seedingPage(GObject* core)
{
GtkWidget* t;
GtkWidget* w;
GtkWidget* w2;
char const* s;
guint row = 0;
t = hig_workarea_create();
hig_workarea_add_section_title(t, &row, _("Limits"));
s = _("Stop seeding at _ratio:");
w = new_check_button(s, TR_KEY_ratio_limit_enabled, core);
w2 = new_spin_button_double(TR_KEY_ratio_limit, core, 0, 1000, .05);
gtk_widget_set_sensitive(GTK_WIDGET(w2), gtr_pref_flag_get(TR_KEY_ratio_limit_enabled));
g_signal_connect(w, "toggled", G_CALLBACK(target_cb), w2);
hig_workarea_add_row_w(t, &row, w, w2, NULL);
s = _("Stop seeding if idle for _N minutes:");
w = new_check_button(s, TR_KEY_idle_seeding_limit_enabled, core);
w2 = new_spin_button(TR_KEY_idle_seeding_limit, core, 1, 9999, 5);
gtk_widget_set_sensitive(GTK_WIDGET(w2), gtr_pref_flag_get(TR_KEY_idle_seeding_limit_enabled));
g_signal_connect(w, "toggled", G_CALLBACK(target_cb), w2);
hig_workarea_add_row_w(t, &row, w, w2, NULL);
return t;
}
/****
***** Desktop Tab
****/
static GtkWidget* desktopPage(GObject* core)
{
GtkWidget* t;
GtkWidget* w;
char const* s;
guint row = 0;
t = hig_workarea_create();
hig_workarea_add_section_title(t, &row, _("Desktop"));
s = _("_Inhibit hibernation when torrents are active");
w = new_check_button(s, TR_KEY_inhibit_desktop_hibernation, core);
hig_workarea_add_wide_control(t, &row, w);
s = _("Show Transmission icon in the _notification area");
w = new_check_button(s, TR_KEY_show_notification_area_icon, core);
hig_workarea_add_wide_control(t, &row, w);
hig_workarea_add_section_divider(t, &row);
hig_workarea_add_section_title(t, &row, _("Notification"));
s = _("Show a notification when torrents are a_dded");
w = new_check_button(s, TR_KEY_torrent_added_notification_enabled, core);
hig_workarea_add_wide_control(t, &row, w);
s = _("Show a notification when torrents _finish");
w = new_check_button(s, TR_KEY_torrent_complete_notification_enabled, core);
hig_workarea_add_wide_control(t, &row, w);
s = _("Play a _sound when torrents finish");
w = new_check_button(s, TR_KEY_torrent_complete_sound_enabled, core);
hig_workarea_add_wide_control(t, &row, w);
return t;
}
/****
***** Peer Tab
****/
struct blocklist_data
{
gulong updateBlocklistTag;
GtkWidget* updateBlocklistButton;
GtkWidget* updateBlocklistDialog;
GtkWidget* label;
GtkWidget* check;
TrCore* core;
};
static void updateBlocklistText(GtkWidget* w, TrCore* core)
{
char buf1[512];
char buf2[512];
int const n = tr_blocklistGetRuleCount(gtr_core_session(core));
g_snprintf(buf1, sizeof(buf1), ngettext("Blocklist contains %'d rule", "Blocklist contains %'d rules", n), n);
g_snprintf(buf2, sizeof(buf2), "<i>%s</i>", buf1);
gtk_label_set_markup(GTK_LABEL(w), buf2);
}
/* prefs dialog is being destroyed, so stop listening to blocklist updates */
static void privacyPageDestroyed(gpointer gdata, GObject* dead UNUSED)
{
struct blocklist_data* data = gdata;
if (data->updateBlocklistTag > 0)
{
g_signal_handler_disconnect(data->core, data->updateBlocklistTag);
}
g_free(data);
}
/* user hit "close" in the blocklist-update dialog */
static void onBlocklistUpdateResponse(GtkDialog* dialog, gint response UNUSED, gpointer gdata)
{
struct blocklist_data* data = gdata;
gtk_widget_destroy(GTK_WIDGET(dialog));
gtk_widget_set_sensitive(data->updateBlocklistButton, TRUE);
data->updateBlocklistDialog = NULL;
g_signal_handler_disconnect(data->core, data->updateBlocklistTag);
data->updateBlocklistTag = 0;
}
/* core says the blocklist was updated */
static void onBlocklistUpdated(TrCore* core, int n, gpointer gdata)
{
bool const success = n >= 0;
int const count = n >= 0 ? n : tr_blocklistGetRuleCount(gtr_core_session(core));
char const* s = ngettext("Blocklist has %'d rule.", "Blocklist has %'d rules.", count);
struct blocklist_data* data = gdata;
GtkMessageDialog* d = GTK_MESSAGE_DIALOG(data->updateBlocklistDialog);
gtk_widget_set_sensitive(data->updateBlocklistButton, TRUE);
gtk_message_dialog_set_markup(d, success ? _("<b>Update succeeded!</b>") : _("<b>Unable to update.</b>"));
gtk_message_dialog_format_secondary_text(d, s, count);
updateBlocklistText(data->label, core);
}
/* user pushed a button to update the blocklist */
static void onBlocklistUpdate(GtkButton* w, gpointer gdata)
{
GtkWidget* d;
struct blocklist_data* data = gdata;
d = gtk_message_dialog_new(GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(w))), GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "%s", _("Update Blocklist"));
gtk_widget_set_sensitive(data->updateBlocklistButton, FALSE);
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), "%s", _("Getting new blocklist…"));
data->updateBlocklistDialog = d;
g_signal_connect(d, "response", G_CALLBACK(onBlocklistUpdateResponse), data);
gtk_widget_show(d);
gtr_core_blocklist_update(data->core);
data->updateBlocklistTag = g_signal_connect(data->core, "blocklist-updated", G_CALLBACK(onBlocklistUpdated), data);
}
static void on_blocklist_url_changed(GtkEditable* e, gpointer gbutton)
{
gchar* url = gtk_editable_get_chars(e, 0, -1);
gboolean const is_url_valid = tr_urlParse(url, TR_BAD_SIZE, NULL, NULL, NULL, NULL);
gtk_widget_set_sensitive(GTK_WIDGET(gbutton), is_url_valid);
g_free(url);
}
static void onIntComboChanged(GtkComboBox* combo_box, gpointer core)
{
int const val = gtr_combo_box_get_active_enum(combo_box);
tr_quark const key = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(combo_box), PREF_KEY));
gtr_core_set_pref_int(TR_CORE(core), key, val);
}
static GtkWidget* new_encryption_combo(GObject* core, tr_quark const key)
{
GtkWidget* w = gtr_combo_box_new_enum(_("Allow encryption"), TR_CLEAR_PREFERRED, _("Prefer encryption"),
TR_ENCRYPTION_PREFERRED, _("Require encryption"), TR_ENCRYPTION_REQUIRED, NULL);
gtr_combo_box_set_active_enum(GTK_COMBO_BOX(w), gtr_pref_int_get(key));
g_object_set_data(G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
g_signal_connect(w, "changed", G_CALLBACK(onIntComboChanged), core);
return w;
}
static GtkWidget* privacyPage(GObject* core)
{
char const* s;
GtkWidget* t;
GtkWidget* w;
GtkWidget* b;
GtkWidget* h;
GtkWidget* e;
struct blocklist_data* data;
guint row = 0;
data = g_new0(struct blocklist_data, 1);
data->core = TR_CORE(core);
t = hig_workarea_create();
hig_workarea_add_section_title(t, &row, _("Privacy"));
s = _("_Encryption mode:");
w = new_encryption_combo(core, TR_KEY_encryption);
hig_workarea_add_row(t, &row, s, w, NULL);
hig_workarea_add_section_divider(t, &row);
hig_workarea_add_section_title(t, &row, _("Blocklist"));
b = new_check_button(_("Enable _blocklist:"), TR_KEY_blocklist_enabled, core);
e = new_entry(TR_KEY_blocklist_url, core);
gtk_widget_set_size_request(e, 300, -1);
hig_workarea_add_row_w(t, &row, b, e, NULL);
data->check = b;
g_signal_connect(b, "toggled", G_CALLBACK(target_cb), e);
target_cb(b, e);
w = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(w), 0.0f, 0.5f);
updateBlocklistText(w, TR_CORE(core));
data->label = w;
h = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, GUI_PAD_BIG);
gtk_box_pack_start(GTK_BOX(h), w, TRUE, TRUE, 0);
b = data->updateBlocklistButton = gtk_button_new_with_mnemonic(_("_Update"));
g_object_set_data(G_OBJECT(b), "session", gtr_core_session(TR_CORE(core)));
g_signal_connect(b, "clicked", G_CALLBACK(onBlocklistUpdate), data);
g_signal_connect(data->check, "toggled", G_CALLBACK(target_cb), b);
target_cb(data->check, b);
gtk_box_pack_start(GTK_BOX(h), b, FALSE, FALSE, 0);
g_signal_connect(data->check, "toggled", G_CALLBACK(target_cb), w);
target_cb(data->check, w);
hig_workarea_add_wide_control(t, &row, h);
g_signal_connect(e, "changed", G_CALLBACK(on_blocklist_url_changed), data->updateBlocklistButton);
on_blocklist_url_changed(GTK_EDITABLE(e), data->updateBlocklistButton);
s = _("Enable _automatic updates");
w = new_check_button(s, TR_KEY_blocklist_updates_enabled, core);
hig_workarea_add_wide_control(t, &row, w);
g_signal_connect(data->check, "toggled", G_CALLBACK(target_cb), w);
target_cb(data->check, w);
g_object_weak_ref(G_OBJECT(t), privacyPageDestroyed, data);
return t;
}
/****
***** Remote Tab
****/
enum
{
COL_ADDRESS,
N_COLS
};
static GtkTreeModel* whitelist_tree_model_new(char const* whitelist)
{
char** rules;
GtkListStore* store = gtk_list_store_new(N_COLS,
G_TYPE_STRING,
G_TYPE_STRING);
rules = g_strsplit(whitelist, ",", 0);
for (int i = 0; rules != NULL && rules[i] != NULL; ++i)
{
GtkTreeIter iter;
char const* s = rules[i];
while (isspace(*s))
{
++s;
}
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, COL_ADDRESS, s, -1);
}
g_strfreev(rules);
return GTK_TREE_MODEL(store);
}
struct remote_page
{
TrCore* core;
GtkTreeView* view;
GtkListStore* store;
GtkWidget* remove_button;
GSList* widgets;
GSList* auth_widgets;
GSList* whitelist_widgets;
GtkToggleButton* rpc_tb;
GtkToggleButton* auth_tb;
GtkToggleButton* whitelist_tb;
};
static void refreshWhitelist(struct remote_page* page)
{
GtkTreeIter iter;
GString* gstr = g_string_new(NULL);
GtkTreeModel* model = GTK_TREE_MODEL(page->store);
if (gtk_tree_model_iter_nth_child(model, &iter, NULL, 0))
{
do
{
char* address;
gtk_tree_model_get(model, &iter, COL_ADDRESS, &address, -1);
g_string_append(gstr, address);
g_string_append(gstr, ",");
g_free(address);
}
while (gtk_tree_model_iter_next(model, &iter));
}
g_string_truncate(gstr, gstr->len - 1); /* remove the trailing comma */
gtr_core_set_pref(page->core, TR_KEY_rpc_whitelist, gstr->str);
g_string_free(gstr, TRUE);
}
static void onAddressEdited(GtkCellRendererText* r UNUSED, gchar* path_string, gchar* address, gpointer gpage)
{
GtkTreeIter iter;
struct remote_page* page = gpage;
GtkTreeModel* model = GTK_TREE_MODEL(page->store);
GtkTreePath* path = gtk_tree_path_new_from_string(path_string);
if (gtk_tree_model_get_iter(model, &iter, path))
{
gtk_list_store_set(page->store, &iter, COL_ADDRESS, address, -1);
}
gtk_tree_path_free(path);
refreshWhitelist(page);
}
static void onAddWhitelistClicked(GtkButton* b UNUSED, gpointer gpage)
{
GtkTreeIter iter;
GtkTreePath* path;
struct remote_page* page = gpage;
gtk_list_store_append(page->store, &iter);
gtk_list_store_set(page->store, &iter, COL_ADDRESS, "0.0.0.0", -1);
path = gtk_tree_model_get_path(GTK_TREE_MODEL(page->store), &iter);
gtk_tree_view_set_cursor(page->view, path, gtk_tree_view_get_column(page->view, COL_ADDRESS), TRUE);
gtk_tree_path_free(path);
}
static void onRemoveWhitelistClicked(GtkButton* b UNUSED, gpointer gpage)
{
struct remote_page* page = gpage;
GtkTreeSelection* sel = gtk_tree_view_get_selection(page->view);
GtkTreeIter iter;
if (gtk_tree_selection_get_selected(sel, NULL, &iter))
{
gtk_list_store_remove(page->store, &iter);
refreshWhitelist(page);
}
}
static void refreshRPCSensitivity(struct remote_page* page)
{
int const rpc_active = gtk_toggle_button_get_active(page->rpc_tb);
int const auth_active = gtk_toggle_button_get_active(page->auth_tb);
int const whitelist_active = gtk_toggle_button_get_active(page->whitelist_tb);
GtkTreeSelection* sel = gtk_tree_view_get_selection(page->view);
int const have_addr = gtk_tree_selection_get_selected(sel, NULL, NULL);
int const n_rules = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(page->store), NULL);
for (GSList* l = page->widgets; l != NULL; l = l->next)
{
gtk_widget_set_sensitive(GTK_WIDGET(l->data), rpc_active);
}
for (GSList* l = page->auth_widgets; l != NULL; l = l->next)
{
gtk_widget_set_sensitive(GTK_WIDGET(l->data), rpc_active && auth_active);
}
for (GSList* l = page->whitelist_widgets; l != NULL; l = l->next)
{
gtk_widget_set_sensitive(GTK_WIDGET(l->data), rpc_active && whitelist_active);
}
gtk_widget_set_sensitive(page->remove_button, rpc_active && have_addr && n_rules > 1);
}
static void onRPCToggled(GtkToggleButton* tb UNUSED, gpointer page)
{
refreshRPCSensitivity(page);
}
static void onWhitelistSelectionChanged(GtkTreeSelection* sel UNUSED, gpointer page)
{
refreshRPCSensitivity(page);
}
static void onLaunchClutchCB(GtkButton* w UNUSED, gpointer data UNUSED)
{
char* uri;
int const port = gtr_pref_int_get(TR_KEY_rpc_port);
uri = g_strdup_printf("http://localhost:%d/", port);
gtr_open_uri(uri);
g_free(uri);
}
static void remotePageFree(gpointer gpage)
{
struct remote_page* page = gpage;
g_slist_free(page->widgets);
g_slist_free(page->auth_widgets);
g_slist_free(page->whitelist_widgets);
g_free(page);
}
static GtkWidget* remotePage(GObject* core)
{
GtkWidget* t;
GtkWidget* w;
GtkWidget* h;
char const* s;
guint row = 0;
struct remote_page* page = g_new0(struct remote_page, 1);
page->core = TR_CORE(core);
t = hig_workarea_create();
g_object_set_data_full(G_OBJECT(t), "page", page, remotePageFree);
hig_workarea_add_section_title(t, &row, _("Remote Control"));
/* "enabled" checkbutton */
s = _("Allow _remote access");
w = new_check_button(s, TR_KEY_rpc_enabled, core);
page->rpc_tb = GTK_TOGGLE_BUTTON(w);
g_signal_connect(w, "clicked", G_CALLBACK(onRPCToggled), page);
h = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, GUI_PAD_BIG);
gtk_box_pack_start(GTK_BOX(h), w, TRUE, TRUE, 0);
w = gtk_button_new_with_mnemonic(_("_Open web client"));
page->widgets = g_slist_prepend(page->widgets, w);
g_signal_connect(w, "clicked", G_CALLBACK(onLaunchClutchCB), NULL);
gtk_box_pack_start(GTK_BOX(h), w, FALSE, FALSE, 0);
hig_workarea_add_wide_control(t, &row, h);
/* port */
w = new_spin_button(TR_KEY_rpc_port, core, 0, USHRT_MAX, 1);
page->widgets = g_slist_prepend(page->widgets, w);
w = hig_workarea_add_row(t, &row, _("HTTP _port:"), w, NULL);
page->widgets = g_slist_prepend(page->widgets, w);
/* require authentication */
s = _("Use _authentication");
w = new_check_button(s, TR_KEY_rpc_authentication_required, core);
hig_workarea_add_wide_control(t, &row, w);
page->auth_tb = GTK_TOGGLE_BUTTON(w);
page->widgets = g_slist_prepend(page->widgets, w);
g_signal_connect(w, "clicked", G_CALLBACK(onRPCToggled), page);
/* username */
s = _("_Username:");
w = new_entry(TR_KEY_rpc_username, core);
page->auth_widgets = g_slist_prepend(page->auth_widgets, w);
w = hig_workarea_add_row(t, &row, s, w, NULL);
page->auth_widgets = g_slist_prepend(page->auth_widgets, w);
/* password */
s = _("Pass_word:");
w = new_entry(TR_KEY_rpc_password, core);
gtk_entry_set_visibility(GTK_ENTRY(w), FALSE);
page->auth_widgets = g_slist_prepend(page->auth_widgets, w);
w = hig_workarea_add_row(t, &row, s, w, NULL);
page->auth_widgets = g_slist_prepend(page->auth_widgets, w);
/* require authentication */
s = _("Only allow these IP a_ddresses:");
w = new_check_button(s, TR_KEY_rpc_whitelist_enabled, core);
hig_workarea_add_wide_control(t, &row, w);
page->whitelist_tb = GTK_TOGGLE_BUTTON(w);
page->widgets = g_slist_prepend(page->widgets, w);
g_signal_connect(w, "clicked", G_CALLBACK(onRPCToggled), page);
/* access control list */
{
char const* val = gtr_pref_string_get(TR_KEY_rpc_whitelist);
GtkTreeModel* m = whitelist_tree_model_new(val);
GtkTreeViewColumn* c;
GtkCellRenderer* r;
GtkTreeSelection* sel;
GtkTreeView* v;
GtkWidget* w;
GtkWidget* h;
page->store = GTK_LIST_STORE(m);
w = gtk_tree_view_new_with_model(m);
g_signal_connect(w, "button-release-event", G_CALLBACK(on_tree_view_button_released), NULL);
page->whitelist_widgets = g_slist_prepend(page->whitelist_widgets, w);
v = page->view = GTK_TREE_VIEW(w);
gtk_widget_set_tooltip_text(w, _("IP addresses may use wildcards, such as 192.168.*.*"));
sel = gtk_tree_view_get_selection(v);
g_signal_connect(sel, "changed",
G_CALLBACK(onWhitelistSelectionChanged), page);
g_object_unref(G_OBJECT(m));
gtk_tree_view_set_headers_visible(v, TRUE);
w = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(w), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(v));
/* ip address column */
r = gtk_cell_renderer_text_new();
g_signal_connect(r, "edited", G_CALLBACK(onAddressEdited), page);
g_object_set(G_OBJECT(r), "editable", TRUE, NULL);
c = gtk_tree_view_column_new_with_attributes(NULL, r, "text", COL_ADDRESS, NULL);
gtk_tree_view_column_set_expand(c, TRUE);
gtk_tree_view_append_column(v, c);
gtk_tree_view_set_headers_visible(v, FALSE);
s = _("Addresses:");
w = hig_workarea_add_row(t, &row, s, w, NULL);
gtk_misc_set_alignment(GTK_MISC(w), 0.0f, 0.0f);
gtk_misc_set_padding(GTK_MISC(w), 0, GUI_PAD);
page->whitelist_widgets = g_slist_prepend(page->whitelist_widgets, w);
h = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, GUI_PAD);
w = gtk_button_new_from_stock(GTK_STOCK_REMOVE);
g_signal_connect(w, "clicked", G_CALLBACK(onRemoveWhitelistClicked), page);
page->remove_button = w;
onWhitelistSelectionChanged(sel, page);
gtk_box_pack_start(GTK_BOX(h), w, TRUE, TRUE, 0);
w = gtk_button_new_from_stock(GTK_STOCK_ADD);
page->whitelist_widgets = g_slist_prepend(page->whitelist_widgets, w);
g_signal_connect(w, "clicked", G_CALLBACK(onAddWhitelistClicked), page);
gtk_box_pack_start(GTK_BOX(h), w, TRUE, TRUE, 0);
w = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(w), gtk_alignment_new(0, 0, 0, 0), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(w), h, FALSE, FALSE, 0);
hig_workarea_add_wide_control(t, &row, w);
}
refreshRPCSensitivity(page);
return t;
}
/****
***** Bandwidth Tab
****/
struct BandwidthPage
{
TrCore* core;
GSList* sched_widgets;
};
static void refreshSchedSensitivity(struct BandwidthPage* p)
{
gboolean const sched_enabled = gtr_pref_flag_get(TR_KEY_alt_speed_time_enabled);
for (GSList* l = p->sched_widgets; l != NULL; l = l->next)
{
gtk_widget_set_sensitive(GTK_WIDGET(l->data), sched_enabled);
}
}
static void onSchedToggled(GtkToggleButton* tb UNUSED, gpointer user_data)
{
refreshSchedSensitivity(user_data);
}
static void onTimeComboChanged(GtkComboBox* w, gpointer core)
{
GtkTreeIter iter;
if (gtk_combo_box_get_active_iter(w, &iter))
{
int val = 0;
tr_quark const key = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(w), PREF_KEY));
gtk_tree_model_get(gtk_combo_box_get_model(w), &iter, 0, &val, -1);
gtr_core_set_pref_int(TR_CORE(core), key, val);
}
}
static GtkWidget* new_time_combo(GObject* core, tr_quark const key)
{
int val;
GtkWidget* w;
GtkCellRenderer* r;
GtkListStore* store;
/* build a store at 15 minute intervals */
store = gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING);
for (int i = 0; i < 60 * 24; i += 15)
{
char buf[128];
GtkTreeIter iter;
g_snprintf(buf, sizeof(buf), "%02d:%02d", i / 60, i % 60);
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, i, 1, buf, -1);
}
/* build the widget */
w = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(w), 4);
r = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(w), r, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(w), r, "text", 1, NULL);
g_object_set_data(G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
val = gtr_pref_int_get(key);
gtk_combo_box_set_active(GTK_COMBO_BOX(w), val / (15));
g_signal_connect(w, "changed", G_CALLBACK(onTimeComboChanged), core);
/* cleanup */
g_object_unref(G_OBJECT(store));
return w;
}
static GtkWidget* new_week_combo(GObject* core, tr_quark const key)
{
GtkWidget* w = gtr_combo_box_new_enum(
_("Every Day"), TR_SCHED_ALL,
_("Weekdays"), TR_SCHED_WEEKDAY,
_("Weekends"), TR_SCHED_WEEKEND,
_("Sunday"), TR_SCHED_SUN,
_("Monday"), TR_SCHED_MON,
_("Tuesday"), TR_SCHED_TUES,
_("Wednesday"), TR_SCHED_WED,
_("Thursday"), TR_SCHED_THURS,
_("Friday"), TR_SCHED_FRI,
_("Saturday"), TR_SCHED_SAT,
NULL);
gtr_combo_box_set_active_enum(GTK_COMBO_BOX(w), gtr_pref_int_get(key));
g_object_set_data(G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
g_signal_connect(w, "changed", G_CALLBACK(onIntComboChanged), core);
return w;
}
static void speedPageFree(gpointer gpage)
{
struct BandwidthPage* page = gpage;
g_slist_free(page->sched_widgets);
g_free(page);
}
static GtkWidget* speedPage(GObject* core)
{
char const* s;
GtkWidget* t;
GtkWidget* l;
GtkWidget* w;
GtkWidget* w2;
GtkWidget* h;
char buf[512];
guint row = 0;
struct BandwidthPage* page = tr_new0(struct BandwidthPage, 1);
page->core = TR_CORE(core);
t = hig_workarea_create();
hig_workarea_add_section_title(t, &row, _("Speed Limits"));
g_snprintf(buf, sizeof(buf), _("_Upload (%s):"), _(speed_K_str));
w = new_check_button(buf, TR_KEY_speed_limit_up_enabled, core);
w2 = new_spin_button(TR_KEY_speed_limit_up, core, 0, INT_MAX, 5);
gtk_widget_set_sensitive(GTK_WIDGET(w2), gtr_pref_flag_get(TR_KEY_speed_limit_up_enabled));
g_signal_connect(w, "toggled", G_CALLBACK(target_cb), w2);
hig_workarea_add_row_w(t, &row, w, w2, NULL);
g_snprintf(buf, sizeof(buf), _("_Download (%s):"), _(speed_K_str));
w = new_check_button(buf, TR_KEY_speed_limit_down_enabled, core);
w2 = new_spin_button(TR_KEY_speed_limit_down, core, 0, INT_MAX, 5);
gtk_widget_set_sensitive(GTK_WIDGET(w2), gtr_pref_flag_get(TR_KEY_speed_limit_down_enabled));
g_signal_connect(w, "toggled", G_CALLBACK(target_cb), w2);
hig_workarea_add_row_w(t, &row, w, w2, NULL);
hig_workarea_add_section_divider(t, &row);
h = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, GUI_PAD);
g_snprintf(buf, sizeof(buf), "<b>%s</b>", _("Alternative Speed Limits"));
w = gtk_label_new(buf);
gtk_misc_set_alignment(GTK_MISC(w), 0.0f, 0.5f);
gtk_label_set_use_markup(GTK_LABEL(w), TRUE);
gtk_box_pack_start(GTK_BOX(h), w, FALSE, FALSE, 0);
w = gtk_image_new_from_stock("alt-speed-on", -1);
gtk_box_pack_start(GTK_BOX(h), w, FALSE, FALSE, 0);
hig_workarea_add_section_title_widget(t, &row, h);
s = _("Override normal speed limits manually or at scheduled times");
g_snprintf(buf, sizeof(buf), "<small>%s</small>", s);
w = gtk_label_new(buf);
gtk_label_set_use_markup(GTK_LABEL(w), TRUE);
gtk_misc_set_alignment(GTK_MISC(w), 0.0f, 0.5f);
hig_workarea_add_wide_control(t, &row, w);
g_snprintf(buf, sizeof(buf), _("U_pload (%s):"), _(speed_K_str));
w = new_spin_button(TR_KEY_alt_speed_up, core, 0, INT_MAX, 5);
hig_workarea_add_row(t, &row, buf, w, NULL);
g_snprintf(buf, sizeof(buf), _("Do_wnload (%s):"), _(speed_K_str));
w = new_spin_button(TR_KEY_alt_speed_down, core, 0, INT_MAX, 5);
hig_workarea_add_row(t, &row, buf, w, NULL);
s = _("_Scheduled times:");
h = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
w2 = new_time_combo(core, TR_KEY_alt_speed_time_begin);
page->sched_widgets = g_slist_prepend(page->sched_widgets, w2);
gtk_box_pack_start(GTK_BOX(h), w2, TRUE, TRUE, 0);
w2 = l = gtk_label_new_with_mnemonic(_(" _to "));
page->sched_widgets = g_slist_prepend(page->sched_widgets, w2);
gtk_box_pack_start(GTK_BOX(h), w2, FALSE, FALSE, 0);
w2 = new_time_combo(core, TR_KEY_alt_speed_time_end);
gtk_label_set_mnemonic_widget(GTK_LABEL(l), w2);
page->sched_widgets = g_slist_prepend(page->sched_widgets, w2);
gtk_box_pack_start(GTK_BOX(h), w2, TRUE, TRUE, 0);
w = new_check_button(s, TR_KEY_alt_speed_time_enabled, core);
g_signal_connect(w, "toggled", G_CALLBACK(onSchedToggled), page);
hig_workarea_add_row_w(t, &row, w, h, NULL);
s = _("_On days:");
w = new_week_combo(core, TR_KEY_alt_speed_time_day);
page->sched_widgets = g_slist_prepend(page->sched_widgets, w);
w = hig_workarea_add_row(t, &row, s, w, NULL);
page->sched_widgets = g_slist_prepend(page->sched_widgets, w);
g_object_set_data_full(G_OBJECT(t), "page", page, speedPageFree);
refreshSchedSensitivity(page);
return t;
}
/****
***** Network Tab
****/
struct network_page_data
{
TrCore* core;
GtkWidget* portLabel;
GtkWidget* portButton;
GtkWidget* portSpin;
gulong portTag;
gulong prefsTag;
};
static void onCorePrefsChanged(TrCore* core UNUSED, tr_quark const key, gpointer gdata)
{
if (key == TR_KEY_peer_port)
{
struct network_page_data* data = gdata;
gtr_label_set_text(GTK_LABEL(data->portLabel), _("Status unknown"));
gtk_widget_set_sensitive(data->portButton, TRUE);
gtk_widget_set_sensitive(data->portSpin, TRUE);
}
}
static void networkPageDestroyed(gpointer gdata, GObject* dead UNUSED)
{
struct network_page_data* data = gdata;
if (data->prefsTag > 0)
{
g_signal_handler_disconnect(data->core, data->prefsTag);
}
if (data->portTag > 0)
{
g_signal_handler_disconnect(data->core, data->portTag);
}
g_free(data);
}
static void onPortTested(TrCore* core UNUSED, gboolean isOpen, gpointer vdata)
{
struct network_page_data* data = vdata;
char const* markup = isOpen ? _("Port is <b>open</b>") : _("Port is <b>closed</b>");
// gdk_threads_enter();
gtk_label_set_markup(GTK_LABEL(data->portLabel), markup);
gtk_widget_set_sensitive(data->portButton, TRUE);
gtk_widget_set_sensitive(data->portSpin, TRUE);
// gdk_threads_leave();
}
static void onPortTest(GtkButton* button UNUSED, gpointer vdata)
{
struct network_page_data* data = vdata;
gtk_widget_set_sensitive(data->portButton, FALSE);
gtk_widget_set_sensitive(data->portSpin, FALSE);
gtk_label_set_markup(GTK_LABEL(data->portLabel), _("<i>Testing TCP port…</i>"));
if (data->portTag == 0)
{
data->portTag = g_signal_connect(data->core, "port-tested", G_CALLBACK(onPortTested), data);
}
gtr_core_port_test(data->core);
}
static GtkWidget* networkPage(GObject* core)
{
GtkWidget* t;
GtkWidget* w;
GtkWidget* h;
GtkWidget* l;
char const* s;
struct network_page_data* data;
guint row = 0;
/* register to stop listening to core prefs changes when the page is destroyed */
data = g_new0(struct network_page_data, 1);
data->core = TR_CORE(core);
/* build the page */
t = hig_workarea_create();
hig_workarea_add_section_title(t, &row, _("Listening Port"));
s = _("_Port used for incoming connections:");
w = data->portSpin = new_spin_button(TR_KEY_peer_port, core, 1, USHRT_MAX, 1);
hig_workarea_add_row(t, &row, s, w, NULL);
h = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, GUI_PAD_BIG);
l = data->portLabel = gtk_label_new(_("Status unknown"));
gtk_misc_set_alignment(GTK_MISC(l), 0.0f, 0.5f);
gtk_box_pack_start(GTK_BOX(h), l, TRUE, TRUE, 0);
w = data->portButton = gtk_button_new_with_mnemonic(_("Te_st Port"));
gtk_box_pack_end(GTK_BOX(h), w, FALSE, FALSE, 0);
g_signal_connect(w, "clicked", G_CALLBACK(onPortTest), data);
hig_workarea_add_row(t, &row, NULL, h, NULL);
data->prefsTag = g_signal_connect(TR_CORE(core), "prefs-changed", G_CALLBACK(onCorePrefsChanged), data);
g_object_weak_ref(G_OBJECT(t), networkPageDestroyed, data);
s = _("Pick a _random port every time Transmission is started");
w = new_check_button(s, TR_KEY_peer_port_random_on_start, core);
hig_workarea_add_wide_control(t, &row, w);
s = _("Use UPnP or NAT-PMP port _forwarding from my router");
w = new_check_button(s, TR_KEY_port_forwarding_enabled, core);
hig_workarea_add_wide_control(t, &row, w);
hig_workarea_add_section_divider(t, &row);
hig_workarea_add_section_title(t, &row, _("Peer Limits"));
w = new_spin_button(TR_KEY_peer_limit_per_torrent, core, 1, FD_SETSIZE, 5);
hig_workarea_add_row(t, &row, _("Maximum peers per _torrent:"), w, NULL);
w = new_spin_button(TR_KEY_peer_limit_global, core, 1, FD_SETSIZE, 5);
hig_workarea_add_row(t, &row, _("Maximum peers _overall:"), w, NULL);
hig_workarea_add_section_divider(t, &row);
hig_workarea_add_section_title(t, &row, _("Options"));
#ifdef WITH_UTP
s = _("Enable _uTP for peer communication");
w = new_check_button(s, TR_KEY_utp_enabled, core);
s = _("uTP is a tool for reducing network congestion.");
gtk_widget_set_tooltip_text(w, s);
hig_workarea_add_wide_control(t, &row, w);
#endif
s = _("Use PE_X to find more peers");
w = new_check_button(s, TR_KEY_pex_enabled, core);
s = _("PEX is a tool for exchanging peer lists with the peers you're connected to.");
gtk_widget_set_tooltip_text(w, s);
hig_workarea_add_wide_control(t, &row, w);
s = _("Use _DHT to find more peers");
w = new_check_button(s, TR_KEY_dht_enabled, core);
s = _("DHT is a tool for finding peers without a tracker.");
gtk_widget_set_tooltip_text(w, s);
hig_workarea_add_wide_control(t, &row, w);
s = _("Use _Local Peer Discovery to find more peers");
w = new_check_button(s, TR_KEY_lpd_enabled, core);
s = _("LPD is a tool for finding peers on your local network.");
gtk_widget_set_tooltip_text(w, s);
hig_workarea_add_wide_control(t, &row, w);
return t;
}
/****
*****
****/
static void on_prefs_dialog_destroyed(gpointer gdata, GObject* dead_dialog G_GNUC_UNUSED)
{
struct prefs_dialog_data* data = gdata;
if (data->core_prefs_tag > 0)
{
g_signal_handler_disconnect(data->core, data->core_prefs_tag);
}
g_free(data);
}
static void on_core_prefs_changed(TrCore* core, tr_quark const key, gpointer gdata)
{
struct prefs_dialog_data* data = gdata;
#if 0
if (key == TR_KEY_peer_port)
{
gtr_label_set_text(GTK_LABEL(data->port_label), _("Status unknown"));
gtk_widget_set_sensitive(data->port_button, TRUE);
gtk_widget_set_sensitive(data->port_spin, TRUE);
}
#endif
if (key == TR_KEY_download_dir)
{
char const* downloadDir = tr_sessionGetDownloadDir(gtr_core_session(core));
gtr_freespace_label_set_dir(data->freespace_label, downloadDir);
}
}
GtkWidget* gtr_prefs_dialog_new(GtkWindow* parent, GObject* core)
{
GtkWidget* d;
GtkWidget* n;
struct prefs_dialog_data* data;
tr_quark const prefs_quarks[] = { TR_KEY_peer_port, TR_KEY_download_dir };
data = g_new0(struct prefs_dialog_data, 1);
data->core = TR_CORE(core);
data->core_prefs_tag = g_signal_connect(TR_CORE(core), "prefs-changed", G_CALLBACK(on_core_prefs_changed), data);
d = gtk_dialog_new_with_buttons(_("Transmission Preferences"), parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_HELP,
GTK_RESPONSE_HELP, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
g_object_weak_ref(G_OBJECT(d), on_prefs_dialog_destroyed, data);
gtk_window_set_role(GTK_WINDOW(d), "transmission-preferences-dialog");
gtk_container_set_border_width(GTK_CONTAINER(d), GUI_PAD);
n = gtk_notebook_new();
gtk_container_set_border_width(GTK_CONTAINER(n), GUI_PAD);
gtk_notebook_append_page(GTK_NOTEBOOK(n), speedPage(core), gtk_label_new(_("Speed")));
gtk_notebook_append_page(GTK_NOTEBOOK(n), downloadingPage(core, data), gtk_label_new(C_("Gerund", "Downloading")));
gtk_notebook_append_page(GTK_NOTEBOOK(n), seedingPage(core), gtk_label_new(C_("Gerund", "Seeding")));
gtk_notebook_append_page(GTK_NOTEBOOK(n), privacyPage(core), gtk_label_new(_("Privacy")));
gtk_notebook_append_page(GTK_NOTEBOOK(n), networkPage(core), gtk_label_new(_("Network")));
gtk_notebook_append_page(GTK_NOTEBOOK(n), desktopPage(core), gtk_label_new(_("Desktop")));
gtk_notebook_append_page(GTK_NOTEBOOK(n), remotePage(core), gtk_label_new(_("Remote")));
/* init from prefs keys */
for (size_t i = 0; i < G_N_ELEMENTS(prefs_quarks); ++i)
{
on_core_prefs_changed(TR_CORE(core), prefs_quarks[i], data);
}
g_signal_connect(d, "response", G_CALLBACK(response_cb), core);
gtr_dialog_set_content(GTK_DIALOG(d), n);
return d;
}