// This file Copyright © 2007-2022 Mnemosyne LLC. // It may be used under GPLv2 (SPDX: GPL-2.0-only), GPLv3 (SPDX: GPL-3.0-only), // or any future license endorsed by Mnemosyne LLC. // License text can be found in the licenses/ folder. #include #include #include #include #include #include #include #include #include #include #include "FreeSpaceLabel.h" #include "PathButton.h" #include "Prefs.h" #include "PrefsDialog.h" #include "Session.h" #include "SystemTrayIcon.h" #include "Utils.h" /** *** **/ class PrefsDialog::Impl { public: Impl(PrefsDialog& dialog, Glib::RefPtr const& builder, Glib::RefPtr const& core); TR_DISABLE_COPY_MOVE(Impl) private: void response_cb(int response); private: PrefsDialog& dialog_; Glib::RefPtr const core_; }; /** *** **/ void PrefsDialog::Impl::response_cb(int response) { if (response == TR_GTK_RESPONSE_TYPE(HELP)) { gtr_open_uri(gtr_get_help_uri() + "/html/preferences.html"); } if (response == TR_GTK_RESPONSE_TYPE(CLOSE)) { dialog_.close(); } } namespace { void init_check_button(Gtk::CheckButton& button, tr_quark const key, Glib::RefPtr const& core) { button.set_active(gtr_pref_flag_get(key)); button.signal_toggled().connect([&button, key, core]() { core->set_pref(key, button.get_active()); }); } auto const IdleDataKey = Glib::Quark("idle-data"); bool spun_cb_idle(Gtk::SpinButton* spin, tr_quark const key, Glib::RefPtr const& core, bool isDouble) { bool keep_waiting = true; /* has the user stopped making changes? */ if (auto const* const last_change = static_cast(spin->get_data(IdleDataKey)); last_change->elapsed() > 0.33) { /* update the core */ if (isDouble) { double const value = spin->get_value(); core->set_pref(key, value); } else { int const value = spin->get_value_as_int(); core->set_pref(key, value); } /* cleanup */ spin->set_data(IdleDataKey, nullptr); keep_waiting = false; spin->unreference(); } return keep_waiting; } void spun_cb(Gtk::SpinButton* w, tr_quark const key, Glib::RefPtr const& core, bool isDouble) { /* user may be spinning through many values, so let's hold off for a moment to keep from flooding the core with changes */ auto* last_change = static_cast(w->get_data(IdleDataKey)); if (last_change == nullptr) { last_change = new Glib::Timer(); w->set_data(IdleDataKey, last_change, [](gpointer p) { delete static_cast(p); }); w->reference(); Glib::signal_timeout().connect_seconds([w, key, core, isDouble]() { return spun_cb_idle(w, key, core, isDouble); }, 1); } last_change->start(); } void init_spin_button( Gtk::SpinButton& button, tr_quark const key, Glib::RefPtr const& core, int low, int high, int step) { button.set_adjustment(Gtk::Adjustment::create(gtr_pref_int_get(key), low, high, step)); button.set_digits(0); button.signal_value_changed().connect([&button, key, core]() { spun_cb(&button, key, core, false); }); } void init_spin_button_double( Gtk::SpinButton& button, tr_quark const key, Glib::RefPtr const& core, double low, double high, double step) { button.set_adjustment(Gtk::Adjustment::create(gtr_pref_double_get(key), low, high, step)); button.set_digits(2); button.signal_value_changed().connect([&button, key, core]() { spun_cb(&button, key, core, true); }); } void entry_changed_cb(Gtk::Entry* w, tr_quark const key, Glib::RefPtr const& core) { core->set_pref(key, w->get_text()); } void init_entry(Gtk::Entry& entry, tr_quark const key, Glib::RefPtr const& core) { if (auto const value = gtr_pref_string_get(key); !value.empty()) { entry.set_text(value); } entry.signal_changed().connect([&entry, key, core]() { entry_changed_cb(&entry, key, core); }); } void init_text_view(Gtk::TextView& view, tr_quark const key, Glib::RefPtr const& core) { auto buffer = view.get_buffer(); buffer->set_text(gtr_pref_string_get(key)); auto const save_buffer = [buffer, key, core]() { core->set_pref(key, buffer->get_text()); }; #if GTKMM_CHECK_VERSION(4, 0, 0) auto focus_controller = Gtk::EventControllerFocus::create(); focus_controller->signal_leave().connect(save_buffer); view.add_controller(focus_controller); #else view.add_events(Gdk::FOCUS_CHANGE_MASK); view.signal_focus_out_event().connect_notify(sigc::hide<0>(save_buffer)); #endif } void chosen_cb(PathButton* w, tr_quark const key, Glib::RefPtr const& core) { core->set_pref(key, w->get_filename()); } void init_chooser_button(PathButton& button, tr_quark const key, Glib::RefPtr const& core) { if (auto const path = gtr_pref_string_get(key); !path.empty()) { button.set_filename(path); } button.signal_selection_changed().connect([&button, key, core]() { chosen_cb(&button, key, core); }); } } // namespace /**** ***** Download Tab ****/ namespace { class DownloadingPage : public Gtk::Box { public: DownloadingPage(BaseObjectType* cast_item, Glib::RefPtr const& builder, Glib::RefPtr const& core); ~DownloadingPage() override; TR_DISABLE_COPY_MOVE(DownloadingPage) private: void on_core_prefs_changed(tr_quark key); private: Glib::RefPtr const core_; FreeSpaceLabel* freespace_label_ = nullptr; sigc::connection core_prefs_tag_; }; void DownloadingPage::on_core_prefs_changed(tr_quark const key) { if (key == TR_KEY_download_dir) { char const* downloadDir = tr_sessionGetDownloadDir(core_->get_session()); freespace_label_->set_dir(downloadDir); } } DownloadingPage::~DownloadingPage() { if (core_prefs_tag_.connected()) { core_prefs_tag_.disconnect(); } } DownloadingPage::DownloadingPage( BaseObjectType* cast_item, Glib::RefPtr const& builder, Glib::RefPtr const& core) : Gtk::Box(cast_item) , core_(core) , freespace_label_(gtr_get_widget_derived(builder, "download_dir_stats_label", core)) { core_prefs_tag_ = core_->signal_prefs_changed().connect(sigc::mem_fun(*this, &DownloadingPage::on_core_prefs_changed)); { auto* l = gtr_get_widget(builder, "watch_dir_check"); init_check_button(*l, TR_KEY_watch_dir_enabled, core_); auto* w = gtr_get_widget_derived(builder, "watch_dir_chooser"); init_chooser_button(*w, TR_KEY_watch_dir, core_); } init_check_button( *gtr_get_widget(builder, "show_options_dialog_check"), TR_KEY_show_options_window, core); init_check_button(*gtr_get_widget(builder, "start_on_add_check"), TR_KEY_start_added_torrents, core_); init_check_button( *gtr_get_widget(builder, "trash_on_add_check"), TR_KEY_trash_original_torrent_files, core_); init_chooser_button(*gtr_get_widget_derived(builder, "download_dir_chooser"), TR_KEY_download_dir, core_); init_spin_button( *gtr_get_widget(builder, "max_active_downloads_spin"), TR_KEY_download_queue_size, core_, 0, std::numeric_limits::max(), 1); init_spin_button( *gtr_get_widget(builder, "max_inactive_time_spin"), TR_KEY_queue_stalled_minutes, core_, 1, std::numeric_limits::max(), 15); init_check_button( *gtr_get_widget(builder, "append_suffix_to_incomplete_check"), TR_KEY_rename_partial_files, core_); { auto* l = gtr_get_widget(builder, "incomplete_dir_check"); init_check_button(*l, TR_KEY_incomplete_dir_enabled, core_); auto* w = gtr_get_widget_derived(builder, "incomplete_dir_chooser"); init_chooser_button(*w, TR_KEY_incomplete_dir, core_); } { auto* l = gtr_get_widget(builder, "download_done_script_check"); init_check_button(*l, TR_KEY_script_torrent_done_enabled, core_); auto* w = gtr_get_widget_derived(builder, "download_done_script_chooser"); init_chooser_button(*w, TR_KEY_script_torrent_done_filename, core_); } on_core_prefs_changed(TR_KEY_download_dir); } } // namespace /**** ***** Torrent Tab ****/ namespace { class SeedingPage : public Gtk::Box { public: SeedingPage(BaseObjectType* cast_item, Glib::RefPtr const& builder, Glib::RefPtr const& core); TR_DISABLE_COPY_MOVE(SeedingPage) private: Glib::RefPtr const core_; }; SeedingPage::SeedingPage( BaseObjectType* cast_item, Glib::RefPtr const& builder, Glib::RefPtr const& core) : Gtk::Box(cast_item) , core_(core) { { auto* w = gtr_get_widget(builder, "stop_seeding_ratio_check"); init_check_button(*w, TR_KEY_ratio_limit_enabled, core_); auto* w2 = gtr_get_widget(builder, "stop_seeding_ratio_spin"); init_spin_button_double(*w2, TR_KEY_ratio_limit, core_, 0, 1000, .05); } { auto* w = gtr_get_widget(builder, "stop_seeding_timeout_check"); init_check_button(*w, TR_KEY_idle_seeding_limit_enabled, core_); auto* w2 = gtr_get_widget(builder, "stop_seeding_timeout_spin"); init_spin_button(*w2, TR_KEY_idle_seeding_limit, core_, 1, 40320, 5); } { auto* l = gtr_get_widget(builder, "seeding_done_script_check"); init_check_button(*l, TR_KEY_script_torrent_done_seeding_enabled, core_); auto* w = gtr_get_widget_derived(builder, "seeding_done_script_chooser"); init_chooser_button(*w, TR_KEY_script_torrent_done_seeding_filename, core_); } } } // namespace /**** ***** Desktop Tab ****/ namespace { class DesktopPage : public Gtk::Box { public: DesktopPage(BaseObjectType* cast_item, Glib::RefPtr const& builder, Glib::RefPtr const& core); TR_DISABLE_COPY_MOVE(DesktopPage) private: Glib::RefPtr const core_; }; DesktopPage::DesktopPage( BaseObjectType* cast_item, Glib::RefPtr const& builder, Glib::RefPtr const& core) : Gtk::Box(cast_item) , core_(core) { init_check_button( *gtr_get_widget(builder, "inhibit_hibernation_check"), TR_KEY_inhibit_desktop_hibernation, core_); if (auto* const show_systray_icon_check = gtr_get_widget(builder, "show_systray_icon_check"); SystemTrayIcon::is_available()) { init_check_button(*show_systray_icon_check, TR_KEY_show_notification_area_icon, core_); } else { show_systray_icon_check->hide(); } init_check_button( *gtr_get_widget(builder, "notify_on_torrent_add_check"), TR_KEY_torrent_added_notification_enabled, core_); init_check_button( *gtr_get_widget(builder, "notify_on_torrent_finish_check"), TR_KEY_torrent_complete_notification_enabled, core_); init_check_button( *gtr_get_widget(builder, "ding_no_torrent_finish_check"), TR_KEY_torrent_complete_sound_enabled, core_); } } // namespace /**** ***** Peer Tab ****/ namespace { class PrivacyPage : public Gtk::Box { public: PrivacyPage(BaseObjectType* cast_item, Glib::RefPtr const& builder, Glib::RefPtr const& core); ~PrivacyPage() override; TR_DISABLE_COPY_MOVE(PrivacyPage) private: void updateBlocklistText(); void onBlocklistUpdateResponse(); void onBlocklistUpdated(int n); void onBlocklistUpdate(); void on_blocklist_url_changed(Gtk::Editable* e); static void init_encryption_combo(Gtk::ComboBox& combo, Glib::RefPtr const& core, tr_quark key); private: Glib::RefPtr core_; Gtk::Button* updateBlocklistButton_ = nullptr; Gtk::Label* label_ = nullptr; Gtk::CheckButton* check_ = nullptr; sigc::connection updateBlocklistTag_; std::unique_ptr updateBlocklistDialog_; }; void PrivacyPage::updateBlocklistText() { int const n = tr_blocklistGetRuleCount(core_->get_session()); auto const msg = fmt::format( ngettext("Blocklist has {count:L} entry", "Blocklist has {count:L} entries", n), fmt::arg("count", n)); label_->set_markup(fmt::format(FMT_STRING("{:s}"), msg)); } /* prefs dialog is being destroyed, so stop listening to blocklist updates */ PrivacyPage::~PrivacyPage() { if (updateBlocklistTag_.connected()) { updateBlocklistTag_.disconnect(); } } /* user hit "close" in the blocklist-update dialog */ void PrivacyPage::onBlocklistUpdateResponse() { updateBlocklistButton_->set_sensitive(true); updateBlocklistDialog_.reset(); updateBlocklistTag_.disconnect(); } /* core says the blocklist was updated */ void PrivacyPage::onBlocklistUpdated(int n) { bool const success = n >= 0; int const count = n >= 0 ? n : tr_blocklistGetRuleCount(core_->get_session()); auto const msg = fmt::format( ngettext("Blocklist has {count:L} entry", "Blocklist has {count:L} entries", count), fmt::arg("count", count)); updateBlocklistButton_->set_sensitive(true); updateBlocklistDialog_->set_message( fmt::format(FMT_STRING("{:s}"), success ? _("Blocklist updated!") : _("Couldn't update blocklist")), true); updateBlocklistDialog_->set_secondary_text(msg); updateBlocklistText(); } /* user pushed a button to update the blocklist */ void PrivacyPage::onBlocklistUpdate() { updateBlocklistDialog_ = std::make_unique( *static_cast(TR_GTK_WIDGET_GET_ROOT(*this)), _("Update Blocklist"), false, TR_GTK_MESSAGE_TYPE(INFO), TR_GTK_BUTTONS_TYPE(CLOSE)); updateBlocklistButton_->set_sensitive(false); updateBlocklistDialog_->set_secondary_text(_("Getting new blocklist…")); updateBlocklistDialog_->signal_response().connect([this](int /*response*/) { onBlocklistUpdateResponse(); }); updateBlocklistDialog_->show(); core_->blocklist_update(); updateBlocklistTag_ = core_->signal_blocklist_updated().connect([this](auto n) { onBlocklistUpdated(n); }); } void PrivacyPage::on_blocklist_url_changed(Gtk::Editable* e) { auto const url = e->get_chars(0, -1); updateBlocklistButton_->set_sensitive(tr_urlIsValid(url.c_str())); } void onIntComboChanged(Gtk::ComboBox* combo_box, tr_quark const key, Glib::RefPtr const& core) { core->set_pref(key, gtr_combo_box_get_active_enum(*combo_box)); } void PrivacyPage::init_encryption_combo(Gtk::ComboBox& combo, Glib::RefPtr const& core, tr_quark const key) { gtr_combo_box_set_enum( combo, { { _("Allow encryption"), TR_CLEAR_PREFERRED }, { _("Prefer encryption"), TR_ENCRYPTION_PREFERRED }, { _("Require encryption"), TR_ENCRYPTION_REQUIRED }, }); gtr_combo_box_set_active_enum(combo, gtr_pref_int_get(key)); combo.signal_changed().connect([&combo, key, core]() { onIntComboChanged(&combo, key, core); }); } PrivacyPage::PrivacyPage( BaseObjectType* cast_item, Glib::RefPtr const& builder, Glib::RefPtr const& core) : Gtk::Box(cast_item) , core_(core) , updateBlocklistButton_(gtr_get_widget(builder, "update_blocklist_button")) , label_(gtr_get_widget(builder, "blocklist_stats_label")) , check_(gtr_get_widget(builder, "blocklist_check")) { init_encryption_combo(*gtr_get_widget(builder, "encryption_mode_combo"), core_, TR_KEY_encryption); init_check_button(*check_, TR_KEY_blocklist_enabled, core_); auto* const e = gtr_get_widget(builder, "blocklist_url_entry"); init_entry(*e, TR_KEY_blocklist_url, core_); updateBlocklistText(); updateBlocklistButton_->set_data("session", core_->get_session()); updateBlocklistButton_->signal_clicked().connect([this]() { onBlocklistUpdate(); }); updateBlocklistButton_->set_sensitive(check_->get_active()); e->signal_changed().connect([this, e]() { on_blocklist_url_changed(e); }); on_blocklist_url_changed(e); auto* update_check = gtr_get_widget(builder, "blocklist_autoupdate_check"); init_check_button(*update_check, TR_KEY_blocklist_updates_enabled, core_); } } // namespace /**** ***** Remote Tab ****/ namespace { class WhitelistModelColumns : public Gtk::TreeModelColumnRecord { public: WhitelistModelColumns() { add(address); } Gtk::TreeModelColumn address; }; WhitelistModelColumns const whitelist_cols; Glib::RefPtr whitelist_tree_model_new(std::string const& whitelist) { auto const store = Gtk::ListStore::create(whitelist_cols); std::istringstream stream(whitelist); std::string s; while (std::getline(stream, s, ',')) { s = gtr_str_strip(s); if (s.empty()) { continue; } auto const iter = store->append(); (*iter)[whitelist_cols.address] = s; } return store; } class RemotePage : public Gtk::Box { public: RemotePage(BaseObjectType* cast_item, Glib::RefPtr const& builder, Glib::RefPtr const& core); TR_DISABLE_COPY_MOVE(RemotePage) private: void refreshWhitelist(); void onAddressEdited(Glib::ustring const& path, Glib::ustring const& address); void onAddWhitelistClicked(); void onRemoveWhitelistClicked(); void refreshRPCSensitivity(); private: Glib::RefPtr core_; Gtk::TreeView* view_; Gtk::Button* remove_button_; Gtk::CheckButton* rpc_tb_; Gtk::CheckButton* auth_tb_; Gtk::CheckButton* whitelist_tb_; Glib::RefPtr store_; std::vector auth_widgets_; std::vector whitelist_widgets_; }; void RemotePage::refreshWhitelist() { std::ostringstream gstr; for (auto const& row : store_->children()) { gstr << row.get_value(whitelist_cols.address) << ","; } auto str = gstr.str(); if (!str.empty()) { str.resize(str.size() - 1); /* remove the trailing comma */ } core_->set_pref(TR_KEY_rpc_whitelist, str); } void RemotePage::onAddressEdited(Glib::ustring const& path, Glib::ustring const& address) { if (auto const iter = store_->get_iter(path); iter) { (*iter)[whitelist_cols.address] = address; } refreshWhitelist(); } void RemotePage::onAddWhitelistClicked() { auto const iter = store_->append(); (*iter)[whitelist_cols.address] = "0.0.0.0"; view_->set_cursor(store_->get_path(iter), *view_->get_column(0), true); } void RemotePage::onRemoveWhitelistClicked() { auto const sel = view_->get_selection(); if (auto const iter = sel->get_selected(); iter) { store_->erase(iter); refreshWhitelist(); } } void RemotePage::refreshRPCSensitivity() { bool const rpc_active = rpc_tb_->get_active(); bool const auth_active = auth_tb_->get_active(); bool const whitelist_active = whitelist_tb_->get_active(); auto const sel = view_->get_selection(); auto const have_addr = sel->get_selected(); auto const n_rules = store_->children().size(); for (auto* const widget : auth_widgets_) { widget->set_sensitive(rpc_active && auth_active); } for (auto* const widget : whitelist_widgets_) { widget->set_sensitive(rpc_active && whitelist_active); } remove_button_->set_sensitive(rpc_active && whitelist_active && have_addr && n_rules > 1); } void onLaunchClutchCB() { gtr_open_uri(fmt::format("http://localhost:{}/", gtr_pref_int_get(TR_KEY_rpc_port))); } } // namespace RemotePage::RemotePage(BaseObjectType* cast_item, Glib::RefPtr const& builder, Glib::RefPtr const& core) : Gtk::Box(cast_item) , core_(core) , view_(gtr_get_widget(builder, "rpc_whitelist_view")) , remove_button_(gtr_get_widget(builder, "remove_from_rpc_whistlist_button")) , rpc_tb_(gtr_get_widget(builder, "enable_rpc_check")) , auth_tb_(gtr_get_widget(builder, "enable_rpc_auth_check")) , whitelist_tb_(gtr_get_widget(builder, "rpc_whitelist_check")) { /* "enabled" checkbutton */ init_check_button(*rpc_tb_, TR_KEY_rpc_enabled, core_); rpc_tb_->signal_toggled().connect([this]() { refreshRPCSensitivity(); }); auto* const open_button = gtr_get_widget(builder, "open_web_client_button"); open_button->signal_clicked().connect(&onLaunchClutchCB); /* port */ auto* port_spin = gtr_get_widget(builder, "rpc_port_spin"); init_spin_button(*port_spin, TR_KEY_rpc_port, core_, 0, std::numeric_limits::max(), 1); /* require authentication */ init_check_button(*auth_tb_, TR_KEY_rpc_authentication_required, core_); auth_tb_->signal_toggled().connect([this]() { refreshRPCSensitivity(); }); /* username */ auto* username_entry = gtr_get_widget(builder, "rpc_username_entry"); init_entry(*username_entry, TR_KEY_rpc_username, core_); auth_widgets_.push_back(username_entry); auth_widgets_.push_back(gtr_get_widget(builder, "rpc_username_label")); /* password */ auto* password_entry = gtr_get_widget(builder, "rpc_password_entry"); init_entry(*password_entry, TR_KEY_rpc_password, core_); auth_widgets_.push_back(password_entry); auth_widgets_.push_back(gtr_get_widget(builder, "rpc_password_label")); /* require authentication */ init_check_button(*whitelist_tb_, TR_KEY_rpc_whitelist_enabled, core_); whitelist_tb_->signal_toggled().connect([this]() { refreshRPCSensitivity(); }); /* access control list */ { store_ = whitelist_tree_model_new(gtr_pref_string_get(TR_KEY_rpc_whitelist)); view_->set_model(store_); setup_tree_view_button_event_handling( *view_, {}, [this](double view_x, double view_y) { return on_tree_view_button_released(*view_, view_x, view_y); }); whitelist_widgets_.push_back(view_); auto const sel = view_->get_selection(); sel->signal_changed().connect([this]() { refreshRPCSensitivity(); }); /* ip address column */ auto* r = Gtk::make_managed(); r->signal_edited().connect([this](auto const& path, auto const& new_text) { onAddressEdited(path, new_text); }); r->property_editable() = true; auto* c = Gtk::make_managed("", *r); c->add_attribute(r->property_text(), whitelist_cols.address); c->set_expand(true); view_->append_column(*c); whitelist_widgets_.push_back(gtr_get_widget(builder, "rpc_whitelist_label")); remove_button_->signal_clicked().connect([this]() { onRemoveWhitelistClicked(); }); refreshRPCSensitivity(); auto* add_button = gtr_get_widget(builder, "add_to_rpc_whitelist_button"); whitelist_widgets_.push_back(add_button); add_button->signal_clicked().connect([this]() { onAddWhitelistClicked(); }); } refreshRPCSensitivity(); } /**** ***** Bandwidth Tab ****/ namespace { class SpeedPage : public Gtk::Box { public: SpeedPage(BaseObjectType* cast_item, Glib::RefPtr const& builder, Glib::RefPtr const& core); TR_DISABLE_COPY_MOVE(SpeedPage) private: static void init_time_combo(Gtk::ComboBox& combo, Glib::RefPtr const& core, tr_quark key); static void init_week_combo(Gtk::ComboBox& combo, Glib::RefPtr const& core, tr_quark key); static auto get_weekday_string(Glib::Date::Weekday weekday); private: Glib::RefPtr core_; }; void SpeedPage::init_time_combo(Gtk::ComboBox& combo, Glib::RefPtr const& core, tr_quark const key) { class TimeModelColumns : public Gtk::TreeModelColumnRecord { public: TimeModelColumns() { add(offset); add(title); } Gtk::TreeModelColumn offset; Gtk::TreeModelColumn title; }; static TimeModelColumns const time_cols; /* build a store at 15 minute intervals */ auto store = Gtk::ListStore::create(time_cols); for (int i = 0; i < 60 * 24; i += 15) { auto const iter = store->append(); (*iter)[time_cols.offset] = i; (*iter)[time_cols.title] = fmt::format("{:02}:{:02}", i / 60, i % 60); } /* build the widget */ combo.set_model(store); auto* r = Gtk::make_managed(); combo.pack_start(*r, true); combo.add_attribute(r->property_text(), time_cols.title); combo.set_active(gtr_pref_int_get(key) / 15); combo.signal_changed().connect( [&combo, key, core]() { if (auto const iter = combo.get_active(); iter) { core->set_pref(key, iter->get_value(time_cols.offset)); } }); } auto SpeedPage::get_weekday_string(Glib::Date::Weekday weekday) { auto date = Glib::Date{}; date.set_time_current(); date.add_days(static_cast(weekday) - static_cast(date.get_weekday())); return date.format_string("%A"); } void SpeedPage::init_week_combo(Gtk::ComboBox& combo, Glib::RefPtr const& core, tr_quark const key) { gtr_combo_box_set_enum( combo, { { _("Every Day"), TR_SCHED_ALL }, { _("Weekdays"), TR_SCHED_WEEKDAY }, { _("Weekends"), TR_SCHED_WEEKEND }, { get_weekday_string(Glib::Date::Weekday::MONDAY), TR_SCHED_MON }, { get_weekday_string(Glib::Date::Weekday::TUESDAY), TR_SCHED_TUES }, { get_weekday_string(Glib::Date::Weekday::WEDNESDAY), TR_SCHED_WED }, { get_weekday_string(Glib::Date::Weekday::THURSDAY), TR_SCHED_THURS }, { get_weekday_string(Glib::Date::Weekday::FRIDAY), TR_SCHED_FRI }, { get_weekday_string(Glib::Date::Weekday::SATURDAY), TR_SCHED_SAT }, { get_weekday_string(Glib::Date::Weekday::SUNDAY), TR_SCHED_SUN }, }); gtr_combo_box_set_active_enum(combo, gtr_pref_int_get(key)); combo.signal_changed().connect([&combo, key, core]() { onIntComboChanged(&combo, key, core); }); } SpeedPage::SpeedPage(BaseObjectType* cast_item, Glib::RefPtr const& builder, Glib::RefPtr const& core) : Gtk::Box(cast_item) , core_(core) { { auto* const w = gtr_get_widget(builder, "upload_limit_check"); init_check_button(*w, TR_KEY_speed_limit_up_enabled, core_); w->set_label(fmt::format(w->get_label().raw(), fmt::arg("speed_units", speed_K_str))); auto* const w2 = gtr_get_widget(builder, "upload_limit_spin"); init_spin_button(*w2, TR_KEY_speed_limit_up, core_, 0, std::numeric_limits::max(), 5); } { auto* const w = gtr_get_widget(builder, "download_limit_check"); init_check_button(*w, TR_KEY_speed_limit_down_enabled, core_); w->set_label(fmt::format(w->get_label().raw(), fmt::arg("speed_units", speed_K_str))); auto* const w2 = gtr_get_widget(builder, "download_limit_spin"); init_spin_button(*w2, TR_KEY_speed_limit_down, core_, 0, std::numeric_limits::max(), 5); } { auto* const w = gtr_get_widget(builder, "alt_upload_limit_label"); w->set_label(fmt::format(w->get_label().raw(), fmt::arg("speed_units", speed_K_str))); auto* const w2 = gtr_get_widget(builder, "alt_upload_limit_spin"); init_spin_button(*w2, TR_KEY_alt_speed_up, core_, 0, std::numeric_limits::max(), 5); } { auto* const w = gtr_get_widget(builder, "alt_download_limit_label"); w->set_label(fmt::format(w->get_label().raw(), fmt::arg("speed_units", speed_K_str))); auto* const w2 = gtr_get_widget(builder, "alt_download_limit_spin"); init_spin_button(*w2, TR_KEY_alt_speed_down, core_, 0, std::numeric_limits::max(), 5); } { auto* start_combo = gtr_get_widget(builder, "alt_speed_start_time_combo"); init_time_combo(*start_combo, core_, TR_KEY_alt_speed_time_begin); auto* end_combo = gtr_get_widget(builder, "alt_speed_end_time_combo"); init_time_combo(*end_combo, core_, TR_KEY_alt_speed_time_end); auto* w = gtr_get_widget(builder, "alt_schedule_time_check"); init_check_button(*w, TR_KEY_alt_speed_time_enabled, core_); } auto* week_combo = gtr_get_widget(builder, "alt_speed_days_combo"); init_week_combo(*week_combo, core_, TR_KEY_alt_speed_time_day); } } // namespace /**** ***** Network Tab ****/ namespace { class NetworkPage : public Gtk::Box { public: NetworkPage(BaseObjectType* cast_item, Glib::RefPtr const& builder, Glib::RefPtr const& core); ~NetworkPage() override; TR_DISABLE_COPY_MOVE(NetworkPage) private: void onCorePrefsChanged(tr_quark key); void onPortTested(bool isOpen); void onPortTest(); private: Glib::RefPtr core_; Gtk::Label* portLabel_ = nullptr; Gtk::Button* portButton_ = nullptr; Gtk::SpinButton* portSpin_ = nullptr; sigc::connection portTag_; sigc::connection prefsTag_; }; void NetworkPage::onCorePrefsChanged(tr_quark const key) { if (key == TR_KEY_peer_port) { gtr_label_set_text(*portLabel_, _("Status unknown")); portButton_->set_sensitive(true); portSpin_->set_sensitive(true); } } NetworkPage::~NetworkPage() { if (prefsTag_.connected()) { prefsTag_.disconnect(); } if (portTag_.connected()) { portTag_.disconnect(); } } void NetworkPage::onPortTested(bool isOpen) { portLabel_->set_markup(fmt::format( isOpen ? _("Port is {markup_begin}open{markup_end}") : _("Port is {markup_begin}closed{markup_end}"), fmt::arg("markup_begin", ""), fmt::arg("markup_end", ""))); portButton_->set_sensitive(true); portSpin_->set_sensitive(true); } void NetworkPage::onPortTest() { portButton_->set_sensitive(false); portSpin_->set_sensitive(false); portLabel_->set_text(_("Testing TCP port…")); if (!portTag_.connected()) { portTag_ = core_->signal_port_tested().connect([this](bool is_open) { onPortTested(is_open); }); } core_->port_test(); } NetworkPage::NetworkPage( BaseObjectType* cast_item, Glib::RefPtr const& builder, Glib::RefPtr const& core) : Gtk::Box(cast_item) , core_(core) , portLabel_(gtr_get_widget(builder, "listening_port_status_label")) , portButton_(gtr_get_widget(builder, "test_listening_port_button")) , portSpin_(gtr_get_widget(builder, "listening_port_spin")) { init_spin_button(*portSpin_, TR_KEY_peer_port, core_, 1, std::numeric_limits::max(), 1); portButton_->signal_clicked().connect([this]() { onPortTest(); }); prefsTag_ = core_->signal_prefs_changed().connect([this](auto key) { onCorePrefsChanged(key); }); init_check_button( *gtr_get_widget(builder, "pick_random_listening_port_at_start_check"), TR_KEY_peer_port_random_on_start, core_); init_check_button( *gtr_get_widget(builder, "enable_listening_port_forwarding_check"), TR_KEY_port_forwarding_enabled, core_); init_spin_button( *gtr_get_widget(builder, "max_torrent_peers_spin"), TR_KEY_peer_limit_per_torrent, core_, 1, FD_SETSIZE, 5); init_spin_button( *gtr_get_widget(builder, "max_total_peers_spin"), TR_KEY_peer_limit_global, core_, 1, FD_SETSIZE, 5); #ifdef WITH_UTP init_check_button(*gtr_get_widget(builder, "enable_utp_check"), TR_KEY_utp_enabled, core_); #else gtr_get_widget(builder, "enable_utp_check")->hide(); #endif init_check_button(*gtr_get_widget(builder, "enable_pex_check"), TR_KEY_pex_enabled, core_); init_check_button(*gtr_get_widget(builder, "enable_dht_check"), TR_KEY_dht_enabled, core_); init_check_button(*gtr_get_widget(builder, "enable_lpd_check"), TR_KEY_lpd_enabled, core_); init_text_view(*gtr_get_widget(builder, "default_trackers_view"), TR_KEY_default_trackers, core_); } } // namespace /**** ***** ****/ std::unique_ptr PrefsDialog::create(Gtk::Window& parent, Glib::RefPtr const& core) { auto const builder = Gtk::Builder::create_from_resource(gtr_get_full_resource_path("PrefsDialog.ui")); return std::unique_ptr(gtr_get_widget_derived(builder, "PrefsDialog", parent, core)); } PrefsDialog::PrefsDialog( BaseObjectType* cast_item, Glib::RefPtr const& builder, Gtk::Window& parent, Glib::RefPtr const& core) : Gtk::Dialog(cast_item) , impl_(std::make_unique(*this, builder, core)) { set_transient_for(parent); } PrefsDialog::~PrefsDialog() = default; PrefsDialog::Impl::Impl(PrefsDialog& dialog, Glib::RefPtr const& builder, Glib::RefPtr const& core) : dialog_(dialog) , core_(core) { gtr_get_widget_derived(builder, "speed_page_layout", core_); gtr_get_widget_derived(builder, "downloading_page_layout", core_); gtr_get_widget_derived(builder, "seeding_page_layout", core_); gtr_get_widget_derived(builder, "privacy_page_layout", core_); gtr_get_widget_derived(builder, "network_page_layout", core_); gtr_get_widget_derived(builder, "desktop_page_layout", core_); gtr_get_widget_derived(builder, "remote_page_layout", core_); dialog_.signal_response().connect(sigc::mem_fun(*this, &Impl::response_cb)); }