mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity
transmission/gtk/DetailsDialog.cc

2659 lines
81 KiB
C++
Raw Blame History

// This file Copyright © 2007-2022 Mnemosyne LLC.
// It may be used under GPLv2 (SPDX: GPL-2.0), GPLv3 (SPDX: GPL-3.0),
// or any future license endorsed by Mnemosyne LLC.
// License text can be found in the licenses/ folder.
#include <algorithm>
#include <array>
#include <limits.h> /* INT_MAX */
#include <sstream>
#include <stddef.h>
#include <stdio.h> /* sscanf() */
#include <stdlib.h> /* abort() */
#include <string>
#include <string_view>
#include <unordered_map>
#include <glibmm/i18n.h>
#include <libtransmission/transmission.h>
#include <libtransmission/utils.h> /* tr_free */
#include <libtransmission/web-utils.h>
#include "Actions.h"
#include "DetailsDialog.h"
#include "FaviconCache.h" /* gtr_get_favicon() */
#include "FileList.h"
#include "HigWorkarea.h"
#include "Prefs.h"
#include "PrefsDialog.h"
#include "Session.h"
#include "Utils.h"
using namespace std::literals;
class DetailsDialog::Impl
{
public:
Impl(DetailsDialog& dialog, Glib::RefPtr<Session> const& core);
~Impl();
TR_DISABLE_COPY_MOVE(Impl)
void set_torrents(std::vector<int> const& torrent_ids);
private:
Gtk::Widget* info_page_new();
Gtk::Widget* peer_page_new();
Gtk::Widget* tracker_page_new();
Gtk::Widget* options_page_new();
void on_details_window_size_allocated(Gtk::Allocation& alloc);
bool onPeerViewQueryTooltip(int x, int y, bool keyboard_tip, Glib::RefPtr<Gtk::Tooltip> const& tooltip);
void onMorePeerInfoToggled();
bool trackerVisibleFunc(Gtk::TreeModel::const_iterator const& iter);
void on_tracker_list_selection_changed();
void on_tracker_list_add_button_clicked();
void on_edit_trackers();
void on_tracker_list_remove_button_clicked();
void onScrapeToggled();
void onBackupToggled();
void on_add_tracker_response(int response, std::shared_ptr<Gtk::Dialog>& dialog);
void on_edit_trackers_response(int response, std::shared_ptr<Gtk::Dialog>& dialog);
void torrent_set_bool(tr_quark key, bool value);
void torrent_set_int(tr_quark key, int value);
void torrent_set_real(tr_quark key, double value);
void refresh();
void refreshInfo(std::vector<tr_torrent*> const& torrents);
void refreshPeers(std::vector<tr_torrent*> const& torrents);
void refreshTracker(std::vector<tr_torrent*> const& torrents);
void refreshOptions(std::vector<tr_torrent*> const& torrents);
void refreshPeerList(std::vector<tr_torrent*> const& torrents);
void refreshWebseedList(std::vector<tr_torrent*> const& torrents);
int tracker_list_get_current_torrent_id() const;
tr_torrent* tracker_list_get_current_torrent() const;
std::vector<tr_torrent*> getTorrents() const;
private:
DetailsDialog& dialog_;
Gtk::CheckButton* honor_limits_check_ = nullptr;
Gtk::CheckButton* up_limited_check_ = nullptr;
Gtk::SpinButton* up_limit_sping_ = nullptr;
Gtk::CheckButton* down_limited_check_ = nullptr;
Gtk::SpinButton* down_limit_spin_ = nullptr;
Gtk::ComboBox* bandwidth_combo_ = nullptr;
Gtk::ComboBox* ratio_combo_ = nullptr;
Gtk::SpinButton* ratio_spin_ = nullptr;
Gtk::ComboBox* idle_combo_ = nullptr;
Gtk::SpinButton* idle_spin_ = nullptr;
Gtk::SpinButton* max_peers_spin_ = nullptr;
sigc::connection honor_limits_check_tag_;
sigc::connection up_limited_check_tag_;
sigc::connection down_limited_check_tag_;
sigc::connection down_limit_spin_tag_;
sigc::connection up_limit_spin_tag_;
sigc::connection bandwidth_combo_tag_;
sigc::connection ratio_combo_tag_;
sigc::connection ratio_spin_tag_;
sigc::connection idle_combo_tag_;
sigc::connection idle_spin_tag_;
sigc::connection max_peers_spin_tag_;
Gtk::Label* size_lb_ = nullptr;
Gtk::Label* state_lb_ = nullptr;
Gtk::Label* have_lb_ = nullptr;
Gtk::Label* dl_lb_ = nullptr;
Gtk::Label* ul_lb_ = nullptr;
Gtk::Label* error_lb_ = nullptr;
Gtk::Label* date_started_lb_ = nullptr;
Gtk::Label* eta_lb_ = nullptr;
Gtk::Label* last_activity_lb_ = nullptr;
Gtk::Label* hash_lb_ = nullptr;
Gtk::Label* privacy_lb_ = nullptr;
Gtk::Label* origin_lb_ = nullptr;
Gtk::Label* destination_lb_ = nullptr;
Glib::RefPtr<Gtk::TextBuffer> comment_buffer_;
std::unordered_map<std::string, Gtk::TreeRowReference> peer_hash_;
std::unordered_map<std::string, Gtk::TreeRowReference> webseed_hash_;
Glib::RefPtr<Gtk::ListStore> peer_store_;
Glib::RefPtr<Gtk::ListStore> webseed_store_;
Gtk::ScrolledWindow* webseed_view_ = nullptr;
Gtk::TreeView* peer_view_ = nullptr;
Gtk::CheckButton* more_peer_details_check_ = nullptr;
Glib::RefPtr<Gtk::ListStore> tracker_store_;
std::unordered_map<std::string, Gtk::TreeRowReference> tracker_hash_;
Glib::RefPtr<Gtk::TreeModelFilter> trackers_filtered_;
Gtk::Button* add_tracker_button_ = nullptr;
Gtk::Button* edit_trackers_button_ = nullptr;
Gtk::Button* remove_tracker_button_ = nullptr;
Gtk::TreeView* tracker_view_ = nullptr;
Gtk::CheckButton* scrape_check_ = nullptr;
Gtk::CheckButton* all_check_ = nullptr;
FileList* file_list_ = nullptr;
Gtk::Label* file_label_ = nullptr;
std::vector<int> ids_;
Glib::RefPtr<Session> const core_;
sigc::connection periodic_refresh_tag_;
Glib::Quark const TORRENT_ID_KEY = Glib::Quark("tr-torrent-id-key");
Glib::Quark const TEXT_BUFFER_KEY = Glib::Quark("tr-text-buffer-key");
Glib::Quark const URL_ENTRY_KEY = Glib::Quark("tr-url-entry-key");
};
std::vector<tr_torrent*> DetailsDialog::Impl::getTorrents() const
{
std::vector<tr_torrent*> torrents;
torrents.reserve(ids_.size());
for (auto const id : ids_)
{
if (auto* torrent = core_->find_torrent(id); torrent != nullptr)
{
torrents.push_back(torrent);
}
}
return torrents;
}
/****
*****
***** OPTIONS TAB
*****
****/
namespace
{
void set_togglebutton_if_different(Gtk::ToggleButton* toggle, sigc::connection& tag, bool value)
{
bool const currentValue = toggle->get_active();
if (currentValue != value)
{
tag.block();
toggle->set_active(value);
tag.unblock();
}
}
void set_int_spin_if_different(Gtk::SpinButton* spin, sigc::connection& tag, int value)
{
int const currentValue = spin->get_value_as_int();
if (currentValue != value)
{
tag.block();
spin->set_value(value);
tag.unblock();
}
}
void set_double_spin_if_different(Gtk::SpinButton* spin, sigc::connection& tag, double value)
{
double const currentValue = spin->get_value();
if ((int)(currentValue * 100) != (int)(value * 100))
{
tag.block();
spin->set_value(value);
tag.unblock();
}
}
void unset_combo(Gtk::ComboBox* combobox, sigc::connection& tag)
{
tag.block();
combobox->set_active(-1);
tag.unblock();
}
} // namespace
void DetailsDialog::Impl::refreshOptions(std::vector<tr_torrent*> const& torrents)
{
/***
**** Options Page
***/
/* honor_limits_check */
if (!torrents.empty())
{
bool const baseline = tr_torrentUsesSessionLimits(torrents.front());
bool const is_uniform = std::all_of(
torrents.begin(),
torrents.end(),
[baseline](auto const* torrent) { return baseline == tr_torrentUsesSessionLimits(torrent); });
if (is_uniform)
{
set_togglebutton_if_different(honor_limits_check_, honor_limits_check_tag_, baseline);
}
}
/* down_limited_check */
if (!torrents.empty())
{
bool const baseline = tr_torrentUsesSpeedLimit(torrents.front(), TR_DOWN);
bool const is_uniform = std::all_of(
torrents.begin(),
torrents.end(),
[baseline](auto const* torrent) { return baseline == tr_torrentUsesSpeedLimit(torrent, TR_DOWN); });
if (is_uniform)
{
set_togglebutton_if_different(down_limited_check_, down_limited_check_tag_, baseline);
}
}
/* down_limit_spin */
if (!torrents.empty())
{
auto const baseline = tr_torrentGetSpeedLimit_KBps(torrents.front(), TR_DOWN);
bool const is_uniform = std::all_of(
torrents.begin(),
torrents.end(),
[baseline](auto const* torrent) { return baseline == tr_torrentGetSpeedLimit_KBps(torrent, TR_DOWN); });
if (is_uniform)
{
set_int_spin_if_different(down_limit_spin_, down_limit_spin_tag_, baseline);
}
}
/* up_limited_check */
if (!torrents.empty())
{
bool const baseline = tr_torrentUsesSpeedLimit(torrents.front(), TR_UP);
bool const is_uniform = std::all_of(
torrents.begin(),
torrents.end(),
[baseline](auto const* torrent) { return baseline == tr_torrentUsesSpeedLimit(torrent, TR_UP); });
if (is_uniform)
{
set_togglebutton_if_different(up_limited_check_, up_limited_check_tag_, baseline);
}
}
/* up_limit_sping */
if (!torrents.empty())
{
auto const baseline = tr_torrentGetSpeedLimit_KBps(torrents.front(), TR_UP);
bool const is_uniform = std::all_of(
torrents.begin(),
torrents.end(),
[baseline](auto const* torrent) { return baseline == tr_torrentGetSpeedLimit_KBps(torrent, TR_UP); });
if (is_uniform)
{
set_int_spin_if_different(up_limit_sping_, up_limit_spin_tag_, baseline);
}
}
/* bandwidth_combo */
if (!torrents.empty())
{
auto const baseline = tr_torrentGetPriority(torrents.front());
bool const is_uniform = std::all_of(
torrents.begin(),
torrents.end(),
[baseline](auto const* torrent) { return baseline == tr_torrentGetPriority(torrent); });
if (is_uniform)
{
bandwidth_combo_tag_.block();
gtr_priority_combo_set_value(*bandwidth_combo_, baseline);
bandwidth_combo_tag_.unblock();
}
else
{
unset_combo(bandwidth_combo_, bandwidth_combo_tag_);
}
}
/* ratio_combo */
if (!torrents.empty())
{
auto const baseline = tr_torrentGetRatioMode(torrents.front());
bool const is_uniform = std::all_of(
torrents.begin(),
torrents.end(),
[baseline](auto const* torrent) { return baseline == tr_torrentGetRatioMode(torrent); });
if (is_uniform)
{
ratio_combo_tag_.block();
gtr_combo_box_set_active_enum(*ratio_combo_, baseline);
gtr_widget_set_visible(*ratio_spin_, baseline == TR_RATIOLIMIT_SINGLE);
ratio_combo_tag_.unblock();
}
}
/* ratio_spin */
if (!torrents.empty())
{
auto const baseline = tr_torrentGetRatioLimit(torrents.front());
set_double_spin_if_different(ratio_spin_, ratio_spin_tag_, baseline);
}
/* idle_combo */
if (!torrents.empty())
{
auto const baseline = tr_torrentGetIdleMode(torrents.front());
bool const is_uniform = std::all_of(
torrents.begin(),
torrents.end(),
[baseline](auto const* torrent) { return baseline == tr_torrentGetIdleMode(torrent); });
if (is_uniform)
{
idle_combo_tag_.block();
gtr_combo_box_set_active_enum(*idle_combo_, baseline);
gtr_widget_set_visible(*idle_spin_, baseline == TR_IDLELIMIT_SINGLE);
idle_combo_tag_.unblock();
}
}
/* idle_spin */
if (!torrents.empty())
{
auto const baseline = tr_torrentGetIdleLimit(torrents.front());
set_int_spin_if_different(idle_spin_, idle_spin_tag_, baseline);
}
/* max_peers_spin */
if (!torrents.empty())
{
auto const baseline = tr_torrentGetPeerLimit(torrents.front());
set_int_spin_if_different(max_peers_spin_, max_peers_spin_tag_, baseline);
}
}
void DetailsDialog::Impl::torrent_set_bool(tr_quark key, bool value)
{
tr_variant top;
tr_variantInitDict(&top, 2);
tr_variantDictAddStrView(&top, TR_KEY_method, "torrent-set"sv);
tr_variant* const args = tr_variantDictAddDict(&top, TR_KEY_arguments, 2);
tr_variantDictAddBool(args, key, value);
tr_variant* const ids = tr_variantDictAddList(args, TR_KEY_ids, ids_.size());
for (auto const id : ids_)
{
tr_variantListAddInt(ids, id);
}
core_->exec(&top);
tr_variantFree(&top);
}
void DetailsDialog::Impl::torrent_set_int(tr_quark key, int value)
{
tr_variant top;
tr_variantInitDict(&top, 2);
tr_variantDictAddStrView(&top, TR_KEY_method, "torrent-set"sv);
tr_variant* const args = tr_variantDictAddDict(&top, TR_KEY_arguments, 2);
tr_variantDictAddInt(args, key, value);
tr_variant* const ids = tr_variantDictAddList(args, TR_KEY_ids, ids_.size());
for (auto const id : ids_)
{
tr_variantListAddInt(ids, id);
}
core_->exec(&top);
tr_variantFree(&top);
}
void DetailsDialog::Impl::torrent_set_real(tr_quark key, double value)
{
tr_variant top;
tr_variantInitDict(&top, 2);
tr_variantDictAddStrView(&top, TR_KEY_method, "torrent-set"sv);
tr_variant* const args = tr_variantDictAddDict(&top, TR_KEY_arguments, 2);
tr_variantDictAddReal(args, key, value);
tr_variant* const ids = tr_variantDictAddList(args, TR_KEY_ids, ids_.size());
for (auto const id : ids_)
{
tr_variantListAddInt(ids, id);
}
core_->exec(&top);
tr_variantFree(&top);
}
Gtk::Widget* DetailsDialog::Impl::options_page_new()
{
guint row;
row = 0;
auto* t = Gtk::make_managed<HigWorkarea>();
t->add_section_title(row, _("Speed"));
honor_limits_check_ = t->add_wide_checkbutton(row, _("Honor global _limits"), 0);
honor_limits_check_tag_ = honor_limits_check_->signal_toggled().connect(
[this]() { torrent_set_bool(TR_KEY_honorsSessionLimits, honor_limits_check_->get_active()); });
down_limited_check_ = Gtk::make_managed<Gtk::CheckButton>(
gtr_sprintf(_("Limit _download speed (%s):"), _(speed_K_str)),
true);
down_limited_check_->set_active(false);
down_limited_check_tag_ = down_limited_check_->signal_toggled().connect(
[this]() { torrent_set_bool(TR_KEY_downloadLimited, down_limited_check_->get_active()); });
down_limit_spin_ = Gtk::make_managed<Gtk::SpinButton>(Gtk::Adjustment::create(0, 0, INT_MAX, 5));
down_limit_spin_tag_ = down_limit_spin_->signal_value_changed().connect(
[this]() { torrent_set_int(TR_KEY_downloadLimit, down_limit_spin_->get_value_as_int()); });
t->add_row_w(row, *down_limited_check_, *down_limit_spin_);
up_limited_check_ = Gtk::make_managed<Gtk::CheckButton>(gtr_sprintf(_("Limit _upload speed (%s):"), _(speed_K_str)), true);
up_limited_check_tag_ = up_limited_check_->signal_toggled().connect(
[this]() { torrent_set_bool(TR_KEY_uploadLimited, up_limited_check_->get_active()); });
up_limit_sping_ = Gtk::make_managed<Gtk::SpinButton>(Gtk::Adjustment::create(0, 0, INT_MAX, 5));
up_limit_spin_tag_ = up_limit_sping_->signal_value_changed().connect(
[this]() { torrent_set_int(TR_KEY_uploadLimit, up_limit_sping_->get_value_as_int()); });
t->add_row_w(row, *up_limited_check_, *up_limit_sping_);
bandwidth_combo_ = gtr_priority_combo_new();
bandwidth_combo_tag_ = bandwidth_combo_->signal_changed().connect(
[this]() { torrent_set_int(TR_KEY_bandwidthPriority, gtr_priority_combo_get_value(*bandwidth_combo_)); });
t->add_row(row, _("Torrent _priority:"), *bandwidth_combo_);
t->add_section_divider(row);
t->add_section_title(row, _("Seeding Limits"));
auto* h1 = Gtk::make_managed<Gtk::Box>(Gtk::ORIENTATION_HORIZONTAL, GUI_PAD);
ratio_combo_ = gtr_combo_box_new_enum({
{ _("Use global settings"), TR_RATIOLIMIT_GLOBAL },
{ _("Seed regardless of ratio"), TR_RATIOLIMIT_UNLIMITED },
{ _("Stop seeding at ratio:"), TR_RATIOLIMIT_SINGLE },
});
ratio_combo_tag_ = ratio_combo_->signal_changed().connect(
[this]()
{
torrent_set_int(TR_KEY_seedRatioMode, gtr_combo_box_get_active_enum(*ratio_combo_));
refresh();
});
h1->pack_start(*ratio_combo_, true, true, 0);
ratio_spin_ = Gtk::make_managed<Gtk::SpinButton>(Gtk::Adjustment::create(0, 0, 1000, .05));
ratio_spin_->set_width_chars(7);
ratio_spin_tag_ = ratio_spin_->signal_value_changed().connect(
[this]() { torrent_set_real(TR_KEY_seedRatioLimit, ratio_spin_->get_value()); });
h1->pack_start(*ratio_spin_, false, false, 0);
t->add_row(row, _("_Ratio:"), *h1);
auto* h2 = Gtk::make_managed<Gtk::Box>(Gtk::ORIENTATION_HORIZONTAL, GUI_PAD);
idle_combo_ = gtr_combo_box_new_enum({
{ _("Use global settings"), TR_IDLELIMIT_GLOBAL },
{ _("Seed regardless of activity"), TR_IDLELIMIT_UNLIMITED },
{ _("Stop seeding if idle for N minutes:"), TR_IDLELIMIT_SINGLE },
});
idle_combo_tag_ = idle_combo_->signal_changed().connect(
[this]()
{
torrent_set_int(TR_KEY_seedIdleMode, gtr_combo_box_get_active_enum(*idle_combo_));
refresh();
});
h2->pack_start(*idle_combo_, true, true, 0);
idle_spin_ = Gtk::make_managed<Gtk::SpinButton>(Gtk::Adjustment::create(1, 1, 40320, 5));
idle_spin_tag_ = idle_spin_->signal_value_changed().connect(
[this]() { torrent_set_int(TR_KEY_seedIdleLimit, idle_spin_->get_value_as_int()); });
h2->pack_start(*idle_spin_, false, false, 0);
t->add_row(row, _("_Idle:"), *h2);
t->add_section_divider(row);
t->add_section_title(row, _("Peer Connections"));
max_peers_spin_ = Gtk::make_managed<Gtk::SpinButton>(Gtk::Adjustment::create(1, 1, 3000, 5));
t->add_row(row, _("_Maximum peers:"), *max_peers_spin_, max_peers_spin_);
max_peers_spin_tag_ = max_peers_spin_->signal_value_changed().connect(
[this]() { torrent_set_int(TR_KEY_peer_limit, max_peers_spin_->get_value_as_int()); });
return t;
}
/****
*****
***** INFO TAB
*****
****/
namespace
{
Glib::ustring activityString(int activity, bool finished)
{
switch (activity)
{
case TR_STATUS_CHECK_WAIT:
return _("Queued for verification");
case TR_STATUS_CHECK:
return _("Verifying local data");
case TR_STATUS_DOWNLOAD_WAIT:
return _("Queued for download");
case TR_STATUS_DOWNLOAD:
return C_("Verb", "Downloading");
case TR_STATUS_SEED_WAIT:
return _("Queued for seeding");
case TR_STATUS_SEED:
return C_("Verb", "Seeding");
case TR_STATUS_STOPPED:
return finished ? _("Finished") : _("Paused");
default:
g_assert_not_reached();
}
return {};
}
/* Only call gtk_text_buffer_set_text () if the new text differs from the old.
* This way if the user has text selected, refreshing won't deselect it */
void gtr_text_buffer_set_text(Glib::RefPtr<Gtk::TextBuffer> const& b, Glib::ustring const& str)
{
if (b->get_text() != str)
{
b->set_text(str);
}
}
Glib::ustring get_short_date_string(time_t t)
{
char buf[64];
struct tm tm;
if (t == 0)
{
return _("N/A");
}
tr_localtime_r(&t, &tm);
strftime(buf, sizeof(buf), "%d %b %Y", &tm);
return Glib::locale_to_utf8(buf);
}
} // namespace
void DetailsDialog::Impl::refreshInfo(std::vector<tr_torrent*> const& torrents)
{
Glib::ustring str;
Glib::ustring const mixed = _("Mixed");
Glib::ustring const no_torrent = _("No Torrents Selected");
Glib::ustring stateString;
uint64_t sizeWhenDone = 0;
std::vector<tr_stat const*> stats;
std::vector<tr_torrent_view> infos;
stats.reserve(torrents.size());
infos.reserve(torrents.size());
for (auto* const torrent : torrents)
{
stats.push_back(tr_torrentStatCached(torrent));
infos.push_back(tr_torrentView(torrent));
}
/* privacy_lb */
if (infos.empty())
{
str = no_torrent;
}
else
{
bool const baseline = infos.front().is_private;
bool const is_uniform = std::all_of(
infos.begin(),
infos.end(),
[baseline](auto const& info) { return info.is_private == baseline; });
if (is_uniform)
{
str = baseline ? _("Private to this tracker -- DHT and PEX disabled") : _("Public torrent");
}
else
{
str = mixed;
}
}
privacy_lb_->set_text(str);
/* origin_lb */
if (infos.empty())
{
str = no_torrent;
}
else
{
auto const creator = Glib::ustring(infos.front().creator != nullptr ? infos.front().creator : "");
auto const date = infos.front().date_created;
auto const datestr = get_short_date_string(date);
bool const mixed_creator = std::any_of(
infos.begin(),
infos.end(),
[&creator](auto const& info) { return creator != (info.creator != nullptr ? info.creator : ""); });
bool const mixed_date = std::any_of(
infos.begin(),
infos.end(),
[date](auto const& info) { return date != info.date_created; });
bool const empty_creator = creator.empty();
bool const empty_date = date == 0;
if (mixed_date || mixed_creator)
{
str = mixed;
}
else if (empty_date && empty_creator)
{
str = _("N/A");
}
else
{
if (empty_date && !empty_creator)
{
str = gtr_sprintf(_("Created by %1$s"), creator);
}
else if (empty_creator && !empty_date)
{
str = gtr_sprintf(_("Created on %1$s"), datestr);
}
else
{
str = gtr_sprintf(_("Created by %1$s on %2$s"), creator, datestr);
}
}
}
origin_lb_->set_text(str);
/* comment_buffer */
if (infos.empty())
{
str.clear();
}
else
{
auto const baseline = Glib::ustring(infos.front().comment != nullptr ? infos.front().comment : "");
bool const is_uniform = std::all_of(
infos.begin(),
infos.end(),
[&baseline](auto const& info) { return baseline == (info.comment != nullptr ? info.comment : ""); });
str = is_uniform ? baseline : mixed;
}
gtr_text_buffer_set_text(comment_buffer_, str);
/* destination_lb */
if (torrents.empty())
{
str = no_torrent;
}
else
{
auto const baseline = Glib::ustring(tr_torrentGetDownloadDir(torrents.front()));
bool const is_uniform = std::all_of(
torrents.begin(),
torrents.end(),
[&baseline](auto const* torrent) { return baseline == tr_torrentGetDownloadDir(torrent); });
str = is_uniform ? baseline : mixed;
}
destination_lb_->set_text(str);
/* state_lb */
if (stats.empty())
{
str = no_torrent;
}
else
{
auto const activity = stats.front()->activity;
bool const is_uniform = std::all_of(
stats.begin(),
stats.end(),
[activity](auto const* st) { return activity == st->activity; });
bool const allFinished = std::all_of(stats.begin(), stats.end(), [](auto const* st) { return st->finished; });
str = is_uniform ? activityString(activity, allFinished) : mixed;
}
stateString = str;
state_lb_->set_text(str);
/* date started */
if (stats.empty())
{
str = no_torrent;
}
else
{
time_t const baseline = stats.front()->startDate;
bool const is_uniform = std::all_of(
stats.begin(),
stats.end(),
[baseline](auto const* st) { return baseline == st->startDate; });
if (!is_uniform)
{
str = mixed;
}
else if (baseline <= 0 || stats[0]->activity == TR_STATUS_STOPPED)
{
str = stateString;
}
else
{
str = tr_strltime(time(nullptr) - baseline);
}
}
date_started_lb_->set_text(str);
/* eta */
if (stats.empty())
{
str = no_torrent;
}
else
{
int const baseline = stats.front()->eta;
bool const is_uniform = std::all_of(
stats.begin(),
stats.end(),
[baseline](auto const* st) { return baseline == st->eta; });
if (!is_uniform)
{
str = mixed;
}
else if (baseline < 0)
{
str = _("Unknown");
}
else
{
str = tr_strltime(baseline);
}
}
eta_lb_->set_text(str);
/* size_lb */
{
uint64_t size = 0;
int pieces = 0;
int32_t pieceSize = 0;
for (auto const& info : infos)
{
size += info.total_size;
pieces += info.n_pieces;
if (pieceSize == 0)
{
pieceSize = info.piece_size;
}
else if (pieceSize != (int)info.piece_size)
{
pieceSize = -1;
}
}
auto const sizebuf = tr_strlsize(size);
if (size == 0)
{
str.clear();
}
else if (pieceSize >= 0)
{
str = gtr_sprintf(
ngettext("%1$s (%2$'d piece @ %3$s)", "%1$s (%2$'d pieces @ %3$s)", pieces),
sizebuf,
pieces,
tr_formatter_mem_B(pieceSize));
}
else
{
str = gtr_sprintf(ngettext("%1$s (%2$'d piece)", "%1$s (%2$'d pieces)", pieces), sizebuf, pieces);
}
size_lb_->set_text(str);
}
/* have_lb */
if (stats.empty())
{
str = no_torrent;
}
else
{
uint64_t leftUntilDone = 0;
uint64_t haveUnchecked = 0;
uint64_t haveValid = 0;
uint64_t available = 0;
for (auto const* const st : stats)
{
haveUnchecked += st->haveUnchecked;
haveValid += st->haveValid;
sizeWhenDone += st->sizeWhenDone;
leftUntilDone += st->leftUntilDone;
available += st->sizeWhenDone - st->leftUntilDone + st->haveUnchecked + st->desiredAvailable;
}
{
double const d = sizeWhenDone != 0 ? (100.0 * available) / sizeWhenDone : 0;
double const ratio = 100.0 * (sizeWhenDone != 0 ? (haveValid + haveUnchecked) / (double)sizeWhenDone : 1);
auto const avail = tr_strlpercent(d);
auto const buf2 = tr_strlpercent(ratio);
auto const total = tr_strlsize(haveUnchecked + haveValid);
auto const unver = tr_strlsize(haveUnchecked);
if (haveUnchecked == 0 && leftUntilDone == 0)
{
str = gtr_sprintf(_("%1$s (%2$s%%)"), total, buf2);
}
else if (haveUnchecked == 0)
{
str = gtr_sprintf(_("%1$s (%2$s%% of %3$s%% Available)"), total, buf2, avail);
}
else
{
str = gtr_sprintf(_("%1$s (%2$s%% of %3$s%% Available); %4$s Unverified"), total, buf2, avail, unver);
}
}
}
have_lb_->set_text(str);
/* dl_lb */
if (stats.empty())
{
str = no_torrent;
}
else
{
uint64_t d = 0;
uint64_t f = 0;
for (auto const* const st : stats)
{
d += st->downloadedEver;
f += st->corruptEver;
}
auto const dbuf = tr_strlsize(d);
auto const fbuf = tr_strlsize(f);
if (f != 0)
{
str = gtr_sprintf(_("%1$s (+%2$s corrupt)"), dbuf, fbuf);
}
else
{
str = dbuf;
}
}
dl_lb_->set_text(str);
/* ul_lb */
if (stats.empty())
{
str = no_torrent;
}
else
{
uint64_t up = 0;
uint64_t down = 0;
for (auto const* const st : stats)
{
up += st->uploadedEver;
down += st->downloadedEver;
}
str = gtr_sprintf(_("%s (Ratio: %s)"), tr_strlsize(up), tr_strlratio(tr_getRatio(up, down)));
}
ul_lb_->set_text(str);
/* hash_lb */
if (infos.empty())
{
str = no_torrent;
}
else if (infos.size() == 1)
{
str = infos.front().hash_string;
}
else
{
str = mixed;
}
hash_lb_->set_text(str);
/* error */
if (stats.empty())
{
str = no_torrent;
}
else
{
auto const baseline = Glib::ustring(stats.front()->errorString);
bool const is_uniform = std::all_of(
stats.begin(),
stats.end(),
[&baseline](auto const* st) { return baseline == st->errorString; });
str = is_uniform ? baseline : mixed;
}
if (str.empty())
{
str = _("No errors");
}
error_lb_->set_text(str);
/* activity date */
if (stats.empty())
{
str = no_torrent;
}
else
{
time_t const latest = (*std::max_element(
stats.begin(),
stats.end(),
[](auto const* lhs, auto const* rhs) { return lhs->activityDate < rhs->activityDate; }))
->activityDate;
if (latest <= 0)
{
str = _("Never");
}
else
{
time_t const period = time(nullptr) - latest;
if (period < 5)
{
str = _("Active now");
}
else
{
str = gtr_sprintf(_("%1$s ago"), tr_strltime(period));
}
}
}
last_activity_lb_->set_text(str);
}
Gtk::Widget* DetailsDialog::Impl::info_page_new()
{
guint row = 0;
auto* t = Gtk::make_managed<HigWorkarea>();
t->add_section_title(row, _("Activity"));
/* size */
size_lb_ = Gtk::make_managed<Gtk::Label>();
size_lb_->set_single_line_mode(true);
t->add_row(row, _("Torrent size:"), *size_lb_);
/* have */
have_lb_ = Gtk::make_managed<Gtk::Label>();
have_lb_->set_single_line_mode(true);
t->add_row(row, _("Have:"), *have_lb_);
/* uploaded */
ul_lb_ = Gtk::make_managed<Gtk::Label>();
ul_lb_->set_single_line_mode(true);
t->add_row(row, _("Uploaded:"), *ul_lb_);
/* downloaded */
dl_lb_ = Gtk::make_managed<Gtk::Label>();
dl_lb_->set_single_line_mode(true);
t->add_row(row, _("Downloaded:"), *dl_lb_);
/* state */
state_lb_ = Gtk::make_managed<Gtk::Label>();
state_lb_->set_single_line_mode(true);
t->add_row(row, _("State:"), *state_lb_);
/* running for */
date_started_lb_ = Gtk::make_managed<Gtk::Label>();
date_started_lb_->set_single_line_mode(true);
t->add_row(row, _("Running time:"), *date_started_lb_);
/* eta */
eta_lb_ = Gtk::make_managed<Gtk::Label>();
eta_lb_->set_single_line_mode(true);
t->add_row(row, _("Remaining time:"), *eta_lb_);
/* last activity */
last_activity_lb_ = Gtk::make_managed<Gtk::Label>();
last_activity_lb_->set_single_line_mode(true);
t->add_row(row, _("Last activity:"), *last_activity_lb_);
/* error */
error_lb_ = Gtk::make_managed<Gtk::Label>();
error_lb_->set_selectable(true);
error_lb_->set_ellipsize(Pango::ELLIPSIZE_END);
t->add_row(row, _("Error:"), *error_lb_);
t->add_section_divider(row);
t->add_section_title(row, _("Details"));
/* destination */
destination_lb_ = Gtk::make_managed<Gtk::Label>();
destination_lb_->set_selectable(true);
destination_lb_->set_ellipsize(Pango::ELLIPSIZE_END);
t->add_row(row, _("Location:"), *destination_lb_);
/* hash */
hash_lb_ = Gtk::make_managed<Gtk::Label>();
hash_lb_->set_selectable(true);
hash_lb_->set_ellipsize(Pango::ELLIPSIZE_END);
t->add_row(row, _("Hash:"), *hash_lb_);
/* privacy */
privacy_lb_ = Gtk::make_managed<Gtk::Label>();
privacy_lb_->set_single_line_mode(true);
t->add_row(row, _("Privacy:"), *privacy_lb_);
/* origins */
origin_lb_ = Gtk::make_managed<Gtk::Label>();
origin_lb_->set_selectable(true);
origin_lb_->set_ellipsize(Pango::ELLIPSIZE_END);
t->add_row(row, _("Origin:"), *origin_lb_);
/* comment */
comment_buffer_ = Gtk::TextBuffer::create();
auto* tw = Gtk::make_managed<Gtk::TextView>(comment_buffer_);
tw->set_wrap_mode(Gtk::WRAP_WORD);
tw->set_editable(false);
auto* sw = Gtk::make_managed<Gtk::ScrolledWindow>();
sw->set_size_request(350, 36);
sw->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
sw->add(*tw);
auto* fr = Gtk::make_managed<Gtk::Frame>();
fr->set_shadow_type(Gtk::SHADOW_IN);
fr->add(*sw);
auto* w = t->add_tall_row(row, _("Comment:"), *fr);
w->set_halign(Gtk::ALIGN_START);
w->set_valign(Gtk::ALIGN_START);
t->add_section_divider(row);
return t;
}
/****
*****
***** PEERS TAB
*****
****/
namespace
{
class WebseedModelColumns : public Gtk::TreeModelColumnRecord
{
public:
WebseedModelColumns()
{
add(key);
add(was_updated);
add(url);
add(download_rate_double);
add(download_rate_string);
}
Gtk::TreeModelColumn<std::string> key;
Gtk::TreeModelColumn<bool> was_updated;
Gtk::TreeModelColumn<Glib::ustring> url;
Gtk::TreeModelColumn<double> download_rate_double;
Gtk::TreeModelColumn<Glib::ustring> download_rate_string;
};
WebseedModelColumns const webseed_cols;
class PeerModelColumns : public Gtk::TreeModelColumnRecord
{
public:
PeerModelColumns()
{
add(key);
add(was_updated);
add(address);
add(address_collated);
add(download_rate_double);
add(download_rate_string);
add(upload_rate_double);
add(upload_rate_string);
add(client);
add(progress);
add(upload_request_count_int);
add(upload_request_count_string);
add(download_request_count_int);
add(download_request_count_string);
add(blocks_downloaded_count_int);
add(blocks_downloaded_count_string);
add(blocks_uploaded_count_int);
add(blocks_uploaded_count_string);
add(reqs_cancelled_by_client_count_int);
add(reqs_cancelled_by_client_count_string);
add(reqs_cancelled_by_peer_count_int);
add(reqs_cancelled_by_peer_count_string);
add(encryption_stock_id);
add(flags);
add(torrent_name);
}
Gtk::TreeModelColumn<std::string> key;
Gtk::TreeModelColumn<bool> was_updated;
Gtk::TreeModelColumn<Glib::ustring> address;
Gtk::TreeModelColumn<Glib::ustring> address_collated;
Gtk::TreeModelColumn<double> download_rate_double;
Gtk::TreeModelColumn<Glib::ustring> download_rate_string;
Gtk::TreeModelColumn<double> upload_rate_double;
Gtk::TreeModelColumn<Glib::ustring> upload_rate_string;
Gtk::TreeModelColumn<Glib::ustring> client;
Gtk::TreeModelColumn<int> progress;
Gtk::TreeModelColumn<int> upload_request_count_int;
Gtk::TreeModelColumn<Glib::ustring> upload_request_count_string;
Gtk::TreeModelColumn<int> download_request_count_int;
Gtk::TreeModelColumn<Glib::ustring> download_request_count_string;
Gtk::TreeModelColumn<int> blocks_downloaded_count_int;
Gtk::TreeModelColumn<Glib::ustring> blocks_downloaded_count_string;
Gtk::TreeModelColumn<int> blocks_uploaded_count_int;
Gtk::TreeModelColumn<Glib::ustring> blocks_uploaded_count_string;
Gtk::TreeModelColumn<int> reqs_cancelled_by_client_count_int;
Gtk::TreeModelColumn<Glib::ustring> reqs_cancelled_by_client_count_string;
Gtk::TreeModelColumn<int> reqs_cancelled_by_peer_count_int;
Gtk::TreeModelColumn<Glib::ustring> reqs_cancelled_by_peer_count_string;
Gtk::TreeModelColumn<Glib::ustring> encryption_stock_id;
Gtk::TreeModelColumn<Glib::ustring> flags;
Gtk::TreeModelColumn<Glib::ustring> torrent_name;
};
PeerModelColumns const peer_cols;
void initPeerRow(Gtk::TreeIter const& iter, std::string const& key, std::string const& torrentName, tr_peer_stat const* peer)
{
g_return_if_fail(peer != nullptr);
char const* client = peer->client;
if (client == nullptr || g_strcmp0(client, "Unknown Client") == 0)
{
client = "";
}
int q[4];
Glib::ustring collated_name;
if (sscanf(peer->addr, "%d.%d.%d.%d", q, q + 1, q + 2, q + 3) != 4)
{
collated_name = peer->addr;
}
else
{
collated_name = gtr_sprintf("%03d.%03d.%03d.%03d", q[0], q[1], q[2], q[3]);
}
(*iter)[peer_cols.address] = peer->addr;
(*iter)[peer_cols.address_collated] = collated_name;
(*iter)[peer_cols.client] = client;
(*iter)[peer_cols.encryption_stock_id] = peer->isEncrypted ? "lock" : "";
(*iter)[peer_cols.key] = key;
(*iter)[peer_cols.torrent_name] = torrentName;
}
void refreshPeerRow(Gtk::TreeIter const& iter, tr_peer_stat const* peer)
{
std::string up_speed;
std::string down_speed;
std::string up_count;
std::string down_count;
std::string blocks_to_peer;
std::string blocks_to_client;
std::string cancelled_by_peer;
std::string cancelled_by_client;
g_return_if_fail(peer != nullptr);
if (peer->rateToPeer_KBps > 0.01)
{
up_speed = tr_formatter_speed_KBps(peer->rateToPeer_KBps);
}
if (peer->rateToClient_KBps > 0)
{
down_speed = tr_formatter_speed_KBps(peer->rateToClient_KBps);
}
if (peer->pendingReqsToPeer > 0)
{
down_count = std::to_string(peer->pendingReqsToPeer);
}
if (peer->pendingReqsToClient > 0)
{
up_count = std::to_string(peer->pendingReqsToClient);
}
if (peer->blocksToPeer > 0)
{
blocks_to_peer = std::to_string(peer->blocksToPeer);
}
if (peer->blocksToClient > 0)
{
blocks_to_client = std::to_string(peer->blocksToClient);
}
if (peer->cancelsToPeer > 0)
{
cancelled_by_client = std::to_string(peer->cancelsToPeer);
}
if (peer->cancelsToClient > 0)
{
cancelled_by_peer = std::to_string(peer->cancelsToClient);
}
(*iter)[peer_cols.progress] = (int)(100.0 * peer->progress);
(*iter)[peer_cols.upload_request_count_int] = peer->pendingReqsToClient;
(*iter)[peer_cols.upload_request_count_string] = up_count;
(*iter)[peer_cols.download_request_count_int] = peer->pendingReqsToPeer;
(*iter)[peer_cols.download_request_count_string] = down_count;
(*iter)[peer_cols.download_rate_double] = peer->rateToClient_KBps;
(*iter)[peer_cols.download_rate_string] = down_speed;
(*iter)[peer_cols.upload_rate_double] = peer->rateToPeer_KBps;
(*iter)[peer_cols.upload_rate_string] = up_speed;
(*iter)[peer_cols.flags] = peer->flagStr;
(*iter)[peer_cols.was_updated] = true;
(*iter)[peer_cols.blocks_downloaded_count_int] = (int)peer->blocksToClient;
(*iter)[peer_cols.blocks_downloaded_count_string] = blocks_to_client;
(*iter)[peer_cols.blocks_uploaded_count_int] = (int)peer->blocksToPeer;
(*iter)[peer_cols.blocks_uploaded_count_string] = blocks_to_peer;
(*iter)[peer_cols.reqs_cancelled_by_client_count_int] = (int)peer->cancelsToPeer;
(*iter)[peer_cols.reqs_cancelled_by_client_count_string] = cancelled_by_client;
(*iter)[peer_cols.reqs_cancelled_by_peer_count_int] = (int)peer->cancelsToClient;
(*iter)[peer_cols.reqs_cancelled_by_peer_count_string] = cancelled_by_peer;
}
} // namespace
void DetailsDialog::Impl::refreshPeerList(std::vector<tr_torrent*> const& torrents)
{
auto& hash = peer_hash_;
auto& store = peer_store_;
/* step 1: get all the peers */
std::vector<tr_peer_stat*> peers;
std::vector<int> peerCount;
peers.reserve(torrents.size());
peerCount.reserve(torrents.size());
for (auto const* const torrent : torrents)
{
int count = 0;
peers.push_back(tr_torrentPeers(torrent, &count));
peerCount.push_back(count);
}
/* step 2: mark all the peers in the list as not-updated */
for (auto const& row : store->children())
{
row[peer_cols.was_updated] = false;
}
/* step 3: add any new peers */
for (size_t i = 0; i < torrents.size(); ++i)
{
auto const* tor = torrents.at(i);
for (int j = 0; j < peerCount[i]; ++j)
{
auto const* s = &peers.at(i)[j];
auto const key = gtr_sprintf("%d.%s", tr_torrentId(tor), s->addr);
if (hash.find(key) == hash.end())
{
auto const iter = store->append();
initPeerRow(iter, key, tr_torrentName(tor), s);
hash.try_emplace(key, Gtk::TreeRowReference(store, store->get_path(iter)));
}
}
}
/* step 4: update the peers */
for (size_t i = 0; i < torrents.size(); ++i)
{
auto const* tor = torrents.at(i);
for (int j = 0; j < peerCount[i]; ++j)
{
auto const* s = &peers.at(i)[j];
auto const key = gtr_sprintf("%d.%s", tr_torrentId(tor), s->addr);
refreshPeerRow(store->get_iter(hash.at(key).get_path()), s);
}
}
/* step 5: remove peers that have disappeared */
if (auto iter = store->children().begin(); iter)
{
while (iter)
{
if (iter->get_value(peer_cols.was_updated))
{
++iter;
}
else
{
auto const key = iter->get_value(peer_cols.key);
hash.erase(key);
iter = store->erase(iter);
}
}
}
/* step 6: cleanup */
for (size_t i = 0; i < peers.size(); ++i)
{
tr_torrentPeersFree(peers[i], peerCount[i]);
}
}
void DetailsDialog::Impl::refreshWebseedList(std::vector<tr_torrent*> const& torrents)
{
auto has_any_webseeds = bool{ false };
auto& hash = webseed_hash_;
auto& store = webseed_store_;
/* step 1: mark all webseeds as not-updated */
for (auto const& row : store->children())
{
row[webseed_cols.was_updated] = false;
}
/* step 2: add any new webseeds */
for (auto const* const tor : torrents)
{
for (size_t j = 0, n = tr_torrentWebseedCount(tor); j < n; ++j)
{
has_any_webseeds = true;
auto const* const url = tr_torrentWebseed(tor, j).url;
auto const key = gtr_sprintf("%d.%s", tr_torrentId(tor), url);
if (hash.find(key) == hash.end())
{
auto const iter = store->append();
(*iter)[webseed_cols.url] = url;
(*iter)[webseed_cols.key] = key;
hash.try_emplace(key, Gtk::TreeRowReference(store, store->get_path(iter)));
}
}
}
/* step 3: update the webseeds */
for (auto const* const tor : torrents)
{
for (size_t j = 0, n = tr_torrentWebseedCount(tor); j < n; ++j)
{
auto const webseed = tr_torrentWebseed(tor, j);
auto const key = gtr_sprintf("%d.%s", tr_torrentId(tor), webseed.url);
auto const iter = store->get_iter(hash.at(key).get_path());
auto const KBps = double(webseed.download_bytes_per_second) / speed_K;
auto const buf = webseed.is_downloading ? tr_formatter_speed_KBps(KBps) : std::string();
(*iter)[webseed_cols.download_rate_double] = KBps;
(*iter)[webseed_cols.download_rate_string] = buf;
(*iter)[webseed_cols.was_updated] = true;
}
}
/* step 4: remove webseeds that have disappeared */
if (auto iter = store->children().begin(); iter)
{
while (iter)
{
if (iter->get_value(webseed_cols.was_updated))
{
++iter;
}
else
{
auto const key = iter->get_value(webseed_cols.key);
hash.erase(key);
iter = store->erase(iter);
}
}
}
/* most of the time there are no webseeds...
don't waste space showing an empty list */
webseed_view_->set_visible(has_any_webseeds);
}
void DetailsDialog::Impl::refreshPeers(std::vector<tr_torrent*> const& torrents)
{
refreshPeerList(torrents);
refreshWebseedList(torrents);
}
bool DetailsDialog::Impl::onPeerViewQueryTooltip(int x, int y, bool keyboard_tip, Glib::RefPtr<Gtk::Tooltip> const& tooltip)
{
Gtk::TreeModel::iterator iter;
bool show_tip = false;
if (peer_view_->get_tooltip_context_iter(x, y, keyboard_tip, iter))
{
auto const name = iter->get_value(peer_cols.torrent_name);
auto const addr = iter->get_value(peer_cols.address);
auto const flagstr = iter->get_value(peer_cols.flags);
std::ostringstream gstr;
gstr << "<b>" << Glib::Markup::escape_text(name) << "</b>\n" << addr << "\n \n";
for (char const ch : flagstr)
{
char const* s = nullptr;
switch (ch)
{
case 'O':
s = _("Optimistic unchoke");
break;
case 'D':
s = _("Downloading from this peer");
break;
case 'd':
s = _("We would download from this peer if they would let us");
break;
case 'U':
s = _("Uploading to peer");
break;
case 'u':
s = _("We would upload to this peer if they asked");
break;
case 'K':
s = _("Peer has unchoked us, but we're not interested");
break;
case '?':
s = _("We unchoked this peer, but they're not interested");
break;
case 'E':
s = _("Encrypted connection");
break;
case 'X':
s = _("Peer was found through Peer Exchange (PEX)");
break;
case 'H':
s = _("Peer was found through DHT");
break;
case 'I':
s = _("Peer is an incoming connection");
break;
case 'T':
s = _("Peer is connected over µTP");
break;
default:
g_assert_not_reached();
}
if (s != nullptr)
{
gstr << ch << ": " << s << '\n';
}
}
auto str = gstr.str();
if (!str.empty()) /* remove the last linefeed */
{
str.resize(str.size() - 1);
}
tooltip->set_markup(str);
show_tip = true;
}
return show_tip;
}
namespace
{
void setPeerViewColumns(Gtk::TreeView* peer_view)
{
std::vector<Gtk::TreeModelColumnBase const*> view_columns;
Gtk::TreeViewColumn* c;
bool const more = gtr_pref_flag_get(TR_KEY_show_extra_peer_details);
view_columns.push_back(&peer_cols.encryption_stock_id);
view_columns.push_back(&peer_cols.upload_rate_string);
if (more)
{
view_columns.push_back(&peer_cols.upload_request_count_string);
}
view_columns.push_back(&peer_cols.download_rate_string);
if (more)
{
view_columns.push_back(&peer_cols.download_request_count_string);
}
if (more)
{
view_columns.push_back(&peer_cols.blocks_downloaded_count_string);
}
if (more)
{
view_columns.push_back(&peer_cols.blocks_uploaded_count_string);
}
if (more)
{
view_columns.push_back(&peer_cols.reqs_cancelled_by_client_count_string);
}
if (more)
{
view_columns.push_back(&peer_cols.reqs_cancelled_by_peer_count_string);
}
view_columns.push_back(&peer_cols.progress);
view_columns.push_back(&peer_cols.flags);
view_columns.push_back(&peer_cols.address);
view_columns.push_back(&peer_cols.client);
/* remove any existing columns */
peer_view->remove_all_columns();
for (auto const* const col : view_columns)
{
auto const* sort_col = col;
if (*col == peer_cols.address)
{
auto* r = Gtk::make_managed<Gtk::CellRendererText>();
c = Gtk::make_managed<Gtk::TreeViewColumn>(_("Address"), *r);
c->add_attribute(r->property_text(), *col);
sort_col = &peer_cols.address_collated;
}
else if (*col == peer_cols.progress)
{
auto* r = Gtk::make_managed<Gtk::CellRendererProgress>();
c = Gtk::make_managed<Gtk::TreeViewColumn>(_("%"), *r);
c->add_attribute(r->property_text(), *col);
}
else if (*col == peer_cols.encryption_stock_id)
{
auto* r = Gtk::make_managed<Gtk::CellRendererPixbuf>();
r->property_xalign() = 0.0F;
r->property_yalign() = 0.5F;
c = Gtk::make_managed<Gtk::TreeViewColumn>(Glib::ustring(), *r);
c->add_attribute(r->property_icon_name(), *col);
c->set_sizing(Gtk::TREE_VIEW_COLUMN_FIXED);
c->set_fixed_width(20);
}
else if (*col == peer_cols.download_request_count_string)
{
auto* r = Gtk::make_managed<Gtk::CellRendererText>();
c = Gtk::make_managed<Gtk::TreeViewColumn>(_("Dn Reqs"), *r);
c->add_attribute(r->property_text(), *col);
sort_col = &peer_cols.download_request_count_int;
}
else if (*col == peer_cols.upload_request_count_string)
{
auto* r = Gtk::make_managed<Gtk::CellRendererText>();
c = Gtk::make_managed<Gtk::TreeViewColumn>(_("Up Reqs"), *r);
c->add_attribute(r->property_text(), *col);
sort_col = &peer_cols.upload_request_count_int;
}
else if (*col == peer_cols.blocks_downloaded_count_string)
{
auto* r = Gtk::make_managed<Gtk::CellRendererText>();
c = Gtk::make_managed<Gtk::TreeViewColumn>(_("Dn Blocks"), *r);
c->add_attribute(r->property_text(), *col);
sort_col = &peer_cols.blocks_downloaded_count_int;
}
else if (*col == peer_cols.blocks_uploaded_count_string)
{
auto* r = Gtk::make_managed<Gtk::CellRendererText>();
c = Gtk::make_managed<Gtk::TreeViewColumn>(_("Up Blocks"), *r);
c->add_attribute(r->property_text(), *col);
sort_col = &peer_cols.blocks_uploaded_count_int;
}
else if (*col == peer_cols.reqs_cancelled_by_client_count_string)
{
auto* r = Gtk::make_managed<Gtk::CellRendererText>();
c = Gtk::make_managed<Gtk::TreeViewColumn>(_("We Cancelled"), *r);
c->add_attribute(r->property_text(), *col);
sort_col = &peer_cols.reqs_cancelled_by_client_count_int;
}
else if (*col == peer_cols.reqs_cancelled_by_peer_count_string)
{
auto* r = Gtk::make_managed<Gtk::CellRendererText>();
c = Gtk::make_managed<Gtk::TreeViewColumn>(_("They Cancelled"), *r);
c->add_attribute(r->property_text(), *col);
sort_col = &peer_cols.reqs_cancelled_by_peer_count_int;
}
else if (*col == peer_cols.download_rate_string)
{
auto* r = Gtk::make_managed<Gtk::CellRendererText>();
r->property_xalign() = 1.0F;
c = Gtk::make_managed<Gtk::TreeViewColumn>(_("Down"), *r);
c->add_attribute(r->property_text(), *col);
sort_col = &peer_cols.download_rate_double;
}
else if (*col == peer_cols.upload_rate_string)
{
auto* r = Gtk::make_managed<Gtk::CellRendererText>();
r->property_xalign() = 1.0F;
c = Gtk::make_managed<Gtk::TreeViewColumn>(_("Up"), *r);
c->add_attribute(r->property_text(), *col);
sort_col = &peer_cols.upload_rate_double;
}
else if (*col == peer_cols.client)
{
auto* r = Gtk::make_managed<Gtk::CellRendererText>();
c = Gtk::make_managed<Gtk::TreeViewColumn>(_("Client"), *r);
c->add_attribute(r->property_text(), *col);
}
else if (*col == peer_cols.flags)
{
auto* r = Gtk::make_managed<Gtk::CellRendererText>();
c = Gtk::make_managed<Gtk::TreeViewColumn>(_("Flags"), *r);
c->add_attribute(r->property_text(), *col);
}
else
{
abort();
}
c->set_resizable(false);
c->set_sort_column(*sort_col);
peer_view->append_column(*c);
}
/* the 'expander' column has a 10-pixel margin on the left
that doesn't look quite correct in any of these columns...
so create a non-visible column and assign it as the
'expander column. */
c = Gtk::make_managed<Gtk::TreeViewColumn>();
c->set_visible(false);
peer_view->append_column(*c);
peer_view->set_expander_column(*c);
}
} // namespace
void DetailsDialog::Impl::onMorePeerInfoToggled()
{
tr_quark const key = TR_KEY_show_extra_peer_details;
bool const value = more_peer_details_check_->get_active();
core_->set_pref(key, value);
setPeerViewColumns(peer_view_);
}
Gtk::Widget* DetailsDialog::Impl::peer_page_new()
{
/* webseeds */
webseed_store_ = Gtk::ListStore::create(webseed_cols);
auto* v = Gtk::make_managed<Gtk::TreeView>(webseed_store_);
v->signal_button_release_event().connect([v](GdkEventButton* event) { return on_tree_view_button_released(v, event); });
{
auto* r = Gtk::make_managed<Gtk::CellRendererText>();
r->property_ellipsize() = Pango::ELLIPSIZE_END;
auto* c = Gtk::make_managed<Gtk::TreeViewColumn>(_("Web Seeds"), *r);
c->add_attribute(r->property_text(), webseed_cols.url);
c->set_expand(true);
c->set_sort_column(webseed_cols.url);
v->append_column(*c);
}
{
auto* r = Gtk::make_managed<Gtk::CellRendererText>();
auto* c = Gtk::make_managed<Gtk::TreeViewColumn>(_("Down"), *r);
c->add_attribute(r->property_text(), webseed_cols.download_rate_string);
c->set_sort_column(webseed_cols.download_rate_double);
v->append_column(*c);
}
webseed_view_ = Gtk::make_managed<Gtk::ScrolledWindow>();
webseed_view_->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
webseed_view_->set_shadow_type(Gtk::SHADOW_IN);
webseed_view_->add(*v);
/* peers */
peer_store_ = Gtk::ListStore::create(peer_cols);
auto m = Gtk::TreeModelSort::create(peer_store_);
m->set_sort_column(peer_cols.progress, Gtk::SORT_DESCENDING);
peer_view_ = Gtk::make_managed<Gtk::TreeView>(m);
peer_view_->set_has_tooltip(true);
peer_view_->signal_query_tooltip().connect(sigc::mem_fun(*this, &Impl::onPeerViewQueryTooltip));
peer_view_->signal_button_release_event().connect([this](GdkEventButton* event)
{ return on_tree_view_button_released(peer_view_, event); });
setPeerViewColumns(peer_view_);
auto* sw = Gtk::make_managed<Gtk::ScrolledWindow>();
sw->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
sw->set_shadow_type(Gtk::SHADOW_IN);
sw->add(*peer_view_);
auto* vbox = Gtk::make_managed<Gtk::Box>(Gtk::ORIENTATION_VERTICAL, GUI_PAD);
vbox->set_border_width(GUI_PAD_BIG);
auto* v2 = Gtk::make_managed<Gtk::Paned>(Gtk::ORIENTATION_VERTICAL);
v2->add(*webseed_view_);
v2->add(*sw);
vbox->pack_start(*v2, true, true);
more_peer_details_check_ = Gtk::make_managed<Gtk::CheckButton>(_("Show _more details"), true);
more_peer_details_check_->set_active(gtr_pref_flag_get(TR_KEY_show_extra_peer_details));
more_peer_details_check_->signal_toggled().connect(sigc::mem_fun(*this, &Impl::onMorePeerInfoToggled));
vbox->pack_start(*more_peer_details_check_, false, false);
return vbox;
}
/****
*****
***** TRACKER
*****
****/
namespace
{
char const err_markup_begin[] = "<span color=\"red\">";
char const err_markup_end[] = "</span>";
char const timeout_markup_begin[] = "<span color=\"#246\">";
char const timeout_markup_end[] = "</span>";
char const success_markup_begin[] = "<span color=\"#080\">";
char const success_markup_end[] = "</span>";
std::array<std::string_view, 3> const text_dir_mark = { ""sv, "\u200E"sv, "\u200F"sv };
// if it's been longer than a minute, don't bother showing the seconds
Glib::ustring tr_strltime_rounded(time_t t)
{
if (t > 60)
{
t -= (t % 60);
}
return tr_strltime(t);
}
void appendAnnounceInfo(tr_tracker_view const& tracker, time_t const now, Gtk::TextDirection direction, std::ostream& gstr)
{
if (tracker.hasAnnounced && tracker.announceState != TR_TRACKER_INACTIVE)
{
gstr << '\n';
gstr << text_dir_mark[direction];
auto const timebuf = tr_strltime_rounded(now - tracker.lastAnnounceTime);
if (tracker.lastAnnounceSucceeded)
{
gstr << gtr_sprintf(
_("Got a list of %1$s%2$'d peers%3$s %4$s ago"),
success_markup_begin,
tracker.lastAnnouncePeerCount,
success_markup_end,
timebuf);
}
else if (tracker.lastAnnounceTimedOut)
{
gstr << gtr_sprintf(
_("Peer list request %1$stimed out%2$s %3$s ago; will retry"),
timeout_markup_begin,
timeout_markup_end,
timebuf);
}
else
{
gstr << gtr_sprintf(
_("Got an error %1$s\"%2$s\"%3$s %4$s ago"),
err_markup_begin,
tracker.lastAnnounceResult,
err_markup_end,
timebuf);
}
}
switch (tracker.announceState)
{
case TR_TRACKER_INACTIVE:
gstr << '\n';
gstr << text_dir_mark[direction];
gstr << _("No updates scheduled");
break;
case TR_TRACKER_WAITING:
gstr << '\n';
gstr << text_dir_mark[direction];
gstr << gtr_sprintf(_("Asking for more peers in %s"), tr_strltime_rounded(tracker.nextAnnounceTime - now));
break;
case TR_TRACKER_QUEUED:
gstr << '\n';
gstr << text_dir_mark[direction];
gstr << _("Queued to ask for more peers");
break;
case TR_TRACKER_ACTIVE:
gstr << '\n';
gstr << text_dir_mark[direction];
gstr << gtr_sprintf(
_("Asking for more peers now… <small>%s</small>"),
tr_strltime_rounded(now - tracker.lastAnnounceStartTime));
break;
default:
g_assert_not_reached();
}
}
void appendScrapeInfo(tr_tracker_view const& tracker, time_t const now, Gtk::TextDirection direction, std::ostream& gstr)
{
if (tracker.hasScraped)
{
gstr << '\n';
gstr << text_dir_mark[direction];
auto const timebuf = tr_strltime_rounded(now - tracker.lastScrapeTime);
if (tracker.lastScrapeSucceeded)
{
gstr << gtr_sprintf(
_("Tracker had %s%'d seeders and %'d leechers%s %s ago"),
success_markup_begin,
tracker.seederCount,
tracker.leecherCount,
success_markup_end,
timebuf);
}
else
{
gstr << gtr_sprintf(
_("Got a scrape error \"%s%s%s\" %s ago"),
err_markup_begin,
tracker.lastScrapeResult,
err_markup_end,
timebuf);
}
}
switch (tracker.scrapeState)
{
case TR_TRACKER_INACTIVE:
break;
case TR_TRACKER_WAITING:
gstr << '\n';
gstr << text_dir_mark[direction];
gstr << gtr_sprintf(_("Asking for peer counts in %s"), tr_strltime_rounded(tracker.nextScrapeTime - now));
break;
case TR_TRACKER_QUEUED:
gstr << '\n';
gstr << text_dir_mark[direction];
gstr << _("Queued to ask for peer counts");
break;
case TR_TRACKER_ACTIVE:
gstr << '\n';
gstr << text_dir_mark[direction];
gstr << gtr_sprintf(
_("Asking for peer counts now… <small>%s</small>"),
tr_strltime_rounded(now - tracker.lastScrapeStartTime));
break;
default:
g_assert_not_reached();
}
}
void buildTrackerSummary(
std::ostream& gstr,
std::string const& key,
tr_tracker_view const& tracker,
bool showScrape,
Gtk::TextDirection direction)
{
// hostname
gstr << text_dir_mark[direction];
gstr << (tracker.isBackup ? "<i>" : "<b>");
gstr << Glib::Markup::escape_text(!key.empty() ? gtr_sprintf("%s - %s", tracker.host, key) : tracker.host);
gstr << (tracker.isBackup ? "</i>" : "</b>");
if (!tracker.isBackup)
{
time_t const now = time(nullptr);
appendAnnounceInfo(tracker, now, direction, gstr);
if (showScrape)
{
appendScrapeInfo(tracker, now, direction, gstr);
}
}
}
class TrackerModelColumns : public Gtk::TreeModelColumnRecord
{
public:
TrackerModelColumns()
{
add(torrent_id);
add(text);
add(is_backup);
add(tracker_id);
add(favicon);
add(was_updated);
add(key);
}
Gtk::TreeModelColumn<int> torrent_id;
Gtk::TreeModelColumn<Glib::ustring> text;
Gtk::TreeModelColumn<bool> is_backup;
Gtk::TreeModelColumn<int> tracker_id;
Gtk::TreeModelColumn<Glib::RefPtr<Gdk::Pixbuf>> favicon;
Gtk::TreeModelColumn<bool> was_updated;
Gtk::TreeModelColumn<std::string> key;
};
TrackerModelColumns const tracker_cols;
} // namespace
bool DetailsDialog::Impl::trackerVisibleFunc(Gtk::TreeModel::const_iterator const& iter)
{
/* show all */
if (all_check_->get_active())
{
return true;
}
/* don't show the backups... */
return !iter->get_value(tracker_cols.is_backup);
}
int DetailsDialog::Impl::tracker_list_get_current_torrent_id() const
{
int torrent_id = -1;
/* if there's only one torrent in the dialog, always use it */
if (ids_.size() == 1)
{
torrent_id = ids_.front();
}
/* otherwise, use the selected tracker's torrent */
if (torrent_id < 0)
{
auto const sel = tracker_view_->get_selection();
if (auto const iter = sel->get_selected(); iter)
{
torrent_id = iter->get_value(tracker_cols.torrent_id);
}
}
return torrent_id;
}
tr_torrent* DetailsDialog::Impl::tracker_list_get_current_torrent() const
{
int const torrent_id = tracker_list_get_current_torrent_id();
return core_->find_torrent(torrent_id);
}
namespace
{
void favicon_ready_cb(Glib::RefPtr<Gdk::Pixbuf> const& pixbuf, Gtk::TreeRowReference& reference)
{
if (pixbuf != nullptr)
{
auto const path = reference.get_path();
auto const model = reference.get_model();
if (auto const iter = model->get_iter(path); iter)
{
(*iter)[tracker_cols.favicon] = pixbuf;
}
}
}
} // namespace
void DetailsDialog::Impl::refreshTracker(std::vector<tr_torrent*> const& torrents)
{
std::ostringstream gstr;
auto& hash = tracker_hash_;
auto& store = tracker_store_;
auto* session = core_->get_session();
bool const showScrape = scrape_check_->get_active();
/* step 1: get all the trackers */
auto trackers = std::multimap<tr_torrent const*, tr_tracker_view>{};
for (auto const* tor : torrents)
{
for (size_t i = 0, n = tr_torrentTrackerCount(tor); i < n; ++i)
{
trackers.emplace(tor, tr_torrentTracker(tor, i));
}
}
/* step 2: mark all the trackers in the list as not-updated */
for (auto const& row : store->children())
{
row[tracker_cols.was_updated] = false;
}
/* step 3: add / update trackers */
for (auto const& [tor, tracker] : trackers)
{
auto const torrent_id = tr_torrentId(tor);
// build the key to find the row
gstr.str({});
gstr << torrent_id << '\t' << tracker.tier << '\t' << tracker.announce;
if (hash.find(gstr.str()) == hash.end())
{
// if we didn't have that row, add it
auto const iter = store->append();
(*iter)[tracker_cols.torrent_id] = torrent_id;
(*iter)[tracker_cols.tracker_id] = tracker.id;
(*iter)[tracker_cols.key] = gstr.str();
auto const p = store->get_path(iter);
hash.try_emplace(gstr.str(), Gtk::TreeRowReference(store, p));
gtr_get_favicon_from_url(
session,
tracker.announce,
[ref = Gtk::TreeRowReference(store, p)](auto const& pixbuf) mutable { favicon_ready_cb(pixbuf, ref); });
}
}
/* step 4: update the rows */
auto const summary_name = std::string(std::size(torrents) == 1 ? tr_torrentName(torrents.front()) : "");
for (auto const& [tor, tracker] : trackers)
{
auto const torrent_id = tr_torrentId(tor);
// build the key to find the row
gstr.str({});
gstr << torrent_id << '\t' << tracker.tier << '\t' << tracker.announce;
auto const iter = store->get_iter(hash.at(gstr.str()).get_path());
// update the row
gstr.str({});
buildTrackerSummary(gstr, summary_name, tracker, showScrape, dialog_.get_direction());
(*iter)[tracker_cols.text] = gstr.str();
(*iter)[tracker_cols.is_backup] = tracker.isBackup;
(*iter)[tracker_cols.tracker_id] = tracker.id;
(*iter)[tracker_cols.was_updated] = true;
}
/* step 5: remove trackers that have disappeared */
if (auto iter = store->children().begin(); iter)
{
while (iter)
{
if (iter->get_value(tracker_cols.was_updated))
{
++iter;
}
else
{
auto const key = iter->get_value(tracker_cols.key);
hash.erase(key);
iter = store->erase(iter);
}
}
}
edit_trackers_button_->set_sensitive(tracker_list_get_current_torrent_id() >= 0);
}
void DetailsDialog::Impl::onScrapeToggled()
{
tr_quark const key = TR_KEY_show_tracker_scrapes;
bool const value = scrape_check_->get_active();
core_->set_pref(key, value);
refresh();
}
void DetailsDialog::Impl::onBackupToggled()
{
tr_quark const key = TR_KEY_show_backup_trackers;
bool const value = all_check_->get_active();
core_->set_pref(key, value);
refresh();
}
void DetailsDialog::Impl::on_edit_trackers_response(int response, std::shared_ptr<Gtk::Dialog>& dialog)
{
bool do_destroy = true;
if (response == Gtk::RESPONSE_ACCEPT)
{
auto const torrent_id = GPOINTER_TO_INT(dialog->get_data(TORRENT_ID_KEY));
auto* const text_buffer = static_cast<Gtk::TextBuffer*>(dialog->get_data(TEXT_BUFFER_KEY));
tr_torrent* const tor = core_->find_torrent(torrent_id);
if (tor != nullptr)
{
/* build the array of trackers */
auto const tracker_text = text_buffer->get_text(false);
std::istringstream tracker_strings(tracker_text);
auto announce_url_strings = std::vector<std::string>{};
auto announce_urls = std::vector<char const*>{};
auto tiers = std::vector<tr_tracker_tier_t>{};
auto tier = tr_tracker_tier_t{ 0 };
std::string str;
while (std::getline(tracker_strings, str))
{
if (str.empty())
{
++tier;
}
else
{
announce_url_strings.push_back(str);
tiers.push_back(tier);
}
}
std::transform(
std::begin(announce_url_strings),
std::end(announce_url_strings),
std::back_inserter(announce_urls),
[](auto const& url) { return url.c_str(); });
if (tr_torrentSetAnnounceList(tor, std::data(announce_urls), std::data(tiers), std::size(announce_urls)))
{
refresh();
}
else
{
Gtk::MessageDialog
w(*dialog, _("List contains invalid URLs"), false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_CLOSE, true);
w.set_secondary_text(_("Please correct the errors and try again."));
w.run();
do_destroy = false;
}
}
}
if (do_destroy)
{
dialog.reset();
}
}
namespace
{
std::string get_editable_tracker_list(tr_torrent const* tor)
{
std::ostringstream gstr;
int tier = 0;
for (size_t i = 0, n = tr_torrentTrackerCount(tor); i < n; ++i)
{
auto const tracker = tr_torrentTracker(tor, i);
if (tier != tracker.tier)
{
tier = tracker.tier;
gstr << '\n';
}
gstr << tracker.announce << '\n';
}
auto str = gstr.str();
if (!str.empty())
{
str.resize(str.size() - 1);
}
return str;
}
} // namespace
void DetailsDialog::Impl::on_edit_trackers()
{
tr_torrent const* tor = tracker_list_get_current_torrent();
if (tor != nullptr)
{
guint row;
int const torrent_id = tr_torrentId(tor);
auto d = std::make_shared<Gtk::Dialog>(
gtr_sprintf(_("%s - Edit Trackers"), tr_torrentName(tor)),
dialog_,
Gtk::DIALOG_MODAL | Gtk::DIALOG_DESTROY_WITH_PARENT);
d->add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
d->add_button(_("_Save"), Gtk::RESPONSE_ACCEPT);
d->signal_response().connect([this, d](int response) mutable { on_edit_trackers_response(response, d); });
row = 0;
auto* t = Gtk::make_managed<HigWorkarea>();
t->add_section_title(row, _("Tracker Announce URLs"));
auto* l = Gtk::make_managed<Gtk::Label>();
l->set_markup(
_("To add a backup URL, add it on the line after the primary URL.\n"
"To add another primary URL, add it after a blank line."));
l->set_justify(Gtk::JUSTIFY_LEFT);
l->set_halign(Gtk::ALIGN_START);
l->set_valign(Gtk::ALIGN_CENTER);
t->add_wide_control(row, *l);
auto* w = Gtk::make_managed<Gtk::TextView>();
w->get_buffer()->set_text(get_editable_tracker_list(tor));
auto* fr = Gtk::make_managed<Gtk::Frame>();
fr->set_shadow_type(Gtk::SHADOW_IN);
auto* sw = Gtk::make_managed<Gtk::ScrolledWindow>();
sw->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
sw->add(*w);
fr->add(*sw);
fr->set_size_request(500U, 166U);
t->add_wide_tall_control(row, *fr);
gtr_dialog_set_content(*d, *t);
d->set_data(TORRENT_ID_KEY, GINT_TO_POINTER(torrent_id));
d->set_data(TEXT_BUFFER_KEY, gtr_get_ptr(w->get_buffer()));
d->show();
}
}
void DetailsDialog::Impl::on_tracker_list_selection_changed()
{
int const n = tracker_view_->get_selection()->count_selected_rows();
auto* tor = tracker_list_get_current_torrent();
remove_tracker_button_->set_sensitive(n > 0);
add_tracker_button_->set_sensitive(tor != nullptr);
edit_trackers_button_->set_sensitive(tor != nullptr);
}
void DetailsDialog::Impl::on_add_tracker_response(int response, std::shared_ptr<Gtk::Dialog>& dialog)
{
bool destroy = true;
if (response == Gtk::RESPONSE_ACCEPT)
{
auto* e = static_cast<Gtk::Entry*>(dialog->get_data(URL_ENTRY_KEY));
auto const torrent_id = GPOINTER_TO_INT(dialog->get_data(TORRENT_ID_KEY));
auto const url = gtr_str_strip(e->get_text());
if (!url.empty())
{
if (tr_urlIsValidTracker(url.c_str()))
{
tr_variant top;
tr_variant* args;
tr_variant* trackers;
tr_variantInitDict(&top, 2);
tr_variantDictAddStrView(&top, TR_KEY_method, "torrent-set"sv);
args = tr_variantDictAddDict(&top, TR_KEY_arguments, 2);
tr_variantDictAddInt(args, TR_KEY_id, torrent_id);
trackers = tr_variantDictAddList(args, TR_KEY_trackerAdd, 1);
tr_variantListAddStr(trackers, url.raw());
core_->exec(&top);
refresh();
tr_variantFree(&top);
}
else
{
gtr_unrecognized_url_dialog(*dialog, url);
destroy = false;
}
}
}
if (destroy)
{
dialog.reset();
}
}
void DetailsDialog::Impl::on_tracker_list_add_button_clicked()
{
tr_torrent const* tor = tracker_list_get_current_torrent();
if (tor != nullptr)
{
guint row;
auto w = std::make_shared<Gtk::Dialog>(
gtr_sprintf(_("%s - Add Tracker"), tr_torrentName(tor)),
dialog_,
Gtk::DIALOG_DESTROY_WITH_PARENT);
w->add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
w->add_button(_("_Add"), Gtk::RESPONSE_ACCEPT);
w->signal_response().connect([this, w](int response) mutable { on_add_tracker_response(response, w); });
row = 0;
auto* t = Gtk::make_managed<HigWorkarea>();
t->add_section_title(row, _("Tracker"));
auto* e = Gtk::make_managed<Gtk::Entry>();
e->set_size_request(400, -1);
gtr_paste_clipboard_url_into_entry(*e);
w->set_data(URL_ENTRY_KEY, e);
w->set_data(TORRENT_ID_KEY, GINT_TO_POINTER(tr_torrentId(tor)));
t->add_row(row, _("_Announce URL:"), *e);
gtr_dialog_set_content(*w, *t);
w->show_all();
}
}
void DetailsDialog::Impl::on_tracker_list_remove_button_clicked()
{
auto* v = tracker_view_;
auto sel = v->get_selection();
if (auto const iter = sel->get_selected(); iter)
{
auto const torrent_id = iter->get_value(tracker_cols.torrent_id);
auto const tracker_id = iter->get_value(tracker_cols.tracker_id);
tr_variant top;
tr_variant* args;
tr_variant* trackers;
tr_variantInitDict(&top, 2);
tr_variantDictAddStrView(&top, TR_KEY_method, "torrent-set"sv);
args = tr_variantDictAddDict(&top, TR_KEY_arguments, 2);
tr_variantDictAddInt(args, TR_KEY_id, torrent_id);
trackers = tr_variantDictAddList(args, TR_KEY_trackerRemove, 1);
tr_variantListAddInt(trackers, tracker_id);
core_->exec(&top);
refresh();
tr_variantFree(&top);
}
}
Gtk::Widget* DetailsDialog::Impl::tracker_page_new()
{
int const pad = (GUI_PAD + GUI_PAD_BIG) / 2;
auto* vbox = Gtk::make_managed<Gtk::Box>(Gtk::ORIENTATION_VERTICAL, GUI_PAD);
vbox->set_border_width(GUI_PAD_BIG);
tracker_store_ = Gtk::ListStore::create(tracker_cols);
trackers_filtered_ = Gtk::TreeModelFilter::create(tracker_store_);
trackers_filtered_->set_visible_func(sigc::mem_fun(*this, &Impl::trackerVisibleFunc));
auto* hbox = Gtk::make_managed<Gtk::Box>(Gtk::ORIENTATION_HORIZONTAL, GUI_PAD_BIG);
tracker_view_ = Gtk::make_managed<Gtk::TreeView>(trackers_filtered_);
tracker_view_->set_headers_visible(false);
tracker_view_->signal_button_press_event().connect([this](GdkEventButton* event)
{ return on_tree_view_button_pressed(tracker_view_, event); });
tracker_view_->signal_button_release_event().connect([this](GdkEventButton* event)
{ return on_tree_view_button_released(tracker_view_, event); });
auto sel = tracker_view_->get_selection();
sel->signal_changed().connect(sigc::mem_fun(*this, &Impl::on_tracker_list_selection_changed));
auto* c = Gtk::make_managed<Gtk::TreeViewColumn>();
c->set_title(_("Trackers"));
tracker_view_->append_column(*c);
{
auto* r = Gtk::make_managed<Gtk::CellRendererPixbuf>();
r->property_width() = 20 + (GUI_PAD_SMALL * 2);
r->property_xpad() = GUI_PAD_SMALL;
r->property_ypad() = pad;
r->property_yalign() = 0.0F;
c->pack_start(*r, false);
c->add_attribute(r->property_pixbuf(), tracker_cols.favicon);
}
{
auto* r = Gtk::make_managed<Gtk::CellRendererText>();
r->property_ellipsize() = Pango::ELLIPSIZE_END;
r->property_xpad() = GUI_PAD_SMALL;
r->property_ypad() = pad;
c->pack_start(*r, true);
c->add_attribute(r->property_markup(), tracker_cols.text);
}
auto* sw = Gtk::make_managed<Gtk::ScrolledWindow>();
sw->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
sw->add(*tracker_view_);
auto* w = Gtk::make_managed<Gtk::Frame>();
w->set_shadow_type(Gtk::SHADOW_IN);
w->add(*sw);
hbox->pack_start(*w, true, true);
auto* v = Gtk::make_managed<Gtk::Box>(Gtk::ORIENTATION_VERTICAL, GUI_PAD);
add_tracker_button_ = Gtk::make_managed<Gtk::Button>(_("_Add"), true);
add_tracker_button_->signal_clicked().connect(sigc::mem_fun(*this, &Impl::on_tracker_list_add_button_clicked));
v->pack_start(*add_tracker_button_, false, false);
edit_trackers_button_ = Gtk::make_managed<Gtk::Button>(_("_Edit"), true);
edit_trackers_button_->signal_clicked().connect(sigc::mem_fun(*this, &Impl::on_edit_trackers));
v->pack_start(*edit_trackers_button_, false, false);
remove_tracker_button_ = Gtk::make_managed<Gtk::Button>(_("_Remove"), true);
remove_tracker_button_->signal_clicked().connect(sigc::mem_fun(*this, &Impl::on_tracker_list_remove_button_clicked));
v->pack_start(*remove_tracker_button_, false, false);
hbox->pack_start(*v, false, false);
vbox->pack_start(*hbox, true, true);
scrape_check_ = Gtk::make_managed<Gtk::CheckButton>(_("Show _more details"), true);
scrape_check_->set_active(gtr_pref_flag_get(TR_KEY_show_tracker_scrapes));
scrape_check_->signal_toggled().connect(sigc::mem_fun(*this, &Impl::onScrapeToggled));
vbox->pack_start(*scrape_check_, false, false);
all_check_ = Gtk::make_managed<Gtk::CheckButton>(_("Show _backup trackers"), true);
all_check_->set_active(gtr_pref_flag_get(TR_KEY_show_backup_trackers));
all_check_->signal_toggled().connect(sigc::mem_fun(*this, &Impl::onBackupToggled));
vbox->pack_start(*all_check_, false, false);
return vbox;
}
/****
***** DIALOG
****/
void DetailsDialog::Impl::refresh()
{
auto const torrents = getTorrents();
refreshInfo(torrents);
refreshPeers(torrents);
refreshTracker(torrents);
refreshOptions(torrents);
if (torrents.empty())
{
dialog_.response(Gtk::RESPONSE_CLOSE);
}
}
void DetailsDialog::Impl::on_details_window_size_allocated(Gtk::Allocation& /*alloc*/)
{
int w = 0;
int h = 0;
dialog_.get_size(w, h);
gtr_pref_int_set(TR_KEY_details_window_width, w);
gtr_pref_int_set(TR_KEY_details_window_height, h);
}
DetailsDialog::Impl::~Impl()
{
periodic_refresh_tag_.disconnect();
}
std::unique_ptr<DetailsDialog> DetailsDialog::create(Gtk::Window& parent, Glib::RefPtr<Session> const& core)
{
return std::unique_ptr<DetailsDialog>(new DetailsDialog(parent, core));
}
DetailsDialog::DetailsDialog(Gtk::Window& parent, Glib::RefPtr<Session> const& core)
: Gtk::Dialog({}, parent)
, impl_(std::make_unique<Impl>(*this, core))
{
}
DetailsDialog::~DetailsDialog() = default;
DetailsDialog::Impl::Impl(DetailsDialog& dialog, Glib::RefPtr<Session> const& core)
: dialog_(dialog)
, core_(core)
{
/* create the dialog */
dialog_.add_button(_("_Close"), Gtk::RESPONSE_CLOSE);
dialog_.set_role("tr-info");
/* return saved window size */
dialog_.resize((int)gtr_pref_int_get(TR_KEY_details_window_width), (int)gtr_pref_int_get(TR_KEY_details_window_height));
dialog_.signal_size_allocate().connect(sigc::mem_fun(*this, &Impl::on_details_window_size_allocated));
dialog_.signal_response().connect(sigc::hide<0>(sigc::mem_fun(dialog_, &DetailsDialog::hide)));
dialog_.set_border_width(GUI_PAD);
auto* n = Gtk::make_managed<Gtk::Notebook>();
n->set_border_width(GUI_PAD);
n->append_page(*info_page_new(), _("Information"));
n->append_page(*peer_page_new(), _("Peers"));
n->append_page(*tracker_page_new(), _("Trackers"));
auto* v = Gtk::make_managed<Gtk::Box>(Gtk::ORIENTATION_VERTICAL);
file_list_ = Gtk::make_managed<FileList>(core, 0);
file_label_ = Gtk::make_managed<Gtk::Label>(_("File listing not available for combined torrent properties"));
v->pack_start(*file_list_, true, true, 0);
v->pack_start(*file_label_, true, true, 0);
v->set_border_width(GUI_PAD_BIG);
n->append_page(*v, _("Files"));
n->append_page(*options_page_new(), _("Options"));
gtr_dialog_set_content(dialog_, *n);
periodic_refresh_tag_ = Glib::signal_timeout().connect_seconds(
[this]() { return refresh(), true; },
SECONDARY_WINDOW_REFRESH_INTERVAL_SECONDS);
}
void DetailsDialog::set_torrents(std::vector<int> const& ids)
{
impl_->set_torrents(ids);
}
void DetailsDialog::Impl::set_torrents(std::vector<int> const& ids)
{
Glib::ustring title;
int const len = ids.size();
ids_ = ids;
if (len == 1)
{
int const id = ids.front();
auto const* tor = core_->find_torrent(id);
title = gtr_sprintf(_("%s Properties"), tr_torrentName(tor));
file_list_->set_torrent(id);
file_list_->show();
file_label_->hide();
}
else
{
file_list_->clear();
file_list_->hide();
file_label_->show();
title = gtr_sprintf(_("%'d Torrent Properties"), len);
}
dialog_.set_title(title);
refresh();
}
Reference in New Issue View Git Blame Copy Permalink