Changeset 11044


Ignore:
Timestamp:
Jul 24, 2010, 2:57:39 AM (12 years ago)
Author:
charles
Message:

(trunk) #2560: rename "inactive limit" to "idle limit". Add support in GTK+ client and preliminary support to Qt client

Location:
trunk
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • trunk/doc/rpc-spec.txt

    r11037 r11044  
    101101   "priority-low"        | array      indices of low-priority file(s)
    102102   "priority-normal"     | array      indices of normal-priority file(s)
    103    "seedInactiveLimit"   | number     torrent-level number of minutes of seeding inactivity
    104    "seedInactiveMode"    | number     which seeding inactivity to use.  See tr_inactvelimit
     103   "seedIdleLimit"       | number     torrent-level number of minutes of seeding inactivity
     104   "seedIdleMode"        | number     which seeding inactivity to use.  See tr_inactvelimit
    105105   "seedRatioLimit"      | double     torrent-level seeding ratio
    106106   "seedRatioMode"       | number     which ratio to use.  See tr_ratiolimit
     
    206206   rateUpload (KBps)           | double                      | tr_stat
    207207   recheckProgress             | double                      | tr_stat
    208    seedInactiveLimit           | number                      | tr_torrent
    209    seedInactiveMode            | number                      | tr_inactvelimit
     208   seedIdleLimit               | number                      | tr_torrent
     209   seedIdleMode                | number                      | tr_inactvelimit
    210210   seedRatioLimit              | double                      | tr_torrent
    211211   seedRatioMode               | number                      | tr_ratiolimit
     
    646646         |         | yes       | session-get    | new arg "inactive-seeding-limit"
    647647         |         | yes       | session-get    | new arg "inactive-seeding-limit-enabled"
    648          |         | yes       | torrent-set    | new arg "seedInactiveLimit"
    649          |         | yes       | torrent-set    | new arg "seedInactiveMode"
    650          |         | yes       | torrent-get    | new arg "seedInactiveLimit"
    651          |         | yes       | torrent-get    | new arg "seedInactiveMode"
     648         |         | yes       | torrent-set    | new arg "seedIdleLimit"
     649         |         | yes       | torrent-set    | new arg "seedIdleMode"
  • trunk/gtk/add-dialog.c

    r10915 r11044  
    126126            tr_torrent * tor = tr_torrent_handle( data->gtor );
    127127
    128             tr_torrentSetPriority( tor, gtr_priority_combo_get_value( data->priority_combo ) );
     128            tr_torrentSetPriority( tor, gtr_priority_combo_get_value( GTK_COMBO_BOX( data->priority_combo ) ) );
    129129
    130130            if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( data->run_check ) ) )
     
    298298    data->run_check = gtk_check_button_new_with_mnemonic( str );
    299299
    300     data->priority_combo = gtr_priority_combo_new( );
    301     gtr_priority_combo_set_value( data->priority_combo, TR_PRI_NORMAL );
     300    w = data->priority_combo = gtr_priority_combo_new( );
     301    gtr_priority_combo_set_value( GTK_COMBO_BOX( w ), TR_PRI_NORMAL );
    302302
    303303    g_signal_connect( G_OBJECT( d ), "response",
  • trunk/gtk/details.c

    r11040 r11044  
    3535    GtkWidget * dialog;
    3636
    37     GtkWidget * peersPage;
    38     GtkWidget * trackerPage;
    39     GtkWidget * activityPage;
    40 
    41     GtkWidget * honorLimitsCheck;
    42     GtkWidget * upLimitedCheck;
    43     GtkWidget * upLimitSpin;
    44     GtkWidget * downLimitedCheck;
    45     GtkWidget * downLimitSpin;
    46     GtkWidget * bandwidthCombo;
    47     GtkWidget * seedGlobalRadio;
    48     GtkWidget * seedForeverRadio;
    49     GtkWidget * seedCustomRadio;
    50     GtkWidget * seedCustomSpin;
    51     GtkWidget * maxPeersSpin;
    52 
    53     guint honorLimitsCheckTag;
    54     guint upLimitedCheckTag;
    55     guint downLimitedCheckTag;
    56     guint downLimitSpinTag;
    57     guint upLimitSpinTag;
    58     guint bandwidthComboTag;
    59     guint seedForeverRadioTag;
    60     guint seedGlobalRadioTag;
    61     guint seedCustomRadioTag;
    62     guint seedCustomSpinTag;
    63     guint maxPeersSpinTag;
     37    GtkWidget * honor_limits_check;
     38    GtkWidget * up_limited_check;
     39    GtkWidget * up_limit_sping;
     40    GtkWidget * down_limited_check;
     41    GtkWidget * down_limit_spin;
     42    GtkWidget * bandwidth_combo;
     43
     44    GtkWidget * ratio_combo;
     45    GtkWidget * ratio_spin;
     46    GtkWidget * idle_combo;
     47    GtkWidget * idle_spin;
     48    GtkWidget * max_peers_spin;
     49
     50    guint honor_limits_check_tag;
     51    guint up_limited_check_tag;
     52    guint down_limited_check_tag;
     53    guint down_limit_spin_tag;
     54    guint up_limit_spin_tag;
     55    guint bandwidth_combo_tag;
     56    guint ratio_combo_tag;
     57    guint ratio_spin_tag;
     58    guint idle_combo_tag;
     59    guint idle_spin_tag;
     60    guint max_peers_spin_tag;
    6461
    6562    GtkWidget * size_lb;
     
    193190    ***/
    194191
    195     /* honorLimitsCheck */
     192    /* honor_limits_check */
    196193    if( n ) {
    197194        const tr_bool baseline = tr_torrentUsesSessionLimits( torrents[0] );
     
    201198                break;
    202199        if( i == n )
    203             set_togglebutton_if_different( di->honorLimitsCheck,
    204                                            di->honorLimitsCheckTag, baseline );
    205     }
    206 
    207     /* downLimitedCheck */
     200            set_togglebutton_if_different( di->honor_limits_check,
     201                                           di->honor_limits_check_tag, baseline );
     202    }
     203
     204    /* down_limited_check */
    208205    if( n ) {
    209206        const tr_bool baseline = tr_torrentUsesSpeedLimit( torrents[0], TR_DOWN );
     
    213210                break;
    214211        if( i == n )
    215             set_togglebutton_if_different( di->downLimitedCheck,
    216                                            di->downLimitedCheckTag, baseline );
    217     }
    218 
    219     /* downLimitSpin */
     212            set_togglebutton_if_different( di->down_limited_check,
     213                                           di->down_limited_check_tag, baseline );
     214    }
     215
     216    /* down_limit_spin */
    220217    if( n ) {
    221218        const int baseline = tr_torrentGetSpeedLimit_KBps( torrents[0], TR_DOWN );
     
    225222                break;
    226223        if( i == n )
    227             set_int_spin_if_different( di->downLimitSpin,
    228                                        di->downLimitSpinTag, baseline );
    229     }
    230 
    231     /* upLimitedCheck */
     224            set_int_spin_if_different( di->down_limit_spin,
     225                                       di->down_limit_spin_tag, baseline );
     226    }
     227
     228    /* up_limited_check */
    232229    if( n ) {
    233230        const tr_bool baseline = tr_torrentUsesSpeedLimit( torrents[0], TR_UP );
     
    237234                break;
    238235        if( i == n )
    239             set_togglebutton_if_different( di->upLimitedCheck,
    240                                            di->upLimitedCheckTag, baseline );
    241     }
    242 
    243     /* upLimitSpin */
     236            set_togglebutton_if_different( di->up_limited_check,
     237                                           di->up_limited_check_tag, baseline );
     238    }
     239
     240    /* up_limit_sping */
    244241    if( n ) {
    245242        const int baseline = tr_torrentGetSpeedLimit_KBps( torrents[0], TR_UP );
     
    249246                break;
    250247        if( i == n )
    251             set_int_spin_if_different( di->upLimitSpin,
    252                                        di->upLimitSpinTag, baseline );
    253     }
    254 
    255     /* bandwidthCombo */
     248            set_int_spin_if_different( di->up_limit_sping,
     249                                       di->up_limit_spin_tag, baseline );
     250    }
     251
     252    /* bandwidth_combo */
    256253    if( n ) {
    257254        const int baseline = tr_torrentGetPriority( torrents[0] );
     
    261258                break;
    262259        if( i == n ) {
    263             g_signal_handler_block( di->bandwidthCombo, di->bandwidthComboTag );
    264             gtr_priority_combo_set_value( GTK_COMBO_BOX( di->bandwidthCombo ), baseline );
    265             g_signal_handler_unblock( di->bandwidthCombo, di->bandwidthComboTag );
     260            GtkWidget * w = di->bandwidth_combo;
     261            g_signal_handler_block( w, di->bandwidth_combo_tag );
     262            gtr_priority_combo_set_value( GTK_COMBO_BOX( w ), baseline );
     263            g_signal_handler_unblock( w, di->bandwidth_combo_tag );
    266264        }
    267265        else
    268             unset_combo( di->bandwidthCombo, di->bandwidthComboTag );
    269     }
    270 
    271     /* seedGlobalRadio */
    272     /* seedForeverRadio */
    273     /* seedCustomRadio */
     266            unset_combo( di->bandwidth_combo, di->bandwidth_combo_tag );
     267    }
     268
     269    /* ratio_combo */
     270    /* ratio_spin */
    274271    if( n ) {
    275         guint t;
     272        int i;
    276273        const int baseline = tr_torrentGetRatioMode( torrents[0] );
    277         int i;
    278274        for( i=1; i<n; ++i )
    279275            if( baseline != (int)tr_torrentGetRatioMode( torrents[i] ) )
    280276                break;
    281277        if( i == n ) {
    282             GtkWidget * w;
    283             switch( baseline ) {
    284                 case TR_RATIOLIMIT_SINGLE: w = di->seedCustomRadio;
    285                                            t = di->seedCustomRadioTag; break;
    286                 case TR_RATIOLIMIT_UNLIMITED: w = di->seedForeverRadio;
    287                                               t = di->seedForeverRadioTag; break;
    288                 default /*TR_RATIOLIMIT_GLOBAL*/: w = di->seedGlobalRadio;
    289                                                   t = di->seedGlobalRadioTag; break;
    290             }
    291             set_togglebutton_if_different( w, t, TRUE );
    292         }
    293     }
    294 
    295     /* seedCustomSpin */
     278            GtkWidget * w = di->ratio_combo;
     279            g_signal_handler_block( w, di->ratio_combo_tag );
     280            gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), baseline );
     281            gtk_widget_set_visible( di->ratio_spin, baseline == TR_RATIOLIMIT_SINGLE );
     282            g_signal_handler_unblock( w, di->ratio_combo_tag );
     283        }
     284    }
    296285    if( n ) {
    297286        const double baseline = tr_torrentGetRatioLimit( torrents[0] );
    298         set_double_spin_if_different( di->seedCustomSpin,
    299                                       di->seedCustomSpinTag, baseline );
    300     }
    301 
    302     /* maxPeersSpin */
     287        set_double_spin_if_different( di->ratio_spin,
     288                                      di->ratio_spin_tag, baseline );
     289    }
     290
     291    /* idle_combo */
     292    /* idle_spin */
     293    if( n ) {
     294        int i;
     295        const int baseline = tr_torrentGetIdleMode( torrents[0] );
     296        for( i=1; i<n; ++i )
     297            if( baseline != (int)tr_torrentGetIdleMode( torrents[i] ) )
     298                break;
     299        if( i == n ) {
     300            GtkWidget * w = di->idle_combo;
     301            g_signal_handler_block( w, di->idle_combo_tag );
     302            gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), baseline );
     303            gtk_widget_set_visible( di->idle_spin, baseline == TR_IDLELIMIT_SINGLE );
     304            g_signal_handler_unblock( w, di->idle_combo_tag );
     305        }
     306    }
     307    if( n ) {
     308        const int baseline = tr_torrentGetIdleLimit( torrents[0] );
     309        set_int_spin_if_different( di->idle_spin,
     310                                   di->idle_spin_tag, baseline );
     311    }
     312
     313    /* max_peers_spin */
    303314    if( n ) {
    304315        const int baseline = tr_torrentGetPeerLimit( torrents[0] );
    305         set_int_spin_if_different( di->maxPeersSpin,
    306                                    di->maxPeersSpinTag, baseline );
     316        set_int_spin_if_different( di->max_peers_spin,
     317                                   di->max_peers_spin_tag, baseline );
    307318    }
    308319}
     
    380391}
    381392
    382 #define RATIO_KEY "ratio-mode"
    383 
    384 static void
    385 ratio_mode_changed_cb( GtkToggleButton * tb, struct DetailsImpl * d )
    386 {
    387     if( gtk_toggle_button_get_active( tb ) )
    388     {
    389         GObject * o = G_OBJECT( tb );
    390         const int mode = GPOINTER_TO_INT( g_object_get_data( o, RATIO_KEY ) );
    391         torrent_set_int( d, "seedRatioMode", mode );
    392     }
    393 }
    394 
    395393static void
    396394up_speed_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
     
    406404
    407405static void
     406idle_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
     407{
     408    torrent_set_int( di, "seedInactiveLimit", gtk_spin_button_get_value_as_int( s ) );
     409}
     410
     411static void
    408412ratio_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
    409413{
    410414    torrent_set_real( di, "seedRatioLimit", gtk_spin_button_get_value( s ) );
    411     gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( di->seedCustomRadio ), TRUE );
    412415}
    413416
     
    429432{
    430433    GtkWidget * w = gtr_priority_combo_new( );
    431     di->bandwidthComboTag = g_signal_connect( w, "changed", G_CALLBACK( onPriorityChanged ), di );
     434    di->bandwidth_combo_tag = g_signal_connect( w, "changed", G_CALLBACK( onPriorityChanged ), di );
    432435    return w;
    433436}
    434437
     438static void refresh( struct DetailsImpl * di );
     439
     440#define ARG_KEY "arg-key"
     441
     442static void
     443onComboEnumChanged( GtkComboBox * combo_box, struct DetailsImpl * di )
     444{
     445    const char * key = g_object_get_data( G_OBJECT( combo_box ), ARG_KEY );
     446    torrent_set_int( di, key, gtr_combo_box_get_active_enum( combo_box ) );
     447    refresh( di );
     448}
     449
     450static GtkWidget*
     451ratio_combo_new( void )
     452{
     453    GtkWidget * w = gtr_combo_box_new_enum( _( "Use global settings" ),       TR_RATIOLIMIT_GLOBAL,
     454                                            _( "Seed regardless of ratio" ),  TR_RATIOLIMIT_UNLIMITED,
     455                                            _( "Stop seeding at ratio:" ),    TR_RATIOLIMIT_SINGLE,
     456                                            NULL );
     457    g_object_set_data_full( G_OBJECT( w ), ARG_KEY, g_strdup( "seedRatioMode" ), g_free );
     458    return w;
     459}
     460
     461static GtkWidget*
     462idle_combo_new( void )
     463{
     464    GtkWidget * w = gtr_combo_box_new_enum ( _( "Use global settings" ),                 TR_IDLELIMIT_GLOBAL,
     465                                             _( "Seed regardless of activity" ),         TR_IDLELIMIT_UNLIMITED,
     466                                             _( "Stop seeding if idle for N minutes:" ), TR_IDLELIMIT_SINGLE,
     467                                             NULL );
     468    g_object_set_data_full( G_OBJECT( w ), ARG_KEY, g_strdup( "seedIdleMode" ), g_free );
     469    return w;
     470}
    435471
    436472static GtkWidget*
     
    440476    int row;
    441477    char buf[128];
    442     const char *s;
    443478    GtkWidget *t, *w, *tb, *h;
    444479
     
    448483
    449484    tb = hig_workarea_add_wide_checkbutton( t, &row, _( "Honor global _limits" ), 0 );
    450     d->honorLimitsCheck = tb;
     485    d->honor_limits_check = tb;
    451486    tag = g_signal_connect( tb, "toggled", G_CALLBACK( global_speed_toggled_cb ), d );
    452     d->honorLimitsCheckTag = tag;
     487    d->honor_limits_check_tag = tag;
    453488
    454489    g_snprintf( buf, sizeof( buf ), _( "Limit _download speed (%s):" ), _(speed_K_str) );
    455490    tb = gtk_check_button_new_with_mnemonic( buf );
    456491    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( tb ), FALSE );
    457     d->downLimitedCheck = tb;
     492    d->down_limited_check = tb;
    458493    tag = g_signal_connect( tb, "toggled", G_CALLBACK( down_speed_toggled_cb ), d );
    459     d->downLimitedCheckTag = tag;
     494    d->down_limited_check_tag = tag;
    460495
    461496    w = gtk_spin_button_new_with_range( 0, INT_MAX, 5 );
    462497    tag = g_signal_connect( w, "value-changed", G_CALLBACK( down_speed_spun_cb ), d );
    463     d->downLimitSpinTag = tag;
     498    d->down_limit_spin_tag = tag;
    464499    hig_workarea_add_row_w( t, &row, tb, w, NULL );
    465     d->downLimitSpin = w;
     500    d->down_limit_spin = w;
    466501
    467502    g_snprintf( buf, sizeof( buf ), _( "Limit _upload speed (%s):" ), _(speed_K_str) );
    468503    tb = gtk_check_button_new_with_mnemonic( buf );
    469     d->upLimitedCheck = tb;
     504    d->up_limited_check = tb;
    470505    tag = g_signal_connect( tb, "toggled", G_CALLBACK( up_speed_toggled_cb ), d );
    471     d->upLimitedCheckTag = tag;
     506    d->up_limited_check_tag = tag;
    472507
    473508    w = gtk_spin_button_new_with_range( 0, INT_MAX, 5 );
    474509    tag = g_signal_connect( w, "value-changed", G_CALLBACK( up_speed_spun_cb ), d );
    475     d->upLimitSpinTag = tag;
     510    d->up_limit_spin_tag = tag;
    476511    hig_workarea_add_row_w( t, &row, tb, w, NULL );
    477     d->upLimitSpin = w;
     512    d->up_limit_sping = w;
    478513
    479514    w = new_priority_combo( d );
    480515    hig_workarea_add_row( t, &row, _( "Torrent _priority:" ), w, NULL );
    481     d->bandwidthCombo = w;
     516    d->bandwidth_combo = w;
    482517
    483518    hig_workarea_add_section_divider( t, &row );
    484     hig_workarea_add_section_title( t, &row, _( "Seed-Until Ratio" ) );
    485 
    486     s = _( "Use _global settings" );
    487     w = gtk_radio_button_new_with_mnemonic( NULL, s );
    488     hig_workarea_add_wide_control( t, &row, w );
    489     g_object_set_data( G_OBJECT( w ), RATIO_KEY, GINT_TO_POINTER( TR_RATIOLIMIT_GLOBAL ) );
    490     tag = g_signal_connect( w, "toggled", G_CALLBACK( ratio_mode_changed_cb ), d );
    491     d->seedGlobalRadio = w;
    492     d->seedGlobalRadioTag = tag;
    493 
    494     s = _( "Seed _regardless of ratio" );
    495     w = gtk_radio_button_new_with_mnemonic_from_widget( GTK_RADIO_BUTTON( w ), s );
    496     hig_workarea_add_wide_control( t, &row, w );
    497     g_object_set_data( G_OBJECT( w ), RATIO_KEY, GINT_TO_POINTER( TR_RATIOLIMIT_UNLIMITED ) );
    498     tag = g_signal_connect( w, "toggled", G_CALLBACK( ratio_mode_changed_cb ), d );
    499     d->seedForeverRadio = w;
    500     d->seedForeverRadioTag = tag;
     519    hig_workarea_add_section_title( t, &row, _( "Seeding Limits" ) );
    501520
    502521    h = gtk_hbox_new( FALSE, GUI_PAD );
    503     s = _( "_Seed torrent until its ratio reaches:" );
    504     w = gtk_radio_button_new_with_mnemonic_from_widget( GTK_RADIO_BUTTON( w ), s );
    505     d->seedCustomRadio = w;
    506     g_object_set_data( G_OBJECT( w ), RATIO_KEY, GINT_TO_POINTER( TR_RATIOLIMIT_SINGLE ) );
    507     tag = g_signal_connect( w, "toggled", G_CALLBACK( ratio_mode_changed_cb ), d );
    508     d->seedCustomRadioTag = tag;
     522    w = d->ratio_combo = ratio_combo_new( );
     523    d->ratio_combo_tag = g_signal_connect( w, "changed", G_CALLBACK( onComboEnumChanged ), d );
     524    gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
     525    w = d->ratio_spin = gtk_spin_button_new_with_range( 0, 1000, .05 );
     526    gtk_entry_set_width_chars( GTK_ENTRY( w ), 7 );
     527    d->ratio_spin_tag = g_signal_connect( w, "value-changed", G_CALLBACK( ratio_spun_cb ), d );
    509528    gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
    510     w = gtk_spin_button_new_with_range( 0, INT_MAX, .05 );
    511     gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 2 );
    512     tag = g_signal_connect( w, "value-changed", G_CALLBACK( ratio_spun_cb ), d );
     529    hig_workarea_add_row( t, &row, _( "Ratio:" ), h, NULL );
     530
     531    h = gtk_hbox_new( FALSE, GUI_PAD );
     532    w = d->idle_combo = idle_combo_new( );
     533    d->idle_combo_tag = g_signal_connect( w, "changed", G_CALLBACK( onComboEnumChanged ), d );
     534    gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
     535    w = d->idle_spin = gtk_spin_button_new_with_range( 1, INT_MAX, 5 );
     536    d->idle_spin_tag = g_signal_connect( w, "value-changed", G_CALLBACK( idle_spun_cb ), d );
    513537    gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
    514     hig_workarea_add_wide_control( t, &row, h );
    515     d->seedCustomSpin = w;
    516     d->seedCustomSpinTag = tag;
     538    hig_workarea_add_row( t, &row, _( "_Idle:" ), h, NULL );
    517539
    518540    hig_workarea_add_section_divider( t, &row );
     
    522544    hig_workarea_add_row( t, &row, _( "_Maximum peers:" ), w, w );
    523545    tag = g_signal_connect( w, "value-changed", G_CALLBACK( max_peers_spun_cb ), d );
    524     d->maxPeersSpin = w;
    525     d->maxPeersSpinTag = tag;
     546    d->max_peers_spin = w;
     547    d->max_peers_spin_tag = tag;
    526548
    527549    hig_workarea_finish( t, &row );
     
    10681090                               G_TYPE_BOOLEAN,  /* was-updated */
    10691091                               G_TYPE_STRING,   /* url */
    1070                                G_TYPE_INT,      /* download rate int */
     1092                               G_TYPE_DOUBLE,   /* download rate double */
    10711093                               G_TYPE_STRING ); /* download rate string */
    10721094}
     
    20702092}
    20712093
    2072 static void refresh( struct DetailsImpl * di );
    2073 
    20742094static void
    20752095onScrapeToggled( GtkToggleButton * button, struct DetailsImpl * di )
  • trunk/gtk/main.c

    r10993 r11044  
    12581258        tr_sessionSetRatioLimit( tr, pref_double_get( key ) );
    12591259    }
     1260    else if( !strcmp( key, TR_PREFS_KEY_IDLE_LIMIT ) )
     1261    {
     1262        tr_sessionSetIdleLimit( tr, pref_int_get( key ) );
     1263    }
     1264    else if( !strcmp( key, TR_PREFS_KEY_IDLE_LIMIT_ENABLED ) )
     1265    {
     1266        tr_sessionSetIdleLimited( tr, pref_flag_get( key ) );
     1267    }
    12601268    else if( !strcmp( key, TR_PREFS_KEY_PORT_FORWARDING ) )
    12611269    {
  • trunk/gtk/tr-prefs.c

    r11040 r11044  
    320320
    321321    hig_workarea_add_section_divider( t, &row );
    322     hig_workarea_add_section_title( t, &row, _( "Seeding" ) );
     322    hig_workarea_add_section_title( t, &row, _( "Seeding Limits" ) );
    323323
    324324    s = _( "Stop seeding at _ratio:" );
     
    326326    w2 = new_spin_button_double( TR_PREFS_KEY_RATIO, core, 0, 1000, .05 );
    327327    gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED ) );
     328    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
     329    hig_workarea_add_row_w( t, &row, w, w2, NULL );
     330
     331    s = _( "Stop seeding if idle for _N minutes:" );
     332    w = new_check_button( s, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, core );
     333    w2 = new_spin_button( TR_PREFS_KEY_IDLE_LIMIT, core, 1, 9999, 5 );
     334    gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_IDLE_LIMIT_ENABLED ) );
    328335    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
    329336    hig_workarea_add_row_w( t, &row, w, w2, NULL );
  • trunk/libtransmission/resume.c

    r11013 r11044  
    4545#define KEY_SPEEDLIMIT_DOWN     "speed-limit-down"
    4646#define KEY_RATIOLIMIT          "ratio-limit"
    47 #define KEY_INACTIVELIMIT       "inactivity-limit"
     47#define KEY_IDLELIMIT           "idle-limit"
    4848#define KEY_UPLOADED            "uploaded"
    4949
     
    5858#define KEY_RATIOLIMIT_RATIO       "ratio-limit"
    5959#define KEY_RATIOLIMIT_MODE        "ratio-mode"
    60 #define KEY_INACTIVELIMIT_MINS     "inactivity-limit"
    61 #define KEY_INACTIVELIMIT_MODE     "inactivity-mode"
     60#define KEY_IDLELIMIT_MINS         "idle-limit"
     61#define KEY_IDLELIMIT_MODE         "idle-mode"
    6262
    6363#define KEY_PROGRESS_MTIMES    "mtimes"
     
    295295
    296296static void
    297 saveInactivityLimits( tr_benc * dict, const tr_torrent * tor )
    298 {
    299     tr_benc * d = tr_bencDictAddDict( dict, KEY_INACTIVELIMIT, 2 );
    300     tr_bencDictAddInt( d, KEY_INACTIVELIMIT_MINS, tr_torrentGetInactiveLimit( tor ) );
    301     tr_bencDictAddInt( d, KEY_INACTIVELIMIT_MODE, tr_torrentGetInactiveMode( tor ) );
     297saveIdleLimits( tr_benc * dict, const tr_torrent * tor )
     298{
     299    tr_benc * d = tr_bencDictAddDict( dict, KEY_IDLELIMIT, 2 );
     300    tr_bencDictAddInt( d, KEY_IDLELIMIT_MINS, tr_torrentGetIdleLimit( tor ) );
     301    tr_bencDictAddInt( d, KEY_IDLELIMIT_MODE, tr_torrentGetIdleMode( tor ) );
    302302}
    303303
     
    388388
    389389static uint64_t
    390 loadInactivityLimits( tr_benc *    dict,
     390loadIdleLimits( tr_benc *    dict,
    391391                      tr_torrent * tor )
    392392{
     
    394394    tr_benc * d;
    395395
    396     if( tr_bencDictFindDict( dict, KEY_INACTIVELIMIT, &d ) )
     396    if( tr_bencDictFindDict( dict, KEY_IDLELIMIT, &d ) )
    397397    {
    398398        int64_t i;
    399399        int64_t imin;
    400         if( tr_bencDictFindInt( d, KEY_INACTIVELIMIT_MINS, &imin ) )
    401             tr_torrentSetInactiveLimit( tor, imin );
    402         if( tr_bencDictFindInt( d, KEY_INACTIVELIMIT_MODE, &i ) )
    403             tr_torrentSetInactiveMode( tor, i );
    404       ret = TR_FR_INACTIVELIMIT;
     400        if( tr_bencDictFindInt( d, KEY_IDLELIMIT_MINS, &imin ) )
     401            tr_torrentSetIdleLimit( tor, imin );
     402        if( tr_bencDictFindInt( d, KEY_IDLELIMIT_MODE, &i ) )
     403            tr_torrentSetIdleMode( tor, i );
     404      ret = TR_FR_IDLELIMIT;
    405405    }
    406406
     
    571571    saveSpeedLimits( &top, tor );
    572572    saveRatioLimits( &top, tor );
    573     saveInactivityLimits( &top, tor );
     573    saveIdleLimits( &top, tor );
    574574
    575575    filename = getResumeFilename( tor );
     
    707707        fieldsLoaded |= loadRatioLimits( &top, tor );
    708708
    709     if( fieldsToLoad & TR_FR_INACTIVELIMIT )
    710         fieldsLoaded |= loadInactivityLimits( &top, tor );
     709    if( fieldsToLoad & TR_FR_IDLELIMIT )
     710        fieldsLoaded |= loadIdleLimits( &top, tor );
    711711
    712712    /* loading the resume file triggers of a lot of changes,
  • trunk/libtransmission/resume.h

    r11014 r11044  
    3737    TR_FR_ACTIVITY_DATE       = ( 1 << 15 ),
    3838    TR_FR_RATIOLIMIT          = ( 1 << 16 ),
    39     TR_FR_INACTIVELIMIT       = ( 1 << 17 )
     39    TR_FR_IDLELIMIT           = ( 1 << 17 )
    4040};
    4141
  • trunk/libtransmission/rpcimpl.c

    r11037 r11044  
    575575    else if( tr_streq( key, keylen, "recheckProgress" ) )
    576576        tr_bencDictAddReal( d, key, st->recheckProgress );
    577     else if( tr_streq( key, keylen, "seedInactiveLimit" ) )
    578         tr_bencDictAddInt( d, key, tr_torrentGetInactiveLimit( tor ) );
    579     else if( tr_streq( key, keylen, "seedInactiveMode" ) )
    580         tr_bencDictAddInt( d, key, tr_torrentGetInactiveMode( tor ) );
     577    else if( tr_streq( key, keylen, "seedIdleLimit" ) )
     578        tr_bencDictAddInt( d, key, tr_torrentGetIdleLimit( tor ) );
     579    else if( tr_streq( key, keylen, "seedIdleMode" ) )
     580        tr_bencDictAddInt( d, key, tr_torrentGetIdleMode( tor ) );
    581581    else if( tr_streq( key, keylen, "seedRatioLimit" ) )
    582582        tr_bencDictAddReal( d, key, tr_torrentGetRatioLimit( tor ) );
     
    10181018        if( tr_bencDictFindBool( args_in, "uploadLimited", &boolVal ) )
    10191019            tr_torrentUseSpeedLimit( tor, TR_UP, boolVal );
    1020         if( tr_bencDictFindInt( args_in, "seedInactiveLimit", &tmp ) )
    1021             tr_torrentSetInactiveLimit( tor, tmp );
    1022         if( tr_bencDictFindInt( args_in, "seedInactiveMode", &tmp ) )
    1023             tr_torrentSetInactiveMode( tor, tmp );
     1020        if( tr_bencDictFindInt( args_in, "seedIdleLimit", &tmp ) )
     1021            tr_torrentSetIdleLimit( tor, tmp );
     1022        if( tr_bencDictFindInt( args_in, "seedIdleMode", &tmp ) )
     1023            tr_torrentSetIdleMode( tor, tmp );
    10241024        if( tr_bencDictFindReal( args_in, "seedRatioLimit", &d ) )
    10251025            tr_torrentSetRatioLimit( tor, d );
     
    14621462    if( tr_bencDictFindBool( args_in, "seedRatioLimited", &boolVal ) )
    14631463        tr_sessionSetRatioLimited( session, boolVal );
    1464     if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_INACTIVE_LIMIT, &i ) )
    1465         tr_sessionSetInactiveLimit( session, i );
    1466     if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_INACTIVE_LIMIT_ENABLED, &boolVal ) )
    1467         tr_sessionSetInactivityLimited( session, boolVal );
     1464    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_IDLE_LIMIT, &i ) )
     1465        tr_sessionSetIdleLimit( session, i );
     1466    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, &boolVal ) )
     1467        tr_sessionSetIdleLimited( session, boolVal );
    14681468    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_START, &boolVal ) )
    14691469        tr_sessionSetPaused( session, !boolVal );
     
    15801580    tr_bencDictAddReal( d, "seedRatioLimit", tr_sessionGetRatioLimit( s ) );
    15811581    tr_bencDictAddBool( d, "seedRatioLimited", tr_sessionIsRatioLimited( s ) );
    1582     tr_bencDictAddInt ( d, TR_PREFS_KEY_INACTIVE_LIMIT, tr_sessionGetInactiveLimit( s ) );
    1583     tr_bencDictAddBool( d, TR_PREFS_KEY_INACTIVE_LIMIT_ENABLED, tr_sessionIsInactivityLimited( s ) );
     1582    tr_bencDictAddInt ( d, TR_PREFS_KEY_IDLE_LIMIT, tr_sessionGetIdleLimit( s ) );
     1583    tr_bencDictAddBool( d, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, tr_sessionIsIdleLimited( s ) );
    15841584    tr_bencDictAddBool( d, TR_PREFS_KEY_START, !tr_sessionGetPaused( s ) );
    15851585    tr_bencDictAddBool( d, TR_PREFS_KEY_TRASH_ORIGINAL, tr_sessionGetDeleteSource( s ) );
  • trunk/libtransmission/session.c

    r11013 r11044  
    256256    tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED,           FALSE );
    257257    tr_bencDictAddInt ( d, TR_PREFS_KEY_ENCRYPTION,               TR_DEFAULT_ENCRYPTION );
    258     tr_bencDictAddReal( d, TR_PREFS_KEY_INACTIVE_LIMIT,           30 );
    259     tr_bencDictAddBool( d, TR_PREFS_KEY_INACTIVE_LIMIT_ENABLED,   FALSE );
     258    tr_bencDictAddInt ( d, TR_PREFS_KEY_IDLE_LIMIT,               30 );
     259    tr_bencDictAddBool( d, TR_PREFS_KEY_IDLE_LIMIT_ENABLED,       FALSE );
    260260    tr_bencDictAddStr ( d, TR_PREFS_KEY_INCOMPLETE_DIR,           tr_getDefaultDownloadDir( ) );
    261261    tr_bencDictAddBool( d, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED,   FALSE );
     
    324324    tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED,           tr_sessionIsSpeedLimited( s, TR_DOWN ) );
    325325    tr_bencDictAddInt ( d, TR_PREFS_KEY_ENCRYPTION,               s->encryptionMode );
    326     tr_bencDictAddInt(  d, TR_PREFS_KEY_INACTIVE_LIMIT,           s->inactiveLimitMinutes );
    327     tr_bencDictAddBool( d, TR_PREFS_KEY_INACTIVE_LIMIT_ENABLED,   s->isInactivityLimited );
     326    tr_bencDictAddInt ( d, TR_PREFS_KEY_IDLE_LIMIT,               tr_sessionGetIdleLimit( s ) );
     327    tr_bencDictAddBool( d, TR_PREFS_KEY_IDLE_LIMIT_ENABLED,       tr_sessionIsIdleLimited( s ) );
    328328    tr_bencDictAddStr ( d, TR_PREFS_KEY_INCOMPLETE_DIR,           tr_sessionGetIncompleteDir( s ) );
    329329    tr_bencDictAddBool( d, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED,   tr_sessionIsIncompleteDirEnabled( s ) );
     
    802802        tr_sessionSetRatioLimited( session, boolVal );
    803803
    804     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_INACTIVE_LIMIT, &i ) )
    805         tr_sessionSetInactiveLimit( session, i );
    806     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_INACTIVE_LIMIT_ENABLED, &boolVal ) )
    807         tr_sessionSetInactivityLimited( session, boolVal );
     804    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_IDLE_LIMIT, &i ) )
     805        tr_sessionSetIdleLimit( session, i );
     806    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, &boolVal ) )
     807        tr_sessionSetIdleLimited( session, boolVal );
    808808
    809809    /**
     
    11091109
    11101110void
    1111 tr_sessionSetInactivityLimited( tr_session * session, tr_bool isLimited )
    1112 {
    1113     assert( tr_isSession( session ) );
    1114 
    1115     session->isInactivityLimited = isLimited;
    1116 }
    1117 
    1118 void
    1119 tr_sessionSetInactiveLimit( tr_session * session, uint64_t inactivityMinutes )
    1120 {
    1121     assert( tr_isSession( session ) );
    1122 
    1123     session->inactiveLimitMinutes = inactivityMinutes;
    1124 }
    1125 
    1126 tr_bool
    1127 tr_sessionIsInactivityLimited( const tr_session  * session )
    1128 {
    1129     assert( tr_isSession( session ) );
    1130 
    1131     return session->isInactivityLimited;
    1132 }
    1133 
    1134 uint64_t
    1135 tr_sessionGetInactiveLimit( const tr_session * session )
    1136 {
    1137     assert( tr_isSession( session ) );
    1138 
    1139     return session->inactiveLimitMinutes;
     1111tr_sessionSetIdleLimited( tr_session * session, tr_bool isLimited )
     1112{
     1113    assert( tr_isSession( session ) );
     1114
     1115    session->isIdleLimited = isLimited;
     1116}
     1117
     1118void
     1119tr_sessionSetIdleLimit( tr_session * session, uint16_t inactivityMinutes )
     1120{
     1121    assert( tr_isSession( session ) );
     1122
     1123    session->idleLimitMinutes = inactivityMinutes;
     1124}
     1125
     1126tr_bool
     1127tr_sessionIsIdleLimited( const tr_session  * session )
     1128{
     1129    assert( tr_isSession( session ) );
     1130
     1131    return session->isIdleLimited;
     1132}
     1133
     1134uint16_t
     1135tr_sessionGetIdleLimit( const tr_session * session )
     1136{
     1137    assert( tr_isSession( session ) );
     1138
     1139    return session->idleLimitMinutes;
    11401140}
    11411141
  • trunk/libtransmission/session.h

    r11013 r11044  
    9696    tr_bool                      isIncompleteFileNamingEnabled;
    9797    tr_bool                      isRatioLimited;
    98     tr_bool                      isInactivityLimited;
     98    tr_bool                      isIdleLimited;
    9999    tr_bool                      isIncompleteDirEnabled;
    100100    tr_bool                      pauseAddedTorrent;
     
    187187    double                       desiredRatio;
    188188   
    189     uint64_t                     inactiveLimitMinutes;
     189    uint16_t                     idleLimitMinutes;
    190190
    191191    struct tr_bindinfo         * public_ipv4;
  • trunk/libtransmission/torrent.c

    r11041 r11044  
    329329
    330330void
    331 tr_torrentSetInactiveMode( tr_torrent *  tor, tr_inactivelimit mode )
    332 {
    333     assert( tr_isTorrent( tor ) );
    334     assert( mode==TR_INACTIVELIMIT_GLOBAL || mode==TR_INACTIVELIMIT_SINGLE || mode==TR_INACTIVELIMIT_UNLIMITED  );
    335 
    336     if( mode != tor->inactiveLimitMode )
    337     {
    338         tor->inactiveLimitMode = mode;
     331tr_torrentSetIdleMode( tr_torrent *  tor, tr_idlelimit mode )
     332{
     333    assert( tr_isTorrent( tor ) );
     334    assert( mode==TR_IDLELIMIT_GLOBAL || mode==TR_IDLELIMIT_SINGLE || mode==TR_IDLELIMIT_UNLIMITED  );
     335
     336    if( mode != tor->idleLimitMode )
     337    {
     338        tor->idleLimitMode = mode;
    339339
    340340        tr_torrentSetDirty( tor );
     
    342342}
    343343
    344 tr_inactivelimit
    345 tr_torrentGetInactiveMode( const tr_torrent * tor )
    346 {
    347     assert( tr_isTorrent( tor ) );
    348 
    349     return tor->inactiveLimitMode;
    350 }
    351 
    352 void
    353 tr_torrentSetInactiveLimit( tr_torrent * tor, uint64_t inactiveMinutes)
    354 {
    355     assert( tr_isTorrent( tor ) );
    356 
    357     if( inactiveMinutes > 0 )
    358     {
    359         tor->inactiveLimitMinutes = inactiveMinutes;
     344tr_idlelimit
     345tr_torrentGetIdleMode( const tr_torrent * tor )
     346{
     347    assert( tr_isTorrent( tor ) );
     348
     349    return tor->idleLimitMode;
     350}
     351
     352void
     353tr_torrentSetIdleLimit( tr_torrent * tor, uint16_t idleMinutes )
     354{
     355    assert( tr_isTorrent( tor ) );
     356
     357    if( idleMinutes > 0 )
     358    {
     359        tor->idleLimitMinutes = idleMinutes;
    360360
    361361        tr_torrentSetDirty( tor );
     
    363363}
    364364
    365 uint64_t
    366 tr_torrentGetInactiveLimit( const tr_torrent * tor )
    367 {
    368     assert( tr_isTorrent( tor ) );
    369 
    370     return tor->inactiveLimitMinutes;
     365uint16_t
     366tr_torrentGetIdleLimit( const tr_torrent * tor )
     367{
     368    assert( tr_isTorrent( tor ) );
     369
     370    return tor->idleLimitMinutes;
    371371}
    372372
    373373tr_bool
    374 tr_torrentGetSeedInactive( const tr_torrent * tor, uint64_t * inactiveMinutes )
     374tr_torrentGetSeedIdle( const tr_torrent * tor, uint16_t * idleMinutes )
    375375{
    376376    tr_bool isLimited;
    377377
    378     switch( tr_torrentGetInactiveMode( tor ) )
    379     {
    380         case TR_INACTIVELIMIT_SINGLE:
     378    switch( tr_torrentGetIdleMode( tor ) )
     379    {
     380        case TR_IDLELIMIT_SINGLE:
    381381            isLimited = TRUE;
    382             if( inactiveMinutes )
    383                 *inactiveMinutes = tr_torrentGetInactiveLimit( tor );
     382            if( idleMinutes )
     383                *idleMinutes = tr_torrentGetIdleLimit( tor );
    384384            break;
    385385
    386         case TR_INACTIVELIMIT_GLOBAL:
    387             isLimited = tr_sessionIsInactivityLimited( tor->session );
    388             if( isLimited && inactiveMinutes )
    389                 *inactiveMinutes = tr_sessionGetInactiveLimit( tor->session );
     386        case TR_IDLELIMIT_GLOBAL:
     387            isLimited = tr_sessionIsIdleLimited( tor->session );
     388            if( isLimited && idleMinutes )
     389                *idleMinutes = tr_sessionGetIdleLimit( tor->session );
    390390            break;
    391391
    392         default: /* TR_INACTIVELIMIT_UNLIMITED */
     392        default: /* TR_IDLELIMIT_UNLIMITED */
    393393            isLimited = FALSE;
    394394            break;
     
    399399
    400400static tr_bool
    401 tr_torrentIsSeedInactiveLimitDone( tr_torrent * tor )
    402 {
    403     uint64_t inactiveMinutes;
     401tr_torrentIsSeedIdleLimitDone( tr_torrent * tor )
     402{
     403    uint16_t idleMinutes;
    404404#warning can this use the idleSecs from tr_stat?
    405     return tr_torrentGetSeedInactive( tor, &inactiveMinutes )
    406         && difftime(tr_time(), MAX(tor->startDate, tor->activityDate)) >= inactiveMinutes * 60;
     405    return tr_torrentGetSeedIdle( tor, &idleMinutes )
     406        && difftime(tr_time(), MAX(tor->startDate, tor->activityDate)) >= idleMinutes * 60u;
    407407}
    408408
     
    431431    }
    432432    /* if we're seeding and reach our inactiviy limit, stop the torrent */
    433     else if( tr_torrentIsSeedInactiveLimitDone( tor ) )
     433    else if( tr_torrentIsSeedIdleLimitDone( tor ) )
    434434    {
    435435        tr_torinf( tor, "Seeding inactivity limit reached; pausing torrent" );
     
    438438
    439439        /* maybe notify the client */
    440         if( tor->inactive_limit_hit_func != NULL )
    441             tor->inactive_limit_hit_func( tor, tor->inactive_limit_hit_func_user_data );
     440        if( tor->idle_limit_hit_func != NULL )
     441            tor->idle_limit_hit_func( tor, tor->idle_limit_hit_func_user_data );
    442442    }
    443443}
     
    809809    }
    810810
    811     if( !( loaded & TR_FR_INACTIVELIMIT ) )
    812     {
    813         tr_torrentSetInactiveMode( tor, TR_INACTIVELIMIT_GLOBAL );
    814         tr_torrentSetInactiveLimit( tor, tr_sessionGetInactiveLimit( tor->session ) );
     811    if( !( loaded & TR_FR_IDLELIMIT ) )
     812    {
     813        tr_torrentSetIdleMode( tor, TR_IDLELIMIT_GLOBAL );
     814        tr_torrentSetIdleLimit( tor, tr_sessionGetIdleLimit( tor->session ) );
    815815    }
    816816
     
    17831783}
    17841784
    1785 void
    1786 tr_torrentSetInactiveLimitHitCallback( tr_torrent                        * tor,
    1787                                        tr_torrent_inactive_limit_hit_func  func,
    1788                                        void                              * user_data )
    1789 {
    1790     assert( tr_isTorrent( tor ) );
    1791 
    1792     tor->inactive_limit_hit_func = func;
    1793     tor->inactive_limit_hit_func_user_data = user_data;
    1794 }
    1795 
    1796 void
    1797 tr_torrentClearInactiveLimitHitCallback( tr_torrent * torrent )
    1798 {
    1799     tr_torrentSetInactiveLimitHitCallback( torrent, NULL, NULL );
     1785static void
     1786tr_torrentSetIdleLimitHitCallback( tr_torrent                    * tor,
     1787                                   tr_torrent_idle_limit_hit_func  func,
     1788                                   void                          * user_data )
     1789{
     1790    assert( tr_isTorrent( tor ) );
     1791
     1792    tor->idle_limit_hit_func = func;
     1793    tor->idle_limit_hit_func_user_data = user_data;
     1794}
     1795
     1796void
     1797tr_torrentClearIdleLimitHitCallback( tr_torrent * torrent )
     1798{
     1799    tr_torrentSetIdleLimitHitCallback( torrent, NULL, NULL );
    18001800}
    18011801
  • trunk/libtransmission/torrent.h

    r11039 r11044  
    230230    void                             * ratio_limit_hit_func_user_data;
    231231
    232     tr_torrent_inactive_limit_hit_func  * inactive_limit_hit_func;
    233     void                                * inactive_limit_hit_func_user_data;
     232    tr_torrent_idle_limit_hit_func  * idle_limit_hit_func;
     233    void                            * idle_limit_hit_func_user_data;
    234234
    235235    tr_bool                    isRunning;
     
    259259    tr_ratiolimit              ratioLimitMode;
    260260
    261     uint64_t                   inactiveLimitMinutes;
    262     tr_inactivelimit           inactiveLimitMode;
     261    uint16_t                   idleLimitMinutes;
     262    tr_idlelimit               idleLimitMode;
    263263
    264264    uint64_t                   preVerifyTotal;
  • trunk/libtransmission/transmission.h

    r11039 r11044  
    171171#define TR_PREFS_KEY_DOWNLOAD_DIR                  "download-dir"
    172172#define TR_PREFS_KEY_ENCRYPTION                    "encryption"
    173 #define TR_PREFS_KEY_INACTIVE_LIMIT                "inactive-seeding-limit"
    174 #define TR_PREFS_KEY_INACTIVE_LIMIT_ENABLED        "inactive-seeding-limit-enabled"
     173#define TR_PREFS_KEY_IDLE_LIMIT                    "idle-seeding-limit"
     174#define TR_PREFS_KEY_IDLE_LIMIT_ENABLED            "idle-seeding-limit-enabled"
    175175#define TR_PREFS_KEY_INCOMPLETE_DIR                "incomplete-dir"
    176176#define TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED        "incomplete-dir-enabled"
     
    726726double     tr_sessionGetRatioLimit    ( const tr_session * );
    727727
    728 void       tr_sessionSetInactivityLimited  ( tr_session *, tr_bool isLimited );
    729 tr_bool    tr_sessionIsInactivityLimited   ( const tr_session * );
    730 
    731 void       tr_sessionSetInactiveLimit      ( tr_session *, uint64_t inactivityMinutes );
    732 uint64_t   tr_sessionGetInactiveLimit      ( const tr_session * );
     728void       tr_sessionSetIdleLimited  ( tr_session *, tr_bool isLimited );
     729tr_bool    tr_sessionIsIdleLimited   ( const tr_session * );
     730
     731void       tr_sessionSetIdleLimit ( tr_session *, uint16_t idleMinutes );
     732uint16_t   tr_sessionGetIdleLimit ( const tr_session * );
    733733
    734734void       tr_sessionSetPeerLimit( tr_session *, uint16_t maxGlobalPeers );
     
    11701170
    11711171/****
    1172 *****  Inactive Time Limits
     1172*****  Idle Time Limits
    11731173****/
    11741174
    11751175typedef enum
    11761176{
    1177     TR_INACTIVELIMIT_GLOBAL    = 0, /* follow the global settings */
    1178     TR_INACTIVELIMIT_SINGLE    = 1, /* override the global settings, seeding until a certain inactive time */
    1179     TR_INACTIVELIMIT_UNLIMITED = 2  /* override the global settings, seeding regardless of activity */
    1180 }
    1181 tr_inactivelimit;
    1182 
    1183 void             tr_torrentSetInactiveMode( tr_torrent         * tor,
    1184                                             tr_inactivelimit      mode );
    1185 
    1186 tr_inactivelimit tr_torrentGetInactiveMode( const tr_torrent   * tor );
    1187 
    1188 void             tr_torrentSetInactiveLimit( tr_torrent        * tor,
    1189                                           uint64_t            inactiveMinutes );
    1190 
    1191 uint64_t         tr_torrentGetInactiveLimit( const tr_torrent  * tor );
    1192 
    1193 
    1194 tr_bool          tr_torrentGetSeedInactive( const tr_torrent *, uint64_t * inactiveMinutes );
     1177    TR_IDLELIMIT_GLOBAL    = 0, /* follow the global settings */
     1178    TR_IDLELIMIT_SINGLE    = 1, /* override the global settings, seeding until a certain idle time */
     1179    TR_IDLELIMIT_UNLIMITED = 2  /* override the global settings, seeding regardless of activity */
     1180}
     1181tr_idlelimit;
     1182
     1183void          tr_torrentSetIdleMode ( tr_torrent         * tor,
     1184                                      tr_idlelimit         mode );
     1185
     1186tr_idlelimit  tr_torrentGetIdleMode ( const tr_torrent   * tor );
     1187
     1188void          tr_torrentSetIdleLimit( tr_torrent         * tor,
     1189                                      uint16_t             idleMinutes );
     1190
     1191uint16_t      tr_torrentGetIdleLimit( const tr_torrent   * tor );
     1192
     1193
     1194tr_bool       tr_torrentGetSeedIdle( const tr_torrent *, uint16_t * idleMinutes );
    11951195
    11961196/****
     
    13231323                                                  void         * user_data );
    13241324
    1325 typedef void ( tr_torrent_inactive_limit_hit_func )( tr_torrent   * torrent,
    1326                                                     void         * user_data );
     1325typedef void ( tr_torrent_idle_limit_hit_func )( tr_torrent   * torrent,
     1326                                                 void         * user_data );
    13271327
    13281328
     
    13851385void tr_torrentSetInactivityLimitHitCallback(
    13861386     tr_torrent                          * torrent,
    1387      tr_torrent_inactive_limit_hit_func  func,
     1387     tr_torrent_idle_limit_hit_func        func,
    13881388     void                                * user_data );
    13891389
    1390 void tr_torrentClearInactiveLimitHitCallback( tr_torrent * torrent );
     1390void tr_torrentClearIdleLimitHitCallback( tr_torrent * torrent );
    13911391
    13921392
  • trunk/qt/details.cc

    r10957 r11044  
    12301230
    12311231    hig->addSectionDivider( );
    1232     hig->addSectionTitle( tr( "Seed-Until Ratio" ) );
     1232    hig->addSectionTitle( tr( "Seeding Limits" ) );
    12331233
    12341234    r = new QRadioButton( tr( "Use &global settings" ) );
  • trunk/qt/prefs-dialog.cc

    r10957 r11044  
    596596
    597597    hig->addSectionDivider( );
    598     hig->addSectionTitle( tr( "Seeding" ) );
    599 
    600         l = checkBoxNew( tr( "&Seed torrent until its ratio reaches:" ), Prefs::RATIO_ENABLED );
     598    hig->addSectionTitle( tr( "Seeding Limits" ) );
     599
     600        l = checkBoxNew( tr( "Stop seeding at &ratio:" ), Prefs::RATIO_ENABLED );
    601601        r = doubleSpinBoxNew( Prefs::RATIO, 0, INT_MAX, 0.5, 2 );
     602        hig->addRow( l, r );
     603        enableBuddyWhenChecked( qobject_cast<QCheckBox*>(l), r );
     604
     605        l = checkBoxNew( tr( "Stop seeding if idle for &N minutes:" ), Prefs::IDLE_LIMIT_ENABLED );
     606        r = spinBoxNew( Prefs::IDLE_LIMIT, 1, INT_MAX, 5 );
    602607        hig->addRow( l, r );
    603608        enableBuddyWhenChecked( qobject_cast<QCheckBox*>(l), r );
  • trunk/qt/prefs.cc

    r10937 r11044  
    7777    { DOWNLOAD_DIR, TR_PREFS_KEY_DOWNLOAD_DIR, QVariant::String },
    7878    { ENCRYPTION, TR_PREFS_KEY_ENCRYPTION, QVariant::Int },
     79    { IDLE_LIMIT, TR_PREFS_KEY_IDLE_LIMIT, QVariant::Int },
     80    { IDLE_LIMIT_ENABLED, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, QVariant::Bool },
    7981    { INCOMPLETE_DIR, TR_PREFS_KEY_INCOMPLETE_DIR, QVariant::String },
    8082    { INCOMPLETE_DIR_ENABLED, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, QVariant::Bool },
  • trunk/qt/prefs.h

    r10908 r11044  
    8181            DOWNLOAD_DIR,
    8282            ENCRYPTION,
     83            IDLE_LIMIT,
     84            IDLE_LIMIT_ENABLED,
    8385            INCOMPLETE_DIR,
    8486            INCOMPLETE_DIR_ENABLED,
  • trunk/qt/session.cc

    r10908 r11044  
    145145        case Prefs :: DSPEED:
    146146        case Prefs :: DSPEED_ENABLED:
     147        case Prefs :: IDLE_LIMIT:
     148        case Prefs :: IDLE_LIMIT_ENABLED:
    147149        case Prefs :: INCOMPLETE_DIR:
    148150        case Prefs :: INCOMPLETE_DIR_ENABLED:
Note: See TracChangeset for help on using the changeset viewer.