Ticket #1788: gtk-ratiolimit.patch

File gtk-ratiolimit.patch, 9.8 KB (added by JasonBorden, 13 years ago)

GTK+ seeding ratio limiting support

  • gtk/conf.c

    diff -ruN Transmission/gtk/conf.c Transmission-jb/gtk/conf.c
    old new  
    200200        pref_int_set( key, value );
    201201}
    202202
     203double
     204pref_double_get( const char * key )
     205{
     206    double d = 0.0;
     207
     208    tr_bencDictFindDouble( getPrefs( ), key, &d );
     209    return d;
     210}
     211
     212void
     213pref_double_set( const char * key,
     214                 double       value )
     215{
     216    tr_bencDictAddDouble( getPrefs( ), key, value );
     217}
     218
     219void
     220pref_double_set_default( const char * key,
     221                         double       value )
     222{
     223    if ( !tr_bencDictFind( getPrefs( ), key ) )
     224         pref_double_set( key, value );
     225}
     226
    203227/***
    204228****
    205229***/
  • gtk/conf.h

    diff -ruN Transmission/gtk/conf.h Transmission-jb/gtk/conf.h
    old new  
    3232void             pref_int_set           ( const char * key, int64_t value );
    3333void             pref_int_set_default   ( const char * key, int64_t value );
    3434
     35double           pref_double_get        ( const char * key );
     36void             pref_double_set        ( const char * key, double value );
     37void             pref_double_set_default( const char * key, double value );
     38
    3539gboolean         pref_flag_get          ( const char * key );
    3640void             pref_flag_set          ( const char * key, gboolean value );
    3741void             pref_flag_set_default  ( const char * key, gboolean value );
  • gtk/details.c

    diff -ruN Transmission/gtk/details.c Transmission-jb/gtk/details.c
    old new  
    11711171}
    11721172
    11731173static void
     1174ratio_toggled_cb( GtkToggleButton *tb,
     1175                  gpointer         gtor )
     1176{
     1177    tr_torrent * tor = tr_torrent_handle( gtor );
     1178   
     1179    tr_torrentSetRatioLimited( tor, gtk_toggle_button_get_active( tb ) );
     1180}
     1181
     1182static void
    11741183sensitize_from_check_cb( GtkToggleButton *toggle,
    11751184                         gpointer         w )
    11761185{
     
    11901199}
    11911200
    11921201static void
     1202setRatioLimit( GtkSpinButton* spin,
     1203               gpointer       gtor )
     1204{
     1205    tr_torrent * tor = tr_torrent_handle ( gtor );
     1206    float        ratio = gtk_spin_button_get_value ( spin );
     1207
     1208    tr_torrentSetRatioLimit( tor, ratio );
     1209}
     1210
     1211static void
    11931212ul_speed_spun_cb( GtkSpinButton *spin,
    11941213                  gpointer       gtor )
    11951214{
     
    12041223}
    12051224
    12061225static void
     1226ratio_spun_cb( GtkSpinButton *spin,
     1227               gpointer       gtor )
     1228{
     1229    setRatioLimit( spin, gtor );
     1230}
     1231
     1232static void
    12071233max_peers_spun_cb( GtkSpinButton * spin,
    12081234                   gpointer        gtor )
    12091235{
     
    12171243{
    12181244    uint16_t     maxConnectedPeers;
    12191245    int          i, row;
     1246    double       d;
    12201247    gboolean     b;
    12211248    GtkWidget *  t, *w, *tb;
    12221249    tr_torrent * tor = tr_torrent_handle ( gtor );
     
    12631290    sensitize_from_check_cb ( GTK_TOGGLE_BUTTON( tb ), w );
    12641291    hig_workarea_add_row_w ( t, &row, tb, w, NULL );
    12651292
     1293    tb =
     1294        gtk_check_button_new_with_mnemonic( _(
     1295                                               "Limit seeding _ratio:" ) );
     1296   
     1297    b = tr_torrentIsRatioLimited( tor );
     1298    gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON( tb ), b );
     1299    g_signal_connect ( tb, "toggled", G_CALLBACK(
     1300                           ratio_toggled_cb ), gtor );
     1301
     1302    d = tr_torrentGetRatioLimit( tor );
     1303    w = gtk_spin_button_new_with_range( 0.5, INT_MAX, .05 );
     1304    gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 2);
     1305    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), d );
     1306
     1307    g_signal_connect ( w, "value-changed", G_CALLBACK(
     1308                          ratio_spun_cb ), gtor );
     1309    g_signal_connect ( tb, "toggled", G_CALLBACK(
     1310                          sensitize_from_check_cb ), w );
     1311    sensitize_from_check_cb ( GTK_TOGGLE_BUTTON( tb ), w );
     1312    hig_workarea_add_row_w ( t, &row, tb, w, NULL );
     1313
    12661314    hig_workarea_add_section_divider ( t, &row );
    12671315    hig_workarea_add_section_title ( t, &row, _( "Peer Connections" ) );
    12681316
  • gtk/main.c

    diff -ruN Transmission/gtk/main.c Transmission-jb/gtk/main.c
    old new  
    10821082        const int limit = pref_int_get( key );
    10831083        tr_sessionSetSpeedLimit( tr, TR_UP, limit );
    10841084    }
     1085    else if( !strcmp( key, TR_PREFS_KEY_RATIO_ENABLED ) )
     1086    {
     1087        const gboolean b = pref_flag_get( key );
     1088        tr_sessionSetRatioLimited( tr, b );
     1089    }
     1090    else if( !strcmp( key, TR_PREFS_KEY_RATIO ) )
     1091    {
     1092        const double limit = pref_double_get( key );
     1093        tr_sessionSetRatioLimit( tr, limit );
     1094    }
    10851095    else if( !strncmp( key, "sched-", 6 ) )
    10861096    {
    10871097        updateScheduledLimits( tr );
  • gtk/tr-core.c

    diff -ruN Transmission/gtk/tr-core.c Transmission-jb/gtk/tr-core.c
    old new  
    12701270    }
    12711271}
    12721272
     1273void
     1274tr_core_set_pref_double( TrCore *     self,
     1275                         const char * key,
     1276                         double       newval )
     1277{
     1278    const double oldval = pref_double_get( key );
     1279
     1280    if( oldval != newval )
     1281    {
     1282        pref_double_set( key, newval );
     1283        commitPrefsChange( self, key );
     1284    }
     1285}
     1286
  • gtk/tr-core.h

    diff -ruN Transmission/gtk/tr-core.h Transmission-jb/gtk/tr-core.h
    old new  
    204204                               const char * key,
    205205                               int          val );
    206206
     207/* Set a double preference value, save the prefs file, and emit the
     208   "prefs-changed" signal */
     209void     tr_core_set_pref_double( TrCore *     self,
     210                                  const char * key,
     211                                  double       val );
    207212
    208213/**
    209214***
  • gtk/tr-prefs.c

    diff -ruN Transmission/gtk/tr-prefs.c Transmission-jb/gtk/tr-prefs.c
    old new  
    145145{
    146146    gpointer    core;
    147147    GTimer *    last_change;
     148    gboolean    isDouble;
    148149};
    149150
    150151static void
     
    168169    {
    169170        /* update the core */
    170171        const char * key = g_object_get_data( o, PREF_KEY );
    171         const int    value = gtk_spin_button_get_value_as_int(
    172              GTK_SPIN_BUTTON( spin ) );
    173         tr_core_set_pref_int( TR_CORE( data->core ), key, value );
     172        if (data->isDouble)
     173        {
     174            const double value = gtk_spin_button_get_value( GTK_SPIN_BUTTON( spin ) );
     175            tr_core_set_pref_double( TR_CORE( data->core ), key, value );
     176        }
     177        else
     178        {
     179            const int    value = gtk_spin_button_get_value_as_int(
     180                                 GTK_SPIN_BUTTON( spin ) );
     181            tr_core_set_pref_int( TR_CORE( data->core ), key, value );
     182        }
    174183
    175184        /* cleanup */
    176185        g_object_set_data( o, IDLE_DATA, NULL );
     
    183192
    184193static void
    185194spun_cb( GtkSpinButton * w,
    186          gpointer        core )
     195         gpointer        core,
     196         gboolean        isDouble )
    187197{
    188198    /* user may be spinning through many values, so let's hold off
    189199       for a moment to keep from flooding the core with changes */
     
    195205        data = g_new( struct spin_idle_data, 1 );
    196206        data->core = core;
    197207        data->last_change = g_timer_new( );
     208        data->isDouble = isDouble;
    198209        g_object_set_data_full( o, IDLE_DATA, data, spin_idle_data_free );
    199210        g_object_ref( G_OBJECT( o ) );
    200211        g_timeout_add( 100, spun_cb_idle, w );
     
    202213    g_timer_start( data->last_change );
    203214}
    204215
     216static void
     217spun_cb_int( GtkSpinButton * w,
     218             gpointer        core )
     219{
     220    spun_cb( w, core, FALSE );
     221}
     222
     223static void
     224spun_cb_double( GtkSpinButton * w,
     225                gpointer        core )
     226{
     227    spun_cb( w, core, TRUE );
     228}
     229
    205230static GtkWidget*
    206231new_spin_button( const char * key,
    207232                 gpointer     core,
     
    215240                                key ), g_free );
    216241    gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 0 );
    217242    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), pref_int_get( key ) );
    218     g_signal_connect( w, "value-changed", G_CALLBACK( spun_cb ), core );
     243    g_signal_connect( w, "value-changed", G_CALLBACK( spun_cb_int ), core );
     244    return w;
     245}
     246
     247static GtkWidget*
     248new_spin_button_double( const char * key,
     249                       gpointer      core,
     250                       double        low,
     251                       double        high,
     252                       double        step )
     253{
     254    GtkWidget * w = gtk_spin_button_new_with_range( low, high, step );
     255
     256    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup(
     257                                key ), g_free );
     258    gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 2 );
     259    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), pref_double_get( key ) );
     260    g_signal_connect( w, "value-changed", G_CALLBACK( spun_cb_double ), core );
    219261    return w;
    220262}
    221263
     
    11201162    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
    11211163    hig_workarea_add_row_w( t, &row, w, w2, NULL );
    11221164
     1165    s = _( "Default seeding _ratio limit:" );
     1166    w = new_check_button( s, TR_PREFS_KEY_RATIO_ENABLED, core );
     1167    w2 = new_spin_button_double( TR_PREFS_KEY_RATIO, core, .5, INT_MAX, .05 );
     1168    gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED ) );
     1169    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
     1170    hig_workarea_add_row_w( t, &row, w, w2, NULL );
     1171
    11231172    hig_workarea_add_section_divider( t, &row );
    11241173    hig_workarea_add_section_title( t, &row, _( "Scheduled Limits" ) );
    11251174