string | value type & description
----------------------------------+-------------------------------------------------
"downloadLimit" | number maximum download speed (in K/s)
- "downloadLimitHonored" | 'boolean' true if "downloadLimit" is honored
- "downloadGlobalHonored" | 'boolean' true if global speed limit is honored
+ "downloadLimited" | 'boolean' true if "downloadLimit" is honored
"files-wanted" | array indices of file(s) to download
"files-unwanted" | array indices of file(s) to not download
+ "honorsSessionLimits" | 'boolean' true if session upload limits are honored
"ids" | array torrent list, as described in 3.1
"peer-limit" | number maximum number of peers
"priority-high" | array indices of high-priority file(s)
"priority-low" | array indices of low-priority file(s)
"priority-normal" | array indices of normal-priority file(s)
"uploadLimit" | number maximum upload speed (in K/s)
- "uploadLimitHonored" | 'boolean' true if "uploadLimit" is honored
- "uploadGlobalHonored" | 'boolean' true if global speed limit is honored
+ "uploadLimited" | 'boolean' true if "uploadLimit" is honored
Just as an empty "ids" value is shorthand for "all ids", using an empty array
for "files-wanted", "files-unwanted", "priority-high", "priority-low", or
downloadedEver | number | tr_stat
downloaders | number | tr_stat
downloadLimit | number | tr_torrent
- downloadHonorsLimit | 'boolean' | tr_torrent
- downloadHonorsGlobalLimit | 'boolean' | tr_torrent
+ downloadLimited | 'boolean' | tr_torrent
error | number | tr_stat
errorString | number | tr_stat
eta | number | tr_stat
hashString | string | tr_info
haveUnchecked | number | tr_stat
haveValid | number | tr_stat
+ honorsSessionLimits | 'boolean' | tr_torrent
id | number | tr_torrent
isPrivate | 'boolean' | tr_torrent
lastAnnounceTime | number | tr_stat
totalSize | number | tr_info
uploadedEver | number | tr_stat
uploadLimit | number | tr_torrent
- uploadHonorsLimit | 'boolean' | tr_torrent
- uploadHonorsGlobalLimit | 'boolean' | tr_torrent
+ uploadLimited | 'boolean' | tr_torrent
uploadRatio | 'double' | tr_stat
wanted | array (see below) | n/a
webseeds | array (see below) | n/a
string | value type & description
---------------------------+-------------------------------------------------
- "alt-speed-limit-enabled" | 'boolean' true means enabled
- "alt-speed-limit-up" | number max global upload speed (in K/s)
- "alt-speed-limit-down" | number max global download speed (in K/s)
- "alt-speed-limit-begin" | number minutes after midnight. (ex: 60 means starting at 1 am)
- "alt-speed-limit-end" | number minutes after midnight. (ex: 300 means ending at 5 am)
+ "alt-speed-down" | number max global download speed (in K/s)
+ "alt-speed-enabled" | 'boolean' true means use the alt speeds
+ "alt-speed-time-begin" | number when to turn on alt speeds (units: minutes after midnight)
+ "alt-speed-time-enabled" | 'boolean' true means the scheduled on/off times are used
+ "alt-speed-time-end" | number when to turn off alt speeds (units: same)
+ "alt-speed-up" | number max global upload speed (in K/s)
"blocklist-enabled" | 'boolean' true means enabled
"blocklist-size" | number number of rules in the blocklist
"encryption" | string "required", "preferred", "tolerated"
------+---------+-----------+----------------+-------------------------------
6 | 1.60 | yes | torrent-get | new arg "pieces"
| | yes | torrent-set | new arg "ratio"
- | | yes | torrent-set | new arg "downloadHonorsLimit"
- | | yes | torrent-set | new arg "downloadHonorsGlobalLimit"
- | | yes | torrent-set | new arg "uploadHonorsLimit"
- | | yes | torrent-set | new arg "uploadHonorsGlobalLimit"
- | | yes | torrent-get | new ids option "recently-active"
- | | yes | session-get | new arg "alt-speed-limit-enabled"
- | | yes | session-get | new arg "alt-speed-limit-up"
- | | yes | session-get | new arg "alt-speed-limit-down"
- | | yes | session-get | new arg "alt-speed-limit-begin"
- | | yes | session-get | new arg "alt-speed-limit-end"
+ | | yes | torrent-set | new arg "downloadLimited"
+ | | yes | torrent-set | new arg "uploadLimited"
+ | | yes | torrent-set | new arg "honorsSessionLImits"
+ | | yes | session-get | new arg "alt-speed-enabled"
+ | | yes | session-get | new arg "alt-speed-time-enabled"
+ | | yes | session-get | new arg "alt-speed-up"
+ | | yes | session-get | new arg "alt-speed-down"
+ | | yes | session-get | new arg "alt-speed-begin"
+ | | yes | session-get | new arg "alt-speed-end"
| | yes | session-get | new arg "blocklist-enabled"
| | yes | session-get | new arg "blocklist-size"
| | yes | session-get | new arg "peer-limit-per-torrent"
+ | | yes | torrent-get | new ids option "recently-active"
| | yes | | new method "torrent-reannounce"
| | NO | torrent-get | removed arg "downloadLimitMode"
| | NO | torrent-get | removed arg "uploadLimitMode"
tr-prefs.h \
tr-torrent.h \
tr-window.h \
+ turtles.h \
ui.h \
util.h
#include "tr-prefs.h"
#include "lock.h"
#include "logo.h"
+#include "turtles.h"
#define UNUSED G_GNUC_UNUSED
static GtkToggleActionEntry show_toggle_entries[] =
{
- { "toggle-main-window", NULL,
- N_( "_Main Window" ), NULL, NULL, G_CALLBACK( action_cb ), TRUE },
- { "toggle-message-log", NULL,
- N_( "Message _Log" ), NULL, NULL, G_CALLBACK( action_cb ), FALSE }
+ { "toggle-main-window", NULL, N_( "_Main Window" ), NULL, NULL, G_CALLBACK( action_cb ), TRUE },
+ { "toggle-message-log", NULL, N_( "Message _Log" ), NULL, NULL, G_CALLBACK( action_cb ), FALSE }
};
static void
static const BuiltinIconInfo my_fallback_icons[] =
{
{ tr_icon_logo, "transmission" },
- { tr_icon_lock, "transmission-lock" }
+ { tr_icon_lock, "transmission-lock" },
+ { blue_turtle, "alt-speed-on" },
+ { grey_turtle, "alt-speed-off" }
};
static void
tr_torrent * tor = tr_torrent_handle( gtor );
const gboolean b = gtk_toggle_button_get_active( tb );
- tr_torrentUseGlobalSpeedLimit( tor, TR_UP, b );
- tr_torrentUseGlobalSpeedLimit( tor, TR_DOWN, b );
+ tr_torrentUseSessionLimits( tor, b );
}
#define RATIO_MODE_KEY "ratio-mode"
t = hig_workarea_create( );
hig_workarea_add_section_title( t, &row, _( "Speed Limits" ) );
- b = tr_torrentIsUsingGlobalSpeedLimit( tor, TR_UP );
+ b = tr_torrentUsesSessionLimits( tor );
tb = hig_workarea_add_wide_checkbutton( t, &row, _( "Honor global _limits" ), b );
g_signal_connect( tb, "toggled", G_CALLBACK( global_speed_toggled_cb ), gtor );
tb = gtk_check_button_new_with_mnemonic( _( "Limit _download speed (KB/s):" ) );
- b = tr_torrentIsUsingSpeedLimit( tor, TR_DOWN );
+ b = tr_torrentUsesSpeedLimit( tor, TR_DOWN );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( tb ), b );
g_signal_connect( tb, "toggled", G_CALLBACK( down_speed_toggled_cb ), gtor );
hig_workarea_add_row_w( t, &row, tb, w, NULL );
tb = gtk_check_button_new_with_mnemonic( _( "Limit _upload speed (KB/s):" ) );
- b = tr_torrentIsUsingSpeedLimit( tor, TR_UP );
+ b = tr_torrentUsesSpeedLimit( tor, TR_UP );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( tb ), b );
g_signal_connect( tb, "toggled", G_CALLBACK( up_speed_toggled_cb ), gtor );
{
GtkWidget * r = rowNew( w );
- gtk_table_attach( GTK_TABLE(
- t ), r, 0, 2, *row, *row + 1, GTK_FILL, 0, 0, 0 );
+ gtk_table_attach( GTK_TABLE( t ), r, 0, 2, *row, *row + 1, GTK_FILL, 0, 0, 0 );
++ * row;
}
/* initialize the libtransmission session */
session = tr_sessionInit( "gtk", configDir, TRUE, pref_get_all( ) );
+ pref_flag_set( TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed( session ) );
cbdata->core = tr_core_new( session );
/* create main window now to be a parent to any error dialogs */
}
else if( !strcmp( key, TR_PREFS_KEY_PEER_PORT ) )
{
- const int port = pref_int_get( key );
- tr_sessionSetPeerPort( tr, port );
+ tr_sessionSetPeerPort( tr, pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_BLOCKLIST_ENABLED ) )
{
- const gboolean flag = pref_flag_get( key );
- tr_blocklistSetEnabled( tr, flag );
+ tr_blocklistSetEnabled( tr, pref_flag_get( key ) );
}
else if( !strcmp( key, PREF_KEY_SHOW_TRAY_ICON ) )
{
const int show = pref_flag_get( key );
if( show && !cbdata->icon )
cbdata->icon = tr_icon_new( cbdata->core );
- else if( !show && cbdata->icon )
- {
+ else if( !show && cbdata->icon ) {
g_object_unref( cbdata->icon );
cbdata->icon = NULL;
}
}
else if( !strcmp( key, TR_PREFS_KEY_DSPEED_ENABLED ) )
{
- const gboolean b = pref_flag_get( key );
- tr_sessionSetSpeedLimitEnabled( tr, TR_DOWN, b );
+ tr_sessionLimitSpeed( tr, TR_DOWN, pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_DSPEED ) )
{
- const int limit = pref_int_get( key );
- tr_sessionSetSpeedLimit( tr, TR_DOWN, limit );
+ tr_sessionSetSpeedLimit( tr, TR_DOWN, pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_USPEED_ENABLED ) )
{
- const gboolean b = pref_flag_get( key );
- tr_sessionSetSpeedLimitEnabled( tr, TR_UP, b );
+ tr_sessionLimitSpeed( tr, TR_UP, pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_USPEED ) )
{
- const int limit = pref_int_get( key );
- tr_sessionSetSpeedLimit( tr, TR_UP, limit );
+ tr_sessionSetSpeedLimit( tr, TR_UP, pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RATIO_ENABLED ) )
{
- const gboolean b = pref_flag_get( key );
- tr_sessionSetRatioLimited( tr, b );
+ tr_sessionSetRatioLimited( tr, pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RATIO ) )
{
- const double limit = pref_double_get( key );
- tr_sessionSetRatioLimit( tr, limit );
+ tr_sessionSetRatioLimit( tr, pref_double_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_PORT_FORWARDING ) )
{
}
else if( !strcmp( key, TR_PREFS_KEY_RPC_WHITELIST ) )
{
- const char * s = pref_string_get( key );
- tr_sessionSetRPCWhitelist( tr, s );
+ tr_sessionSetRPCWhitelist( tr, pref_string_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RPC_WHITELIST_ENABLED ) )
{
}
else if( !strcmp( key, TR_PREFS_KEY_RPC_USERNAME ) )
{
- const char * s = pref_string_get( key );
- tr_sessionSetRPCUsername( tr, s );
+ tr_sessionSetRPCUsername( tr, pref_string_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RPC_PASSWORD ) )
{
- const char * s = pref_string_get( key );
- tr_sessionSetRPCPassword( tr, s );
+ tr_sessionSetRPCPassword( tr, pref_string_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RPC_AUTH_REQUIRED ) )
{
- const gboolean enabled = pref_flag_get( key );
- tr_sessionSetRPCPasswordEnabled( tr, enabled );
+ tr_sessionSetRPCPasswordEnabled( tr, pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_PROXY ) )
{
- const char * s = pref_string_get( key );
- tr_sessionSetProxy( tr, s );
+ tr_sessionSetProxy( tr, pref_string_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_PROXY_TYPE ) )
{
- const int i = pref_int_get( key );
- tr_sessionSetProxyType( tr, i );
+ tr_sessionSetProxyType( tr, pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_PROXY_ENABLED ) )
{
- const gboolean enabled = pref_flag_get( key );
- tr_sessionSetProxyEnabled( tr, enabled );
+ tr_sessionSetProxyEnabled( tr, pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_PROXY_AUTH_ENABLED ) )
{
- const gboolean enabled = pref_flag_get( key );
- tr_sessionSetProxyAuthEnabled( tr, enabled );
+ tr_sessionSetProxyAuthEnabled( tr, pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_PROXY_USERNAME ) )
{
- const char * s = pref_string_get( key );
- tr_sessionSetProxyUsername( tr, s );
+ tr_sessionSetProxyUsername( tr, pref_string_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_PROXY_PASSWORD ) )
{
- const char * s = pref_string_get( key );
- tr_sessionSetProxyPassword( tr, s );
+ tr_sessionSetProxyPassword( tr, pref_string_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_PROXY_PORT ) )
{
tr_sessionSetProxyPort( tr, pref_int_get( key ) );
}
- else if( !strcmp( key, TR_PREFS_KEY_RPC_PASSWORD ) )
+ else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_UP ) )
{
- const char * s = pref_string_get( key );
- tr_sessionSetProxyPassword( tr, s );
+ tr_sessionSetAltSpeed( tr, TR_UP, pref_int_get( key ) );
}
- else if( !strcmp( key, TR_PREFS_KEY_ALT_LIMIT_ENABLED ) )
+ else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_DOWN ) )
{
- const gboolean enabled = pref_flag_get( key );
- tr_sessionSetAltSpeedLimitEnabled( tr, enabled );
+ tr_sessionSetAltSpeed( tr, TR_DOWN, pref_int_get( key ) );
}
- else if( !strcmp( key, TR_PREFS_KEY_ALT_BEGIN ) )
+ else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_ENABLED ) )
{
- const int minutes = pref_int_get( key );
- tr_sessionSetAltSpeedLimitBegin( tr, minutes );
+ tr_sessionUseAltSpeed( tr, pref_flag_get( key ) );
}
- else if( !strcmp( key, TR_PREFS_KEY_ALT_DL_LIMIT ) )
+ else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN ) )
{
- const int speed = pref_int_get( key );
- tr_sessionSetAltSpeedLimit( tr, TR_DOWN, speed );
+ tr_sessionSetAltSpeedBegin( tr, pref_int_get( key ) );
}
- else if( !strcmp( key, TR_PREFS_KEY_ALT_END ) )
+ else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_END ) )
{
- const int minutes = pref_int_get( key );
- tr_sessionSetAltSpeedLimitEnd( tr, minutes );
+ tr_sessionSetAltSpeedEnd( tr, pref_int_get( key ) );
}
- else if( !strcmp( key, TR_PREFS_KEY_ALT_UL_LIMIT ) )
+ else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED ) )
{
- const int speed = pref_int_get( key );
- tr_sessionSetAltSpeedLimit( tr, TR_UP, speed );
+ tr_sessionUseAltSpeedTime( tr, pref_flag_get( key ) );
}
}
const char * s;
GtkWidget * t;
GtkWidget * w;
+ GtkWidget * w2;
#ifdef HAVE_GIO
GtkWidget * l;
w = new_path_chooser_button( TR_PREFS_KEY_DOWNLOAD_DIR, core );
hig_workarea_add_row( t, &row, _( "_Destination folder:" ), w, NULL );
+ hig_workarea_add_section_divider( t, &row );
+ hig_workarea_add_section_title( t, &row, _( "Limits" ) );
+
+ s = _( "_Stop seeding torrents at ratio:" );
+ w = new_check_button( s, TR_PREFS_KEY_RATIO_ENABLED, core );
+ w2 = new_spin_button_double( TR_PREFS_KEY_RATIO, core, .5, INT_MAX, .05 );
+ gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED ) );
+ g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
+ hig_workarea_add_row_w( t, &row, w, w2, NULL );
+
hig_workarea_finish( t, &row );
return t;
}
page->whitelist_widgets = g_slist_append( page->whitelist_widgets, w );
v = page->view = GTK_TREE_VIEW( w );
-#if GTK_CHECK_VERSION( 2,12,0 )
- gtk_widget_set_tooltip_text( w,
- _( "IP addresses may use wildcards, such as 192.168.*.*" ) );
-#endif
+ gtr_widget_set_tooltip_text( w, _( "IP addresses may use wildcards, such as 192.168.*.*" ) );
sel = gtk_tree_view_get_selection( v );
g_signal_connect( sel, "changed",
G_CALLBACK( onWhitelistSelectionChanged ), page );
refreshSchedSensitivity( struct BandwidthPage * p )
{
GSList * l;
- const gboolean sched_enabled = pref_flag_get( TR_PREFS_KEY_ALT_LIMIT_ENABLED );
+ const gboolean sched_enabled = pref_flag_get( TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED );
for( l = p->sched_widgets; l != NULL; l = l->next )
gtk_widget_set_sensitive( GTK_WIDGET( l->data ), sched_enabled );
int row = 0;
const char * s;
GtkWidget * t;
- GtkWidget * w, * w2, * h, * l;
+ GtkWidget * w, * w2, * h;
+ char buf[512];
struct BandwidthPage * page = tr_new0( struct BandwidthPage, 1 );
page->core = TR_CORE( core );
t = hig_workarea_create( );
- hig_workarea_add_section_title( t, &row, _( "Limits" ) );
-
- s = _( "Limit _download speed (KB/s):" );
- w = new_check_button( s, TR_PREFS_KEY_DSPEED_ENABLED, core );
- w2 = new_spin_button( TR_PREFS_KEY_DSPEED, core, 0, INT_MAX, 5 );
- gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED ) );
- g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
- hig_workarea_add_row_w( t, &row, w, w2, NULL );
-
- s = _( "Limit _upload speed (KB/s):" );
- w = new_check_button( s, TR_PREFS_KEY_USPEED_ENABLED, core );
- w2 = new_spin_button( TR_PREFS_KEY_USPEED, core, 0, INT_MAX, 5 );
- gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED ) );
- g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
- hig_workarea_add_row_w( t, &row, w, w2, NULL );
-
- s = _( "_Stop seeding when a torrent's ratio reaches:" );
- w = new_check_button( s, TR_PREFS_KEY_RATIO_ENABLED, core );
- w2 = new_spin_button_double( TR_PREFS_KEY_RATIO, core, .5, INT_MAX, .05 );
- gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED ) );
- g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
- hig_workarea_add_row_w( t, &row, w, w2, NULL );
+ hig_workarea_add_section_title( t, &row, _( "Global Bandwidth Limits" ) );
+
+ s = _( "Limit _download speed (KB/s):" );
+ w = new_check_button( s, TR_PREFS_KEY_DSPEED_ENABLED, core );
+ w2 = new_spin_button( TR_PREFS_KEY_DSPEED, core, 0, INT_MAX, 5 );
+ gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED ) );
+ g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
+ hig_workarea_add_row_w( t, &row, w, w2, NULL );
+
+ s = _( "Limit _upload speed (KB/s):" );
+ w = new_check_button( s, TR_PREFS_KEY_USPEED_ENABLED, core );
+ w2 = new_spin_button( TR_PREFS_KEY_USPEED, core, 0, INT_MAX, 5 );
+ gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED ) );
+ g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
+ hig_workarea_add_row_w( t, &row, w, w2, NULL );
hig_workarea_add_section_divider( t, &row );
- hig_workarea_add_section_title( t, &row, _( "Scheduled Limits" ) );
-
- h = gtk_hbox_new( FALSE, 0 );
- w2 = new_time_combo( core, TR_PREFS_KEY_ALT_BEGIN );
- page->sched_widgets = g_slist_append( page->sched_widgets, w2 );
- gtk_box_pack_start( GTK_BOX( h ), w2, FALSE, FALSE, 0 );
- w2 = gtk_label_new ( _( " and " ) );
- page->sched_widgets = g_slist_append( page->sched_widgets, w2 );
- gtk_box_pack_start( GTK_BOX( h ), w2, FALSE, FALSE, 0 );
- w2 = new_time_combo( core, TR_PREFS_KEY_ALT_END );
- page->sched_widgets = g_slist_append( page->sched_widgets, w2 );
- gtk_box_pack_start( GTK_BOX( h ), w2, FALSE, FALSE, 0 );
-
- s = _( "_Limit bandwidth between" );
- w = new_check_button( s, TR_PREFS_KEY_ALT_LIMIT_ENABLED, core );
- g_signal_connect( w, "toggled", G_CALLBACK( onSchedToggled ), page );
- hig_workarea_add_row_w( t, &row, w, h, NULL );
-
- w = new_spin_button( TR_PREFS_KEY_ALT_DL_LIMIT, core, 0, INT_MAX, 5 );
- page->sched_widgets = g_slist_append( page->sched_widgets, w );
- l = hig_workarea_add_row( t, &row, _( "Limit d_ownload speed (KB/s):" ), w, NULL );
- page->sched_widgets = g_slist_append( page->sched_widgets, l );
-
- w = new_spin_button( TR_PREFS_KEY_ALT_UL_LIMIT, core, 0, INT_MAX, 5 );
- page->sched_widgets = g_slist_append( page->sched_widgets, w );
- l = hig_workarea_add_row( t, &row, _( "Limit u_pload speed (KB/s):" ), w, NULL );
- page->sched_widgets = g_slist_append( page->sched_widgets, l );
+ h = gtk_hbox_new( FALSE, GUI_PAD );
+ w = gtk_image_new_from_stock( "alt-speed-off", GTK_ICON_SIZE_BUTTON );
+ gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
+ g_snprintf( buf, sizeof( buf ), "<b>%s</b>", _( "Speed Limit Mode" ) );
+ w = gtk_label_new( buf );
+ gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.5f );
+ gtk_label_set_use_markup( GTK_LABEL( w ), TRUE );
+ gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
+ hig_workarea_add_section_title_widget( t, &row, h );
+
+ s = _( "Limit do_wnload speed (KB/s):" );
+ w = new_spin_button( TR_PREFS_KEY_ALT_SPEED_DOWN, core, 0, INT_MAX, 5 );
+ hig_workarea_add_row( t, &row, s, w, NULL );
+
+ s = _( "Limit u_pload speed (KB/s):" );
+ w = new_spin_button( TR_PREFS_KEY_ALT_SPEED_UP, core, 0, INT_MAX, 5 );
+ hig_workarea_add_row( t, &row, s, w, NULL );
+
+ s = _( "Use Speed Limit Mode between:" );
+ h = gtk_hbox_new( FALSE, 0 );
+ w2 = new_time_combo( core, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN );
+ page->sched_widgets = g_slist_append( page->sched_widgets, w2 );
+ gtk_box_pack_start( GTK_BOX( h ), w2, TRUE, TRUE, 0 );
+ w2 = gtk_label_new ( _( " and " ) );
+ page->sched_widgets = g_slist_append( page->sched_widgets, w2 );
+ gtk_box_pack_start( GTK_BOX( h ), w2, FALSE, FALSE, 0 );
+ w2 = new_time_combo( core, TR_PREFS_KEY_ALT_SPEED_TIME_END );
+ page->sched_widgets = g_slist_append( page->sched_widgets, w2 );
+ gtk_box_pack_start( GTK_BOX( h ), w2, TRUE, TRUE, 0 );
+ w = new_check_button( s, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, core );
+ g_signal_connect( w, "toggled", G_CALLBACK( onSchedToggled ), page );
+ hig_workarea_add_row_w( t, &row, w, h, NULL );
+
+ g_snprintf( buf, sizeof( buf ), "<small>%s</small>", _( "When enabled, Speed Limit Mode overrides the Global Bandwidth Limits" ) );
+ w = gtk_label_new( buf );
+ gtk_label_set_use_markup( GTK_LABEL( w ), TRUE );
+ gtk_misc_set_alignment( GTK_MISC( w ), 0.5f, 0.5f );
+ hig_workarea_add_wide_control( t, &row, w );
hig_workarea_finish( t, &row );
g_object_set_data_full( G_OBJECT( t ), "page", page, bandwidthPageFree );
GtkWidget * dl_lb;
GtkWidget * stats_lb;
GtkWidget * gutter_lb;
+ GtkWidget * alt_speed_image[2]; /* 0==off, 1==on */
+ GtkWidget * alt_speed_button;
GtkTreeSelection * selection;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
return view;
}
+static void syncAltSpeedButton( PrivateData * p );
+
static void
prefsChanged( TrCore * core UNUSED,
const char * key,
{
tr_window_update( (TrWindow*)wind );
}
+ else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_ENABLED ) )
+ {
+ syncAltSpeedButton( p );
+ }
}
static void
}
}
+static void
+syncAltSpeedButton( PrivateData * p )
+{
+ const char * tip;
+ const gboolean b = pref_flag_get( TR_PREFS_KEY_ALT_SPEED_ENABLED );
+ GtkWidget * w = p->alt_speed_button;
+
+ gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
+
+ gtk_button_set_image( GTK_BUTTON( w ), p->alt_speed_image[b?1:0] );
+
+ tip = b ? _( "Click to disable Speed Limit Mode" )
+ : _( "Click to enable Speed Limit Mode" );
+ gtr_widget_set_tooltip_text( w, tip );
+}
+
+static void
+alt_speed_toggled_cb( GtkToggleButton * button, gpointer vprivate )
+{
+ PrivateData * p = vprivate;
+ const gboolean b = gtk_toggle_button_get_active( button );
+ tr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED, b );
+}
+
/***
**** FILTER
***/
#endif
+static gboolean
+onAltSpeedToggledIdle( gpointer vp )
+{
+ PrivateData * p = vp;
+ gboolean b = tr_sessionUsesAltSpeed( tr_core_session( p->core ) );
+ tr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED, b );
+
+ return FALSE;
+}
+
+static void
+onAltSpeedToggled( tr_session * s UNUSED, tr_bool b UNUSED, void * p )
+{
+ g_idle_add( onAltSpeedToggledIdle, p );
+}
+
/***
**** PUBLIC
***/
/* status */
h = status = p->status = gtk_hbox_new( FALSE, GUI_PAD );
- gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD );
- w = p->gutter_lb = gtk_label_new( "N Torrents" );
+ gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
+ p->alt_speed_image[0] = gtk_image_new_from_stock( "alt-speed-off", -1 );
+ p->alt_speed_image[1] = gtk_image_new_from_stock( "alt-speed-on", -1 );
+ w = p->alt_speed_button = gtk_toggle_button_new( );
+ gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
+ g_object_ref( G_OBJECT( p->alt_speed_image[0] ) );
+ g_object_ref( G_OBJECT( p->alt_speed_image[1] ) );
+ g_signal_connect( w, "toggled", G_CALLBACK(alt_speed_toggled_cb ), p );
gtk_box_pack_start( GTK_BOX( h ), w, 0, 0, 0 );
+ w = p->gutter_lb = gtk_label_new( "N Torrents" );
+ gtk_box_pack_start( GTK_BOX( h ), w, 1, 1, GUI_PAD_BIG );
w = p->ul_lb = gtk_label_new( NULL );
gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
w = gtk_image_new_from_stock( GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU );
prefsChanged( core, PREF_KEY_STATUSBAR, self );
prefsChanged( core, PREF_KEY_STATUSBAR_STATS, self );
prefsChanged( core, PREF_KEY_TOOLBAR, self );
+ prefsChanged( core, TR_PREFS_KEY_ALT_SPEED_ENABLED, self );
p->pref_handler_id = g_signal_connect( core, "prefs-changed",
G_CALLBACK( prefsChanged ), self );
+ tr_sessionSetAltSpeedFunc( tr_core_session( core ), onAltSpeedToggled, p );
+
filter_entry_changed( GTK_EDITABLE( s ), p );
return self;
}
--- /dev/null
+/* GdkPixbuf RGBA C-Source image dump 1-byte-run-length-encoded */
+
+#ifdef __SUNPRO_C
+#pragma align 4 (blue_turtle)
+#endif
+#ifdef __GNUC__
+static const guint8 blue_turtle[] __attribute__ ((__aligned__ (4))) =
+#else
+static const guint8 blue_turtle[] =
+#endif
+{ ""
+ /* Pixbuf magic (0x47646b50) */
+ "GdkP"
+ /* length: header (24) + pixel_data (315) */
+ "\0\0\1S"
+ /* pixdata_type (0x2010002) */
+ "\2\1\0\2"
+ /* rowstride (80) */
+ "\0\0\0P"
+ /* width (20) */
+ "\0\0\0\24"
+ /* height (14) */
+ "\0\0\0\16"
+ /* pixel_data: */
+ "\304\377\377\377\0\3""66\377@77\377p55\3770\205\377\377\377\0\1\0\0\0"
+ "\0\211\377\377\377\0\2""66\3770<<\377\317\202\77\77\377\377\2>>\377\377"
+ "::\377\237\204\377\377\377\0\1\0\0\0\0\210\377\377\377\0\14""66\3770"
+ "BB\377\360FF\377\377II\377\377JJ\377\377HH\377\377DD\377\377==\377\237"
+ "\377\377\377\0""99\377`\77\77\377\377;;\377\237\207\377\377\377\0\4""5"
+ "5\377\20FF\377\360KK\377\377OO\377\377\202QQ\377\377\7PP\377\377NN\377"
+ "\377II\377\377EE\377\377FF\377\377II\377\377[[\377\267\207\377\377\377"
+ "\0\3EE\377\261NN\377\377TT\377\377\204VV\377\377\3UU\377\377ee\377\331"
+ "\252\252\377\214\202\377\377\377f\1\377\377\377@\207\377\377\377\0\3"
+ "\377\377\377F\224\224\377\240YY\377\377\204ZZ\377\377\3XX\377\377kk\377"
+ "\274\377\377\377\31\202\377\377\377\0\1\0\0\0\0\210\377\377\377\0\2m"
+ "m\377wvv\377\305\204\377\377\377f\3\230\230\377\237TT\377\377FF\377\237"
+ "\202\377\377\377\0\1\0\0\0\0\323\377\377\377\0"};
+
+
+/* GdkPixbuf RGBA C-Source image dump 1-byte-run-length-encoded */
+
+#ifdef __SUNPRO_C
+#pragma align 4 (grey_turtle)
+#endif
+#ifdef __GNUC__
+static const guint8 grey_turtle[] __attribute__ ((__aligned__ (4))) =
+#else
+static const guint8 grey_turtle[] =
+#endif
+{ ""
+ /* Pixbuf magic (0x47646b50) */
+ "GdkP"
+ /* length: header (24) + pixel_data (315) */
+ "\0\0\1S"
+ /* pixdata_type (0x2010002) */
+ "\2\1\0\2"
+ /* rowstride (80) */
+ "\0\0\0P"
+ /* width (20) */
+ "\0\0\0\24"
+ /* height (14) */
+ "\0\0\0\16"
+ /* pixel_data: */
+ "\304\377\377\377\0\3\3\3\3@\5\5\5p\2\2\2""0\205\377\377\377\0\1\0\0\0"
+ "\0\211\377\377\377\0\2\3\3\3""0\13\13\13\317\202\17\17\17\377\2\16\16"
+ "\16\377\11\11\11\237\204\377\377\377\0\1\0\0\0\0\210\377\377\377\0\14"
+ "\4\4\4""0\23\23\23\360\27\27\27\377\33\33\33\377\34\34\34\377\32\32\32"
+ "\377\25\25\25\377\14\14\14\237\377\377\377\0\7\7\7`\17\17\17\377\12\12"
+ "\12\237\207\377\377\377\0\4\2\2\2\20\27\27\27\360\36\36\36\377###\377"
+ "\202%%%\377\7$$$\377!!!\377\33\33\33\377\26\26\26\377\30\30\30\377\33"
+ "\33\33\377222\267\207\377\377\377\0\3\26\26\26\261\"\"\"\377)))\377\204"
+ "+++\377\3***\377\77\77\77\331\225\225\225\214\202\377\377\377f\1\377"
+ "\377\377@\207\377\377\377\0\3\377\377\377Fyyy\240///\377\204000\377\3"
+ "...\377FFF\274\377\377\377\31\202\377\377\377\0\1\0\0\0\0\210\377\377"
+ "\377\0\2HHHwTTT\305\204\377\377\377f\3~~~\237)))\377\27\27\27\237\202"
+ "\377\377\377\0\1\0\0\0\0\323\377\377\377\0"};
+
+
return g_timeout_add( seconds*1000, function, data );
#endif
}
+
+
+void
+gtr_widget_set_tooltip_text( GtkWidget * w, const char * tip )
+{
+#if GTK_CHECK_VERSION( 2,12,0 )
+ gtk_widget_set_tooltip_text( w, tip );
+#else
+ /* FIXME */
+#endif
+}
+
#ifdef GTK_MAJOR_VERSION
+void gtr_widget_set_tooltip_text( GtkWidget * w, const char * tip );
+
GtkWidget * gtr_button_new_from_stock( const char * stock,
const char * mnemonic );
const time_t now = time( NULL );
tr_torrent * tor = t->tor;
- tor->activityDate = now;
+ tr_torrentSetActivityDate( tor, now );
if( e->wasPieceData )
tor->uploadedCur += e->length;
{
const time_t now = time( NULL );
tr_torrent * tor = t->tor;
- tor->activityDate = now;
+
+ tr_torrentSetActivityDate( tor, now );
/* only add this to downloadedCur if we got it from a peer --
* webseeds shouldn't count against our ratio. As one tracker
{
tr_bencDictReserve( d, 3 );
tr_bencDictAddInt( d, KEY_SPEED, tr_torrentGetSpeedLimit( tor, dir ) );
- tr_bencDictAddInt( d, KEY_USE_GLOBAL_SPEED_LIMIT, tr_torrentIsUsingGlobalSpeedLimit( tor, dir ) );
- tr_bencDictAddInt( d, KEY_USE_SPEED_LIMIT, tr_torrentIsUsingSpeedLimit( tor, dir ) );
+ tr_bencDictAddInt( d, KEY_USE_GLOBAL_SPEED_LIMIT, tr_torrentUsesSessionLimits( tor ) );
+ tr_bencDictAddInt( d, KEY_USE_SPEED_LIMIT, tr_torrentUsesSpeedLimit( tor, dir ) );
}
static void
if( tr_bencDictFindInt( d, KEY_USE_SPEED_LIMIT, &i ) )
tr_torrentUseSpeedLimit( tor, dir, i!=0 );
if( tr_bencDictFindInt( d, KEY_USE_GLOBAL_SPEED_LIMIT, &i ) )
- tr_torrentUseGlobalSpeedLimit( tor, dir, i!=0 );
+ tr_torrentUseSessionLimits( tor, i!=0 );
}
enum old_speed_modes
if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_DOWN_SPEED, &i ) )
tr_torrentSetSpeedLimit( tor, TR_DOWN, i );
if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_DOWN_MODE, &i ) ) {
- tr_torrentUseSpeedLimit ( tor, TR_DOWN, i==TR_SPEEDLIMIT_SINGLE );
- tr_torrentUseGlobalSpeedLimit( tor, TR_DOWN, i==TR_SPEEDLIMIT_GLOBAL );
+ tr_torrentUseSpeedLimit( tor, TR_DOWN, i==TR_SPEEDLIMIT_SINGLE );
+ tr_torrentUseSessionLimits( tor, i==TR_SPEEDLIMIT_GLOBAL );
}
if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_UP_SPEED, &i ) )
tr_torrentSetSpeedLimit( tor, TR_UP, i );
if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_UP_MODE, &i ) ) {
- tr_torrentUseSpeedLimit ( tor, TR_UP, i==TR_SPEEDLIMIT_SINGLE );
- tr_torrentUseGlobalSpeedLimit( tor, TR_UP, i==TR_SPEEDLIMIT_GLOBAL );
+ tr_torrentUseSpeedLimit( tor, TR_UP, i==TR_SPEEDLIMIT_SINGLE );
+ tr_torrentUseSessionLimits( tor, i==TR_SPEEDLIMIT_GLOBAL );
}
ret = TR_FR_SPEEDLIMIT;
}
if( ( fieldsToLoad & TR_FR_ACTIVITY_DATE )
&& tr_bencDictFindInt( &top, KEY_ACTIVITY_DATE, &i ) )
{
- tor->activityDate = i;
+ tr_torrentSetActivityDate( tor, i );
fieldsLoaded |= TR_FR_ACTIVITY_DATE;
}
tr_bencDictAddInt( d, key, st->downloaders );
else if( !strcmp( key, "downloadLimit" ) )
tr_bencDictAddInt( d, key, tr_torrentGetSpeedLimit( tor, TR_DOWN ) );
- else if( !strcmp( key, "downloadHonorsLimit" ) )
- tr_bencDictAddInt( d, key, tr_torrentIsUsingSpeedLimit( tor, TR_DOWN ) );
- else if( !strcmp( key, "downloadHonorsGlobalLimit" ) )
- tr_bencDictAddInt( d, key, tr_torrentIsUsingGlobalSpeedLimit( tor, TR_DOWN ) );
+ else if( !strcmp( key, "downloadLimited" ) )
+ tr_bencDictAddInt( d, key, tr_torrentUsesSpeedLimit( tor, TR_DOWN ) );
else if( !strcmp( key, "error" ) )
tr_bencDictAddInt( d, key, st->error );
else if( !strcmp( key, "errorString" ) )
tr_bencDictAddInt( d, key, st->haveUnchecked );
else if( !strcmp( key, "haveValid" ) )
tr_bencDictAddInt( d, key, st->haveValid );
+ else if( !strcmp( key, "honorsSessionLimits" ) )
+ tr_bencDictAddInt( d, key, tr_torrentUsesSessionLimits( tor ) );
else if( !strcmp( key, "id" ) )
tr_bencDictAddInt( d, key, st->id );
else if( !strcmp( key, "isPrivate" ) )
tr_bencDictAddDouble( d, key, tr_getRatio( st->uploadedEver, st->downloadedEver ) );
else if( !strcmp( key, "uploadLimit" ) )
tr_bencDictAddInt( d, key, tr_torrentGetSpeedLimit( tor, TR_UP ) );
- else if( !strcmp( key, "uploadHonorsLimit" ) )
- tr_bencDictAddInt( d, key, tr_torrentIsUsingSpeedLimit( tor, TR_UP ) );
- else if( !strcmp( key, "uploadHonorsGlobalLimit" ) )
- tr_bencDictAddInt( d, key, tr_torrentIsUsingGlobalSpeedLimit( tor, TR_UP ) );
+ else if( !strcmp( key, "uploadLimited" ) )
+ tr_bencDictAddInt( d, key, tr_torrentUsesSpeedLimit( tor, TR_UP ) );
else if( !strcmp( key, "wanted" ) )
{
tr_file_index_t i;
errmsg = setFilePriorities( tor, TR_PRI_NORMAL, files );
if( tr_bencDictFindInt( args_in, "downloadLimit", &tmp ) )
tr_torrentSetSpeedLimit( tor, TR_DOWN, tmp );
- if( tr_bencDictFindInt( args_in, "downloadHonorsLimit", &tmp ) )
+ if( tr_bencDictFindInt( args_in, "downloadLimited", &tmp ) )
tr_torrentUseSpeedLimit( tor, TR_DOWN, tmp!=0 );
- if( tr_bencDictFindInt( args_in, "downloadHonorsGlobalLimit", &tmp ) )
- tr_torrentUseGlobalSpeedLimit( tor, TR_DOWN, tmp!=0 );
+ if( tr_bencDictFindInt( args_in, "honorsSessionLimits", &tmp ) )
+ tr_torrentUseSessionLimits( tor, tmp!=0 );
if( tr_bencDictFindInt( args_in, "uploadLimit", &tmp ) )
tr_torrentSetSpeedLimit( tor, TR_UP, tmp );
- if( tr_bencDictFindInt( args_in, "uploadHonorsLimit", &tmp ) )
+ if( tr_bencDictFindInt( args_in, "uploadLimited", &tmp ) )
tr_torrentUseSpeedLimit( tor, TR_UP, tmp!=0 );
- if( tr_bencDictFindInt( args_in, "uploadHonorsGlobalLimit", &tmp ) )
- tr_torrentUseGlobalSpeedLimit( tor, TR_UP, tmp!=0 );
if( tr_bencDictFindDouble( args_in, "ratio-limit", &d ) )
tr_torrentSetRatioLimit( tor, d );
if( tr_bencDictFindInt( args_in, "ratio-limit-mode", &tmp ) )
assert( idle_data == NULL );
- if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_LIMIT_ENABLED, &i ) )
- tr_sessionSetAltSpeedLimitEnabled( session, i!=0 );
- if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_BEGIN, &i ) )
- tr_sessionSetAltSpeedLimitBegin( session, i );
- if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_END, &i ) )
- tr_sessionSetAltSpeedLimitEnd( session, i );
- if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_DL_LIMIT, &i ) )
- tr_sessionSetAltSpeedLimit( session, TR_DOWN, i );
- if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_UL_LIMIT, &i ) )
- tr_sessionSetAltSpeedLimit( session, TR_UP, i );
+ if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_UP, &i ) )
+ tr_sessionSetAltSpeed( session, TR_UP, i );
+ if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_DOWN, &i ) )
+ tr_sessionSetAltSpeed( session, TR_DOWN, i );
+ if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_ENABLED, &i ) )
+ tr_sessionUseAltSpeed( session, i!=0 );
+ if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &i ) )
+ tr_sessionSetAltSpeedBegin( session, i );
+ if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_END, &i ) )
+ tr_sessionSetAltSpeedEnd( session, i );
+ if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &i ) )
+ tr_sessionUseAltSpeedTime( session, i!=0 );
if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_BLOCKLIST_ENABLED, &i ) )
tr_blocklistSetEnabled( session, i!=0 );
if( tr_bencDictFindStr( args_in, TR_PREFS_KEY_DOWNLOAD_DIR, &str ) )
if( tr_bencDictFindInt( args_in, "speed-limit-down", &i ) )
tr_sessionSetSpeedLimit( session, TR_DOWN, i );
if( tr_bencDictFindInt( args_in, "speed-limit-down-enabled", &i ) )
- tr_sessionSetSpeedLimitEnabled( session, TR_DOWN, i );
+ tr_sessionLimitSpeed( session, TR_DOWN, i!=0 );
if( tr_bencDictFindInt( args_in, "speed-limit-up", &i ) )
tr_sessionSetSpeedLimit( session, TR_UP, i );
if( tr_bencDictFindInt( args_in, "speed-limit-up-enabled", &i ) )
- tr_sessionSetSpeedLimitEnabled( session, TR_UP, i );
+ tr_sessionLimitSpeed( session, TR_UP, i!=0 );
if( tr_bencDictFindDouble( args_in, "ratio-limit", &d ) )
tr_sessionSetRatioLimit( session, d );
if( tr_bencDictFindInt( args_in, "ratio-limit-enabled", &i ) )
- tr_sessionSetRatioLimited( session, i );
+ tr_sessionSetRatioLimited( session, i!=0 );
if( tr_bencDictFindStr( args_in, "encryption", &str ) )
{
if( !strcmp( str, "required" ) )
tr_benc * d = args_out;
assert( idle_data == NULL );
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_LIMIT_ENABLED, tr_sessionIsAltSpeedLimitEnabled( s ) );
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_UL_LIMIT, tr_sessionGetAltSpeedLimit( s, TR_UP ) );
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_DL_LIMIT, tr_sessionGetAltSpeedLimit( s, TR_DOWN ) );
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_BEGIN, tr_sessionGetAltSpeedLimitBegin( s ) );
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_END, tr_sessionGetAltSpeedLimitEnd( s ) );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_UP, tr_sessionGetAltSpeed(s,TR_UP) );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_DOWN, tr_sessionGetAltSpeed(s,TR_DOWN) );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed(s) );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, tr_sessionGetAltSpeedBegin(s) );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,tr_sessionGetAltSpeedEnd(s) );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, tr_sessionUsesAltSpeedTime(s) );
tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, tr_blocklistIsEnabled( s ) );
tr_bencDictAddInt( d, "blocklist-size", tr_blocklistGetRuleCount( s ) );
tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, tr_sessionGetDownloadDir( s ) );
tr_bencDictAddInt( d, "rpc-version", 4 );
tr_bencDictAddInt( d, "rpc-version-minimum", 1 );
tr_bencDictAddInt( d, "speed-limit-up", tr_sessionGetSpeedLimit( s, TR_UP ) );
- tr_bencDictAddInt( d, "speed-limit-up-enabled", tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );
+ tr_bencDictAddInt( d, "speed-limit-up-enabled", tr_sessionIsSpeedLimited( s, TR_UP ) );
tr_bencDictAddInt( d, "speed-limit-down", tr_sessionGetSpeedLimit( s, TR_DOWN ) );
- tr_bencDictAddInt( d, "speed-limit-down-enabled", tr_sessionIsSpeedLimitEnabled( s, TR_DOWN ) );
+ tr_bencDictAddInt( d, "speed-limit-down-enabled", tr_sessionIsSpeedLimited( s, TR_DOWN ) );
tr_bencDictAddDouble( d, "ratio-limit", tr_sessionGetRatioLimit( s ) );
tr_bencDictAddInt( d, "ratio-limit-enabled", tr_sessionIsRatioLimited( s ) );
tr_bencDictAddStr( d, "version", LONG_VERSION_STRING );
tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_WHITELIST, TR_DEFAULT_RPC_WHITELIST );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, TRUE );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_PORT, atoi( TR_DEFAULT_RPC_PORT_STR ) );
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_LIMIT_ENABLED, FALSE );
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_BEGIN, 1320 ); /* 10pm */
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_END, 300 ); /* 5am */
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_DL_LIMIT, 200 ); /* double the regular default */
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_UL_LIMIT, 200 ); /* double the regular default */
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_ENABLED, FALSE );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_UP, 50 ); /* half the regular */
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_DOWN, 50 ); /* half the regular */
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, 540 ); /* 9am */
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, FALSE );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_END, 1020 ); /* 5pm */
tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED, 100 );
tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED, 0 );
tr_bencDictAddInt( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, 14 );
tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, tr_blocklistIsEnabled( s ) );
tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, s->downloadDir );
tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED, tr_sessionGetSpeedLimit( s, TR_DOWN ) );
- tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED, tr_sessionIsSpeedLimitEnabled( s, TR_DOWN ) );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED, tr_sessionIsSpeedLimited( s, TR_DOWN ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION, s->encryptionMode );
tr_bencDictAddInt( d, TR_PREFS_KEY_LAZY_BITFIELD, s->useLazyBitfield );
tr_bencDictAddInt( d, TR_PREFS_KEY_MSGLEVEL, tr_getMessageLevel( ) );
tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_USERNAME, freeme[n++] = tr_sessionGetRPCUsername( s ) );
tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_WHITELIST, freeme[n++] = tr_sessionGetRPCWhitelist( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, tr_sessionGetRPCWhitelistEnabled( s ) );
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_LIMIT_ENABLED, tr_sessionIsAltSpeedLimitEnabled( s ) );
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_BEGIN, tr_sessionGetAltSpeedLimitBegin( s ) );
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_END, tr_sessionGetAltSpeedLimitEnd( s ) );
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_DL_LIMIT, tr_sessionGetAltSpeedLimit( s, TR_DOWN ) );
- tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_UL_LIMIT, tr_sessionGetAltSpeedLimit( s, TR_UP ) );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed( s ) );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_UP, tr_sessionGetAltSpeed( s, TR_UP ) );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_DOWN, tr_sessionGetAltSpeed( s, TR_DOWN ) );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, tr_sessionGetAltSpeedBegin( s ) );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, tr_sessionUsesAltSpeedTime( s ) );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_END, tr_sessionGetAltSpeedEnd( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED, tr_sessionGetSpeedLimit( s, TR_UP ) );
- tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED, tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );
+ tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED, tr_sessionIsSpeedLimited( s, TR_UP ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, s->uploadSlotsPerTorrent );
for( i=0; i<n; ++i )
}
void
-tr_sessionSaveSettings( tr_session * session, const char * configDir, tr_benc * settings )
+tr_sessionSaveSettings( tr_session * session,
+ const char * configDir,
+ const tr_benc * clientSettings )
{
- tr_benc fileSettings;
- char * filename;
+ tr_benc settings;
+ char * filename = tr_buildPath( configDir, "settings.json", NULL );
- assert( tr_bencIsDict( settings ) );
+ assert( tr_bencIsDict( clientSettings ) );
- filename = tr_buildPath( configDir, "settings.json", NULL );
+ tr_bencInitDict( &settings, 0 );
+
+ /* the existing file settings are the fallback values */
+ {
+ tr_benc fileSettings;
+ if( !tr_bencLoadJSONFile( filename, &fileSettings ) )
+ {
+ tr_bencMergeDicts( &settings, &fileSettings );
+ tr_bencFree( &fileSettings );
+ }
+ }
- tr_sessionGetSettings( session, settings );
+ /* the client's settings override the file settings */
+ tr_bencMergeDicts( &settings, clientSettings );
- if( tr_bencLoadJSONFile( filename, &fileSettings ) ) {
- tr_bencSaveJSONFile( filename, settings );
- } else {
- tr_bencMergeDicts( &fileSettings, settings );
- tr_bencSaveJSONFile( filename, &fileSettings );
- tr_bencFree( &fileSettings );
+ /* the session's true values override the file & client settings */
+ {
+ tr_benc sessionSettings;
+ tr_bencInitDict( &sessionSettings, 0 );
+ tr_sessionGetSettings( session, &sessionSettings );
+ tr_bencMergeDicts( &settings, &sessionSettings );
+ tr_bencFree( &sessionSettings );
}
+ /* save the result */
+ tr_bencSaveJSONFile( filename, &settings );
tr_inf( "Saved \"%s\"", filename );
+
+ /* cleanup */
tr_free( filename );
+ tr_bencFree( &settings );
}
static void metainfoLookupRescan( tr_session * );
static void tr_sessionInitImpl( void * );
static void onAltTimer( int, short, void* );
-
-/* set the alt-speed timer to go off at the top of the minute */
-static void
-setAltTimer( tr_session * session )
-{
- const time_t now = time( NULL );
- struct tm tm;
- struct timeval tv;
-
- assert( tr_isSession( session ) );
- assert( session->altTimer != NULL );
-
- tr_localtime_r( &now, &tm );
- tv.tv_sec = 60 - tm.tm_sec;
- tv.tv_usec = 0;
- evtimer_add( session->altTimer, &tv );
-}
+static void setAltTimer( tr_session * session );
struct init_data
{
&& tr_bencDictFindInt( &settings, TR_PREFS_KEY_USPEED_ENABLED, &j );
assert( found );
tr_sessionSetSpeedLimit( session, TR_UP, i );
- tr_sessionSetSpeedLimitEnabled( session, TR_UP, j );
+ tr_sessionLimitSpeed( session, TR_UP, j!=0 );
found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_DSPEED, &i )
&& tr_bencDictFindInt( &settings, TR_PREFS_KEY_DSPEED_ENABLED, &j );
assert( found );
tr_sessionSetSpeedLimit( session, TR_DOWN, i );
- tr_sessionSetSpeedLimitEnabled( session, TR_DOWN, j );
+ tr_sessionLimitSpeed( session, TR_DOWN, j!=0 );
found = tr_bencDictFindDouble( &settings, TR_PREFS_KEY_RATIO, &d )
&& tr_bencDictFindInt( &settings, TR_PREFS_KEY_RATIO_ENABLED, &j );
tr_sessionSetRatioLimited( session, j );
/**
- *** Alternate speed limits for off-peak hours
+ *** Alternate speed limits
**/
- found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_LIMIT_ENABLED, &i );
+
+ found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_SPEED_UP, &i );
+ assert( found );
+ session->altSpeed[TR_UP] = i;
+
+ found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_SPEED_DOWN, &i );
+ assert( found );
+ session->altSpeed[TR_DOWN] = i;
+
+ found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &i );
+ assert( found );
+ session->altSpeedTimeBegin = i;
+
+ found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_SPEED_TIME_END, &i );
assert( found );
- session->isAltSpeedLimited = i != 0;
+ session->altSpeedTimeEnd = i;
- found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_BEGIN, &i )
- && tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_END, &j );
+ found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &i );
assert( found );
- session->altSpeedBeginTime = i;
- session->altSpeedEndTime = j;
+ tr_sessionUseAltSpeedTime( session, i!=0 );
- found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_DL_LIMIT, &i )
- && tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_UL_LIMIT, &j );
+ found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_SPEED_ENABLED, &i );
assert( found );
- session->altSpeedLimit[TR_DOWN] = i;
- session->altSpeedLimit[TR_UP] = j;
+ tr_sessionUseAltSpeed( session, i!=0 );
+
+
+ /**
+ *** Blocklist
+ **/
- /* initialize the blocklist */
filename = tr_buildPath( session->configDir, "blocklists", NULL );
tr_mkdirp( filename, 0777 );
tr_free( filename );
}
/***
-****
+**** SPEED LIMITS
***/
+tr_bool
+tr_sessionGetActiveSpeedLimit( const tr_session * session, tr_direction dir, int * setme )
+{
+ int isLimited = TRUE;
+
+ if( tr_sessionUsesAltSpeed( session ) )
+ *setme = tr_sessionGetAltSpeed( session, dir );
+ else if( tr_sessionIsSpeedLimited( session, dir ) )
+ *setme = tr_sessionGetSpeedLimit( session, dir );
+ else
+ isLimited = FALSE;
+
+ return isLimited;
+}
+
static tr_bool
-isAltTime( const tr_session * session )
+isAltTime( const tr_session * s )
{
- const time_t now = time( NULL );
- struct tm tm;
+ tr_bool is;
int minutes;
-
- if( !tr_sessionIsAltSpeedLimitEnabled( session ) )
- return FALSE;
+ struct tm tm;
+ const time_t now = time( NULL );
+ const int begin = s->altSpeedTimeBegin;
+ const int end = s->altSpeedTimeEnd;
tr_localtime_r( &now, &tm );
minutes = tm.tm_hour*60 + tm.tm_min;
- if( session->altSpeedBeginTime <= session->altSpeedEndTime )
- {
- return ( session->altSpeedBeginTime <= minutes )
- && ( minutes < session->altSpeedEndTime );
- }
+ if( begin <= end )
+ is = ( begin <= minutes ) && ( minutes < end );
else /* goes past midnight */
- {
- return ( minutes >= session->altSpeedBeginTime )
- || ( minutes < session->altSpeedEndTime );
- }
-}
+ is = ( begin <= minutes ) || ( minutes < end );
-static int
-getActiveSpeedLimit( const tr_session * session, tr_direction dir )
-{
- int val;
-
- if( tr_sessionIsAltSpeedLimitEnabled( session ) && session->isAltTime )
- val = tr_sessionGetAltSpeedLimit( session, dir );
- else if( tr_sessionIsSpeedLimitEnabled( session, dir ) )
- val = tr_sessionGetSpeedLimit( session, dir );
- else
- val = -1;
-
- return val;
+ return is;
}
static void
updateBandwidth( tr_session * session, tr_direction dir )
{
- const int limit = getActiveSpeedLimit( session, dir );
- const tr_bool isLimited = limit >= 0;
+ int limit;
+ const tr_bool isLimited = tr_sessionGetActiveSpeedLimit( session, dir, &limit );
const tr_bool zeroCase = isLimited && !limit;
tr_bandwidthSetLimited( session->bandwidth, dir, isLimited && !zeroCase );
tr_bandwidthSetDesiredSpeed( session->bandwidth, dir, limit );
}
+static void
+altSpeedToggled( void * vsession )
+{
+ tr_session * session = vsession;
+
+ assert( tr_isSession( session ) );
+
+ updateBandwidth( session, TR_UP );
+ updateBandwidth( session, TR_DOWN );
+
+ if( session->altCallback != NULL )
+ (*session->altCallback)( session, session->altSpeedEnabled, session->altCallbackUserData );
+}
+
+/* tell the alt speed limit timer to fire again at the top of the minute */
+static void
+setAltTimer( tr_session * session )
+{
+ const time_t now = time( NULL );
+ struct tm tm;
+ struct timeval tv;
+
+ assert( tr_isSession( session ) );
+ assert( session->altTimer != NULL );
+
+ tr_localtime_r( &now, &tm );
+ tv.tv_sec = 60 - tm.tm_sec;
+ tv.tv_usec = 0;
+ evtimer_add( session->altTimer, &tv );
+}
+
/* this is called once a minute to:
* (1) update session->isAltTime
* (2) alter the speed limits when the alt limits go on and off */
static void
onAltTimer( int foo UNUSED, short bar UNUSED, void * vsession )
{
- tr_bool wasAltTime;
tr_session * session = vsession;
assert( tr_isSession( session ) );
- wasAltTime = session->isAltTime;
- session->isAltTime = isAltTime( session );
-
- if( wasAltTime != session->isAltTime )
+ if( session->altSpeedTimeEnabled )
{
- updateBandwidth( session, TR_UP );
- updateBandwidth( session, TR_DOWN );
+ const time_t now = time( NULL );
+ struct tm tm;
+ int currentMinute;
+ tr_localtime_r( &now, &tm );
+ currentMinute = tm.tm_hour*60 + tm.tm_min;
- if( session->altCallback != NULL )
- (*session->altCallback)( session, session->isAltTime, session->altCallbackUserData );
+ if( currentMinute == session->altSpeedTimeBegin )
+ {
+ tr_sessionUseAltSpeed( session, TRUE );
+ }
+ else if( currentMinute == session->altSpeedTimeEnd )
+ {
+ tr_sessionUseAltSpeed( session, FALSE );
+ }
}
setAltTimer( session );
}
+/***
+**** Primary session speed limits
+***/
+
void
-tr_sessionSetSpeedLimitEnabled( tr_session * session,
- tr_direction dir,
- tr_bool isLimited )
+tr_sessionSetSpeedLimit( tr_session * s, tr_direction d, int KB_s )
{
- assert( tr_isSession( session ) );
- assert( tr_isDirection( dir ) );
+ assert( tr_isSession( s ) );
+ assert( tr_isDirection( d ) );
+ assert( KB_s >= 0 );
+
+ s->speedLimit[d] = KB_s;
+
+ updateBandwidth( s, d );
+}
+
+int
+tr_sessionGetSpeedLimit( const tr_session * s, tr_direction d )
+{
+ assert( tr_isSession( s ) );
+ assert( tr_isDirection( d ) );
- session->isSpeedLimited[dir] = isLimited;
- updateBandwidth( session, dir );
+ return s->speedLimit[d];
}
void
-tr_sessionSetSpeedLimit( tr_session * session,
- tr_direction dir,
- int desiredSpeed )
+tr_sessionLimitSpeed( tr_session * s, tr_direction d, tr_bool b )
{
- assert( tr_isSession( session ) );
- assert( tr_isDirection( dir ) );
+ assert( tr_isSession( s ) );
+ assert( tr_isDirection( d ) );
+ assert( tr_isBool( b ) );
- session->speedLimit[dir] = desiredSpeed;
- updateBandwidth( session, dir );
+ s->speedLimitEnabled[d] = b;
+
+ updateBandwidth( s, d );
}
tr_bool
-tr_sessionIsSpeedLimitEnabled( const tr_session * session, tr_direction dir )
+tr_sessionIsSpeedLimited( const tr_session * s, tr_direction d )
{
- assert( tr_isSession( session ) );
- assert( tr_isDirection( dir ) );
+ assert( tr_isSession( s ) );
+ assert( tr_isDirection( d ) );
- return session->isSpeedLimited[dir];
+ return s->speedLimitEnabled[d];
}
-int
-tr_sessionGetSpeedLimit( const tr_session * session, tr_direction dir )
+/***
+**** Alternative speed limits that are used during scheduled times
+***/
+
+void
+tr_sessionSetAltSpeed( tr_session * s, tr_direction d, int KB_s )
{
- assert( tr_isSession( session ) );
- assert( tr_isDirection( dir ) );
+ assert( tr_isSession( s ) );
+ assert( tr_isDirection( d ) );
+ assert( KB_s >= 0 );
+
+ s->altSpeed[d] = KB_s;
- return session->speedLimit[dir];
+ updateBandwidth( s, d );
}
-static void
-checkAltTime( void * session )
+int
+tr_sessionGetAltSpeed( const tr_session * s, tr_direction d )
{
- onAltTimer( 0, 0, session );
+ assert( tr_isSession( s ) );
+ assert( tr_isDirection( d ) );
+
+ return s->altSpeed[d];
}
void
-tr_sessionSetAltSpeedLimitEnabled( tr_session * session,
- tr_bool isEnabled )
+tr_sessionUseAltSpeedTime( tr_session * s, tr_bool b )
{
- assert( tr_isSession( session ) );
- assert( tr_isBool( isEnabled ) );
+ assert( tr_isSession( s ) );
+ assert( tr_isBool( b ) );
- session->isAltSpeedLimited = isEnabled;
+ if( s->altSpeedTimeEnabled != b )
+ {
+ s->altSpeedTimeEnabled = b;
- tr_runInEventThread( session, checkAltTime, session );
+ if( isAltTime( s ) )
+ tr_sessionUseAltSpeed( s, b );
+ }
}
tr_bool
-tr_sessionIsAltSpeedLimitEnabled( const tr_session * session )
+tr_sessionUsesAltSpeedTime( const tr_session * s )
{
- assert( tr_isSession( session ) );
+ assert( tr_isSession( s ) );
- return session->isAltSpeedLimited;
+ return s->altSpeedTimeEnabled;
}
void
-tr_sessionSetAltSpeedLimit( tr_session * session,
- tr_direction dir,
- int desiredSpeed )
+tr_sessionSetAltSpeedBegin( tr_session * s, int minutes )
{
- assert( tr_isSession( session ) );
- assert( tr_isDirection( dir ) );
- assert( desiredSpeed >= 0 );
+ assert( tr_isSession( s ) );
+ assert( 0<=minutes && minutes<(60*24) );
- session->altSpeedLimit[dir] = desiredSpeed;
+ if( s->altSpeedTimeBegin != minutes )
+ {
+ s->altSpeedTimeBegin = minutes;
- updateBandwidth( session, dir );
+ if( tr_sessionUsesAltSpeedTime( s ) )
+ tr_sessionUseAltSpeed( s, isAltTime( s ) );
+ }
}
int
-tr_sessionGetAltSpeedLimit( const tr_session * session,
- tr_direction dir )
+tr_sessionGetAltSpeedBegin( const tr_session * s )
{
- assert( tr_isSession( session ) );
- assert( tr_isDirection( dir ) );
+ assert( tr_isSession( s ) );
- return session->altSpeedLimit[dir];
+ return s->altSpeedTimeBegin;
}
void
-tr_sessionSetAltSpeedLimitBegin( tr_session * session, int minutesSinceMidnight )
+tr_sessionSetAltSpeedEnd( tr_session * s, int minutes )
{
- assert( tr_isSession( session ) );
+ assert( tr_isSession( s ) );
+ assert( 0<=minutes && minutes<(60*24) );
- session->altSpeedBeginTime = minutesSinceMidnight;
+ if( s->altSpeedTimeEnd != minutes )
+ {
+ s->altSpeedTimeEnd = minutes;
- tr_runInEventThread( session, checkAltTime, session );
+ if( tr_sessionUsesAltSpeedTime( s ) )
+ tr_sessionUseAltSpeed( s, isAltTime( s ) );
+ }
}
int
-tr_sessionGetAltSpeedLimitBegin( const tr_session * session )
+tr_sessionGetAltSpeedEnd( const tr_session * s )
{
- assert( tr_isSession( session ) );
+ assert( tr_isSession( s ) );
- return session->altSpeedBeginTime;
+ return s->altSpeedTimeEnd;
}
void
-tr_sessionSetAltSpeedLimitEnd( tr_session * session, int minutesSinceMidnight )
+tr_sessionUseAltSpeed( tr_session * s, tr_bool b )
{
- assert( tr_isSession( session ) );
-
- session->altSpeedEndTime = minutesSinceMidnight;
+ assert( tr_isSession( s ) );
+ assert( tr_isBool( b ) );
- tr_runInEventThread( session, checkAltTime, session );
+ if( s->altSpeedEnabled != b)
+ {
+ s->altSpeedEnabled = b;
+
+ tr_runInEventThread( s, altSpeedToggled, s );
+ }
}
-int
-tr_sessionGetAltSpeedLimitEnd( const tr_session * session )
+tr_bool
+tr_sessionUsesAltSpeed( const tr_session * s )
{
- assert( tr_isSession( session ) );
+ assert( tr_isSession( s ) );
- return session->altSpeedEndTime;
+ return s->altSpeedEnabled;
}
void
-tr_sessionSetAltSpeedCallback( tr_session * session,
- tr_alt_speed_func func,
- void * userData )
+tr_sessionSetAltSpeedFunc( tr_session * session,
+ tr_altSpeedFunc func,
+ void * userData )
{
assert( tr_isSession( session ) );
}
void
-tr_sessionClearAltSpeedCallback( tr_session * session )
+tr_sessionClearAltSpeedFunc( tr_session * session )
{
- tr_sessionSetAltSpeedCallback( session, NULL, NULL );
+ tr_sessionSetAltSpeedFunc( session, NULL, NULL );
}
-
/***
****
***/
tr_bool useLazyBitfield;
tr_bool isRatioLimited;
- tr_bool isSpeedLimited[2];
+
int speedLimit[2];
- tr_bool isAltSpeedLimited;
- int altSpeedBeginTime;
- int altSpeedEndTime;
- int altSpeedLimit[2];
- tr_bool isAltTime;
- tr_alt_speed_func * altCallback;
+ tr_bool speedLimitEnabled[2];
+
+ int altSpeed[2];
+ tr_bool altSpeedEnabled;
+
+ int altSpeedTimeBegin;
+ int altSpeedTimeEnd;
+ tr_bool altSpeedTimeEnabled;
+
+ tr_altSpeedFunc * altCallback;
void * altCallbackUserData;
double desiredRatio;
};
+tr_bool tr_sessionGetActiveSpeedLimit( const tr_session * session,
+ tr_direction dir,
+ int * setme );
+
const char * tr_sessionFindTorrentFile( const tr_session * session,
const char * hashString );
}
tr_bool
-tr_torrentIsUsingSpeedLimit( const tr_torrent * tor, tr_direction dir )
+tr_torrentUsesSpeedLimit( const tr_torrent * tor, tr_direction dir )
{
assert( tr_isTorrent( tor ) );
assert( tr_isDirection( dir ) );
}
void
-tr_torrentUseGlobalSpeedLimit( tr_torrent * tor, tr_direction dir, tr_bool do_use )
+tr_torrentUseSessionLimits( tr_torrent * tor, tr_bool doUse )
{
assert( tr_isTorrent( tor ) );
- assert( tr_isDirection( dir ) );
- tr_bandwidthHonorParentLimits( tor->bandwidth, dir, do_use );
+ tr_bandwidthHonorParentLimits( tor->bandwidth, TR_UP, doUse );
+ tr_bandwidthHonorParentLimits( tor->bandwidth, TR_DOWN, doUse );
}
tr_bool
-tr_torrentIsUsingGlobalSpeedLimit( const tr_torrent * tor, tr_direction dir )
+tr_torrentUsesSessionLimits( const tr_torrent * tor )
{
assert( tr_isTorrent( tor ) );
- assert( tr_isDirection( dir ) );
- return tr_bandwidthAreParentLimitsHonored( tor->bandwidth, dir );
+ return tr_bandwidthAreParentLimitsHonored( tor->bandwidth, TR_UP );
}
/***
tr_torrentIsPieceTransferAllowed( const tr_torrent * tor,
tr_direction direction )
{
+ int limit;
tr_bool allowed = TRUE;
- if( tr_torrentIsUsingSpeedLimit( tor, direction ) )
+ if( tr_torrentUsesSpeedLimit( tor, direction ) )
if( tr_torrentGetSpeedLimit( tor, direction ) <= 0 )
allowed = FALSE;
- if( tr_torrentIsUsingGlobalSpeedLimit( tor, direction ) )
- if( tr_sessionIsSpeedLimitEnabled( tor->session, direction ) )
- if( tr_sessionGetSpeedLimit( tor->session, direction ) <= 0 )
+ if( tr_torrentUsesSessionLimits( tor ) )
+ if( tr_sessionGetActiveSpeedLimit( tor->session, direction, &limit ) )
+ if( limit <= 0 )
allowed = FALSE;
return allowed;
if( !( loaded & TR_FR_SPEEDLIMIT ) )
{
- tr_torrentSetSpeedLimit( tor, TR_UP,
- tr_sessionGetSpeedLimit( tor->session, TR_UP ) );
- tr_torrentSetSpeedLimit( tor, TR_DOWN,
- tr_sessionGetSpeedLimit( tor->session, TR_DOWN ) );
+ tr_torrentUseSpeedLimit( tor, TR_UP, FALSE );
+ tr_torrentUseSpeedLimit( tor, TR_DOWN, FALSE );
+ tr_torrentUseSessionLimits( tor, TRUE );
}
if( !( loaded & TR_FR_RATIOLIMIT ) )
#define TR_DEFAULT_PEER_LIMIT_GLOBAL_STR "240"
#define TR_DEFAULT_PEER_LIMIT_TORRENT_STR "60"
-#define TR_PREFS_KEY_ALT_LIMIT_ENABLED "alt-speed-limit-enabled"
-#define TR_PREFS_KEY_ALT_BEGIN "alt-speed-limit-begin"
-#define TR_PREFS_KEY_ALT_DL_LIMIT "alt-speed-limit-down"
-#define TR_PREFS_KEY_ALT_END "alt-speed-limit-end"
-#define TR_PREFS_KEY_ALT_UL_LIMIT "alt-speed-limit-up"
+#define TR_PREFS_KEY_ALT_SPEED_ENABLED "alt-speed-enabled"
+#define TR_PREFS_KEY_ALT_SPEED_UP "alt-speed-up"
+#define TR_PREFS_KEY_ALT_SPEED_DOWN "alt-speed-down"
+#define TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN "alt-speed-time-begin"
+#define TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED "alt-speed-time-enabled"
+#define TR_PREFS_KEY_ALT_SPEED_TIME_END "alt-speed-time-end"
#define TR_PREFS_KEY_BLOCKLIST_ENABLED "blocklist-enabled"
#define TR_PREFS_KEY_DOWNLOAD_DIR "download-dir"
#define TR_PREFS_KEY_DSPEED "download-limit"
* @param dictionary
* @see tr_sessionLoadSettings()
*/
-void tr_sessionSaveSettings( tr_session * session,
- const char * configDir,
- struct tr_benc * dictonary );
+void tr_sessionSaveSettings( tr_session * session,
+ const char * configDir,
+ const struct tr_benc * dictonary );
/**
* Initialize a libtransmission session.
****
***/
-void tr_sessionSetSpeedLimitEnabled ( tr_session * session,
- tr_direction direction,
- tr_bool isEnabled );
-
-tr_bool tr_sessionIsSpeedLimitEnabled ( const tr_session * session,
- tr_direction direction );
-
-void tr_sessionSetSpeedLimit ( tr_session * session,
- tr_direction direction,
- int KiB_sec );
-
-int tr_sessionGetSpeedLimit ( const tr_session * session,
- tr_direction direction );
-
/***
-****
+**** Primary session speed limits
***/
-typedef void ( tr_alt_speed_func )( tr_session * session,
- tr_bool isAltActive,
- void * userData );
-
-/**
- * Register to be notified whenever the alternate speed limits go on and off.
- *
- * func is invoked FROM LIBTRANSMISSION'S THREAD!
- * This means func must be fast (to avoid blocking peers),
- * shouldn't call libtransmission functions (to avoid deadlock),
- * and shouldn't modify client-level memory without using a mutex!
- */
-void tr_sessionSetAltSpeedCallback( tr_session * session,
- tr_alt_speed_func func,
- void * userData );
-
-void tr_sessionClearAltSpeedCallback( tr_session * session );
+void tr_sessionSetSpeedLimit ( tr_session *, tr_direction, int KB_s );
+int tr_sessionGetSpeedLimit ( const tr_session *, tr_direction );
+void tr_sessionLimitSpeed ( tr_session *, tr_direction, tr_bool );
+tr_bool tr_sessionIsSpeedLimited ( const tr_session *, tr_direction );
-void tr_sessionSetAltSpeedLimitEnabled( tr_session * session,
- tr_bool isEnabled );
-tr_bool tr_sessionIsAltSpeedLimitEnabled( const tr_session * session );
+/***
+**** Alternative speed limits that are used during scheduled times
+***/
-void tr_sessionSetAltSpeedLimitBegin( tr_session * session,
- int minutesSinceMidnight );
+void tr_sessionSetAltSpeed ( tr_session *, tr_direction, int KB_s );
+int tr_sessionGetAltSpeed ( const tr_session *, tr_direction );
-int tr_sessionGetAltSpeedLimitBegin( const tr_session * session );
+void tr_sessionUseAltSpeed ( tr_session *, tr_bool );
+tr_bool tr_sessionUsesAltSpeed ( const tr_session * );
-void tr_sessionSetAltSpeedLimitEnd( tr_session * session,
- int minutesSinceMidnight );
+void tr_sessionUseAltSpeedTime ( tr_session *, tr_bool );
+tr_bool tr_sessionUsesAltSpeedTime ( const tr_session * );
-int tr_sessionGetAltSpeedLimitEnd( const tr_session * session );
+void tr_sessionSetAltSpeedBegin ( tr_session *, int minsSinceMidnight );
+int tr_sessionGetAltSpeedBegin ( const tr_session * );
-void tr_sessionSetAltSpeedLimit( tr_session * session,
- tr_direction direction,
- int KiB_sec );
+void tr_sessionSetAltSpeedEnd ( tr_session *, int minsSinceMidnight );
+int tr_sessionGetAltSpeedEnd ( const tr_session * );
-int tr_sessionGetAltSpeedLimit( const tr_session * session,
- tr_direction direction );
+typedef void ( tr_altSpeedFunc ) ( tr_session *, tr_bool active, void * );
+void tr_sessionClearAltSpeedFunc ( tr_session * );
+void tr_sessionSetAltSpeedFunc ( tr_session *, tr_altSpeedFunc *, void * );
/***
****
***/
-void tr_sessionSetRatioLimited ( tr_session * session,
- tr_bool isEnabled );
-
-tr_bool tr_sessionIsRatioLimited ( const tr_session * session);
-
-void tr_sessionSetRatioLimit ( tr_session * session,
- double desiredRatio);
-
-double tr_sessionGetRatioLimit ( const tr_session * session);
+double tr_sessionGetRawSpeed ( const tr_session *, tr_direction );
+double tr_sessionGetPieceSpeed ( const tr_session *, tr_direction );
-tr_bool tr_torrentGetSeedRatio ( const tr_torrent * tor, double * ratio );
-double tr_sessionGetRawSpeed ( const tr_session * session,
- tr_direction direction );
+void tr_sessionSetRatioLimited ( tr_session *, tr_bool isLimited );
+tr_bool tr_sessionIsRatioLimited ( const tr_session * );
-double tr_sessionGetPieceSpeed ( const tr_session * session,
- tr_direction direction );
+void tr_sessionSetRatioLimit ( tr_session *, double desiredRatio );
+double tr_sessionGetRatioLimit ( const tr_session * );
+void tr_sessionSetPeerLimit( tr_session *, uint16_t maxGlobalPeers );
+uint16_t tr_sessionGetPeerLimit( const tr_session * );
-void tr_sessionSetPeerLimit( tr_session * session,
- uint16_t maxGlobalPeers );
-
-uint16_t tr_sessionGetPeerLimit( const tr_session * session );
-
-void tr_sessionSetPeerLimitPerTorrent( tr_session * session,
- uint16_t maxGlobalPeers );
-
-uint16_t tr_sessionGetPeerLimitPerTorrent( const tr_session * session );
+void tr_sessionSetPeerLimitPerTorrent( tr_session *, uint16_t maxGlobalPeers );
+uint16_t tr_sessionGetPeerLimitPerTorrent( const tr_session * );
/**
*/
int tr_torrentId( const tr_torrent * torrent );
-/****
-***** Speed Limits
-****/
-
-void tr_torrentSetSpeedLimit( tr_torrent *, tr_direction, int KiB_sec );
-
-int tr_torrentGetSpeedLimit( const tr_torrent *, tr_direction );
+/***
+**** Torrent speed limits
+****
+***/
-void tr_torrentUseSpeedLimit( tr_torrent *, tr_direction, tr_bool do_use );
+void tr_torrentSetSpeedLimit ( tr_torrent *, tr_direction, int KB_s );
+int tr_torrentGetSpeedLimit ( const tr_torrent *, tr_direction );
-tr_bool tr_torrentIsUsingSpeedLimit( const tr_torrent *, tr_direction );
+void tr_torrentUseSpeedLimit ( tr_torrent *, tr_direction, tr_bool );
+tr_bool tr_torrentUsesSpeedLimit ( const tr_torrent *, tr_direction );
-void tr_torrentUseGlobalSpeedLimit( tr_torrent *, tr_direction, tr_bool do_use );
+void tr_torrentUseSessionLimits ( tr_torrent *, tr_bool );
+tr_bool tr_torrentUsesSessionLimits ( const tr_torrent * );
-tr_bool tr_torrentIsUsingGlobalSpeedLimit ( const tr_torrent *, tr_direction );
/****
***** Ratio Limits
double tr_torrentGetRatioLimit( const tr_torrent * tor );
+
+tr_bool tr_torrentGetSeedRatio( const tr_torrent *, double * ratio );
+
/****
***** Peer Limits
****/
projects / transmission / commitdiff