Changeset 10931


Ignore:
Timestamp:
Jul 3, 2010, 12:25:22 AM (12 years ago)
Author:
charles
Message:

(trunk) #3045 "make libtransmission's API byte-oriented instead of KiB-oriented." -- implemented. This is a largish commit and will break the mac build for a little while.

Location:
trunk
Files:
2 added
55 edited

Legend:

Unmodified
Added
Removed
  • trunk/cli/cli.c

    r10783 r10931  
    3636#include <libtransmission/web.h> /* tr_webRun */
    3737
     38/***
     39****
     40***/
     41
     42#define MEM_K 1024
     43#define MEM_B_STR "B"
     44#define MEM_K_STR "KiB"
     45#define MEM_M_STR "MiB"
     46#define MEM_G_STR "GiB"
     47
     48#define DISK_K 1000
     49#define DISK_B_STR "B"
     50#define DISK_K_STR "kB"
     51#define DISK_M_STR "MB"
     52#define DISK_G_STR "GB"
     53
     54#define SPEED_K 1000
     55#define SPEED_B_STR "B/s"
     56#define SPEED_K_STR "kB/s"
     57#define SPEED_M_STR "MB/s"
     58#define SPEED_G_STR "GB/s"
     59
     60/***
     61****
     62***/
     63
    3864#define LINEWIDTH 80
    3965#define MY_NAME "transmissioncli"
    4066
    41 static tr_bool verify           = 0;
     67static tr_bool verify                = 0;
    4268static sig_atomic_t gotsig           = 0;
    4369static sig_atomic_t manualUpdate     = 0;
     
    4773static const struct tr_option options[] =
    4874{
    49     { 'b', "blocklist",            "Enable peer blocklists", "b",  0, NULL        },
    50     { 'B', "no-blocklist",         "Disable peer blocklists", "B",  0, NULL        },
    51     { 'd', "downlimit",            "Set max download speed in KiB/s", "d",  1, "<speed>"  },
    52     { 'D', "no-downlimit",         "Don't limit the download speed", "D",  0, NULL        },
    53     { 910, "encryption-required",  "Encrypt all peer connections", "er", 0, NULL        },
    54     { 911, "encryption-preferred", "Prefer encrypted peer connections", "ep", 0, NULL        },
    55     { 912, "encryption-tolerated", "Prefer unencrypted peer connections", "et", 0, NULL        },
     75    { 'b', "blocklist",            "Enable peer blocklists", "b",  0, NULL },
     76    { 'B', "no-blocklist",         "Disable peer blocklists", "B",  0, NULL },
     77    { 'd', "downlimit",            "Set max download speed in "SPEED_K_STR, "d",  1, "<speed>" },
     78    { 'D', "no-downlimit",         "Don't limit the download speed", "D",  0, NULL },
     79    { 910, "encryption-required",  "Encrypt all peer connections", "er", 0, NULL },
     80    { 911, "encryption-preferred", "Prefer encrypted peer connections", "ep", 0, NULL },
     81    { 912, "encryption-tolerated", "Prefer unencrypted peer connections", "et", 0, NULL },
    5682    { 'f', "finish",               "Run a script when the torrent finishes", "f", 1, "<script>" },
    5783    { 'g', "config-dir",           "Where to find configuration files", "g", 1, "<path>" },
    58     { 'm', "portmap",              "Enable portmapping via NAT-PMP or UPnP", "m",  0, NULL        },
    59     { 'M', "no-portmap",           "Disable portmapping", "M",  0, NULL        },
     84    { 'm', "portmap",              "Enable portmapping via NAT-PMP or UPnP", "m",  0, NULL },
     85    { 'M', "no-portmap",           "Disable portmapping", "M",  0, NULL },
    6086    { 'p', "port", "Port for incoming peers (Default: " TR_DEFAULT_PEER_PORT_STR ")", "p", 1, "<port>" },
    6187    { 't', "tos", "Peer socket TOS (0 to 255, default=" TR_DEFAULT_PEER_SOCKET_TOS_STR ")", "t", 1, "<tos>" },
    62     { 'u', "uplimit",              "Set max upload speed in KiB/s", "u",  1, "<speed>"   },
     88    { 'u', "uplimit",              "Set max upload speed in "SPEED_K_STR, "u",  1, "<speed>"   },
    6389    { 'U', "no-uplimit",           "Don't limit the upload speed", "U",  0, NULL        },
    6490    { 'v', "verify",               "Verify the specified torrent", "v",  0, NULL        },
     
    128154    else if( st->activity & TR_STATUS_DOWNLOAD )
    129155    {
     156        char upStr[80];
     157        char dnStr[80];
    130158        char ratioStr[80];
     159
     160        tr_formatter_speed( upStr, st->pieceUploadSpeed_Bps, sizeof( upStr ) );
     161        tr_formatter_speed( dnStr, st->pieceDownloadSpeed_Bps, sizeof( dnStr ) );
    131162        tr_strlratio( ratioStr, st->ratio, sizeof( ratioStr ) );
    132         tr_snprintf(
    133             buf, buflen,
    134             "Progress: %.1f%%, dl from %d of %d peers (%.0f KiB/s), "
    135             "ul to %d (%.0f KiB/s) [%s]",
     163
     164        tr_snprintf( buf, buflen,
     165            "Progress: %.1f%%, "
     166            "dl from %d of %d peers (%s), "
     167            "ul to %d (%s) "
     168            "[%s]",
    136169            tr_truncd( 100 * st->percentDone, 1 ),
    137             st->peersSendingToUs,
    138             st->peersConnected,
    139             st->pieceDownloadSpeed,
    140             st->peersGettingFromUs,
    141             st->pieceUploadSpeed,
     170            st->peersSendingToUs, st->peersConnected, upStr,
     171            st->peersGettingFromUs, dnStr,
    142172            ratioStr );
    143173    }
    144174    else if( st->activity & TR_STATUS_SEED )
    145175    {
     176        char upStr[80];
    146177        char ratioStr[80];
     178
     179        tr_formatter_speed( upStr, st->pieceUploadSpeed_Bps, sizeof( upStr ) );
    147180        tr_strlratio( ratioStr, st->ratio, sizeof( ratioStr ) );
    148         tr_snprintf(
    149             buf, buflen,
    150             "Seeding, uploading to %d of %d peer(s), %.0f KiB/s [%s]",
    151             st->peersGettingFromUs, st->peersConnected,
    152             st->pieceUploadSpeed, ratioStr );
     181
     182        tr_snprintf( buf, buflen,
     183                     "Seeding, uploading to %d of %d peer(s), %s [%s]",
     184                     st->peersGettingFromUs, st->peersConnected, upStr, ratioStr );
    153185    }
    154186    else *buf = '\0';
     
    179211
    180212int
    181 main( int     argc,
    182       char ** argv )
     213main( int argc, char ** argv )
    183214{
    184215    int           error;
     
    190221    uint8_t     * fileContents;
    191222    size_t        fileLength;
     223
     224    tr_formatter_mem_init( MEM_K, MEM_B_STR, MEM_K_STR, MEM_M_STR, MEM_G_STR );
     225    tr_formatter_size_init( DISK_K,DISK_B_STR, DISK_K_STR, DISK_M_STR, DISK_G_STR );
     226    tr_formatter_speed_init( SPEED_K, SPEED_B_STR, SPEED_K_STR, SPEED_M_STR, SPEED_G_STR );
    192227
    193228    printf( "Transmission %s - http://www.transmissionbt.com/\n",
     
    324359            case 'B': tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, FALSE );
    325360                      break;
    326             case 'd': tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED, atoi( optarg ) );
     361            case 'd': tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED_Bps, atoi( optarg ) * SPEED_K );
    327362                      tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, TRUE );
    328363                      break;
     
    342377            case 't': tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS, atoi( optarg ) );
    343378                      break;
    344             case 'u': tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED, atoi( optarg ) );
     379            case 'u': tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_Bps, atoi( optarg ) * SPEED_K );
    345380                      tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, TRUE );
    346381                      break;
  • trunk/daemon/remote.c

    r10907 r10931  
    4444#define ARGUMENTS "arguments"
    4545
     46#define MEM_K 1024
     47#define MEM_B_STR "B"
     48#define MEM_K_STR "KiB"
     49#define MEM_M_STR "MiB"
     50#define MEM_G_STR "GiB"
     51
     52#define DISK_K 1000
     53#define DISK_B_STR "B"
     54#define DISK_K_STR "kB"
     55#define DISK_M_STR "MB"
     56#define DISK_G_STR "GB"
     57
     58#define SPEED_K 1000
     59#define SPEED_B_STR "B/s"
     60#define SPEED_K_STR "kB/s"
     61#define SPEED_M_STR "MB/s"
     62#define SPEED_G_STR "GB/s"
     63
    4664/***
    4765****
     
    110128}
    111129
    112 static const double KiB = 1024.0;
    113 static const double MiB = 1024.0 * 1024.0;
    114 static const double GiB = 1024.0 * 1024.0 * 1024.0;
    115 
    116130static char*
    117131strlpercent( char * buf, double x, size_t buflen )
     
    142156
    143157static char*
     158strlmem( char * buf, int64_t bytes, size_t buflen )
     159{
     160    if( !bytes )
     161        tr_strlcpy( buf, "None", buflen );
     162    else
     163        tr_formatter_mem( buf, bytes, buflen );
     164
     165    return buf;
     166}
     167
     168static char*
    144169strlsize( char * buf, int64_t bytes, size_t buflen )
    145170{
    146171    if( !bytes )
    147         tr_strlcpy( buf, _( "None" ), buflen );
     172        tr_strlcpy( buf, "None", buflen );
    148173    else
    149174        tr_formatter_size( buf, bytes, buflen );
     
    156181{
    157182    if( !bytes_per_second )
    158         tr_strlcpy( buf, _( "None" ), buflen );
     183        tr_strlcpy( buf, "None", buflen );
    159184    else
    160185        tr_formatter_speed( buf, bytes_per_second, buflen );
     
    194219    { 970, "alt-speed",              "Use the alternate Limits", "as",  0, NULL },
    195220    { 971, "no-alt-speed",           "Don't use the alternate Limits", "AS",  0, NULL },
    196     { 972, "alt-speed-downlimit",    "max alternate download speed (in KiB/s)", "asd",  1, "<speed>" },
    197     { 973, "alt-speed-uplimit",      "max alternate upload speed (in KiB/s)", "asu",  1, "<speed>" },
     221    { 972, "alt-speed-downlimit",    "max alternate download speed (in "SPEED_K_STR")", "asd",  1, "<speed>" },
     222    { 973, "alt-speed-uplimit",      "max alternate upload speed (in "SPEED_K_STR")", "asu",  1, "<speed>" },
    198223    { 974, "alt-speed-scheduler",    "Use the scheduled on/off times", "asc",  0, NULL },
    199224    { 975, "no-alt-speed-scheduler", "Don't use the scheduled on/off times", "ASC",  0, NULL },
     
    205230    { 'C', "no-incomplete-dir",      "Don't store incomplete torrents in a different location", "C", 0, NULL },
    206231    { 'b', "debug",                  "Print debugging information", "b",  0, NULL },
    207     { 'd', "downlimit",              "Set the max download speed in KiB/s for the current torrent(s) or globally", "d", 1, "<speed>" },
     232    { 'd', "downlimit",              "Set the max download speed in "SPEED_K_STR" for the current torrent(s) or globally", "d", 1, "<speed>" },
    208233    { 'D', "no-downlimit",           "Disable max download speed for the current torrent(s) or globally", "D", 0, NULL },
    209     { 'e', "cache",                  "Set the maximum size of the session's memory cache (in MiB)", "e", 1, "<size>" },
     234    { 'e', "cache",                  "Set the maximum size of the session's memory cache (in " MEM_M_STR ")", "e", 1, "<size>" },
    210235    { 910, "encryption-required",    "Encrypt all peer connections", "er", 0, NULL },
    211236    { 911, "encryption-preferred",   "Prefer encrypted peer connections", "ep", 0, NULL },
     
    256281    { 984, "honor-session",          "Make the current torrent(s) honor the session limits", "hl",  0, NULL },
    257282    { 985, "no-honor-session",       "Make the current torrent(s) not honor the session limits", "HL",  0, NULL },
    258     { 'u', "uplimit",                "Set the max upload speed in KiB/s for the current torrent(s) or globally", "u", 1, "<speed>" },
     283    { 'u', "uplimit",                "Set the max upload speed in "SPEED_K_STR" for the current torrent(s) or globally", "u", 1, "<speed>" },
    259284    { 'U', "no-uplimit",             "Disable max upload speed for the current torrent(s) or globally", "U", 0, NULL },
    260285    { 'v', "verify",                 "Verify the current torrent(s)", "v",  0, NULL },
     
    10731098                printf( "  Piece Count: %" PRId64 "\n", i );
    10741099            if( tr_bencDictFindInt( t, "pieceSize", &i ) )
    1075                 printf( "  Piece Size: %" PRId64 "\n", i );
     1100                printf( "  Piece Size: %s\n", strlmem( buf, i, sizeof( buf ) ) );
    10761101            printf( "\n" );
    10771102
     
    10821107                printf( "  Download Limit: " );
    10831108                if( boolVal )
    1084                     printf( "%s\n", strlspeed( buf, i*1024, sizeof( buf ) ) );
     1109                    printf( "%s\n", strlspeed( buf, i, sizeof( buf ) ) );
    10851110                else
    10861111                    printf( "Unlimited\n" );
     
    10911116                printf( "  Upload Limit: " );
    10921117                if( boolVal )
    1093                     printf( "%s\n", strlspeed( buf, i*1024, sizeof( buf ) ) );
     1118                    printf( "%s\n", strlspeed( buf, i, sizeof( buf ) ) );
    10941119                else
    10951120                    printf( "Unlimited\n" );
     
    12161241            printf( "%-20s  %-12s  %-5.1f %6.1f  %6.1f  %s\n",
    12171242                    address, flagstr, (progress*100.0),
    1218                     rateToClient / 1024.0,
    1219                     rateToPeer / 1024.0,
     1243                    rateToClient / (double)SPEED_K,
     1244                    rateToPeer / (double)SPEED_K,
    12201245                    client );
    12211246        }
     
    13191344                    haveStr,
    13201345                    etaStr,
    1321                     up / 1024.0,
    1322                     down / 1024.0,
     1346                    up / (double)SPEED_K,
     1347                    down / (double)SPEED_K,
    13231348                    strlratio2( ratioStr, ratio, sizeof( ratioStr ) ),
    13241349                    getStatusString( d, statusStr, sizeof( statusStr ) ),
     
    13331358        printf( "Sum:         %9s            %6.1f  %6.1f\n",
    13341359                strlsize( haveStr, total_size, sizeof( haveStr ) ),
    1335                 total_up / 1024.0,
    1336                 total_down / 1024.0 );
     1360                total_up / (double)SPEED_K,
     1361                total_down / (double)SPEED_K );
    13371362    }
    13381363}
     
    13441369    if( ( tr_bencDictFindDict( top, "arguments", &args ) ) )
    13451370    {
    1346         double d;
     1371        int64_t i;
     1372        char buf[64];
     1373        tr_bool boolVal;
    13471374        const char * str;
    1348         int64_t      i;
    1349         tr_bool      boolVal;
    1350         char buf[64];
    13511375
    13521376        printf( "VERSION\n" );
     
    13761400        if( tr_bencDictFindStr( args,  TR_PREFS_KEY_ENCRYPTION, &str ) )
    13771401            printf( "  Encryption: %s\n", str );
    1378         if( tr_bencDictFindReal( args, TR_PREFS_KEY_MAX_CACHE_SIZE_MiB, &d ) )
    1379             printf( "  Maximum memory cache size: %s\n", strlsize( buf, d*MiB, sizeof( buf ) ) );
     1402        if( tr_bencDictFindInt( args, TR_PREFS_KEY_MAX_CACHE_SIZE, &i ) )
     1403            printf( "  Maximum memory cache size: %s\n", strlsize( buf, i, sizeof( buf ) ) );
    13801404        printf( "\n" );
    13811405
     
    13851409            double seedRatioLimit;
    13861410
    1387             if( tr_bencDictFindInt ( args, TR_PREFS_KEY_ALT_SPEED_DOWN, &altDown ) &&
     1411            if( tr_bencDictFindInt ( args, TR_PREFS_KEY_ALT_SPEED_DOWN_Bps, &altDown ) &&
    13881412                tr_bencDictFindBool( args, TR_PREFS_KEY_ALT_SPEED_ENABLED, &altEnabled ) &&
    13891413                tr_bencDictFindInt ( args, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &altBegin ) &&
     
    13911415                tr_bencDictFindInt ( args, TR_PREFS_KEY_ALT_SPEED_TIME_END, &altEnd ) &&
    13921416                tr_bencDictFindInt ( args, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, &altDay ) &&
    1393                 tr_bencDictFindInt ( args, TR_PREFS_KEY_ALT_SPEED_UP, &altUp ) &&
     1417                tr_bencDictFindInt ( args, TR_PREFS_KEY_ALT_SPEED_UP_Bps, &altUp ) &&
    13941418                tr_bencDictFindInt ( args, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &peerLimit ) &&
    1395                 tr_bencDictFindInt ( args, TR_PREFS_KEY_DSPEED, &downLimit ) &&
     1419                tr_bencDictFindInt ( args, TR_PREFS_KEY_DSPEED_Bps, &downLimit ) &&
    13961420                tr_bencDictFindBool( args, TR_PREFS_KEY_DSPEED_ENABLED, &downEnabled ) &&
    1397                 tr_bencDictFindInt ( args, TR_PREFS_KEY_USPEED, &upLimit ) &&
     1421                tr_bencDictFindInt ( args, TR_PREFS_KEY_USPEED_Bps, &upLimit ) &&
    13981422                tr_bencDictFindBool( args, TR_PREFS_KEY_USPEED_ENABLED, &upEnabled ) &&
    13991423                tr_bencDictFindReal( args, "seedRatioLimit", &seedRatioLimit ) &&
     
    14141438
    14151439                if( altEnabled )
    1416                     strlspeed( buf, altUp*1024, sizeof( buf ) );
     1440                    strlspeed( buf, altUp, sizeof( buf ) );
    14171441                else if( upEnabled )
    1418                     strlspeed( buf, upLimit*1024, sizeof( buf ) );
     1442                    strlspeed( buf, upLimit, sizeof( buf ) );
    14191443                else
    14201444                    tr_strlcpy( buf, "Unlimited", sizeof( buf ) );
     
    14221446                        buf,
    14231447                        upEnabled ? "Enabled" : "Disabled",
    1424                         strlspeed( buf2, upLimit*1024, sizeof( buf2 ) ),
     1448                        strlspeed( buf2, upLimit, sizeof( buf2 ) ),
    14251449                        altEnabled ? "Enabled" : "Disabled",
    1426                         strlspeed( buf3, altUp*1024, sizeof( buf3 ) ) );
     1450                        strlspeed( buf3, altUp, sizeof( buf3 ) ) );
    14271451
    14281452                if( altEnabled )
    1429                     strlspeed( buf, altDown*1024, sizeof( buf ) );
     1453                    strlspeed( buf, altDown, sizeof( buf ) );
    14301454                else if( downEnabled )
    1431                     strlspeed( buf, downLimit*1024, sizeof( buf ) );
     1455                    strlspeed( buf, downLimit, sizeof( buf ) );
    14321456                else
    14331457                    tr_strlcpy( buf, "Unlimited", sizeof( buf ) );
     
    14351459                        buf,
    14361460                        downEnabled ? "Enabled" : "Disabled",
    1437                         strlspeed( buf2, downLimit*1024, sizeof( buf2 ) ),
     1461                        strlspeed( buf2, downLimit, sizeof( buf2 ) ),
    14381462                        altEnabled ? "Enabled" : "Disabled",
    1439                         strlspeed( buf2, altDown*1024, sizeof( buf2 ) ) );
     1463                        strlspeed( buf2, altDown, sizeof( buf2 ) ) );
    14401464
    14411465                if( altTimeEnabled ) {
     
    18221846                case 971: tr_bencDictAddBool( args, TR_PREFS_KEY_ALT_SPEED_ENABLED, FALSE );
    18231847                          break;
    1824                 case 972: tr_bencDictAddInt( args, TR_PREFS_KEY_ALT_SPEED_DOWN, numarg( optarg ) );
    1825                           break;
    1826                 case 973: tr_bencDictAddInt( args, TR_PREFS_KEY_ALT_SPEED_UP, numarg( optarg ) );
     1848                case 972: tr_bencDictAddInt( args, TR_PREFS_KEY_ALT_SPEED_DOWN_Bps, numarg( optarg ) * SPEED_K );
     1849                          break;
     1850                case 973: tr_bencDictAddInt( args, TR_PREFS_KEY_ALT_SPEED_UP_Bps, numarg( optarg ) * SPEED_K );
    18271851                          break;
    18281852                case 974: tr_bencDictAddBool( args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, TRUE );
     
    18411865                case 'C': tr_bencDictAddBool( args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, FALSE );
    18421866                          break;
    1843                 case 'e': tr_bencDictAddReal( args, TR_PREFS_KEY_MAX_CACHE_SIZE_MiB, atof(optarg) );
     1867                case 'e': tr_bencDictAddReal( args, TR_PREFS_KEY_MAX_CACHE_SIZE, atof(optarg) * MEM_K * MEM_K );
    18441868                          break;
    18451869                case 910: tr_bencDictAddStr( args, TR_PREFS_KEY_ENCRYPTION, "required" );
     
    18991923            {
    19001924                case 'd': if( targs ) {
    1901                               tr_bencDictAddInt( targs, "downloadLimit", numarg( optarg ) );
     1925                              tr_bencDictAddInt( targs, "downloadLimit", numarg( optarg ) * SPEED_K );
    19021926                              tr_bencDictAddBool( targs, "downloadLimited", TRUE );
    19031927                          } else {
    1904                               tr_bencDictAddInt( sargs, TR_PREFS_KEY_DSPEED, numarg( optarg ) );
     1928                              tr_bencDictAddInt( sargs, TR_PREFS_KEY_DSPEED_Bps, numarg( optarg ) * SPEED_K );
    19051929                              tr_bencDictAddBool( sargs, TR_PREFS_KEY_DSPEED_ENABLED, TRUE );
    19061930                          }
     
    19121936                          break;
    19131937                case 'u': if( targs ) {
    1914                               tr_bencDictAddInt( targs, "uploadLimit", numarg( optarg ) );
     1938                              tr_bencDictAddInt( targs, "uploadLimit", numarg( optarg ) * SPEED_K );
    19151939                              tr_bencDictAddBool( targs, "uploadLimited", TRUE );
    19161940                          } else {
    1917                               tr_bencDictAddInt( sargs, TR_PREFS_KEY_USPEED, numarg( optarg ) );
     1941                              tr_bencDictAddInt( sargs, TR_PREFS_KEY_USPEED_Bps, numarg( optarg ) * SPEED_K );
    19181942                              tr_bencDictAddBool( sargs, TR_PREFS_KEY_USPEED_ENABLED, TRUE );
    19191943                          }
     
    21872211    }
    21882212
    2189     tr_formatter_size_init ( 1024, "B", "KiB", "MiB", "GiB" );
    2190     tr_formatter_speed_init ( 1024, "B/s", "KiB/s", "MiB/s", "GiB/s" );
     2213    tr_formatter_mem_init( MEM_K, MEM_B_STR, MEM_K_STR, MEM_M_STR, MEM_G_STR );
     2214    tr_formatter_size_init( DISK_K,DISK_B_STR, DISK_K_STR, DISK_M_STR, DISK_G_STR );
     2215    tr_formatter_speed_init( SPEED_K, SPEED_B_STR, SPEED_K_STR, SPEED_M_STR, SPEED_G_STR );
    21912216
    21922217    getHostAndPort( &argc, argv, &host, &port );
  • trunk/doc/rpc-spec.txt

    r10906 r10931  
    9090   ----------------------+-------------------------------------------------
    9191   "bandwidthPriority"   | number     this torrent's bandwidth tr_priority_t
    92    "downloadLimit"       | number     maximum download speed (in K/s)
     92   "downloadLimit"       | number     maximum download speed (bytes per second)
    9393   "downloadLimited"     | boolean    true if "downloadLimit" is honored
    9494   "files-wanted"        | array      indices of file(s) to download
     
    106106   "trackerEdit"         | object     (see below)
    107107   "trackerRemove"       | object     (see below)
    108    "uploadLimit"         | number     maximum upload speed (in K/s)
     108   "uploadLimit"         | number     maximum upload speed (bytes per second)
    109109   "uploadLimited"       | boolean    true if "uploadLimit" is honored
    110110                         |
     
    151151       a "removed" array of torrent-id numbers of recently-removed
    152152       torrents.
     153
     154   Note: For more information on what these fields mean, see the comments
     155   in libtransmission/transmission.h.  The "source" column here
     156   corresponds to the data structure there.
    153157
    154158   key                         | type                        | source
     
    415419   string                        | value type & description
    416420   ------------------------------+-------------------------------------------------
    417    "alt-speed-down"              | number     max global download speed (in K/s)
     421   "alt-speed-down"              | number     max global download speed (in bytes per second)
    418422   "alt-speed-enabled"           | boolean    true means use the alt speeds
    419423   "alt-speed-time-begin"        | number     when to turn on alt speeds (units: minutes after midnight)
     
    421425   "alt-speed-time-end"          | number     when to turn off alt speeds (units: same)
    422426   "alt-speed-time-day"          | number     what day(s) to turn on alt speeds (look at tr_sched_day)
    423    "alt-speed-up"                | number     max global upload speed (in K/s)
     427   "alt-speed-up"                | number     max global upload speed (in bytes per second)
    424428   "blocklist-enabled"           | boolean    true means enabled
    425429   "blocklist-size"              | number     number of rules in the blocklist
    426    "cache-size-MiB"              | number     size (in MiB) of the disk cache
     430   "cache-size"                  | number     maximum size (in bytes) of the disk cache
    427431   "config-dir"                  | string     location of transmission's configuration directory
    428432   "download-dir"                | string     default path to download torrents
     
    445449   "seedRatioLimit"              | double     the default seed ratio for torrents to use
    446450   "seedRatioLimited"            | boolean    true if seedRatioLimit is honored by default
    447    "speed-limit-down"            | number     max global download speed (in K/s)
     451   "speed-limit-down"            | number     max global download speed (in bytes per second)
    448452   "speed-limit-down-enabled"    | boolean    true means enabled
    449    "speed-limit-up"              | number     max global upload speed (in K/s)
     453   "speed-limit-up"              | number     max global upload speed (in bytes per second)
    450454   "speed-limit-up-enabled"      | boolean    true means enabled
    451455   "start-added-torrents"        | boolean    true means added torrents will be started right away
     
    620624   ------+---------+-----------+----------------+-------------------------------
    621625   9     | 2.00    | yes       | session-set    | new arg "start-added-torrents"
    622          | 2.00    | yes       | session-set    | new arg "trash-original-torrent-files"
    623          | 2.00    | yes       | session-get    | new arg "start-added-torrents"
    624          | 2.00    | yes       | session-get    | new arg "trash-original-torrent-files"
    625          | 2.00    | yes       | session-get    | new arg "cache-size-MiB"
    626          | 2.00    | yes       | torrent-get    | new arg "isFinished"
    627    ------+---------+-----------+----------------+-------------------------------
    628    10    | 2.10    | yes       | torrent-set    | new arg "trackerAdd"
    629          | 2.10    | yes       | torrent-set    | new arg "trackerEdit"
    630          | 2.10    | yes       | torrent-set    | new arg "trackerRemove"
     626         |         | yes       | session-set    | new arg "trash-original-torrent-files"
     627         |         | yes       | session-get    | new arg "start-added-torrents"
     628         |         | yes       | session-get    | new arg "trash-original-torrent-files"
     629         |         | yes       | torrent-get    | new arg "isFinished"
     630   ------+---------+-----------+----------------+-------------------------------
     631   10    | 2.10    |        NO | torrent-get    | arg "downloadLimit"    is now bytes per second
     632         |         |        NO | torrent-get    | arg "uploadLimit"      is now bytes per second
     633         |         |        NO | session-get    | arg "speed-limit-down" is now bytes per second
     634         |         |        NO | session-get    | arg "speed-limit-up"   is now bytes per second
     635         |         |        NO | session-get    | arg "alt-speed-up"     is now bytes per second
     636         |         |        NO | session-get    | arg "alt-speed-down"   is now bytes per second
     637         |         | yes       | session-get    | new arg "cache-size"
     638         |         | yes       | session-set    | new arg "trash-original-torrent-files"
     639         |         | yes       | session-get    | new arg "start-added-torrents"
     640         |         | yes       | session-get    | new arg "trash-original-torrent-files"
     641         |         | yes       | torrent-get    | new arg "isFinished"
     642         |         | yes       | torrent-set    | new arg "trackerAdd"
     643         |         | yes       | torrent-set    | new arg "trackerEdit"
     644         |         | yes       | torrent-set    | new arg "trackerRemove"
  • trunk/gtk/details.c

    r10889 r10931  
    220220    /* downLimitSpin */
    221221    if( n ) {
    222         const int baseline = tr_torrentGetSpeedLimit( torrents[0], TR_DOWN );
     222        const int baseline = tr_torrentGetSpeedLimit_Bps( torrents[0], TR_DOWN ) / speed_K;
    223223        int i;
    224224        for( i=1; i<n; ++i )
    225             if( baseline != tr_torrentGetSpeedLimit( torrents[i], TR_DOWN ) )
     225            if( baseline != ( tr_torrentGetSpeedLimit_Bps( torrents[i], TR_DOWN )  / speed_K ) )
    226226                break;
    227227        if( i == n )
     
    244244    /* upLimitSpin */
    245245    if( n ) {
    246         const int baseline = tr_torrentGetSpeedLimit( torrents[0], TR_UP );
     246        const int baseline = tr_torrentGetSpeedLimit_Bps( torrents[0], TR_UP ) / speed_K;
    247247        int i;
    248248        for( i=1; i<n; ++i )
    249             if( baseline != tr_torrentGetSpeedLimit( torrents[i], TR_UP ) )
     249            if( baseline != ( tr_torrentGetSpeedLimit_Bps( torrents[i], TR_UP ) / speed_K ) )
    250250                break;
    251251        if( i == n )
     
    440440    guint tag;
    441441    int row;
     442    char buf[128];
    442443    const char *s;
    443444    GtkWidget *t, *w, *tb, *h;
     
    452453    d->honorLimitsCheckTag = tag;
    453454
    454     tb = gtk_check_button_new_with_mnemonic( _( "Limit _download speed (KiB/s):" ) );
     455    g_snprintf( buf, sizeof( buf ), _( "Limit _download speed (%s):" ), _(speed_K_str) );
     456    tb = gtk_check_button_new_with_mnemonic( buf );
    455457    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( tb ), FALSE );
    456458    d->downLimitedCheck = tb;
     
    464466    d->downLimitSpin = w;
    465467
    466     tb = gtk_check_button_new_with_mnemonic( _( "Limit _upload speed (KiB/s):" ) );
     468    g_snprintf( buf, sizeof( buf ), _( "Limit _upload speed (%s):" ), _(speed_K_str) );
     469    tb = gtk_check_button_new_with_mnemonic( buf );
    467470    d->upLimitedCheck = tb;
    468471    tag = g_signal_connect( tb, "toggled", G_CALLBACK( up_speed_toggled_cb ), d );
     
    759762        else if( pieceSize >= 0 ) {
    760763            char piecebuf[128];
    761             tr_strlsize( piecebuf, (uint64_t)pieceSize, sizeof( piecebuf ) );
     764            tr_formatter_mem( piecebuf, pieceSize, sizeof( piecebuf ) );
    762765            g_snprintf( buf, sizeof( buf ),
    763766                        ngettext( "%1$s (%2$'d piece @ %3$s)",
     
    10421045    WEBSEED_COL_WAS_UPDATED,
    10431046    WEBSEED_COL_URL,
    1044     WEBSEED_COL_DOWNLOAD_RATE_DOUBLE,
     1047    WEBSEED_COL_DOWNLOAD_RATE_INT,
    10451048    WEBSEED_COL_DOWNLOAD_RATE_STRING,
    10461049    N_WEBSEED_COLS
     
    10531056    {
    10541057        case WEBSEED_COL_URL: return _( "Webseeds" );
    1055         case WEBSEED_COL_DOWNLOAD_RATE_DOUBLE:
     1058        case WEBSEED_COL_DOWNLOAD_RATE_INT:
    10561059        case WEBSEED_COL_DOWNLOAD_RATE_STRING: return _( "Down" );
    10571060        default: return "";
     
    10661069                               G_TYPE_BOOLEAN,  /* was-updated */
    10671070                               G_TYPE_STRING,   /* url */
    1068                                G_TYPE_DOUBLE,   /* download rate double */
     1071                               G_TYPE_INT,      /* download rate int */
    10691072                               G_TYPE_STRING ); /* download rate string */
    10701073}
     
    10761079    PEER_COL_ADDRESS,
    10771080    PEER_COL_ADDRESS_COLLATED,
    1078     PEER_COL_DOWNLOAD_RATE_DOUBLE,
     1081    PEER_COL_DOWNLOAD_RATE_INT,
    10791082    PEER_COL_DOWNLOAD_RATE_STRING,
    1080     PEER_COL_UPLOAD_RATE_DOUBLE,
     1083    PEER_COL_UPLOAD_RATE_INT,
    10811084    PEER_COL_UPLOAD_RATE_STRING,
    10821085    PEER_COL_CLIENT,
     
    11061109        case PEER_COL_ADDRESS: return _( "Address" );
    11071110        case PEER_COL_DOWNLOAD_RATE_STRING:
    1108         case PEER_COL_DOWNLOAD_RATE_DOUBLE: return _( "Down" );
     1111        case PEER_COL_DOWNLOAD_RATE_INT: return _( "Down" );
    11091112        case PEER_COL_UPLOAD_RATE_STRING:
    1110         case PEER_COL_UPLOAD_RATE_DOUBLE: return _( "Up" );
     1113        case PEER_COL_UPLOAD_RATE_INT: return _( "Up" );
    11111114        case PEER_COL_CLIENT: return _( "Client" );
    11121115        case PEER_COL_PROGRESS: return _( "%" );
     
    11361139                               G_TYPE_STRING,   /* address */
    11371140                               G_TYPE_STRING,   /* collated address */
    1138                                G_TYPE_FLOAT,    /* download speed float */
     1141                               G_TYPE_INT,      /* download speed int */
    11391142                               G_TYPE_STRING,   /* download speed string */
    1140                                G_TYPE_FLOAT,    /* upload speed float */
     1143                               G_TYPE_INT,      /* upload speed int */
    11411144                               G_TYPE_STRING,   /* upload speed string  */
    11421145                               G_TYPE_STRING,   /* client */
     
    11651168{
    11661169    int q[4];
    1167     char up_speed[128];
    1168     char down_speed[128];
    11691170    char collated_name[128];
    11701171    const char * client = peer->client;
     
    11731174        client = "";
    11741175
    1175     tr_strlspeed( up_speed, peer->rateToPeer, sizeof( up_speed ) );
    1176     tr_strlspeed( down_speed, peer->rateToClient, sizeof( down_speed ) );
    11771176    if( sscanf( peer->addr, "%d.%d.%d.%d", q, q+1, q+2, q+3 ) != 4 )
    11781177        g_strlcpy( collated_name, peer->addr, sizeof( collated_name ) );
     
    12041203    char cancelled_by_client[64];
    12051204
    1206     if( peer->rateToPeer > 0.01 )
    1207         tr_strlspeed( up_speed, peer->rateToPeer, sizeof( up_speed ) );
     1205    if( peer->rateToPeer_Bps > 0 )
     1206        tr_formatter_speed( up_speed, peer->rateToPeer_Bps, sizeof( up_speed ) );
    12081207    else
    12091208        *up_speed = '\0';
    12101209
    1211     if( peer->rateToClient > 0.01 )
    1212         tr_strlspeed( down_speed, peer->rateToClient, sizeof( down_speed ) );
     1210    if( peer->rateToClient_Bps > 0 )
     1211        tr_formatter_speed( down_speed, peer->rateToClient_Bps, sizeof( down_speed ) );
    12131212    else
    12141213        *down_speed = '\0';
     
    12501249                        PEER_COL_DOWNLOAD_REQUEST_COUNT_INT, peer->pendingReqsToPeer,
    12511250                        PEER_COL_DOWNLOAD_REQUEST_COUNT_STRING, down_count,
    1252                         PEER_COL_DOWNLOAD_RATE_DOUBLE, peer->rateToClient,
     1251                        PEER_COL_DOWNLOAD_RATE_INT, peer->rateToClient_Bps,
    12531252                        PEER_COL_DOWNLOAD_RATE_STRING, down_speed,
    1254                         PEER_COL_UPLOAD_RATE_DOUBLE, peer->rateToPeer,
     1253                        PEER_COL_UPLOAD_RATE_INT, peer->rateToPeer_Bps,
    12551254                        PEER_COL_UPLOAD_RATE_STRING, up_speed,
    12561255                        PEER_COL_STATUS, peer->flagStr,
     
    13981397        const tr_torrent * tor = torrents[i];
    13991398        const tr_info * inf = tr_torrentInfo( tor );
    1400         float * speeds = tr_torrentWebSpeeds( tor );
     1399        int * speeds_Bps = tr_torrentWebSpeeds_Bps( tor );
    14011400        for( j=0; j<inf->webseedCount; ++j ) {
    14021401            char buf[128];
     
    14091408            p = gtk_tree_row_reference_get_path( ref );
    14101409            gtk_tree_model_get_iter( model, &iter, p );
    1411             if( speeds[j] > 0.01 )
    1412                 tr_strlspeed( buf, speeds[j], sizeof( buf ) );
     1410            if( speeds_Bps[j] > 0 )
     1411                tr_formatter_speed( buf, speeds_Bps[j], sizeof( buf ) );
    14131412            else
    14141413                *buf = '\0';
    1415             gtk_list_store_set( store, &iter, WEBSEED_COL_DOWNLOAD_RATE_DOUBLE, (double)speeds[j],
     1414            gtk_list_store_set( store, &iter, WEBSEED_COL_DOWNLOAD_RATE_INT, speeds_Bps[j],
    14161415                                              WEBSEED_COL_DOWNLOAD_RATE_STRING, buf,
    14171416                                              WEBSEED_COL_WAS_UPDATED, TRUE,
     
    14191418            gtk_tree_path_free( p );
    14201419        }
    1421         tr_free( speeds );
     1420        tr_free( speeds_Bps );
    14221421    }
    14231422
     
    16131612                g_object_set( G_OBJECT( r ), "xalign", 1.0f, NULL );
    16141613                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
    1615                 sort_col = PEER_COL_DOWNLOAD_RATE_DOUBLE;
     1614                sort_col = PEER_COL_DOWNLOAD_RATE_INT;
    16161615                break;
    16171616            case PEER_COL_UPLOAD_RATE_STRING:
     
    16191618                g_object_set( G_OBJECT( r ), "xalign", 1.0f, NULL );
    16201619                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
    1621                 sort_col = PEER_COL_UPLOAD_RATE_DOUBLE;
     1620                sort_col = PEER_COL_UPLOAD_RATE_INT;
    16221621                break;
    16231622
     
    16881687    r = gtk_cell_renderer_text_new( );
    16891688    c = gtk_tree_view_column_new_with_attributes( str, r, "text", WEBSEED_COL_DOWNLOAD_RATE_STRING, NULL );
    1690     gtk_tree_view_column_set_sort_column_id( c, WEBSEED_COL_DOWNLOAD_RATE_DOUBLE );
     1689    gtk_tree_view_column_set_sort_column_id( c, WEBSEED_COL_DOWNLOAD_RATE_INT );
    16911690    gtk_tree_view_append_column( GTK_TREE_VIEW( v ), c );
    16921691
  • trunk/gtk/main.c

    r10863 r10931  
    533533    textdomain( domain );
    534534    g_set_application_name( _( "Transmission" ) );
    535     tr_formatter_size_init( 1024, _("B"), _("KiB"), _("MiB"), _("GiB") );
    536     tr_formatter_speed_init( 1024, _("B/s"), _("KiB/s"), _("MiB/s"), _("GiB/s") );
     535    tr_formatter_mem_init( mem_K, _(mem_B_str), _(mem_K_str), _(mem_M_str), _(mem_G_str) );
     536    tr_formatter_size_init( disk_K, _(disk_B_str), _(disk_K_str), _(disk_M_str), _(disk_G_str) );
     537    tr_formatter_speed_init( speed_K, _(speed_B_str), _(speed_K_str), _(speed_M_str), _(speed_G_str) );
    537538
    538539    /* initialize gtk */
     
    12031204        tr_sessionLimitSpeed( tr, TR_DOWN, pref_flag_get( key ) );
    12041205    }
    1205     else if( !strcmp( key, TR_PREFS_KEY_DSPEED ) )
    1206     {
    1207         tr_sessionSetSpeedLimit( tr, TR_DOWN, pref_int_get( key ) );
     1206    else if( !strcmp( key, TR_PREFS_KEY_DSPEED_Bps ) )
     1207    {
     1208        tr_sessionSetSpeedLimit_Bps( tr, TR_DOWN, pref_int_get( key ) );
    12081209    }
    12091210    else if( !strcmp( key, TR_PREFS_KEY_USPEED_ENABLED ) )
     
    12111212        tr_sessionLimitSpeed( tr, TR_UP, pref_flag_get( key ) );
    12121213    }
    1213     else if( !strcmp( key, TR_PREFS_KEY_USPEED ) )
    1214     {
    1215         tr_sessionSetSpeedLimit( tr, TR_UP, pref_int_get( key ) );
     1214    else if( !strcmp( key, TR_PREFS_KEY_USPEED_Bps ) )
     1215    {
     1216        tr_sessionSetSpeedLimit_Bps( tr, TR_UP, pref_int_get( key ) );
    12161217    }
    12171218    else if( !strcmp( key, TR_PREFS_KEY_RATIO_ENABLED ) )
     
    12991300        tr_sessionSetProxyPort( tr, pref_int_get( key ) );
    13001301    }
    1301     else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_UP ) )
    1302     {
    1303         tr_sessionSetAltSpeed( tr, TR_UP, pref_int_get( key ) );
    1304     }
    1305     else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_DOWN ) )
    1306     {
    1307         tr_sessionSetAltSpeed( tr, TR_DOWN, pref_int_get( key ) );
     1302    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_UP_Bps ) )
     1303    {
     1304        tr_sessionSetAltSpeed_Bps( tr, TR_UP, pref_int_get( key ) );
     1305    }
     1306    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_DOWN_Bps ) )
     1307    {
     1308        tr_sessionSetAltSpeed_Bps( tr, TR_DOWN, pref_int_get( key ) );
    13081309    }
    13091310    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_ENABLED ) )
  • trunk/gtk/torrent-cell-renderer.c

    r10822 r10931  
    155155getShortTransferString( const tr_torrent  * tor,
    156156                        const tr_stat     * torStat,
    157                         double              uploadSpeed,
    158                         double              downloadSpeed,
     157                        int                 uploadSpeed_Bps,
     158                        int                 downloadSpeed_Bps,
    159159                        char              * buf,
    160160                        size_t              buflen )
     
    166166
    167167    if( haveDown )
    168         tr_strlspeed( downStr, downloadSpeed, sizeof( downStr ) );
     168        tr_strlspeed( downStr, downloadSpeed_Bps, sizeof( downStr ) );
    169169    if( haveUp )
    170         tr_strlspeed( upStr, uploadSpeed, sizeof( upStr ) );
     170        tr_strlspeed( upStr, uploadSpeed_Bps, sizeof( upStr ) );
    171171
    172172    if( haveDown && haveUp )
     
    195195getShortStatusString( const tr_torrent  * tor,
    196196                      const tr_stat     * torStat,
    197                       double              uploadSpeed,
    198                       double              downloadSpeed )
     197                      int                 uploadSpeed_Bps,
     198                      int                 downloadSpeed_Bps )
    199199{
    200200    GString * gstr = g_string_new( NULL );
     
    229229                g_string_append( gstr, ", " );
    230230            }
    231             getShortTransferString( tor, torStat, uploadSpeed, downloadSpeed, buf, sizeof( buf ) );
     231            getShortTransferString( tor, torStat, uploadSpeed_Bps, downloadSpeed_Bps, buf, sizeof( buf ) );
    232232            g_string_append( gstr, buf );
    233233            break;
     
    244244getStatusString( const tr_torrent  * tor,
    245245                 const tr_stat     * torStat,
    246                  const double        uploadSpeed,
    247                  const double        downloadSpeed )
     246                 const int           uploadSpeed_Bps,
     247                 const int           downloadSpeed_Bps )
    248248{
    249249    const int isActive = torStat->activity != TR_STATUS_STOPPED;
     
    266266        case TR_STATUS_CHECK:
    267267        {
    268             char * pch = getShortStatusString( tor, torStat, uploadSpeed, downloadSpeed );
     268            char * pch = getShortStatusString( tor, torStat, uploadSpeed_Bps, downloadSpeed_Bps );
    269269            g_string_assign( gstr, pch );
    270270            g_free( pch );
     
    310310    {
    311311        char buf[256];
    312         getShortTransferString( tor, torStat, uploadSpeed, downloadSpeed, buf, sizeof( buf ) );
     312        getShortTransferString( tor, torStat, uploadSpeed_Bps, downloadSpeed_Bps, buf, sizeof( buf ) );
    313313        if( *buf )
    314314            g_string_append_printf( gstr, " - %s", buf );
     
    337337       the individual torrents' speeds and the status bar's overall speed
    338338       in sync even if they refresh at slightly different times */
    339     double upload_speed;
    340 
    341     /* @see upload_speed */
    342     double download_speed;
     339    int upload_speed_Bps;
     340
     341    /* @see upload_speed_Bps */
     342    int download_speed_Bps;
    343343
    344344    gboolean compact;
     
    398398    icon = get_icon( tor, COMPACT_ICON_SIZE, widget );
    399399    name = tr_torrentInfo( tor )->name;
    400     status = getShortStatusString( tor, st, p->upload_speed, p->download_speed );
     400    status = getShortStatusString( tor, st, p->upload_speed_Bps, p->download_speed_Bps );
    401401
    402402    /* get the idealized cell dimensions */
     
    456456    icon = get_icon( tor, FULL_ICON_SIZE, widget );
    457457    name = inf->name;
    458     status = getStatusString( tor, st, p->upload_speed, p->download_speed );
     458    status = getStatusString( tor, st, p->upload_speed_Bps, p->download_speed_Bps );
    459459    progress = getProgressString( tor, inf, st );
    460460
     
    560560    icon = get_icon( tor, COMPACT_ICON_SIZE, widget );
    561561    name = tr_torrentInfo( tor )->name;
    562     status = getShortStatusString( tor, st, p->upload_speed, p->download_speed );
     562    status = getShortStatusString( tor, st, p->upload_speed_Bps, p->download_speed_Bps );
    563563
    564564    /* get the cell dimensions */
     
    664664    icon = get_icon( tor, FULL_ICON_SIZE, widget );
    665665    name = inf->name;
    666     status = getStatusString( tor, st, p->upload_speed, p->download_speed );
     666    status = getStatusString( tor, st, p->upload_speed_Bps, p->download_speed_Bps );
    667667    progress = getProgressString( tor, inf, st );
    668668
     
    783783    switch( property_id )
    784784    {
    785         case P_TORRENT:        p->tor            = g_value_get_pointer( v ); break;
    786         case P_UPLOAD_SPEED:   p->upload_speed   = g_value_get_double( v ); break;
    787         case P_DOWNLOAD_SPEED: p->download_speed = g_value_get_double( v ); break;
    788         case P_BAR_HEIGHT:     p->bar_height     = g_value_get_int( v ); break;
    789         case P_COMPACT:        p->compact        = g_value_get_boolean( v ); break;
     785        case P_TORRENT:        p->tor                = g_value_get_pointer( v ); break;
     786        case P_UPLOAD_SPEED:   p->upload_speed_Bps   = g_value_get_int( v ); break;
     787        case P_DOWNLOAD_SPEED: p->download_speed_Bps = g_value_get_int( v ); break;
     788        case P_BAR_HEIGHT:     p->bar_height         = g_value_get_int( v ); break;
     789        case P_COMPACT:        p->compact            = g_value_get_boolean( v ); break;
    790790        default: G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, pspec ); break;
    791791    }
     
    804804    {
    805805        case P_TORRENT:        g_value_set_pointer( v, p->tor ); break;
    806         case P_UPLOAD_SPEED:   g_value_set_double( v, p->upload_speed ); break;
    807         case P_DOWNLOAD_SPEED: g_value_set_double( v, p->download_speed ); break;
     806        case P_UPLOAD_SPEED:   g_value_set_int( v, p->upload_speed_Bps ); break;
     807        case P_DOWNLOAD_SPEED: g_value_set_int( v, p->download_speed_Bps ); break;
    808808        case P_BAR_HEIGHT:     g_value_set_int( v, p->bar_height ); break;
    809809        case P_COMPACT:        g_value_set_boolean( v, p->compact ); break;
     
    854854
    855855    g_object_class_install_property( gobject_class, P_UPLOAD_SPEED,
    856                                     g_param_spec_double( "piece-upload-speed", NULL,
    857                                                          "tr_stat.pieceUploadSpeed",
    858                                                          0, INT_MAX, 0,
    859                                                          G_PARAM_READWRITE ) );
     856                                    g_param_spec_int( "piece-upload-speed", NULL,
     857                                                      "tr_stat.pieceUploadSpeed_Bps",
     858                                                      0, INT_MAX, 0,
     859                                                      G_PARAM_READWRITE ) );
    860860
    861861    g_object_class_install_property( gobject_class, P_DOWNLOAD_SPEED,
    862                                     g_param_spec_double( "piece-download-speed", NULL,
    863                                                          "tr_stat.pieceDownloadSpeed",
    864                                                          0, INT_MAX, 0,
    865                                                          G_PARAM_READWRITE ) );
     862                                    g_param_spec_int( "piece-download-speed", NULL,
     863                                                      "tr_stat.pieceDownloadSpeed_Bps",
     864                                                      0, INT_MAX, 0,
     865                                                      G_PARAM_READWRITE ) );
    866866
    867867    g_object_class_install_property( gobject_class, P_BAR_HEIGHT,
  • trunk/gtk/tr-core.c

    r10863 r10931  
    777777                      TR_TORRENT_TYPE,  /* TrTorrent object */
    778778                      G_TYPE_POINTER,   /* tr_torrent* */
    779                       G_TYPE_DOUBLE,    /* tr_stat.pieceUploadSpeed */
    780                       G_TYPE_DOUBLE,    /* tr_stat.pieceDownloadSpeed */
     779                      G_TYPE_INT,       /* tr_stat.pieceUploadSpeed_Bps */
     780                      G_TYPE_INT,       /* tr_stat.pieceDownloadSpeed_Bps */
    781781                      G_TYPE_INT };     /* tr_stat.status */
    782782
     
    921921                                       MC_TORRENT,       gtor,
    922922                                       MC_TORRENT_RAW,   tor,
    923                                        MC_SPEED_UP,      st->pieceUploadSpeed,
    924                                        MC_SPEED_DOWN,    st->pieceDownloadSpeed,
     923                                       MC_SPEED_UP,      st->pieceUploadSpeed_Bps,
     924                                       MC_SPEED_DOWN,    st->pieceDownloadSpeed_Bps,
    925925                                       MC_ACTIVITY,      st->activity,
    926926                                       -1 );
     
    13231323{
    13241324    int oldActivity, newActivity;
    1325     double oldUpSpeed, newUpSpeed;
    1326     double oldDownSpeed, newDownSpeed;
     1325    int oldUpSpeed, newUpSpeed;
     1326    int oldDownSpeed, newDownSpeed;
    13271327    const tr_stat * st;
    13281328    TrTorrent * gtor;
     
    13391339    st = tr_torrentStat( tr_torrent_handle( gtor ) );
    13401340    newActivity = st->activity;
    1341     newUpSpeed = st->pieceUploadSpeed;
    1342     newDownSpeed = st->pieceDownloadSpeed;
     1341    newUpSpeed = st->pieceUploadSpeed_Bps;
     1342    newDownSpeed = st->pieceDownloadSpeed_Bps;
    13431343
    13441344    /* updating the model triggers off resort/refresh,
    13451345       so don't do it unless something's actually changed... */
    1346     if( ( newActivity != oldActivity ) ||
    1347         ( (int)(newUpSpeed*10.0) != (int)(oldUpSpeed*10.0) ) ||
    1348         ( (int)(newDownSpeed*10.0) != (int)(oldDownSpeed*10.0) ) )
     1346    if( ( newActivity  != oldActivity ) ||
     1347        ( newUpSpeed   != oldUpSpeed  ) ||
     1348        ( newDownSpeed != oldDownSpeed ) )
    13491349    {
    13501350        gtk_list_store_set( GTK_LIST_STORE( model ), iter,
  • trunk/gtk/tr-icon.c

    r10390 r10931  
    1616 #include <libappindicator/app-indicator.h>
    1717#endif
     18#include <libtransmission/transmission.h>
     19#include <libtransmission/utils.h>
    1820#include "actions.h"
    1921#include "tr-icon.h"
     
    6668tr_icon_refresh( gpointer vicon )
    6769{
    68     double d;
     70    int Bps;
    6971    int limit;
    7072    char up[64];
     
    7880
    7981    /* up */
    80     if(((d = tr_sessionGetRawSpeed( session, TR_UP ))) < 0.1 )
     82    Bps = tr_sessionGetRawSpeed_Bps( session, TR_UP );
     83    if( Bps < 1 )
    8184        g_strlcpy( up, idle, sizeof( up ) );
    8285    else
    83         tr_strlspeed( up, d, sizeof( up ) );
     86        tr_formatter_speed( up, Bps, sizeof( up ) );
    8487
    8588    /* up limit */
    86     if( !tr_sessionGetActiveSpeedLimit( session, TR_UP, &limit ) )
     89    if( !tr_sessionGetActiveSpeedLimit_Bps( session, TR_UP, &limit ) )
    8790        *upLimit = '\0';
    8891    else {
     
    9396
    9497    /* down */
    95     if(((d = tr_sessionGetRawSpeed( session, TR_DOWN ))) < 0.1 )
     98    Bps = tr_sessionGetRawSpeed_Bps( session, TR_DOWN );
     99    if( Bps < 1 )
    96100        g_strlcpy( down, idle, sizeof( down ) );
    97101    else
    98         tr_strlspeed( down, d, sizeof( down ) );
     102        tr_formatter_speed( down, Bps, sizeof( down ) );
    99103
    100104    /* down limit */
    101     if( !tr_sessionGetActiveSpeedLimit( session, TR_DOWN, &limit ) )
     105    if( !tr_sessionGetActiveSpeedLimit_Bps( session, TR_DOWN, &limit ) )
    102106        *downLimit = '\0';
    103107    else {
  • trunk/gtk/tr-prefs.c

    r10724 r10931  
    3131**/
    3232
     33#define MULTIPLIER_KEY "multiplier-key"
    3334#define PREF_KEY "pref-key"
    3435
     
    9798spun_cb_idle( gpointer spin )
    9899{
    99     gboolean                keep_waiting = TRUE;
    100     GObject *               o = G_OBJECT( spin );
     100    gboolean keep_waiting = TRUE;
     101    GObject * o = G_OBJECT( spin );
    101102    struct spin_idle_data * data = g_object_get_data( o, IDLE_DATA );
    102103
     
    106107        /* update the core */
    107108        const char * key = g_object_get_data( o, PREF_KEY );
     109        const int multiplier = GPOINTER_TO_INT( g_object_get_data( o, MULTIPLIER_KEY ) );
     110
    108111        if (data->isDouble)
    109112        {
    110             const double value = gtk_spin_button_get_value( GTK_SPIN_BUTTON( spin ) );
     113            const double value = gtk_spin_button_get_value( GTK_SPIN_BUTTON( spin ) ) * multiplier;
    111114            tr_core_set_pref_double( TR_CORE( data->core ), key, value );
    112115        }
    113116        else
    114117        {
    115             const int    value = gtk_spin_button_get_value_as_int(
    116                                  GTK_SPIN_BUTTON( spin ) );
     118            const int value = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON( spin ) ) * multiplier;
    117119            tr_core_set_pref_int( TR_CORE( data->core ), key, value );
    118120        }
     
    128130
    129131static void
    130 spun_cb( GtkSpinButton * w,
    131          gpointer        core,
    132          gboolean        isDouble )
     132spun_cb( GtkSpinButton * w, gpointer core, gboolean isDouble )
    133133{
    134134    /* user may be spinning through many values, so let's hold off
    135135       for a moment to keep from flooding the core with changes */
    136     GObject *               o = G_OBJECT( w );
     136    GObject * o = G_OBJECT( w );
    137137    struct spin_idle_data * data = g_object_get_data( o, IDLE_DATA );
    138138
     
    151151
    152152static void
    153 spun_cb_int( GtkSpinButton * w,
    154              gpointer        core )
     153spun_cb_int( GtkSpinButton * w, gpointer core )
    155154{
    156155    spun_cb( w, core, FALSE );
     
    158157
    159158static void
    160 spun_cb_double( GtkSpinButton * w,
    161                 gpointer        core )
     159spun_cb_double( GtkSpinButton * w, gpointer core )
    162160{
    163161    spun_cb( w, core, TRUE );
     
    167165new_spin_button( const char * key,
    168166                 gpointer     core,
     167                 int          multiplier,
    169168                 int          low,
    170169                 int          high,
     
    172171{
    173172    GtkWidget * w = gtk_spin_button_new_with_range( low, high, step );
    174 
    175     g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup(
    176                                 key ), g_free );
     173    g_object_set_data( G_OBJECT( w ), MULTIPLIER_KEY, GINT_TO_POINTER( multiplier ) );
     174    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup( key ), g_free );
    177175    gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 0 );
    178     gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), pref_int_get( key ) );
     176    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), pref_int_get( key ) / multiplier );
    179177    g_signal_connect( w, "value-changed", G_CALLBACK( spun_cb_int ), core );
    180178    return w;
     
    184182new_spin_button_double( const char * key,
    185183                       gpointer      core,
     184                       int           multiplier,
    186185                       double        low,
    187186                       double        high,
     
    189188{
    190189    GtkWidget * w = gtk_spin_button_new_with_range( low, high, step );
    191 
    192     g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup(
    193                                 key ), g_free );
     190    g_object_set_data( G_OBJECT( w ), MULTIPLIER_KEY, GINT_TO_POINTER( multiplier ) );
     191    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup( key ), g_free );
    194192    gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 2 );
    195193    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), pref_double_get( key ) );
     
    199197
    200198static void
    201 entry_changed_cb( GtkEntry * w,
    202                   gpointer   core )
     199entry_changed_cb( GtkEntry * w, gpointer   core )
    203200{
    204201    const char * key = g_object_get_data( G_OBJECT( w ), PREF_KEY );
     
    333330    s = _( "_Seed torrent until its ratio reaches:" );
    334331    w = new_check_button( s, TR_PREFS_KEY_RATIO_ENABLED, core );
    335     w2 = new_spin_button_double( TR_PREFS_KEY_RATIO, core, 0, INT_MAX, .05 );
     332    w2 = new_spin_button_double( TR_PREFS_KEY_RATIO, core, 1, 0, INT_MAX, .05 );
    336333    gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED ) );
    337334    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
     
    810807
    811808    /* port */
    812     w = new_spin_button( TR_PREFS_KEY_RPC_PORT, core, 0, USHRT_MAX, 1 );
     809    w = new_spin_button( TR_PREFS_KEY_RPC_PORT, core, 1, 0, USHRT_MAX, 1 );
    813810    page->widgets = g_slist_append( page->widgets, w );
    814811    w = hig_workarea_add_row( t, &row, _( "Listening _port:" ), w, NULL );
     
    10151012    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
    10161013
    1017     w = new_spin_button( TR_PREFS_KEY_PROXY_PORT, core, 0, USHRT_MAX, 1 );
     1014    w = new_spin_button( TR_PREFS_KEY_PROXY_PORT, core, 1, 0, USHRT_MAX, 1 );
    10181015    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
    10191016    w = hig_workarea_add_row( t, &row, _( "Proxy _port:" ), w, NULL );
     
    12211218    hig_workarea_add_section_title( t, &row, _( "Speed Limits" ) );
    12221219
    1223         s = _( "Limit _download speed (KiB/s):" );
    1224         w = new_check_button( s, TR_PREFS_KEY_DSPEED_ENABLED, core );
    1225         w2 = new_spin_button( TR_PREFS_KEY_DSPEED, core, 0, INT_MAX, 5 );
     1220        g_snprintf( buf, sizeof( buf ), _( "Limit _download speed (%s):" ), _(speed_K_str) );
     1221        w = new_check_button( buf, TR_PREFS_KEY_DSPEED_ENABLED, core );
     1222        w2 = new_spin_button( TR_PREFS_KEY_DSPEED_Bps, core, speed_K, 0, INT_MAX, 5 );
    12261223        gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED ) );
    12271224        g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
    12281225        hig_workarea_add_row_w( t, &row, w, w2, NULL );
    12291226
    1230         s = _( "Limit _upload speed (KiB/s):" );
    1231         w = new_check_button( s, TR_PREFS_KEY_USPEED_ENABLED, core );
    1232         w2 = new_spin_button( TR_PREFS_KEY_USPEED, core, 0, INT_MAX, 5 );
     1227        g_snprintf( buf, sizeof( buf ), _( "Limit _upload speed (%s):" ), _(speed_K_str) );
     1228        w = new_check_button( buf, TR_PREFS_KEY_USPEED_ENABLED, core );
     1229        w2 = new_spin_button( TR_PREFS_KEY_USPEED_Bps, core, speed_K, 0, INT_MAX, 5 );
    12331230        gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED ) );
    12341231        g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
     
    12531250        hig_workarea_add_wide_control( t, &row, w );
    12541251
    1255         s = _( "Limit do_wnload speed (KiB/s):" );
    1256         w = new_spin_button( TR_PREFS_KEY_ALT_SPEED_DOWN, core, 0, INT_MAX, 5 );
    1257         hig_workarea_add_row( t, &row, s, w, NULL );
    1258 
    1259         s = _( "Limit u_pload speed (KiB/s):" );
    1260         w = new_spin_button( TR_PREFS_KEY_ALT_SPEED_UP, core, 0, INT_MAX, 5 );
    1261         hig_workarea_add_row( t, &row, s, w, NULL );
     1252        g_snprintf( buf, sizeof( buf ), _( "Limit do_wnload speed (%s):" ), _(speed_K_str) );
     1253        w = new_spin_button( TR_PREFS_KEY_ALT_SPEED_DOWN_Bps, core, speed_K, 0, INT_MAX, 5 );
     1254        hig_workarea_add_row( t, &row, buf, w, NULL );
     1255
     1256        g_snprintf( buf, sizeof( buf ), _( "Limit u_pload speed (%s):" ), _(speed_K_str) );
     1257        w = new_spin_button( TR_PREFS_KEY_ALT_SPEED_UP_Bps, core, speed_K, 0, INT_MAX, 5 );
     1258        hig_workarea_add_row( t, &row, buf, w, NULL );
    12621259
    12631260        s = _( "_Scheduled times:" );
     
    13731370
    13741371    s = _( "_Port for incoming connections:" );
    1375     w = data->portSpin = new_spin_button( TR_PREFS_KEY_PEER_PORT, core, 1, USHRT_MAX, 1 );
     1372    w = data->portSpin = new_spin_button( TR_PREFS_KEY_PEER_PORT, core, 1, 1, USHRT_MAX, 1 );
    13761373    hig_workarea_add_row( t, &row, s, w, NULL );
    13771374
     
    13981395    hig_workarea_add_section_title( t, &row, _( "Limits" ) );
    13991396
    1400     w = new_spin_button( TR_PREFS_KEY_PEER_LIMIT_TORRENT, core, 1, 300, 5 );
     1397    w = new_spin_button( TR_PREFS_KEY_PEER_LIMIT_TORRENT, core, 1, 1, 300, 5 );
    14011398    hig_workarea_add_row( t, &row, _( "Maximum peers per _torrent:" ), w, NULL );
    1402     w = new_spin_button( TR_PREFS_KEY_PEER_LIMIT_GLOBAL, core, 1, 3000, 5 );
     1399    w = new_spin_button( TR_PREFS_KEY_PEER_LIMIT_GLOBAL, core, 1, 1, 3000, 5 );
    14031400    hig_workarea_add_row( t, &row, _( "Maximum peers _overall:" ), w, NULL );
    14041401
  • trunk/gtk/tr-window.c

    r10864 r10931  
    206206    }
    207207    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_ENABLED ) ||
    208              !strcmp( key, TR_PREFS_KEY_ALT_SPEED_UP ) ||
    209              !strcmp( key, TR_PREFS_KEY_ALT_SPEED_DOWN ) )
     208             !strcmp( key, TR_PREFS_KEY_ALT_SPEED_UP_Bps ) ||
     209             !strcmp( key, TR_PREFS_KEY_ALT_SPEED_DOWN_Bps ) )
    210210    {
    211211        syncAltSpeedButton( p );
     
    267267    GtkWidget * w = p->alt_speed_button;
    268268
    269     tr_strlspeed( u, pref_int_get( TR_PREFS_KEY_ALT_SPEED_UP ), sizeof( u ) );
    270     tr_strlspeed( d, pref_int_get( TR_PREFS_KEY_ALT_SPEED_DOWN ), sizeof( d ) );
     269    tr_strlspeed( u, pref_int_get( TR_PREFS_KEY_ALT_SPEED_UP_Bps ), sizeof( u ) );
     270    tr_strlspeed( d, pref_int_get( TR_PREFS_KEY_ALT_SPEED_DOWN_Bps ), sizeof( d ) );
    271271    fmt = b ? _( "Click to disable Temporary Speed Limits\n(%1$s down, %2$s up)" )
    272272            : _( "Click to enable Temporary Speed Limits\n(%1$s down, %2$s up)" );
     
    389389    PrivateData * p = vp;
    390390    GObject * o = G_OBJECT( check );
    391     const int speed = GPOINTER_TO_INT( g_object_get_data( o, SPEED_KEY ) );
     391    const int Bps = GPOINTER_TO_INT( g_object_get_data( o, SPEED_KEY ) ) * speed_K;
    392392    tr_direction dir = GPOINTER_TO_INT( g_object_get_data( o, DIRECTION_KEY ) );
    393393
    394     key = dir==TR_UP ? TR_PREFS_KEY_USPEED : TR_PREFS_KEY_DSPEED;
    395     tr_core_set_pref_int( p->core, key, speed );
     394    key = dir==TR_UP ? TR_PREFS_KEY_USPEED_Bps : TR_PREFS_KEY_DSPEED_Bps;
     395    tr_core_set_pref_int( p->core, key, Bps );
    396396
    397397    key = dir==TR_UP ? TR_PREFS_KEY_USPEED_ENABLED : TR_PREFS_KEY_DSPEED_ENABLED;
     
    428428    {
    429429        char buf[128];
    430         tr_strlspeed( buf, speeds[i], sizeof( buf ) );
     430        tr_strlspeed( buf, speeds[i] * speed_K, sizeof( buf ) );
    431431        w = gtk_menu_item_new_with_label( buf );
    432432        g_object_set_data( G_OBJECT( w ), DIRECTION_KEY, GINT_TO_POINTER( dir ) );
     
    542542
    543543    w = p->speedlimit_on_item[TR_DOWN];
    544     tr_strlspeed( buf1, pref_int_get( TR_PREFS_KEY_DSPEED ), sizeof( buf1 ) );
     544    tr_strlspeed( buf1, pref_int_get( TR_PREFS_KEY_DSPEED_Bps ), sizeof( buf1 ) );
    545545    gtk_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( w ) ) ), buf1 );
    546546
     
    550550
    551551    w = p->speedlimit_on_item[TR_UP];
    552     tr_strlspeed( buf1, pref_int_get( TR_PREFS_KEY_USPEED ), sizeof( buf1 ) );
     552    tr_strlspeed( buf1, pref_int_get( TR_PREFS_KEY_USPEED_Bps ), sizeof( buf1 ) );
    553553    gtk_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( w ) ) ), buf1 );
    554554
     
    843843    {
    844844        char buf[128];
    845         double up=0, down=0;
     845        int up=0, down=0;
    846846        GtkTreeIter iter;
    847847        GtkTreeModel * model = tr_core_model( p->core );
     
    849849        if( gtk_tree_model_get_iter_first( model, &iter ) ) do
    850850        {
    851             double u, d;
     851            int u, d;
    852852            gtk_tree_model_get( model, &iter, MC_SPEED_UP, &u,
    853853                                              MC_SPEED_DOWN, &d,
  • trunk/gtk/util.c

    r10864 r10931  
    4141#include "tr-prefs.h"
    4242#include "util.h"
     43
     44/***
     45****  UNITS
     46***/
     47
     48const int mem_K = 1024;
     49/* abbreviation for bytes */
     50const char * mem_B_str = N_("B");
     51/* abbreviation IEC base 2 units kilobyte */
     52const char * mem_K_str = N_("KiB");
     53/* abbreviation IEC base 2 units megabyte */
     54const char * mem_M_str = N_("MiB");
     55/* abbreviation IEC base 2 units gigabyte */
     56const char * mem_G_str = N_("GiB");
     57
     58const int disk_K = 1000;
     59/* abbreviation for bytes */
     60const char * disk_B_str = N_("B");
     61/* abbreviation for SI base 10 kilobyte */
     62const char * disk_K_str = N_("kB");
     63/* abbreviation for SI base 10 megabyte */
     64const char * disk_M_str = N_("MB");
     65/* abbreviation for SI base 10 gigabyte */
     66const char * disk_G_str = N_("GB");
     67
     68const int speed_K = 1000;
     69/* abbreviation for bytes per second */
     70const char * speed_B_str = N_("B/s");
     71/* abbreviation for kilobytes per second */
     72const char * speed_K_str = N_("kB/s");
     73/* abbreviation for megabytes per second */
     74const char * speed_M_str = N_("MB/s");
     75/* abbreviation for gigabytes per second */
     76const char * speed_G_str = N_("GB/s");
     77
     78/***
     79****
     80***/
    4381
    4482gtr_lockfile_state_t
     
    125163
    126164char*
    127 tr_strlspeed( char * buf, double kb_sec, size_t buflen )
    128 {
    129     const int64_t bytes_per_second = kb_sec * 1024.0;
    130 
     165tr_strlspeed( char * buf, int bytes_per_second, size_t buflen )
     166{
    131167    if( bytes_per_second < 1 )
    132168        g_strlcpy( buf, _( "None" ), buflen );
  • trunk/gtk/util.h

    r10864 r10931  
    1818#include <gtk/gtk.h>
    1919
     20#include <libtransmission/transmission.h>
     21
     22extern const int mem_K;
     23extern const char * mem_B_str;
     24extern const char * mem_K_str;
     25extern const char * mem_M_str;
     26extern const char * mem_G_str;
     27
     28extern const int disk_K;
     29extern const char * disk_B_str;
     30extern const char * disk_K_str;
     31extern const char * disk_M_str;
     32extern const char * disk_G_str;
     33
     34extern const int speed_K;
     35extern const char * speed_B_str;
     36extern const char * speed_K_str;
     37extern const char * speed_M_str;
     38extern const char * speed_G_str;
     39
    2040/* portability wrapper around g_warn_if_fail() for older versions of glib */
    2141#ifdef g_warn_if_fail
     
    4666char* tr_strlsize( char * buf, guint64  size, size_t buflen );
    4767
    48 /* return a human-readable string for the transfer rate given in bytes. */
    49 char* tr_strlspeed( char * buf, double KiBps, size_t buflen );
     68/* return a human-readable string for the transfer rate given in Bps. */
     69char* tr_strlspeed( char * buf, int bytes_per_second, size_t buflen );
    5070
    5171/* return a human-readable string for the given ratio. */
  • trunk/libtransmission/bandwidth.c

    r10662 r10931  
    3131***/
    3232
    33 static float
    34 getSpeed( const struct bratecontrol * r, int interval_msec, uint64_t now )
     33static unsigned int
     34getSpeed_Bps( const struct bratecontrol * r, unsigned int interval_msec, uint64_t now )
    3535{
    3636    uint64_t       bytes = 0;
     
    4949    }
    5050
    51     return ( bytes / 1024.0 ) * ( 1000.0 / interval_msec );
     51    return (unsigned int)(( bytes * 1000u ) / interval_msec);
    5252}
    5353
     
    154154                   tr_priority_t   parent_priority,
    155155                   tr_direction    dir,
    156                    int             period_msec,
     156                   unsigned int    period_msec,
    157157                   tr_ptrArray   * peer_pool )
    158158{
     
    165165    if( b->band[dir].isLimited )
    166166    {
    167         const double desiredSpeed = b->band[dir].desiredSpeed;
    168         const double nextPulseSpeed = desiredSpeed;
    169         b->band[dir].bytesLeft = MAX( 0.0, nextPulseSpeed * 1024.0 * period_msec / 1000.0 );
     167        const unsigned int nextPulseSpeed = b->band[dir].desiredSpeed_Bps;
     168        b->band[dir].bytesLeft = ( nextPulseSpeed * period_msec ) / 1000u;
    170169
    171170#ifdef DEBUG_DIRECTION
    172171        if( dir == DEBUG_DIRECTION )
    173                 fprintf( stderr, "bandwidth %p currentPieceSpeed(%5.2f of %5.2f) desiredSpeed(%5.2f), allocating %5.2f\n",
     172                fprintf( stderr, "bandwidth %p currentPieceSpeed(%5.2f of %5.2f) desiredSpeed(%5.2f), allocating %d\n",
    174173                         b, currentSpeed, tr_bandwidthGetRawSpeed( b, dir ), desiredSpeed,
    175                          b->band[dir].bytesLeft/1024.0 );
     174                         b->band[dir].bytesLeft );
    176175#endif
    177176    }
     
    239238tr_bandwidthAllocate( tr_bandwidth  * b,
    240239                      tr_direction    dir,
    241                       int             period_msec )
     240                      unsigned int    period_msec )
    242241{
    243242    int i, peerCount;
     
    307306***/
    308307
    309 size_t
     308unsigned int
    310309tr_bandwidthClamp( const tr_bandwidth  * b,
    311310                   tr_direction          dir,
    312                    size_t                byteCount )
     311                   unsigned int          byteCount )
    313312{
    314313    assert( tr_isBandwidth( b ) );
     
    327326}
    328327
    329 double
    330 tr_bandwidthGetRawSpeed( const tr_bandwidth * b, const uint64_t now, const tr_direction dir )
    331 {
    332     assert( tr_isBandwidth( b ) );
    333     assert( tr_isDirection( dir ) );
    334 
    335     return getSpeed( &b->band[dir].raw, HISTORY_MSEC, now );
    336 }
    337 
    338 double
    339 tr_bandwidthGetPieceSpeed( const tr_bandwidth * b, const uint64_t now, const tr_direction dir )
    340 {
    341     assert( tr_isBandwidth( b ) );
    342     assert( tr_isDirection( dir ) );
    343 
    344     return getSpeed( &b->band[dir].piece, HISTORY_MSEC, now );
     328unsigned int
     329tr_bandwidthGetRawSpeed_Bps( const tr_bandwidth * b, const uint64_t now, const tr_direction dir )
     330{
     331    assert( tr_isBandwidth( b ) );
     332    assert( tr_isDirection( dir ) );
     333
     334    return getSpeed_Bps( &b->band[dir].raw, HISTORY_MSEC, now );
     335}
     336
     337unsigned int
     338tr_bandwidthGetPieceSpeed_Bps( const tr_bandwidth * b, const uint64_t now, const tr_direction dir )
     339{
     340    assert( tr_isBandwidth( b ) );
     341    assert( tr_isDirection( dir ) );
     342
     343    return getSpeed_Bps( &b->band[dir].piece, HISTORY_MSEC, now );
    345344}
    346345
  • trunk/libtransmission/bandwidth.h

    r9868 r10931  
    3333enum
    3434{
    35     HISTORY_MSEC = 2000,
     35    HISTORY_MSEC = 2000u,
    3636    INTERVAL_MSEC = HISTORY_MSEC,
    3737    GRANULARITY_MSEC = 200,
     
    5454    tr_bool isLimited;
    5555    tr_bool honorParentLimits;
    56     size_t bytesLeft;
    57     double desiredSpeed;
     56    unsigned int bytesLeft;
     57    unsigned int desiredSpeed_Bps;
    5858    struct bratecontrol raw;
    5959    struct bratecontrol piece;
     
    148148
    149149/**
    150  * @brief Set the desired speed (in KiB/s) for this bandwidth subtree.
     150 * @brief Set the desired speed for this bandwidth subtree.
    151151 * @see tr_bandwidthAllocate
    152152 * @see tr_bandwidthGetDesiredSpeed
    153153 */
    154 static inline tr_bool tr_bandwidthSetDesiredSpeed( tr_bandwidth        * bandwidth,
    155                                                       tr_direction          dir,
    156                                                       double                desiredSpeed )
    157 {
    158     double * value = &bandwidth->band[dir].desiredSpeed;
    159     const tr_bool didChange = (int)(desiredSpeed*1024.0) != (int)(*value*1024.0);
     154static inline tr_bool tr_bandwidthSetDesiredSpeed_Bps( tr_bandwidth        * bandwidth,
     155                                                       tr_direction          dir,
     156                                                       unsigned int          desiredSpeed )
     157{
     158    unsigned int * value = &bandwidth->band[dir].desiredSpeed_Bps;
     159    const tr_bool didChange = desiredSpeed != *value;
    160160    *value = desiredSpeed;
    161161    return didChange;
     
    163163
    164164/**
    165  * @brief Get the desired speed (in KiB/s) for ths bandwidth subtree.
     165 * @brief Get the desired speed for the bandwidth subtree.
    166166 * @see tr_bandwidthSetDesiredSpeed
    167167 */
    168168static inline double
    169 tr_bandwidthGetDesiredSpeed( const tr_bandwidth  * bandwidth,
    170                              tr_direction          dir )
    171 {
    172     return bandwidth->band[dir].desiredSpeed;
     169tr_bandwidthGetDesiredSpeed_Bps( const tr_bandwidth  * bandwidth, tr_direction dir )
     170{
     171    return bandwidth->band[dir].desiredSpeed_Bps;
    173172}
    174173
     
    200199void    tr_bandwidthAllocate          ( tr_bandwidth        * bandwidth,
    201200                                        tr_direction          direction,
    202                                         int                   period_msec );
     201                                        unsigned int          period_msec );
    203202
    204203/**
    205204 * @brief clamps byteCount down to a number that this bandwidth will allow to be consumed
    206205 */
    207 size_t  tr_bandwidthClamp             ( const tr_bandwidth  * bandwidth,
     206unsigned int  tr_bandwidthClamp       ( const tr_bandwidth  * bandwidth,
    208207                                        tr_direction          direction,
    209                                         size_t                byteCount );
     208                                        unsigned int          byteCount );
    210209
    211210/******
     
    214213
    215214/** @brief Get the raw total of bytes read or sent by this bandwidth subtree. */
    216 double tr_bandwidthGetRawSpeed( const tr_bandwidth  * bandwidth,
    217                                 const uint64_t        now,
    218                                 const tr_direction    direction );
     215unsigned int tr_bandwidthGetRawSpeed_Bps( const tr_bandwidth  * bandwidth,
     216                                           const uint64_t        now,
     217                                           const tr_direction    direction );
    219218
    220219/** @brief Get the number of piece data bytes read or sent by this bandwidth subtree. */
    221 double tr_bandwidthGetPieceSpeed( const tr_bandwidth  * bandwidth,
    222                                   const uint64_t        now,
    223                                   const tr_direction    direction );
     220unsigned int tr_bandwidthGetPieceSpeed_Bps( const tr_bandwidth  * bandwidth,
     221                                            const uint64_t        now,
     222                                            const tr_direction    direction );
    224223
    225224/**
  • trunk/libtransmission/cache.c

    r10924 r10931  
    4949{
    5050    tr_ptrArray blocks;
    51     int maxBlocks;
    52     size_t maxMiB;
     51    int max_blocks;
     52    size_t max_bytes;
    5353
    5454    size_t disk_writes;
     
    198198    int err = 0;
    199199
    200     while( !err && ( tr_ptrArraySize( &cache->blocks ) > cache->maxBlocks ) )
     200    while( !err && ( tr_ptrArraySize( &cache->blocks ) > cache->max_blocks ) )
    201201    {
    202202        int n;
     
    213213
    214214static int
    215 getMaxBlocks( double maxMiB )
    216 {
    217     const double maxBytes = maxMiB * (1024 * 1024);
    218     return maxBytes / MAX_BLOCK_SIZE;
    219 }
    220 
    221 int
    222 tr_cacheSetLimit( tr_cache * cache, double maxMiB )
    223 {
    224     cache->maxMiB = maxMiB;
    225     cache->maxBlocks = getMaxBlocks( maxMiB );
    226     tr_ndbg( MY_NAME, "Maximum cache size set to %.2f MiB (%d blocks)", maxMiB, cache->maxBlocks );
     215getMaxBlocks( int64_t max_bytes )
     216{
     217    return max_bytes / (double)MAX_BLOCK_SIZE;
     218}
     219
     220int
     221tr_cacheSetLimit( tr_cache * cache, int64_t max_bytes )
     222{
     223    char buf[128];
     224
     225    cache->max_bytes = max_bytes;
     226    cache->max_blocks = getMaxBlocks( max_bytes );
     227
     228    tr_formatter_mem( buf, cache->max_bytes, sizeof( buf ) );
     229    tr_ndbg( MY_NAME, "Maximum cache size set to %s (%d blocks)", buf, cache->max_blocks );
     230
    227231    return cacheTrim( cache );
    228232}
    229233
    230 double
     234int64_t
    231235tr_cacheGetLimit( const tr_cache * cache )
    232236{
    233     return cache->maxMiB;
     237    return cache->max_bytes;
    234238}
    235239
    236240tr_cache *
    237 tr_cacheNew( double maxMiB )
     241tr_cacheNew( int64_t max_bytes )
    238242{
    239243    tr_cache * cache = tr_new0( tr_cache, 1 );
    240244    cache->blocks = TR_PTR_ARRAY_INIT;
    241     cache->maxBlocks = getMaxBlocks( maxMiB );
     245    cache->max_bytes = max_bytes;
     246    cache->max_blocks = getMaxBlocks( max_bytes );
    242247    return cache;
    243248}
  • trunk/libtransmission/cache.h

    r10798 r10931  
    2424***/
    2525
    26 tr_cache * tr_cacheNew( double max_MiB );
     26tr_cache * tr_cacheNew( int64_t max_bytes );
    2727
    2828void tr_cacheFree( tr_cache * );
     
    3232***/
    3333
    34 int tr_cacheSetLimit( tr_cache * cache, double max_MiB );
     34int tr_cacheSetLimit( tr_cache * cache, int64_t max_bytes );
    3535
    36 double tr_cacheGetLimit( const tr_cache * );
     36int64_t tr_cacheGetLimit( const tr_cache * );
    3737
    3838int tr_cacheWriteBlock( tr_cache         * cache,
  • trunk/libtransmission/peer-io.c

    r10913 r10931  
    6767    const double assumed_payload_data_rate = 94.0;
    6868
    69     return (size_t)( d * ( 100.0 / assumed_payload_data_rate ) - d );
     69    return (unsigned int)( d * ( 100.0 / assumed_payload_data_rate ) - d );
    7070}
    7171
     
    9191
    9292static void
    93 didWriteWrapper( tr_peerIo * io, size_t bytes_transferred )
     93didWriteWrapper( tr_peerIo * io, unsigned int bytes_transferred )
    9494{
    9595     while( bytes_transferred && tr_isPeerIo( io ) )
     
    9797        struct tr_datatype * next = io->outbuf_datatypes->data;
    9898
    99         const size_t payload = MIN( next->length, bytes_transferred );
    100         const size_t overhead = guessPacketOverhead( payload );
     99        const unsigned int payload = MIN( next->length, bytes_transferred );
     100        const unsigned int overhead = guessPacketOverhead( payload );
    101101
    102102        tr_bandwidthUsed( &io->bandwidth, TR_UP, payload, next->isPieceData );
     
    207207
    208208    /* Limit the input buffer to 256K, so it doesn't grow too large */
    209     size_t howmuch;
     209    unsigned int howmuch;
     210    unsigned int curlen;
    210211    const tr_direction dir = TR_DOWN;
    211     const size_t max = 256 * 1024;
    212     size_t curlen;
     212    const unsigned int max = 256 * 1024;
    213213
    214214    assert( tr_isPeerIo( io ) );
     
    230230
    231231    EVUTIL_SET_SOCKET_ERROR( 0 );
    232     res = evbuffer_read( io->inbuf, fd, howmuch );
     232    res = evbuffer_read( io->inbuf, fd, (int)howmuch );
    233233    e = EVUTIL_SOCKET_ERROR( );
    234234
     
    283283
    284284    if( n > 0 )
    285         evbuffer_drain( buffer, n );
     285        evbuffer_drain( buffer, (size_t)n );
    286286
    287287    /* keep the iobuf's excess capacity from growing too large */
     
    717717**/
    718718
    719 static size_t
     719static unsigned int
    720720getDesiredOutputBufferSize( const tr_peerIo * io, uint64_t now )
    721721{
     
    724724     * or a few blocks, whichever is bigger.
    725725     * It's okay to tweak this as needed */
    726     const double currentSpeed = tr_bandwidthGetPieceSpeed( &io->bandwidth, now, TR_UP );
    727     const double period = 15; /* arbitrary */
    728     const double numBlocks = 3.5; /* the 3 is arbitrary; the .5 is to leave room for messages */
    729     return MAX( MAX_BLOCK_SIZE*numBlocks, currentSpeed*1024*period );
     726    const unsigned int currentSpeed_Bps = tr_bandwidthGetPieceSpeed_Bps( &io->bandwidth, now, TR_UP );
     727    const unsigned int period = 15u; /* arbitrary */
     728    /* the 3 is arbitrary; the .5 is to leave room for messages */
     729    static const unsigned int ceiling =  (unsigned int)( MAX_BLOCK_SIZE * 3.5 );
     730    return MAX( ceiling, currentSpeed_Bps*period );
    730731}
    731732
     
    883884
    884885        EVUTIL_SET_SOCKET_ERROR( 0 );
    885         res = evbuffer_read( io->inbuf, io->socket, howmuch );
     886        res = evbuffer_read( io->inbuf, io->socket, (int)howmuch );
    886887        e = EVUTIL_SOCKET_ERROR( );
    887888
  • trunk/libtransmission/peer-io.h

    r10912 r10931  
    369369                                  int                   isPieceData );
    370370
    371 static inline tr_bool tr_peerIoHasBandwidthLeft( const tr_peerIo  * io,
    372                                                     tr_direction      dir )
     371static inline tr_bool
     372tr_peerIoHasBandwidthLeft( const tr_peerIo * io, tr_direction dir )
    373373{
    374374    assert( tr_isPeerIo( io ) );
     
    378378}
    379379
    380 static inline double tr_peerIoGetPieceSpeed( const tr_peerIo * io, uint64_t now, tr_direction dir )
     380static inline unsigned int
     381tr_peerIoGetPieceSpeed_Bps( const tr_peerIo * io, uint64_t now, tr_direction dir )
    381382{
    382383    assert( tr_isPeerIo( io ) );
    383384    assert( tr_isDirection( dir ) );
    384385
    385     return tr_bandwidthGetPieceSpeed( &io->bandwidth, now, dir );
     386    return tr_bandwidthGetPieceSpeed_Bps( &io->bandwidth, now, dir );
    386387}
    387388
  • trunk/libtransmission/peer-mgr.c

    r10923 r10931  
    22512251}
    22522252
    2253 float
    2254 tr_peerMgrGetWebseedSpeed( const tr_torrent * tor, uint64_t now )
     2253int
     2254tr_peerMgrGetWebseedSpeed_Bps( const tr_torrent * tor, uint64_t now )
    22552255{
    22562256    int i;
    2257     float tmp;
    2258     float ret = 0;
     2257    int tmp;
     2258    int ret = 0;
    22592259
    22602260    const Torrent * t = tor->torrentPeers;
     
    22632263
    22642264    for( i=0; i<n; ++i )
    2265         if( tr_webseedGetSpeed( webseeds[i], now, &tmp ) )
     2265        if( tr_webseedGetSpeed_Bps( webseeds[i], now, &tmp ) )
    22662266            ret += tmp;
    22672267
     
    22702270
    22712271
    2272 float*
    2273 tr_peerMgrWebSpeeds( const tr_torrent * tor )
     2272int*
     2273tr_peerMgrWebSpeeds_Bps( const tr_torrent * tor )
    22742274{
    22752275    const Torrent * t = tor->torrentPeers;
     
    22772277    int i;
    22782278    int webseedCount;
    2279     float * ret;
     2279    int * ret;
    22802280    uint64_t now;
    22812281
     
    22862286    webseedCount = tr_ptrArraySize( &t->webseeds );
    22872287    assert( webseedCount == tor->info.webseedCount );
    2288     ret = tr_new0( float, webseedCount );
     2288    ret = tr_new0( int, webseedCount );
    22892289    now = tr_date( );
    22902290
    22912291    for( i=0; i<webseedCount; ++i )
    2292         if( !tr_webseedGetSpeed( webseeds[i], now, &ret[i] ) )
     2292        if( !tr_webseedGetSpeed_Bps( webseeds[i], now, &ret[i] ) )
    22932293            ret[i] = -1.0;
    22942294
     
    22972297}
    22982298
    2299 double
    2300 tr_peerGetPieceSpeed( const tr_peer * peer, uint64_t now, tr_direction direction )
    2301 {
    2302     return peer->io ? tr_peerIoGetPieceSpeed( peer->io, now, direction ) : 0.0;
     2299int
     2300tr_peerGetPieceSpeed_Bps( const tr_peer * peer, uint64_t now, tr_direction direction )
     2301{
     2302    return peer->io ? tr_peerIoGetPieceSpeed_Bps( peer->io, now, direction ) : 0.0;
    23032303}
    23042304
     
    23372337        stat->progress            = peer->progress;
    23382338        stat->isEncrypted         = tr_peerIoIsEncrypted( peer->io ) ? 1 : 0;
    2339         stat->rateToPeer          = tr_peerGetPieceSpeed( peer, now, TR_CLIENT_TO_PEER );
    2340         stat->rateToClient        = tr_peerGetPieceSpeed( peer, now, TR_PEER_TO_CLIENT );
     2339        stat->rateToPeer_Bps      = tr_peerGetPieceSpeed_Bps( peer, now, TR_CLIENT_TO_PEER );
     2340        stat->rateToClient_Bps    = tr_peerGetPieceSpeed_Bps( peer, now, TR_PEER_TO_CLIENT );
    23412341        stat->peerIsChoked        = peer->peerIsChoked;
    23422342        stat->peerIsInterested    = peer->peerIsInterested;
     
    26142614getRate( const tr_torrent * tor, struct peer_atom * atom, uint64_t now )
    26152615{
    2616     double KiB_s;
     2616    int Bps;
    26172617
    26182618    if( tr_torrentIsSeed( tor ) )
    2619         KiB_s = tr_peerGetPieceSpeed( atom->peer, now, TR_CLIENT_TO_PEER );
     2619        Bps = tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_CLIENT_TO_PEER );
    26202620
    26212621    /* downloading a private torrent... take upload speed into account
    26222622     * because there may only be a small window of opportunity to share */
    26232623    else if( tr_torrentIsPrivate( tor ) )
    2624         KiB_s = tr_peerGetPieceSpeed( atom->peer, now, TR_PEER_TO_CLIENT )
    2625               + tr_peerGetPieceSpeed( atom->peer, now, TR_CLIENT_TO_PEER );
     2624        Bps = tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_PEER_TO_CLIENT )
     2625            + tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_CLIENT_TO_PEER );
    26262626
    26272627    /* downloading a public torrent */
    26282628    else
    2629         KiB_s = tr_peerGetPieceSpeed( atom->peer, now, TR_PEER_TO_CLIENT );
     2629        Bps = tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_PEER_TO_CLIENT );
    26302630
    26312631    /* convert it to bytes per second */
    2632     return (int)( KiB_s * 1024 );
     2632    return Bps;
    26332633}
    26342634
     
    29962996        l->pieceDataTime = p->atom->piece_data_time;
    29972997        l->time = p->atom->time;
    2998         l->speed = 1024.0 * (   tr_peerGetPieceSpeed( p, now, TR_UP )
    2999                               + tr_peerGetPieceSpeed( p, now, TR_DOWN ) );
     2998        l->speed = tr_peerGetPieceSpeed_Bps( p, now, TR_UP )
     2999                 + tr_peerGetPieceSpeed_Bps( p, now, TR_DOWN );
    30003000        if( clientData )
    30013001            l->clientData = clientData[i];
     
    33163316        return FALSE;
    33173317    else {
    3318         const double got = tr_bandwidthGetPieceSpeed( b, now_msec, dir );
    3319         const double want = tr_bandwidthGetDesiredSpeed( b, dir );
     3318        const int got = tr_bandwidthGetPieceSpeed_Bps( b, now_msec, dir );
     3319        const int want = tr_bandwidthGetDesiredSpeed_Bps( b, dir );
    33203320        return got >= want;
    33213321    }
  • trunk/libtransmission/peer-mgr.h

    r10800 r10931  
    226226                                          int              * setmeCount );
    227227
    228 float tr_peerMgrGetWebseedSpeed( const tr_torrent * tor, uint64_t now );
    229 
    230 float* tr_peerMgrWebSpeeds( const tr_torrent * tor );
    231 
    232 
    233 double tr_peerGetPieceSpeed( const tr_peer    * peer,
    234                              uint64_t           now,
    235                              tr_direction       direction );
     228int tr_peerMgrGetWebseedSpeed_Bps( const tr_torrent * tor, uint64_t now );
     229
     230int* tr_peerMgrWebSpeeds_Bps( const tr_torrent * tor );
     231
     232
     233int tr_peerGetPieceSpeed_Bps( const tr_peer    * peer,
     234                              uint64_t           now,
     235                              tr_direction       direction );
    236236
    237237/* @} */
  • trunk/libtransmission/peer-msgs.c

    r10800 r10931  
    17011701    else
    17021702    {
    1703         int irate;
    17041703        int estimatedBlocksInPeriod;
    1705         double rate;
     1704        int rate_Bps;
     1705        int irate_Bps;
    17061706        const int floor = 4;
    17071707        const int seconds = REQUEST_BUF_SECS;
     
    17091709        /* Get the rate limit we should use.
    17101710         * FIXME: this needs to consider all the other peers as well... */
    1711         rate = tr_peerGetPieceSpeed( msgs->peer, now, TR_PEER_TO_CLIENT );
     1711        rate_Bps = tr_peerGetPieceSpeed_Bps( msgs->peer, now, TR_PEER_TO_CLIENT );
    17121712        if( tr_torrentUsesSpeedLimit( torrent, TR_PEER_TO_CLIENT ) )
    1713             rate = MIN( rate, tr_torrentGetSpeedLimit( torrent, TR_PEER_TO_CLIENT ) );
     1713            rate_Bps = MIN( rate_Bps, tr_torrentGetSpeedLimit_Bps( torrent, TR_PEER_TO_CLIENT ) );
    17141714
    17151715        /* honor the session limits, if enabled */
    17161716        if( tr_torrentUsesSessionLimits( torrent ) )
    1717             if( tr_sessionGetActiveSpeedLimit( torrent->session, TR_PEER_TO_CLIENT, &irate ) )
    1718                 rate = MIN( rate, irate );
     1717            if( tr_sessionGetActiveSpeedLimit_Bps( torrent->session, TR_PEER_TO_CLIENT, &irate_Bps ) )
     1718                rate_Bps = MIN( rate_Bps, irate_Bps );
    17191719
    17201720        /* use this desired rate to figure out how
    17211721         * many requests we should send to this peer */
    1722         estimatedBlocksInPeriod = ( rate * seconds * 1024 ) / torrent->blockSize;
     1722        estimatedBlocksInPeriod = ( rate_Bps * seconds ) / torrent->blockSize;
    17231723        msgs->desiredRequestCount = MAX( floor, estimatedBlocksInPeriod );
    17241724
  • trunk/libtransmission/ratecontrol.c

    r7618 r10931  
    3131
    3232/* return the xfer rate over the last `interval' seconds in KiB/sec */
    33 static float
     33static int
    3434rateForInterval( const tr_ratecontrol * r,
    3535                 int                    interval_msec,
     
    5151    }
    5252
    53     return ( bytes / 1024.0 ) * ( 1000.0 / interval_msec );
     53    return bytes * ( 1000.0 / interval_msec );
    5454}
    5555
     
    5858***/
    5959
    60 float
    61 tr_rcRate( const tr_ratecontrol * r, uint64_t now )
     60int
     61tr_rcRate_Bps( const tr_ratecontrol * r, uint64_t now )
    6262{
    63     float ret = 0.0f;
     63    int ret = 0;
    6464
    6565    if( r )
  • trunk/libtransmission/ratecontrol.h

    r9847 r10931  
    7171                                    size_t                   byteCount );
    7272
    73 float            tr_rcRate        ( const tr_ratecontrol   * ratecontrol,
    74                                     uint64_t                 now );
     73int              tr_rcRate_Bps ( const tr_ratecontrol   * ratecontrol,
     74                                 uint64_t                 now );
    7575
    7676
  • trunk/libtransmission/resume.c

    r10502 r10931  
    4747#define KEY_UPLOADED            "uploaded"
    4848
    49 #define KEY_SPEED                  "speed"
     49#define KEY_SPEED_KiBps            "speed"
     50#define KEY_SPEED_Bps              "speed-Bps"
    5051#define KEY_USE_GLOBAL_SPEED_LIMIT "use-global-speed-limit"
    5152#define KEY_USE_SPEED_LIMIT        "use-speed-limit"
     
    270271{
    271272    tr_bencDictReserve( d, 3 );
    272     tr_bencDictAddInt( d, KEY_SPEED, tr_torrentGetSpeedLimit( tor, dir ) );
     273    tr_bencDictAddInt( d, KEY_SPEED_Bps, tr_torrentGetSpeedLimit_Bps( tor, dir ) );
    273274    tr_bencDictAddBool( d, KEY_USE_GLOBAL_SPEED_LIMIT, tr_torrentUsesSessionLimits( tor ) );
    274275    tr_bencDictAddBool( d, KEY_USE_SPEED_LIMIT, tr_torrentUsesSpeedLimit( tor, dir ) );
     
    296297    tr_bool boolVal;
    297298
    298     if( tr_bencDictFindInt( d, KEY_SPEED, &i ) )
    299         tr_torrentSetSpeedLimit( tor, dir, i );
     299    if( tr_bencDictFindInt( d, KEY_SPEED_Bps, &i ) )
     300        tr_torrentSetSpeedLimit_Bps( tor, dir, i );
     301    else if( tr_bencDictFindInt( d, KEY_SPEED_KiBps, &i ) )
     302        tr_torrentSetSpeedLimit_Bps( tor, dir, i*1024 );
    300303
    301304    if( tr_bencDictFindBool( d, KEY_USE_SPEED_LIMIT, &boolVal ) )
     
    335338        int64_t i;
    336339        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_DOWN_SPEED, &i ) )
    337             tr_torrentSetSpeedLimit( tor, TR_DOWN, i );
     340            tr_torrentSetSpeedLimit_Bps( tor, TR_DOWN, i*1024 );
    338341        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_DOWN_MODE, &i ) ) {
    339342            tr_torrentUseSpeedLimit( tor, TR_DOWN, i==TR_SPEEDLIMIT_SINGLE );
     
    341344         }
    342345        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_UP_SPEED, &i ) )
    343             tr_torrentSetSpeedLimit( tor, TR_UP, i );
     346            tr_torrentSetSpeedLimit_Bps( tor, TR_UP, i*1024 );
    344347        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_UP_MODE, &i ) ) {
    345348            tr_torrentUseSpeedLimit( tor, TR_UP, i==TR_SPEEDLIMIT_SINGLE );
  • trunk/libtransmission/rpcimpl.c

    r10906 r10931  
    443443        tr_bencDictAddInt ( d, "port", peer->port );
    444444        tr_bencDictAddReal( d, "progress", peer->progress );
    445         tr_bencDictAddInt ( d, "rateToClient", (int)( peer->rateToClient * 1024.0 ) );
    446         tr_bencDictAddInt ( d, "rateToPeer", (int)( peer->rateToPeer * 1024.0 ) );
     445        tr_bencDictAddInt ( d, "rateToClient", peer->rateToClient_Bps );
     446        tr_bencDictAddInt ( d, "rateToPeer", peer->rateToPeer_Bps );
    447447    }
    448448
     
    485485        tr_bencDictAddInt( d, key, st->downloadedEver );
    486486    else if( tr_streq( key, keylen, "downloadLimit" ) )
    487         tr_bencDictAddInt( d, key, tr_torrentGetSpeedLimit( tor, TR_DOWN ) );
     487        tr_bencDictAddInt( d, key, tr_torrentGetSpeedLimit_Bps( tor, TR_DOWN ) );
    488488    else if( tr_streq( key, keylen, "downloadLimited" ) )
    489489        tr_bencDictAddBool( d, key, tr_torrentUsesSpeedLimit( tor, TR_DOWN ) );
     
    570570    }
    571571    else if( tr_streq( key, keylen, "rateDownload" ) )
    572         tr_bencDictAddInt( d, key, (int)( st->pieceDownloadSpeed * 1024 ) );
     572        tr_bencDictAddInt( d, key, st->pieceDownloadSpeed_Bps );
    573573    else if( tr_streq( key, keylen, "rateUpload" ) )
    574         tr_bencDictAddInt( d, key, (int)( st->pieceUploadSpeed * 1024 ) );
     574        tr_bencDictAddInt( d, key, st->pieceUploadSpeed_Bps );
    575575    else if( tr_streq( key, keylen, "recheckProgress" ) )
    576576        tr_bencDictAddReal( d, key, st->recheckProgress );
     
    600600        tr_bencDictAddInt( d, key, st->uploadedEver );
    601601    else if( tr_streq( key, keylen, "uploadLimit" ) )
    602         tr_bencDictAddInt( d, key, tr_torrentGetSpeedLimit( tor, TR_UP ) );
     602        tr_bencDictAddInt( d, key, tr_torrentGetSpeedLimit_Bps( tor, TR_UP ) );
    603603    else if( tr_streq( key, keylen, "uploadLimited" ) )
    604604        tr_bencDictAddBool( d, key, tr_torrentUsesSpeedLimit( tor, TR_UP ) );
     
    10051005            errmsg = setFilePriorities( tor, TR_PRI_NORMAL, files );
    10061006        if( tr_bencDictFindInt( args_in, "downloadLimit", &tmp ) )
    1007             tr_torrentSetSpeedLimit( tor, TR_DOWN, tmp );
     1007            tr_torrentSetSpeedLimit_Bps( tor, TR_DOWN, tmp );
    10081008        if( tr_bencDictFindBool( args_in, "downloadLimited", &boolVal ) )
    10091009            tr_torrentUseSpeedLimit( tor, TR_DOWN, boolVal );
     
    10111011            tr_torrentUseSessionLimits( tor, boolVal );
    10121012        if( tr_bencDictFindInt( args_in, "uploadLimit", &tmp ) )
    1013             tr_torrentSetSpeedLimit( tor, TR_UP, tmp );
     1013            tr_torrentSetSpeedLimit_Bps( tor, TR_UP, tmp );
    10141014        if( tr_bencDictFindBool( args_in, "uploadLimited", &boolVal ) )
    10151015            tr_torrentUseSpeedLimit( tor, TR_UP, boolVal );
     
    14081408    assert( idle_data == NULL );
    14091409
    1410     if( tr_bencDictFindReal( args_in, TR_PREFS_KEY_MAX_CACHE_SIZE_MiB, &d ) )
     1410    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_MAX_CACHE_SIZE, &i ) )
    14111411        tr_sessionSetCacheLimit( session, d );
    1412     if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_UP, &i ) )
    1413         tr_sessionSetAltSpeed( session, TR_UP, i );
    1414     if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_DOWN, &i ) )
    1415         tr_sessionSetAltSpeed( session, TR_DOWN, i );
     1412    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_UP_Bps, &i ) )
     1413        tr_sessionSetAltSpeed_Bps( session, TR_UP, i );
     1414    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_DOWN_Bps, &i ) )
     1415        tr_sessionSetAltSpeed_Bps( session, TR_DOWN, i );
    14161416    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_ALT_SPEED_ENABLED, &boolVal ) )
    14171417        tr_sessionUseAltSpeed( session, boolVal );
     
    14621462    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_TRASH_ORIGINAL, &boolVal ) )
    14631463        tr_sessionSetDeleteSource( session, boolVal );
    1464     if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_DSPEED, &i ) )
    1465         tr_sessionSetSpeedLimit( session, TR_DOWN, i );
     1464    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_DSPEED_Bps, &i ) )
     1465        tr_sessionSetSpeedLimit_Bps( session, TR_DOWN, i );
    14661466    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_DSPEED_ENABLED, &boolVal ) )
    14671467        tr_sessionLimitSpeed( session, TR_DOWN, boolVal );
    1468     if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_USPEED, &i ) )
    1469         tr_sessionSetSpeedLimit( session, TR_UP, i );
     1468    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_USPEED_Bps, &i ) )
     1469        tr_sessionSetSpeedLimit_Bps( session, TR_UP, i );
    14701470    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_USPEED_ENABLED, &boolVal ) )
    14711471        tr_sessionLimitSpeed( session, TR_UP, boolVal );
     
    15091509
    15101510    tr_bencDictAddInt( args_out, "activeTorrentCount", running );
    1511     tr_bencDictAddInt( args_out, "downloadSpeed", (int)( tr_sessionGetPieceSpeed( session, TR_DOWN ) * 1024 ) );
     1511    tr_bencDictAddInt( args_out, "downloadSpeed", tr_sessionGetPieceSpeed_Bps( session, TR_DOWN ) );
    15121512    tr_bencDictAddInt( args_out, "pausedTorrentCount", total - running );
    15131513    tr_bencDictAddInt( args_out, "torrentCount", total );
    1514     tr_bencDictAddInt( args_out, "uploadSpeed", (int)( tr_sessionGetPieceSpeed( session, TR_UP ) * 1024 ) );
     1514    tr_bencDictAddInt( args_out, "uploadSpeed", tr_sessionGetPieceSpeed_Bps( session, TR_UP ) );
    15151515
    15161516    d = tr_bencDictAddDict( args_out, "cumulative-stats", 5 );
     
    15411541
    15421542    assert( idle_data == NULL );
    1543     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP, tr_sessionGetAltSpeed(s,TR_UP) );
    1544     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN, tr_sessionGetAltSpeed(s,TR_DOWN) );
     1543    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP_Bps, tr_sessionGetAltSpeed_Bps(s,TR_UP) );
     1544    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN_Bps, tr_sessionGetAltSpeed_Bps(s,TR_DOWN) );
    15451545    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed(s) );
    15461546    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, tr_sessionGetAltSpeedBegin(s) );
     
    15491549    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, tr_sessionUsesAltSpeedTime(s) );
    15501550    tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, tr_blocklistIsEnabled( s ) );
    1551     tr_bencDictAddReal( d, TR_PREFS_KEY_MAX_CACHE_SIZE_MiB, tr_sessionGetCacheLimit( s ) );
     1551    tr_bencDictAddReal( d, TR_PREFS_KEY_MAX_CACHE_SIZE, tr_sessionGetCacheLimit( s ) );
    15521552    tr_bencDictAddInt ( d, "blocklist-size", tr_blocklistGetRuleCount( s ) );
    15531553    tr_bencDictAddStr ( d, "config-dir", tr_sessionGetConfigDir( s ) );
     
    15701570    tr_bencDictAddBool( d, TR_PREFS_KEY_START, !tr_sessionGetPaused( s ) );
    15711571    tr_bencDictAddBool( d, TR_PREFS_KEY_TRASH_ORIGINAL, tr_sessionGetDeleteSource( s ) );
    1572     tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED, tr_sessionGetSpeedLimit( s, TR_UP ) );
     1572    tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED_Bps, tr_sessionGetSpeedLimit_Bps( s, TR_UP ) );
    15731573    tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, tr_sessionIsSpeedLimited( s, TR_UP ) );
    1574     tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED, tr_sessionGetSpeedLimit( s, TR_DOWN ) );
     1574    tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED_Bps, tr_sessionGetSpeedLimit_Bps( s, TR_DOWN ) );
    15751575    tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, tr_sessionIsSpeedLimited( s, TR_DOWN ) );
    15761576    tr_bencDictAddStr ( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, tr_sessionGetTorrentDoneScript( s ) );
  • trunk/libtransmission/session.c

    r10798 r10931  
    2424#include <event.h>
    2525
     26//#define TR_SHOW_DEPRECATED
    2627#include "transmission.h"
    2728#include "announcer.h"
     
    5556    SAVE_INTERVAL_SECS = 120,
    5657
    57     DEFAULT_CACHE_SIZE_MiB = 2 /* 2 MiB */
     58    DEFAULT_CACHE_SIZE_BYTES = ( 2 * 1024 * 1024 ) /* 2 MiB */
    5859};
    5960
     
    241242#endif
    242243
     244static tr_bool
     245getSpeedFromDict( tr_benc * dict, const char * key_in, int64_t * Bps )
     246{
     247    int64_t i;
     248    char key[256];
     249
     250    /* 1. look for it ending in -Bps */
     251    tr_snprintf( key, sizeof( key ), "%s-Bps", key_in );
     252    if( tr_bencDictFindInt( dict, key, &i ) ) {
     253        *Bps = i;
     254        return TRUE;
     255    }
     256
     257    /* 2. look for it an old entry without the -Bps suffix.
     258          if found, interpret that to be either kB/s or KiB/s
     259          based on the formatter settings in utils */
     260    if( tr_bencDictFindInt( dict, key_in, &i ) ) {
     261        *Bps = i * tr_formatter_speed_k( );
     262        return TRUE;
     263    }
     264
     265    return FALSE;
     266}
     267
    243268void
    244269tr_sessionGetDefaultSettings( const char * configDir UNUSED, tr_benc * d )
    245270{
     271    const int speed_K = tr_formatter_speed_k( );
     272
    246273    assert( tr_bencIsDict( d ) );
    247274
    248275    tr_bencDictReserve( d, 60 );
    249276    tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        FALSE );
    250     tr_bencDictAddReal( d, TR_PREFS_KEY_MAX_CACHE_SIZE_MiB,       DEFAULT_CACHE_SIZE_MiB );
     277    tr_bencDictAddInt ( d, TR_PREFS_KEY_MAX_CACHE_SIZE,           DEFAULT_CACHE_SIZE_BYTES );
    251278    tr_bencDictAddBool( d, TR_PREFS_KEY_DHT_ENABLED,              TRUE );
    252279    tr_bencDictAddBool( d, TR_PREFS_KEY_LPD_ENABLED,              FALSE );
    253280    tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR,             tr_getDefaultDownloadDir( ) );
    254     tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED,                   100 );
     281    tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED_Bps,               100 * speed_K );
    255282    tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED,           FALSE );
    256283    tr_bencDictAddInt ( d, TR_PREFS_KEY_ENCRYPTION,               TR_DEFAULT_ENCRYPTION );
     
    291318    tr_bencDictAddBool( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, FALSE );
    292319    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_ENABLED,        FALSE );
    293     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP,             50 ); /* half the regular */
    294     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN,           50 ); /* half the regular */
     320    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP_Bps,         50 * speed_K ); /* half the regular */
     321    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN_Bps,       50 * speed_K ); /* half the regular */
    295322    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN,     540 ); /* 9am */
    296323    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED,   FALSE );
    297324    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,       1020 ); /* 5pm */
    298325    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_DAY,       TR_SCHED_ALL );
    299     tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED,                   100 );
     326    tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED_Bps,               100 * speed_K );
    300327    tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED,           FALSE );
    301328    tr_bencDictAddInt ( d, TR_PREFS_KEY_UMASK,                    022 );
     
    314341    tr_bencDictReserve( d, 60 );
    315342    tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        tr_blocklistIsEnabled( s ) );
    316     tr_bencDictAddReal( d, TR_PREFS_KEY_MAX_CACHE_SIZE_MiB,       tr_cacheGetLimit( s->cache ) );
     343    tr_bencDictAddInt ( d, TR_PREFS_KEY_MAX_CACHE_SIZE,           tr_cacheGetLimit( s->cache ) );
    317344    tr_bencDictAddBool( d, TR_PREFS_KEY_DHT_ENABLED,              s->isDHTEnabled );
    318345    tr_bencDictAddBool( d, TR_PREFS_KEY_LPD_ENABLED,              s->isLPDEnabled );
    319346    tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR,             s->downloadDir );
    320     tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED,                   tr_sessionGetSpeedLimit( s, TR_DOWN ) );
     347    tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED_Bps,               tr_sessionGetSpeedLimit_Bps( s, TR_DOWN ) );
    321348    tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED,           tr_sessionIsSpeedLimited( s, TR_DOWN ) );
    322349    tr_bencDictAddInt ( d, TR_PREFS_KEY_ENCRYPTION,               s->encryptionMode );
     
    359386    tr_bencDictAddStr ( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, tr_sessionGetTorrentDoneScript( s ) );
    360387    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_ENABLED,        tr_sessionUsesAltSpeed( s ) );
    361     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP,             tr_sessionGetAltSpeed( s, TR_UP ) );
    362     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN,           tr_sessionGetAltSpeed( s, TR_DOWN ) );
     388    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP_Bps,         tr_sessionGetAltSpeed_Bps( s, TR_UP ) );
     389    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN_Bps,       tr_sessionGetAltSpeed_Bps( s, TR_DOWN ) );
    363390    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN,     tr_sessionGetAltSpeedBegin( s ) );
    364391    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED,   tr_sessionUsesAltSpeedTime( s ) );
    365392    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,       tr_sessionGetAltSpeedEnd( s ) );
    366393    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_DAY,       tr_sessionGetAltSpeedDay( s ) );
    367     tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED,                   tr_sessionGetSpeedLimit( s, TR_UP ) );
     394    tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED_Bps,               tr_sessionGetSpeedLimit_Bps( s, TR_UP ) );
    368395    tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED,           tr_sessionIsSpeedLimited( s, TR_UP ) );
    369396    tr_bencDictAddInt ( d, TR_PREFS_KEY_UMASK,                    s->umask );
     
    512539    session->bandwidth = tr_bandwidthNew( session, NULL );
    513540    session->lock = tr_lockNew( );
    514     session->cache = tr_cacheNew( DEFAULT_CACHE_SIZE_MiB );
     541    session->cache = tr_cacheNew( DEFAULT_CACHE_SIZE_BYTES );
    515542    session->tag = tr_strdup( tag );
    516543    session->magicNumber = SESSION_MAGIC_NUMBER;
     
    678705
    679706    /* misc features */
    680     if( tr_bencDictFindReal( settings, TR_PREFS_KEY_MAX_CACHE_SIZE_MiB, &d ) )
    681         tr_sessionSetCacheLimit( session, d );
     707    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_MAX_CACHE_SIZE, &i ) )
     708        tr_sessionSetCacheLimit( session, i );
    682709    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_LAZY_BITFIELD, &boolVal ) )
    683710        tr_sessionSetLazyBitfieldEnabled( session, boolVal );
     
    779806        session->uploadSlotsPerTorrent = i;
    780807
    781     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_USPEED, &i ) )
    782         tr_sessionSetSpeedLimit( session, TR_UP, i );
     808    if( getSpeedFromDict( settings, "speed-limit-up", &i ) )
     809        tr_sessionSetSpeedLimit_Bps( session, TR_UP, i );
    783810    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_USPEED_ENABLED, &boolVal ) )
    784811        tr_sessionLimitSpeed( session, TR_UP, boolVal );
    785812
    786     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_DSPEED, &i ) )
    787         tr_sessionSetSpeedLimit( session, TR_DOWN, i );
     813    if( getSpeedFromDict( settings, "speed-limit-down", &i ) )
     814        tr_sessionSetSpeedLimit_Bps( session, TR_DOWN, i );
    788815    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_DSPEED_ENABLED, &boolVal ) )
    789816        tr_sessionLimitSpeed( session, TR_DOWN, boolVal );
     
    799826
    800827    /* update the turtle mode's fields */
    801     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ALT_SPEED_UP, &i ) )
    802         turtle->speedLimit[TR_UP] = i;
    803     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ALT_SPEED_DOWN, &i ) )
    804         turtle->speedLimit[TR_DOWN] = i;
     828    if( getSpeedFromDict( settings, "alt-speed-up", &i ) )
     829        turtle->speedLimit_Bps[TR_UP] = i;
     830    if( getSpeedFromDict( settings, "alt-speed-down", &i ) )
     831        turtle->speedLimit_Bps[TR_DOWN] = i;
    805832    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &i ) )
    806833        turtle->beginMinute = i;
     
    11011128
    11021129tr_bool
    1103 tr_sessionGetActiveSpeedLimit( const tr_session * session, tr_direction dir, int * setme )
     1130tr_sessionGetActiveSpeedLimit_Bps( const tr_session * session, tr_direction dir, int * setme )
    11041131{
    11051132    int isLimited = TRUE;
     
    11091136
    11101137    if( tr_sessionUsesAltSpeed( session ) )
    1111         *setme = tr_sessionGetAltSpeed( session, dir );
     1138        *setme = tr_sessionGetAltSpeed_Bps( session, dir );
    11121139    else if( tr_sessionIsSpeedLimited( session, dir ) )
    1113         *setme = tr_sessionGetSpeedLimit( session, dir );
     1140        *setme = tr_sessionGetSpeedLimit_Bps( session, dir );
    11141141    else
    11151142        isLimited = FALSE;
     
    11211148updateBandwidth( tr_session * session, tr_direction dir )
    11221149{
    1123     int limit = 0;
    1124     const tr_bool isLimited = tr_sessionGetActiveSpeedLimit( session, dir, &limit );
    1125     const tr_bool zeroCase = isLimited && !limit;
     1150    int limit_Bps = 0;
     1151    const tr_bool isLimited = tr_sessionGetActiveSpeedLimit_Bps( session, dir, &limit_Bps );
     1152    const tr_bool zeroCase = isLimited && !limit_Bps;
    11261153
    11271154    tr_bandwidthSetLimited( session->bandwidth, dir, isLimited && !zeroCase );
    11281155
    1129     tr_bandwidthSetDesiredSpeed( session->bandwidth, dir, limit );
     1156    tr_bandwidthSetDesiredSpeed_Bps( session->bandwidth, dir, limit_Bps );
    11301157}
    11311158
     
    12681295
    12691296void
    1270 tr_sessionSetSpeedLimit( tr_session * s, tr_direction d, int KB_s )
     1297tr_sessionSetSpeedLimit_Bps( tr_session * s, tr_direction d, int Bps )
    12711298{
    12721299    assert( tr_isSession( s ) );
    12731300    assert( tr_isDirection( d ) );
    1274     assert( KB_s >= 0 );
    1275 
    1276     s->speedLimit[d] = KB_s;
     1301    assert( Bps >= 0 );
     1302
     1303    s->speedLimit_Bps[d] = Bps;
    12771304
    12781305    updateBandwidth( s, d );
     
    12801307
    12811308int
    1282 tr_sessionGetSpeedLimit( const tr_session * s, tr_direction d )
     1309tr_sessionGetSpeedLimit_Bps( const tr_session * s, tr_direction d )
    12831310{
    12841311    assert( tr_isSession( s ) );
    12851312    assert( tr_isDirection( d ) );
    12861313
    1287     return s->speedLimit[d];
     1314    return s->speedLimit_Bps[d];
    12881315}
    12891316
     
    13141341
    13151342void
    1316 tr_sessionSetAltSpeed( tr_session * s, tr_direction d, int KB_s )
     1343tr_sessionSetAltSpeed_Bps( tr_session * s, tr_direction d, int Bps )
    13171344{
    13181345    assert( tr_isSession( s ) );
    13191346    assert( tr_isDirection( d ) );
    1320     assert( KB_s >= 0 );
    1321 
    1322     s->turtle.speedLimit[d] = KB_s;
     1347    assert( Bps >= 0 );
     1348
     1349    s->turtle.speedLimit_Bps[d] = Bps;
    13231350
    13241351    updateBandwidth( s, d );
     
    13261353
    13271354int
    1328 tr_sessionGetAltSpeed( const tr_session * s, tr_direction d )
     1355tr_sessionGetAltSpeed_Bps( const tr_session * s, tr_direction d )
    13291356{
    13301357    assert( tr_isSession( s ) );
    13311358    assert( tr_isDirection( d ) );
    13321359
    1333     return s->turtle.speedLimit[d];
     1360    return s->turtle.speedLimit_Bps[d];
    13341361}
    13351362
     
    15371564***/
    15381565
    1539 double
    1540 tr_sessionGetPieceSpeed( const tr_session * session, tr_direction dir )
    1541 {
    1542     return tr_isSession( session ) ? tr_bandwidthGetPieceSpeed( session->bandwidth, 0, dir ) : 0.0;
    1543 }
    1544 
    1545 double
    1546 tr_sessionGetRawSpeed( const tr_session * session, tr_direction dir )
    1547 {
    1548     return tr_isSession( session ) ? tr_bandwidthGetRawSpeed( session->bandwidth, 0, dir ) : 0.0;
     1566int
     1567tr_sessionGetPieceSpeed_Bps( const tr_session * session, tr_direction dir )
     1568{
     1569    return tr_isSession( session ) ? tr_bandwidthGetPieceSpeed_Bps( session->bandwidth, 0, dir ) : 0.0;
     1570}
     1571
     1572int
     1573tr_sessionGetRawSpeed_Bps( const tr_session * session, tr_direction dir )
     1574{
     1575    return tr_isSession( session ) ? tr_bandwidthGetRawSpeed_Bps( session->bandwidth, 0, dir ) : 0.0;
    15491576}
    15501577
     
    18501877
    18511878void
    1852 tr_sessionSetCacheLimit( tr_session * session, double maxMiB )
    1853 {
    1854     assert( tr_isSession( session ) );
    1855 
    1856     tr_cacheSetLimit( session->cache, maxMiB );
    1857 }
    1858 
    1859 double
     1879tr_sessionSetCacheLimit( tr_session * session, int64_t max_bytes )
     1880{
     1881    assert( tr_isSession( session ) );
     1882
     1883    tr_cacheSetLimit( session->cache, max_bytes );
     1884}
     1885
     1886int64_t
    18601887tr_sessionGetCacheLimit( const tr_session * session )
    18611888{
  • trunk/libtransmission/session.h

    r10798 r10931  
    4747{
    4848    /* TR_UP and TR_DOWN speed limits */
    49     int speedLimit[2];
     49    int speedLimit_Bps[2];
    5050
    5151    /* is turtle mode on right now? */
     
    103103    int                          umask;
    104104
    105     int                          speedLimit[2];
     105    int                          speedLimit_Bps[2];
    106106    tr_bool                      speedLimitEnabled[2];
    107107
  • trunk/libtransmission/torrent.c

    r10919 r10931  
    130130
    131131void
    132 tr_torrentSetSpeedLimit( tr_torrent * tor, tr_direction dir, int KiB_sec )
     132tr_torrentSetSpeedLimit_Bps( tr_torrent * tor, tr_direction dir, int Bps )
    133133{
    134134    assert( tr_isTorrent( tor ) );
    135135    assert( tr_isDirection( dir ) );
    136 
    137     if( tr_bandwidthSetDesiredSpeed( tor->bandwidth, dir, KiB_sec ) )
     136    assert( Bps >= 0 );
     137
     138    if( tr_bandwidthSetDesiredSpeed_Bps( tor->bandwidth, dir, Bps ) )
    138139        tr_torrentSetDirty( tor );
    139140}
    140141
    141142int
    142 tr_torrentGetSpeedLimit( const tr_torrent * tor, tr_direction dir )
     143tr_torrentGetSpeedLimit_Bps( const tr_torrent * tor, tr_direction dir )
    143144{
    144145    assert( tr_isTorrent( tor ) );
    145146    assert( tr_isDirection( dir ) );
    146147
    147     return tr_bandwidthGetDesiredSpeed( tor->bandwidth, dir );
     148    return tr_bandwidthGetDesiredSpeed_Bps( tor->bandwidth, dir );
    148149}
    149150
     
    244245
    245246    if( tr_torrentUsesSpeedLimit( tor, direction ) )
    246         if( tr_torrentGetSpeedLimit( tor, direction ) <= 0 )
     247        if( tr_torrentGetSpeedLimit_Bps( tor, direction ) <= 0 )
    247248            allowed = FALSE;
    248249
    249250    if( tr_torrentUsesSessionLimits( tor ) )
    250         if( tr_sessionGetActiveSpeedLimit( tor->session, direction, &limit ) )
     251        if( tr_sessionGetActiveSpeedLimit_Bps( tor->session, direction, &limit ) )
    251252            if( limit <= 0 )
    252253                allowed = FALSE;
     
    686687    {
    687688        tr_torrentUseSpeedLimit( tor, TR_UP, FALSE );
    688         tr_torrentSetSpeedLimit( tor, TR_UP, tr_sessionGetSpeedLimit( tor->session, TR_UP ) );
     689        tr_torrentSetSpeedLimit_Bps( tor, TR_UP, tr_sessionGetSpeedLimit_Bps( tor->session, TR_UP ) );
    689690        tr_torrentUseSpeedLimit( tor, TR_DOWN, FALSE );
    690         tr_torrentSetSpeedLimit( tor, TR_DOWN, tr_sessionGetSpeedLimit( tor->session, TR_DOWN ) );
     691        tr_torrentSetSpeedLimit_Bps( tor, TR_DOWN, tr_sessionGetSpeedLimit_Bps( tor->session, TR_DOWN ) );
    691692        tr_torrentUseSessionLimits( tor, TRUE );
    692693    }
     
    967968
    968969    now = tr_date( );
    969     d = tr_peerMgrGetWebseedSpeed( tor, now );
    970     s->rawUploadSpeed     = tr_bandwidthGetRawSpeed  ( tor->bandwidth, now, TR_UP );
    971     s->pieceUploadSpeed   = tr_bandwidthGetPieceSpeed( tor->bandwidth, now, TR_UP );
    972     s->rawDownloadSpeed   = d + tr_bandwidthGetRawSpeed  ( tor->bandwidth, now, TR_DOWN );
    973     s->pieceDownloadSpeed = d + tr_bandwidthGetPieceSpeed( tor->bandwidth, now, TR_DOWN );
     970    d = tr_peerMgrGetWebseedSpeed_Bps( tor, now );
     971    s->rawUploadSpeed_Bps     = tr_bandwidthGetRawSpeed_Bps  ( tor->bandwidth, now, TR_UP );
     972    s->pieceUploadSpeed_Bps   = tr_bandwidthGetPieceSpeed_Bps( tor->bandwidth, now, TR_UP );
     973    s->rawDownloadSpeed_Bps   = d + tr_bandwidthGetRawSpeed_Bps  ( tor->bandwidth, now, TR_DOWN );
     974    s->pieceDownloadSpeed_Bps = d + tr_bandwidthGetPieceSpeed_Bps( tor->bandwidth, now, TR_DOWN );
    974975
    975976    usableSeeds += tor->info.webseedCount;
     
    10321033        case TR_STATUS_DOWNLOAD:
    10331034            if( ( tor->etaDLSpeedCalculatedAt + 800 ) < now ) {
    1034                 tor->etaDLSpeed = ( ( tor->etaDLSpeedCalculatedAt + 4000 ) < now )
    1035                     ? s->pieceDownloadSpeed /* if no recent previous speed, no need to smooth */
    1036                     : 0.8*tor->etaDLSpeed + 0.2*s->pieceDownloadSpeed; /* smooth across 5 readings */
     1035                tor->etaDLSpeed_Bps = ( ( tor->etaDLSpeedCalculatedAt + 4000 ) < now )
     1036                    ? s->pieceDownloadSpeed_Bps /* if no recent previous speed, no need to smooth */
     1037                    : ((tor->etaDLSpeed_Bps*4) + s->pieceDownloadSpeed_Bps)/5; /* smooth across 5 readings */
    10371038                tor->etaDLSpeedCalculatedAt = now;
    10381039            }
     
    10401041            if( s->leftUntilDone > s->desiredAvailable )
    10411042                s->eta = TR_ETA_NOT_AVAIL;
    1042             else if( s->pieceDownloadSpeed < 0.1 )
     1043            else if( s->pieceDownloadSpeed_Bps < 1 )
    10431044                s->eta = TR_ETA_UNKNOWN;
    10441045            else
    1045                 s->eta = s->leftUntilDone / tor->etaDLSpeed / 1024.0;
     1046                s->eta = s->leftUntilDone / tor->etaDLSpeed_Bps;
    10461047            break;
    10471048
     
    10511052            else {
    10521053                if( ( tor->etaULSpeedCalculatedAt + 800 ) < now ) {
    1053                     tor->etaULSpeed = ( ( tor->etaULSpeedCalculatedAt + 4000 ) < now )
    1054                         ? s->pieceUploadSpeed /* if no recent previous speed, no need to smooth */
    1055                         : 0.8*tor->etaULSpeed + 0.2*s->pieceUploadSpeed; /* smooth across 5 readings */
     1054                    tor->etaULSpeed_Bps = ( ( tor->etaULSpeedCalculatedAt + 4000 ) < now )
     1055                        ? s->pieceUploadSpeed_Bps /* if no recent previous speed, no need to smooth */
     1056                        : ((tor->etaULSpeed_Bps*4) + s->pieceUploadSpeed_Bps)/5; /* smooth across 5 readings */
    10561057                    tor->etaULSpeedCalculatedAt = now;
    10571058                }
    1058                 if( s->pieceUploadSpeed < 0.1 )
     1059                if( s->pieceUploadSpeed_Bps < 1 )
    10591060                    s->eta = TR_ETA_UNKNOWN;
    10601061                else
    1061                     s->eta = seedRatioBytesLeft / tor->etaULSpeed / 1024.0;
     1062                    s->eta = seedRatioBytesLeft / tor->etaULSpeed_Bps;
    10621063            }
    10631064            break;
     
    11931194***/
    11941195
    1195 float*
    1196 tr_torrentWebSpeeds( const tr_torrent * tor )
    1197 {
    1198     return tr_isTorrent( tor )
    1199          ? tr_peerMgrWebSpeeds( tor )
    1200          : NULL;
     1196int*
     1197tr_torrentWebSpeeds_Bps( const tr_torrent * tor )
     1198{
     1199    return tr_isTorrent( tor ) ? tr_peerMgrWebSpeeds_Bps( tor ) : NULL;
    12011200}
    12021201
  • trunk/libtransmission/torrent.h

    r10918 r10931  
    211211
    212212    uint64_t                   etaDLSpeedCalculatedAt;
    213     double                     etaDLSpeed;
     213    int                        etaDLSpeed_Bps;
    214214    uint64_t                   etaULSpeedCalculatedAt;
    215     double                     etaULSpeed;
     215    int                        etaULSpeed_Bps;
    216216
    217217    time_t                     addedDate;
  • trunk/libtransmission/transmission.h

    r10918 r10931  
    157157
    158158#define TR_PREFS_KEY_ALT_SPEED_ENABLED             "alt-speed-enabled"
    159 #define TR_PREFS_KEY_ALT_SPEED_UP                  "alt-speed-up"
    160 #define TR_PREFS_KEY_ALT_SPEED_DOWN                "alt-speed-down"
     159#define TR_PREFS_KEY_ALT_SPEED_UP_Bps              "alt-speed-up-Bps"
     160#define TR_PREFS_KEY_ALT_SPEED_DOWN_Bps            "alt-speed-down-Bps"
    161161#define TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN          "alt-speed-time-begin"
    162162#define TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED        "alt-speed-time-enabled"
     
    166166#define TR_PREFS_KEY_BIND_ADDRESS_IPV6             "bind-address-ipv6"
    167167#define TR_PREFS_KEY_BLOCKLIST_ENABLED             "blocklist-enabled"
    168 #define TR_PREFS_KEY_MAX_CACHE_SIZE_MiB            "cache-size-MiB"
     168#define TR_PREFS_KEY_MAX_CACHE_SIZE                "cache-size-bytes"
    169169#define TR_PREFS_KEY_DHT_ENABLED                   "dht-enabled"
    170170#define TR_PREFS_KEY_LPD_ENABLED                   "lpd-enabled"
     
    207207#define TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED   "script-torrent-done-enabled"
    208208#define TR_PREFS_KEY_RPC_WHITELIST                 "rpc-whitelist"
    209 #define TR_PREFS_KEY_DSPEED                        "speed-limit-down"
     209#define TR_PREFS_KEY_DSPEED_Bps                    "speed-limit-down-Bps"
    210210#define TR_PREFS_KEY_DSPEED_ENABLED                "speed-limit-down-enabled"
     211#define TR_PREFS_KEY_USPEED_Bps                    "speed-limit-up-Bps"
    211212#define TR_PREFS_KEY_USPEED_ENABLED                "speed-limit-up-enabled"
    212 #define TR_PREFS_KEY_USPEED                        "speed-limit-up"
    213213#define TR_PREFS_KEY_UMASK                         "umask"
    214214#define TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT      "upload-slots-per-torrent"
     
    599599void     tr_sessionSetLPDEnabled( tr_session * session, tr_bool enabled );
    600600
    601 void     tr_sessionSetCacheLimit( tr_session * session, double MiB );
    602 double   tr_sessionGetCacheLimit( const tr_session * session );
     601void     tr_sessionSetCacheLimit( tr_session * session, int64_t bytes );
     602int64_t  tr_sessionGetCacheLimit( const tr_session * session );
    603603
    604604void     tr_sessionSetLazyBitfieldEnabled( tr_session * session, tr_bool enabled );
     
    658658***/
    659659
    660 void     tr_sessionSetSpeedLimit      ( tr_session *, tr_direction, int KB_s );
    661 int      tr_sessionGetSpeedLimit      ( const tr_session *, tr_direction );
     660void tr_sessionSetSpeedLimit_Bps( tr_session *, tr_direction, int Bps );
     661int tr_sessionGetSpeedLimit_Bps( const tr_session *, tr_direction );
    662662
    663663void     tr_sessionLimitSpeed         ( tr_session *, tr_direction, tr_bool );
     
    669669***/
    670670
    671 void     tr_sessionSetAltSpeed        ( tr_session *, tr_direction, int KB_s );
    672 int      tr_sessionGetAltSpeed        ( const tr_session *, tr_direction );
     671void tr_sessionSetAltSpeed_Bps( tr_session *, tr_direction, int Bps );
     672int  tr_sessionGetAltSpeed_Bps( const tr_session *, tr_direction );
    673673
    674674void     tr_sessionUseAltSpeed        ( tr_session *, tr_bool );
     
    707707
    708708
    709 tr_bool      tr_sessionGetActiveSpeedLimit( const tr_session  * session,
     709tr_bool  tr_sessionGetActiveSpeedLimit_Bps( const tr_session  * session,
    710710                                            tr_direction        dir,
    711711                                            int               * setme );
    712 
    713712
    714713/***
     
    716715***/
    717716
    718 double     tr_sessionGetRawSpeed      ( const tr_session *, tr_direction );
    719 double     tr_sessionGetPieceSpeed    ( const tr_session *, tr_direction );
    720 
     717int        tr_sessionGetRawSpeed_Bps  ( const tr_session *, tr_direction );
     718int        tr_sessionGetPieceSpeed_Bps( const tr_session *, tr_direction );
    721719
    722720void       tr_sessionSetRatioLimited  ( tr_session *, tr_bool isLimited );
     
    11271125***/
    11281126
    1129 void     tr_torrentSetSpeedLimit      ( tr_torrent *, tr_direction, int KB_s );
    1130 int      tr_torrentGetSpeedLimit      ( const tr_torrent *, tr_direction );
     1127void     tr_torrentSetSpeedLimit_Bps  ( tr_torrent *, tr_direction, int KB_s );
     1128int      tr_torrentGetSpeedLimit_Bps  ( const tr_torrent *, tr_direction );
    11311129
    11321130void     tr_torrentUseSpeedLimit      ( tr_torrent *, tr_direction, tr_bool );
     
    13831381
    13841382    float    progress;
    1385     float    rateToPeer;
    1386     float    rateToClient;
     1383    int      rateToPeer_Bps;
     1384    int      rateToClient_Bps;
    13871385
    13881386
     
    15471545 *         NOTE: always free this array with tr_free() when you're done with it.
    15481546 */
    1549 float*         tr_torrentWebSpeeds( const tr_torrent * torrent );
     1547int*  tr_torrentWebSpeeds_Bps( const tr_torrent * torrent );
    15501548
    15511549typedef struct tr_file_stat
     
    17471745    double seedRatioPercentDone;
    17481746
    1749     /** Speed all data being sent for this torrent. (KiB/s)
     1747    /** Speed all data being sent for this torrent.
    17501748        This includes piece data, protocol messages, and TCP overhead */
    1751     double rawUploadSpeed;
    1752 
    1753     /** Speed all data being received for this torrent. (KiB/s)
     1749    int rawUploadSpeed_Bps;
     1750
     1751    /** Speed all data being received for this torrent.
    17541752        This includes piece data, protocol messages, and TCP overhead */
    1755     double rawDownloadSpeed;
    1756 
    1757     /** Speed all piece being sent for this torrent. (KiB/s)
     1753    int rawDownloadSpeed_Bps;
     1754
     1755    /** Speed all piece being sent for this torrent.
    17581756        This ONLY counts piece data. */
    1759     double pieceUploadSpeed;
    1760 
    1761     /** Speed all piece being received for this torrent. (KiB/s)
     1757    int pieceUploadSpeed_Bps;
     1758
     1759    /** Speed all piece being received for this torrent.
    17621760        This ONLY counts piece data. */
    1763     double pieceDownloadSpeed;
     1761    int pieceDownloadSpeed_Bps;
    17641762
    17651763#define TR_ETA_NOT_AVAIL -1
  • trunk/libtransmission/utils-test.c

    r10844 r10931  
    328328    int n = sizeof( array ) / sizeof( array[0] );
    329329
    330     tr_removeElementFromArray( array, 5, sizeof( int ), n-- );
     330    tr_removeElementFromArray( array, 5u, sizeof( int ), n-- );
    331331    for( i=0; i<n; ++i )
    332332        check( array[i] == ( i<5 ? i : i+1 ) );
    333333
    334     tr_removeElementFromArray( array, 0, sizeof( int ), n-- );
     334    tr_removeElementFromArray( array, 0u, sizeof( int ), n-- );
    335335    for( i=0; i<n; ++i )
    336336        check( array[i] == ( i<4 ? i+1 : i+2 ) );
  • trunk/libtransmission/utils.c

    r10921 r10931  
    10661066
    10671067        if( length < 1 )
    1068             length = strlen( input );
     1068            length = (int)strlen( input );
    10691069
    10701070        bmem = BIO_new( BIO_s_mem( ) );
     
    14701470    if( !pageSize ) {
    14711471#ifdef HAVE_GETPAGESIZE
    1472         pageSize = getpagesize();
     1472        pageSize = (size_t) getpagesize();
    14731473#else /* guess */
    14741474        pageSize = 4096;
     
    15171517{
    15181518    char * name;
    1519     double value;
     1519    unsigned int value;
    15201520};
    15211521 
     
    15251525};
    15261526
     1527enum { TR_FMT_B, TR_FMT_KB, TR_FMT_MB, TR_FMT_GB };
     1528
    15271529static void
    15281530formatter_init( struct formatter_units * units,
    1529                 double kilo,
     1531                unsigned int kilo,
    15301532                const char * b, const char * kb,
    15311533                const char * mb, const char * gb )
     
    15381540
    15391541    units->units[TR_FMT_MB].name = tr_strdup( mb );
    1540     units->units[TR_FMT_MB].value = pow( kilo, 2 );
     1542    units->units[TR_FMT_MB].value = kilo * kilo;
    15411543
    15421544    units->units[TR_FMT_GB].name = tr_strdup( gb );
    1543     units->units[TR_FMT_GB].value = pow( kilo, 3 );
    1544 }
    1545 
    1546 static const char*
    1547 tr_formatter_units( const struct formatter_units * u, int size )
    1548 {
    1549     assert( u != NULL );
    1550     assert( 0<=size && size<4 );
    1551 
    1552     return u->units[size].name;
     1545    units->units[TR_FMT_GB].value = kilo * kilo * kilo;
    15531546}
    15541547
     
    15671560    else                                 unit = &u->units[3];
    15681561
    1569     value = bytes / unit->value;
     1562    value = (double)bytes / unit->value;
    15701563    units = unit->name;
    15711564    if( unit->value == 1 )
     
    15821575
    15831576void
    1584 tr_formatter_size_init( double kilo, const char * b, const char * kb,
    1585                                      const char * mb, const char * gb )
     1577tr_formatter_size_init( unsigned int kilo,
     1578                        const char * b, const char * kb,
     1579                        const char * mb, const char * gb )
    15861580{
    15871581    formatter_init( &size_units, kilo, b, kb, mb, gb );
     
    15941588}
    15951589
    1596 const char*
    1597 tr_formatter_size_units( int i )
    1598 {
    1599     return tr_formatter_units( &size_units, i );
    1600 }
    1601 
    16021590static struct formatter_units speed_units;
    16031591
    16041592void
    1605 tr_formatter_speed_init( double kilo, const char * b, const char * kb,
    1606                                       const char * mb, const char * gb )
     1593tr_formatter_speed_init( unsigned int kilo,
     1594                         const char * b, const char * kb,
     1595                         const char * mb, const char * gb )
    16071596{
    16081597    formatter_init( &speed_units, kilo, b, kb, mb, gb );
     
    16151604}
    16161605
    1617 const char*
    1618 tr_formatter_speed_units( int i )
    1619 {
    1620     return tr_formatter_units( &speed_units, i );
    1621 }
     1606unsigned int
     1607tr_formatter_speed_k( void )
     1608{
     1609    return speed_units.units[TR_FMT_KB].value;
     1610}
     1611
     1612static struct formatter_units mem_units;
     1613
     1614void
     1615tr_formatter_mem_init( unsigned int kilo,
     1616                       const char * b, const char * kb,
     1617                       const char * mb, const char * gb )
     1618{
     1619    formatter_init( &mem_units, kilo, b, kb, mb, gb );
     1620}
     1621
     1622char*
     1623tr_formatter_mem( char * buf, uint64_t bytes_per_second, size_t buflen )
     1624{
     1625    return formatter_get_size_str( &mem_units, buf, bytes_per_second, buflen );
     1626}
  • trunk/libtransmission/utils.h

    r10918 r10931  
    565565/* example: tr_formatter_size_init( 1024, _("B"), _("KiB"), _("MiB"), _("GiB") ); */
    566566
    567 void tr_formatter_size_init( double kilo, const char * b, const char * kb,
    568                                           const char * mb, const char * gb );
    569 
    570 void tr_formatter_speed_init( double kilo, const char * b, const char * kb,
    571                                            const char * mb, const char * gb );
    572 
    573 /* format a size into a user-readable string. */
    574 char* tr_formatter_size( char * buf, uint64_t bytes, size_t buflen );
     567void tr_formatter_size_init( unsigned int kilo, const char * b, const char * kb,
     568                                                const char * mb, const char * gb );
     569
     570void tr_formatter_speed_init( unsigned int kilo, const char * b, const char * kb,
     571                                                 const char * mb, const char * gb );
     572
     573void tr_formatter_mem_init( unsigned int kilo, const char * b, const char * kb,
     574                                               const char * mb, const char * gb );
    575575
    576576/* format a speed into a user-readable string. */
    577577char* tr_formatter_speed( char * buf, uint64_t bytes_per_second, size_t buflen );
    578578
    579 enum { TR_FMT_B, TR_FMT_KB, TR_FMT_MB, TR_FMT_GB };
    580 /* return the human-readable unit initialized by tr_formatter_size_init() */
    581 const char* tr_formatter_size_units( int size );
    582 /* return the human-readable unit initialized by tr_formatter_speed_init() */
    583 const char* tr_formatter_speed_units( int size );
     579/* format a file size into a user-readable string. */
     580char* tr_formatter_size( char * buf, uint64_t bytes, size_t buflen );
     581
     582/* format a memory size into a user-readable string. */
     583char* tr_formatter_mem( char * buf, uint64_t bytes, size_t buflen );
     584
     585unsigned int tr_formatter_speed_k( void );
     586
    584587
    585588/***
  • trunk/libtransmission/webseed.c

    r10800 r10931  
    222222
    223223int
    224 tr_webseedGetSpeed( const tr_webseed * w, uint64_t now, float * setme_KiBs )
     224tr_webseedGetSpeed_Bps( const tr_webseed * w, uint64_t now, int * setme_Bps )
    225225{
    226226    const int isActive = tr_webseedIsActive( w );
    227 
    228     *setme_KiBs = isActive ? tr_rcRate( &w->rateDown, now ) : 0.0f;
     227    *setme_Bps = isActive ? tr_rcRate_Bps( &w->rateDown, now ) : 0;
    229228    return isActive;
    230229}
  • trunk/libtransmission/webseed.h

    r10800 r10931  
    3535
    3636/** @return true if a request is being processed, or false if idle */
    37 int         tr_webseedGetSpeed( const tr_webseed * w,
    38                                 uint64_t           now,
    39                                 float *            setme_KiBs );
     37int         tr_webseedGetSpeed_Bps( const tr_webseed * w,
     38                                    uint64_t           now,
     39                                    int              * setme_Bps );
    4040
    4141/** @return true if a request is being processed, or false if idle */
  • trunk/qt/app.cc

    r10846 r10931  
    3838#include "session-dialog.h"
    3939#include "torrent-model.h"
     40#include "units.h"
    4041#include "utils.h"
    4142#include "watchdir.h"
     
    100101
    101102    // initialize the units formatter
    102 
    103     tr_formatter_size_init ( 1024, qPrintable(tr("B")),
    104                                    qPrintable(tr("KiB")),
    105                                    qPrintable(tr("MiB")),
    106                                    qPrintable(tr("GiB")) );
    107 
    108     tr_formatter_speed_init( 1024, qPrintable(tr("B/s")),
    109                                    qPrintable(tr("KiB/s")),
    110                                    qPrintable(tr("MiB/s")),
    111                                    qPrintable(tr("GiB/s")) );
     103    tr_formatter_mem_init( Units::mem_K,
     104                           qPrintable( Units::mem_B_str ),
     105                           qPrintable( Units::mem_K_str ),
     106                           qPrintable( Units::mem_M_str ),
     107                           qPrintable( Units::mem_G_str ) );
     108    tr_formatter_size_init( Units::size_K,
     109                            qPrintable( Units::size_B_str ),
     110                            qPrintable( Units::size_K_str ),
     111                            qPrintable( Units::size_M_str ),
     112                            qPrintable( Units::size_G_str ) );
     113    tr_formatter_speed_init( Units::speed_K,
     114                             qPrintable( Units::speed_B_str ),
     115                             qPrintable( Units::speed_K_str ),
     116                             qPrintable( Units::speed_M_str ),
     117                             qPrintable( Units::speed_G_str ) );
    112118
    113119    // set the default icon
  • trunk/qt/details.cc

    r10908 r10931  
    5353#include "torrent.h"
    5454#include "torrent-model.h"
    55 #include "utils.h"
     55#include "units.h"
    5656
    5757class Prefs;
     
    215215{
    216216    if( seconds > 60 ) seconds -= ( seconds % 60 );
    217     return Utils::timeToString ( seconds );
     217    return Units::timeToString ( seconds );
    218218}
    219219
     
    324324        else {
    325325            const double d = 100.0 * ( sizeWhenDone ? ( sizeWhenDone - leftUntilDone ) / sizeWhenDone : 1 );
    326             QString pct = Utils::percentToString( d );
     326            QString pct = Units::percentToString( d );
    327327            if( !haveUnverified )
    328328                string = tr( "%1 (%2%)" )
    329                              .arg( Utils :: sizeToString( haveVerified + haveUnverified ) )
     329                             .arg( Units::sizeToString( haveVerified + haveUnverified ) )
    330330                             .arg( pct );
    331331            else
    332332                string = tr( "%1 (%2%); %3 Unverified" )
    333                              .arg( Utils :: sizeToString( haveVerified + haveUnverified ) )
     333                             .arg( Units::sizeToString( haveVerified + haveUnverified ) )
    334334                             .arg( pct )
    335                              .arg( Utils :: sizeToString( haveUnverified ) );
     335                             .arg( Units::sizeToString( haveUnverified ) );
    336336        }
    337337    }
     
    345345            string = none;
    346346        else
    347             string = QString( "%1%" ).arg( Utils::percentToString( ( 100.0 * available ) / sizeWhenDone ) );
     347            string = QString( "%1%" ).arg( Units::percentToString( ( 100.0 * available ) / sizeWhenDone ) );
    348348    }
    349349    myAvailabilityLabel->setText( string );
     
    358358            f += t->failedEver( );
    359359        }
    360         const QString dstr = Utils::sizeToString( d );
    361         const QString fstr = Utils::sizeToString( f );
     360        const QString dstr = Units::sizeToString( d );
     361        const QString fstr = Units::sizeToString( f );
    362362        if( f )
    363363            string = tr( "%1 (+%2 corrupt)" ).arg( dstr ).arg( fstr );
     
    372372    else {
    373373        foreach( const Torrent * t, torrents ) u += t->uploadedEver( );
    374         string = QString( Utils::sizeToString( u ) );
     374        string = QString( Units::sizeToString( u ) );
    375375    }
    376376    myUploadedLabel->setText( string );
     
    379379        string = none;
    380380    else if( torrents.length() == 1 )
    381         string = QString( Utils :: ratioToString( torrents.first()->ratio() ) );
     381        string = Units::ratioToString( torrents.first()->ratio() );
    382382    else {
    383383        bool isMixed = false;
     
    395395            string = mixed;
    396396        else if( ratioType < 0 )
    397             string = QString( Utils :: ratioToString( ratioType ) );
     397            string = Units::ratioToString( ratioType );
    398398        else
    399             string = QString( Utils :: ratioToString( (double)u / d ) );
     399            string = Units::ratioToString( (double)u / d );
    400400    }
    401401    myRatioLabel->setText( string );
     
    420420            string = mixed;
    421421        else
    422             string = Utils::timeToString( baseline.secsTo( qdt_now ) );
     422            string = Units::timeToString( baseline.secsTo( qdt_now ) );
    423423    }
    424424    myRunTimeLabel->setText( string );
     
    441441                string = tr( "Unknown" );
    442442            else
    443                 string = Utils::timeToString( baseline );
     443                string = Units::timeToString( baseline );
    444444       }
    445445    }
     
    461461            string = tr( "Active now" );
    462462        else
    463             string = tr( "%1 ago" ).arg( Utils::timeToString( seconds ) );
     463            string = tr( "%1 ago" ).arg( Units::timeToString( seconds ) );
    464464    }
    465465    myLastActivityLabel->setText( string );
     
    503503        else if( pieceSize > 0 )
    504504            string = tr( "%1 (%Ln pieces @ %2)", "", pieces )
    505                      .arg( Utils::sizeToString( size ) )
    506                      .arg( Utils::sizeToString( pieceSize ) );
     505                     .arg( Units::sizeToString( size ) )
     506                     .arg( Units::memToString( pieceSize ) );
    507507        else
    508508            string = tr( "%1 (%Ln pieces)", "", pieces )
    509                      .arg( Utils::sizeToString( size ) );
     509                     .arg( Units::sizeToString( size ) );
    510510    }
    511511    mySizeLabel->setText( string );
     
    637637
    638638        mySingleDownSpin->blockSignals( true );
    639         mySingleDownSpin->setValue( int(tor->downloadLimit().kbps()) );
     639        mySingleDownSpin->setValue( tor->downloadLimit().Bps() / Units::speed_K );
    640640        mySingleDownSpin->blockSignals( false );
    641641
    642642        mySingleUpSpin->blockSignals( true );
    643         mySingleUpSpin->setValue( int(tor->uploadLimit().kbps()) );
     643        mySingleUpSpin->setValue( tor->uploadLimit().Bps() / Units::speed_K );
    644644        mySingleUpSpin->blockSignals( false );
    645645
     
    911911                codeTip.resize( codeTip.size()-1 ); // eat the trailing linefeed
    912912
    913             item->setText( COL_UP, peer.rateToPeer.isZero() ? "" : Utils::speedToString( peer.rateToPeer ) );
    914             item->setText( COL_DOWN, peer.rateToClient.isZero() ? "" : Utils::speedToString( peer.rateToClient ) );
     913            item->setText( COL_UP, peer.rateToPeer.isZero() ? "" : Units::speedToString( peer.rateToPeer ) );
     914            item->setText( COL_DOWN, peer.rateToClient.isZero() ? "" : Units::speedToString( peer.rateToClient ) );
    915915            item->setText( COL_PERCENT, peer.progress > 0 ? QString( "%1%" ).arg( (int)( peer.progress * 100.0 ) ) : "" );
    916916            item->setText( COL_STATUS, code );
     
    10111011Details :: onDownloadLimitChanged( int val )
    10121012{
    1013     mySession.torrentSet( myIds, "downloadLimit", val );
     1013    mySession.torrentSet( myIds, "downloadLimit", val * Units::speed_K  );
    10141014}
    10151015void
     
    10211021Details :: onUploadLimitChanged( int val )
    10221022{
    1023     mySession.torrentSet( myIds, "uploadLimit", val );
     1023    mySession.torrentSet( myIds, "uploadLimit", val * Units::speed_K );
    10241024}
    10251025
     
    11921192    connect( c, SIGNAL(clicked(bool)), this, SLOT(onHonorsSessionLimitsToggled(bool)) );
    11931193
    1194     c = new QCheckBox( tr( "Limit &download speed (KiB/s):" ) );
     1194    c = new QCheckBox( tr( "Limit &download speed (%1):" ).arg( Units::speed_K_str ) );
    11951195    mySingleDownCheck = c;
    11961196    s = new QSpinBox( );
     
    12021202    connect( s, SIGNAL(valueChanged(int)), this, SLOT(onDownloadLimitChanged(int)));
    12031203
    1204     c = new QCheckBox( tr( "Limit &upload speed (KiB/s):" ) );
     1204    c = new QCheckBox( tr( "Limit &upload speed (%1):" ).arg( Units::speed_K_str ) );
    12051205    mySingleUpCheck = c;
    12061206    s = new QSpinBox( );
  • trunk/qt/file-tree.cc

    r10684 r10931  
    2525#include "hig.h"
    2626#include "torrent.h" // FileList
     27#include "units.h"
    2728#include "utils.h" // mime icons
    2829
     
    123124    QString str;
    124125    getSubtreeSize( have, total );
    125     str = QString( name() + " (%1)" ).arg( Utils::sizeToString( total ) );
     126    str = QString( name() + " (%1)" ).arg( Units::sizeToString( total ) );
    126127    return str;
    127128}
  • trunk/qt/mainwin.cc

    r10859 r10931  
    5252#include "triconpushbutton.h"
    5353#include "ui_mainwin.h"
    54 #include "utils.h"
     54#include "units.h"
    5555#include "qticonloader.h"
    5656
     
    550550        g->addAction( a );
    551551        connect( a, SIGNAL(triggered(bool)), this, SLOT(onSetPrefs(bool)) );
    552         a = myDlimitOnAction = sub->addAction( tr( "Limited at %1" ).arg( Utils::speedToString( Speed::fromKbps( currentVal ) ) ) );
     552        a = myDlimitOnAction = sub->addAction( tr( "Limited at %1" ).arg( Units::speedToString( Speed::fromBps( currentVal ) ) ) );
    553553        a->setCheckable( true );
    554554        a->setProperty( PREF_VARIANTS_KEY, QVariantList() << Prefs::DSPEED << currentVal << Prefs::DSPEED_ENABLED << true );
     
    557557        sub->addSeparator( );
    558558        foreach( int i, stockSpeeds ) {
    559             a = sub->addAction( Utils::speedToString( Speed::fromKbps(i) ) );
    560             a->setProperty( PREF_VARIANTS_KEY, QVariantList() << Prefs::DSPEED << i << Prefs::DSPEED_ENABLED << true );
     559            const int Bps = i * Units::speed_K;
     560            a = sub->addAction( Units::speedToString( Speed::fromBps( Bps ) ) );
     561            a->setProperty( PREF_VARIANTS_KEY, QVariantList() << Prefs::DSPEED << Bps << Prefs::DSPEED_ENABLED << true );
    561562            connect( a, SIGNAL(triggered(bool)), this, SLOT(onSetPrefs()));
    562563        }
     
    570571        g->addAction( a );
    571572        connect( a, SIGNAL(triggered(bool)), this, SLOT(onSetPrefs(bool)) );
    572         a = myUlimitOnAction = sub->addAction( tr( "Limited at %1" ).arg( Utils::speedToString( Speed::fromKbps( currentVal ) ) ) );
     573        a = myUlimitOnAction = sub->addAction( tr( "Limited at %1" ).arg( Units::speedToString( Speed::fromBps( currentVal ) ) ) );
    573574        a->setCheckable( true );
    574575        a->setProperty( PREF_VARIANTS_KEY, QVariantList() << Prefs::USPEED << currentVal << Prefs::USPEED_ENABLED << true );
     
    577578        sub->addSeparator( );
    578579        foreach( int i, stockSpeeds ) {
    579             a = sub->addAction( Utils::speedToString( Speed::fromKbps(i) ) );
    580             a->setProperty( PREF_VARIANTS_KEY, QVariantList() << Prefs::USPEED << i << Prefs::USPEED_ENABLED << true );
     580            const int Bps = i * Units::speed_K;
     581            a = sub->addAction( Units::speedToString( Speed::fromBps( Bps ) ) );
     582            a->setProperty( PREF_VARIANTS_KEY, QVariantList() << Prefs::USPEED << Bps << Prefs::USPEED_ENABLED << true );
    581583            connect( a, SIGNAL(triggered(bool)), this, SLOT(onSetPrefs()));
    582584        }
     
    592594        g->addAction( a );
    593595        connect( a, SIGNAL(triggered(bool)), this, SLOT(onSetPrefs(bool)) );
    594         a = myRatioOnAction = sub->addAction( tr( "Stop at Ratio (%1)" ).arg( Utils::ratioToString( d ) ) );
     596        a = myRatioOnAction = sub->addAction( tr( "Stop at Ratio (%1)" ).arg( Units::ratioToString( d ) ) );
    595597        a->setCheckable( true );
    596598        a->setProperty( PREF_VARIANTS_KEY, QVariantList() << Prefs::RATIO << d << Prefs::RATIO_ENABLED << true );
     
    599601        sub->addSeparator( );
    600602        foreach( double i, stockRatios ) {
    601             a = sub->addAction( Utils::ratioToString( i ) );
     603            a = sub->addAction( Units::ratioToString( i ) );
    602604            a->setProperty( PREF_VARIANTS_KEY, QVariantList() << Prefs::RATIO << i << Prefs::RATIO_ENABLED << true );
    603605            connect( a, SIGNAL(triggered(bool)), this, SLOT(onSetPrefs()));
     
    734736    const Speed up( myModel.getUploadSpeed( ) );
    735737    const Speed down( myModel.getDownloadSpeed( ) );
    736     myUploadSpeedLabel->setText( Utils :: speedToString( up ) );
    737     myDownloadSpeedLabel->setText( Utils :: speedToString( down ) );
     738    myUploadSpeedLabel->setText( Units :: speedToString( up ) );
     739    myDownloadSpeedLabel->setText( Units :: speedToString( down ) );
    738740
    739741    myNetworkLabel->setVisible( !mySession.isServer( ) );
     
    744746    if( mode == "session-ratio" )
    745747    {
    746         str = tr( "Ratio: %1" ).arg( Utils :: ratioToString( mySession.getStats().ratio ) );
     748        str = tr( "Ratio: %1" ).arg( Units :: ratioToString( mySession.getStats().ratio ) );
    747749    }
    748750    else if( mode == "session-transfer" )
    749751    {
    750752        const tr_session_stats& stats( mySession.getStats( ) );
    751         str = tr( "Down: %1, Up: %2" ).arg( Utils :: sizeToString( stats.downloadedBytes ) )
    752                                       .arg( Utils :: sizeToString( stats.uploadedBytes ) );
     753        str = tr( "Down: %1, Up: %2" ).arg( Units :: sizeToString( stats.downloadedBytes ) )
     754                                      .arg( Units :: sizeToString( stats.uploadedBytes ) );
    753755    }
    754756    else if( mode == "total-transfer" )
    755757    {
    756758        const tr_session_stats& stats( mySession.getCumulativeStats( ) );
    757         str = tr( "Down: %1, Up: %2" ).arg( Utils :: sizeToString( stats.downloadedBytes ) )
    758                                       .arg( Utils :: sizeToString( stats.uploadedBytes ) );
     759        str = tr( "Down: %1, Up: %2" ).arg( Units :: sizeToString( stats.downloadedBytes ) )
     760                                      .arg( Units :: sizeToString( stats.uploadedBytes ) );
    759761    }
    760762    else // default is "total-ratio"
    761763    {
    762         str = tr( "Ratio: %1" ).arg( Utils :: ratioToString( mySession.getCumulativeStats().ratio ) );
     764        str = tr( "Ratio: %1" ).arg( Units :: ratioToString( mySession.getCumulativeStats().ratio ) );
    763765    }
    764766
     
    10121014
    10131015        case Prefs::DSPEED:
    1014             myDlimitOnAction->setText( tr( "Limited at %1" ).arg( Utils::speedToString( Speed::fromKbps( myPrefs.get<int>(key) ) ) ) );
     1016            myDlimitOnAction->setText( tr( "Limited at %1" ).arg( Units::speedToString( Speed::fromBps( myPrefs.get<int>(key) ) ) ) );
    10151017            break;
    10161018
     
    10201022
    10211023        case Prefs::USPEED:
    1022             myUlimitOnAction->setText( tr( "Limited at %1" ).arg( Utils::speedToString( Speed::fromKbps( myPrefs.get<int>(key) ) ) ) );
     1024            myUlimitOnAction->setText( tr( "Limited at %1" ).arg( Units::speedToString( Speed::fromBps( myPrefs.get<int>(key) ) ) ) );
    10231025            break;
    10241026
     
    10281030
    10291031        case Prefs::RATIO:
    1030             myRatioOnAction->setText( tr( "Stop at Ratio (%1)" ).arg( Utils::ratioToString( myPrefs.get<double>(key) ) ) );
     1032            myRatioOnAction->setText( tr( "Stop at Ratio (%1)" ).arg( Units::ratioToString( myPrefs.get<double>(key) ) ) );
    10311033            break;
    10321034
     
    10861088            const QString fmt = b ? tr( "Click to disable Temporary Speed Limits\n(%1 down, %2 up)" )
    10871089                                  : tr( "Click to enable Temporary Speed Limits\n(%1 down, %2 up)" );
    1088             const Speed d = Speed::fromKbps( myPrefs.getInt( Prefs::ALT_SPEED_LIMIT_DOWN ) );
    1089             const Speed u = Speed::fromKbps( myPrefs.getInt( Prefs::ALT_SPEED_LIMIT_UP ) );
    1090             myAltSpeedButton->setToolTip( fmt.arg( Utils::speedToString( d ) )
    1091                                              .arg( Utils::speedToString( u ) ) );
     1090            const Speed d = Speed::fromBps( myPrefs.getInt( Prefs::ALT_SPEED_LIMIT_DOWN ) );
     1091            const Speed u = Speed::fromBps( myPrefs.getInt( Prefs::ALT_SPEED_LIMIT_UP ) );
     1092            myAltSpeedButton->setToolTip( fmt.arg( Units::speedToString( d ) )
     1093                                             .arg( Units::speedToString( u ) ) );
    10921094            break;
    10931095        }
     
    12941296    myNetworkLabel->setToolTip( isSending || isReading
    12951297        ? tr( "Transmission server is responding" )
    1296         : tr( "Last response from server was %1 ago" ).arg( Utils::timeToString( now-std::max(myLastReadTime,myLastSendTime))));
     1298        : tr( "Last response from server was %1 ago" ).arg( Units::timeToString( now-std::max(myLastReadTime,myLastSendTime))));
    12971299}
    12981300
  • trunk/qt/make-dialog.cc

    r9868 r10931  
    3838#include "make-dialog.h"
    3939#include "session.h"
    40 #include "utils.h"
     40#include "units.h"
    4141
    4242/***
     
    283283        QString pieces = tr( "%Ln Piece(s)", 0, myBuilder->pieceCount );
    284284        text = tr( "%1 in %2; %3 @ %4" )
    285                  .arg( Utils::sizeToString( myBuilder->totalSize ) )
     285                 .arg( Units::sizeToString( myBuilder->totalSize ) )
    286286                 .arg( files )
    287287                 .arg( pieces )
    288                  .arg( Utils::sizeToString( myBuilder->pieceSize ) );
     288                 .arg( Units::sizeToString( myBuilder->pieceSize ) );
    289289    }
    290290
  • trunk/qt/prefs-dialog.cc

    r10922 r10931  
    4242#include "qticonloader.h"
    4343#include "session.h"
     44#include "units.h"
    4445#include "utils.h"
    4546
     
    5152{
    5253    const char * PREF_KEY( "pref-key" );
     54    const char * MULTIPLIER_KEY( "multiplier-key" );
    5355};
    5456
     
    8284{
    8385    const QObject * spin( sender()->property( "SPIN" ).value<QObject*>( ) );
    84     const int key( spin->property( PREF_KEY ).toInt( ) );
     86    const int key = spin->property( PREF_KEY ).toInt( );
     87    const int multiplier = spin->property( MULTIPLIER_KEY ).toInt( );
    8588
    8689    const QDoubleSpinBox * d = qobject_cast<const QDoubleSpinBox*>( spin );
    8790    if( d != 0 )
    88         myPrefs.set( key, d->value( ) );
     91        myPrefs.set( key, multiplier * d->value( ) );
    8992    else
    90         myPrefs.set( key, qobject_cast<const QSpinBox*>(spin)->value( ) );
     93        myPrefs.set( key, multiplier * qobject_cast<const QSpinBox*>(spin)->value( ) );
    9194}
    9295
     
    114117
    115118QSpinBox *
    116 PrefsDialog :: spinBoxNew( int key, int low, int high, int step )
     119PrefsDialog :: spinBoxNew( int key, int low, int high, int step, int multiplier )
    117120{
    118121    QSpinBox * spin = new QSpinBox( );
    119122    spin->setRange( low, high );
    120123    spin->setSingleStep( step );
    121     spin->setValue( myPrefs.getInt( key ) );
     124    spin->setValue( myPrefs.getInt( key ) / multiplier );
    122125    spin->setProperty( PREF_KEY, key );
     126    spin->setProperty( MULTIPLIER_KEY, multiplier );
    123127    connect( spin, SIGNAL(valueChanged(int)), this, SLOT(spinBoxChanged(int)));
    124128    myWidgets.insert( key, spin );
     
    135139
    136140QDoubleSpinBox *
    137 PrefsDialog :: doubleSpinBoxNew( int key, double low, double high, double step, int decimals )
     141PrefsDialog :: doubleSpinBoxNew( int key, double low, double high, double step, int decimals, int multiplier )
    138142{
    139143    QDoubleSpinBox * spin = new QDoubleSpinBox( );
     
    141145    spin->setSingleStep( step );
    142146    spin->setDecimals( decimals );
    143     spin->setValue( myPrefs.getDouble( key ) );
     147    spin->setValue( myPrefs.getDouble( key ) / multiplier );
    144148    spin->setProperty( PREF_KEY, key );
     149    spin->setProperty( MULTIPLIER_KEY, multiplier );
    145150    connect( spin, SIGNAL(valueChanged(double)), this, SLOT(doubleSpinBoxChanged(double)));
    146151    myWidgets.insert( key, spin );
     
    268273    hig->addSectionTitle( tr( "Speed Limits" ) );
    269274
    270         l = checkBoxNew( tr( "Limit &download speed (KiB/s):" ), Prefs::DSPEED_ENABLED );
    271         r = spinBoxNew( Prefs::DSPEED, 0, INT_MAX, 5 );
     275        l = checkBoxNew( tr( "Limit &download speed (%1):" ).arg( Units::speed_K_str ), Prefs::DSPEED_ENABLED );
     276        r = spinBoxNew( Prefs::DSPEED, 0, INT_MAX, 5, Units::speed_K );
    272277        hig->addRow( l, r );
    273278        enableBuddyWhenChecked( qobject_cast<QCheckBox*>(l), r );
    274279
    275         l = checkBoxNew( tr( "Limit &upload speed (KiB/s):" ), Prefs::USPEED_ENABLED );
    276         r = spinBoxNew( Prefs::USPEED, 0, INT_MAX, 5 );
     280        l = checkBoxNew( tr( "Limit &upload speed (%1):" ).arg( Units::speed_K_str ), Prefs::USPEED_ENABLED );
     281        r = spinBoxNew( Prefs::USPEED, 0, INT_MAX, 5, Units::speed_K );
    277282        hig->addRow( l, r );
    278283        enableBuddyWhenChecked( qobject_cast<QCheckBox*>(l), r );
     
    294299        hig->addWideControl( new QLabel( s ) );
    295300
    296         s = tr( "Limit d&ownload speed (KiB/s):" );
    297         r = spinBoxNew( Prefs :: ALT_SPEED_LIMIT_DOWN, 0, INT_MAX, 5 );
     301        s = tr( "Limit d&ownload speed (%1):" ).arg( Units::speed_K_str );
     302        r = spinBoxNew( Prefs :: ALT_SPEED_LIMIT_DOWN, 0, INT_MAX, 5, Units::speed_K );
    298303        hig->addRow( s, r );
    299304
    300         s = tr( "Limit u&pload speed (KiB/s):" );
    301         r = spinBoxNew( Prefs :: ALT_SPEED_LIMIT_UP, 0, INT_MAX, 5 );
     305        s = tr( "Limit u&pload speed (%1):" ).arg( Units::speed_K_str );
     306        r = spinBoxNew( Prefs :: ALT_SPEED_LIMIT_UP, 0, INT_MAX, 5, Units::speed_K );
    302307        hig->addRow( s, r );
    303308
  • trunk/qt/prefs-dialog.h

    r10722 r10931  
    6565
    6666    private:
    67         QDoubleSpinBox * doubleSpinBoxNew( int key, double low, double high, double step, int decimals );
     67        QDoubleSpinBox * doubleSpinBoxNew( int key, double low, double high, double step, int decimals, int multiplier=1 );
    6868        QCheckBox * checkBoxNew( const QString& text, int key );
    69         QSpinBox * spinBoxNew( int key, int low, int high, int step );
     69        QSpinBox * spinBoxNew( int key, int low, int high, int step, int multiplier=1 );
    7070        QTimeEdit * timeEditNew( int key );
    7171        QLineEdit * lineEditNew( int key, int mode = 0 );
  • trunk/qt/prefs.cc

    r10908 r10931  
    6565
    6666    /* libtransmission settings */
    67     { ALT_SPEED_LIMIT_UP, TR_PREFS_KEY_ALT_SPEED_UP, QVariant::Int },
    68     { ALT_SPEED_LIMIT_DOWN, TR_PREFS_KEY_ALT_SPEED_DOWN, QVariant::Int },
     67    { ALT_SPEED_LIMIT_UP, TR_PREFS_KEY_ALT_SPEED_UP_Bps, QVariant::Int },
     68    { ALT_SPEED_LIMIT_DOWN, TR_PREFS_KEY_ALT_SPEED_DOWN_Bps, QVariant::Int },
    6969    { ALT_SPEED_LIMIT_ENABLED, TR_PREFS_KEY_ALT_SPEED_ENABLED, QVariant::Bool },
    7070    { ALT_SPEED_LIMIT_TIME_BEGIN, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, QVariant::Int },
     
    7373    { ALT_SPEED_LIMIT_TIME_DAY, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, QVariant::Int },
    7474    { BLOCKLIST_ENABLED, TR_PREFS_KEY_BLOCKLIST_ENABLED, QVariant::Bool },
    75     { DSPEED, TR_PREFS_KEY_DSPEED, QVariant::Int },
     75    { DSPEED, TR_PREFS_KEY_DSPEED_Bps, QVariant::Int },
    7676    { DSPEED_ENABLED, TR_PREFS_KEY_DSPEED_ENABLED, QVariant::Bool },
    7777    { DOWNLOAD_DIR, TR_PREFS_KEY_DOWNLOAD_DIR, QVariant::String },
     
    116116    { RPC_WHITELIST, TR_PREFS_KEY_RPC_WHITELIST, QVariant::String },
    117117    { USPEED_ENABLED, TR_PREFS_KEY_USPEED_ENABLED, QVariant::Bool },
    118     { USPEED, TR_PREFS_KEY_USPEED, QVariant::Int },
     118    { USPEED, TR_PREFS_KEY_USPEED_Bps, QVariant::Int },
    119119    { UPLOAD_SLOTS_PER_TORRENT, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, QVariant::Int }
    120120};
  • trunk/qt/qtr.pro

    r10887 r10931  
    3636           session-dialog.cc squeezelabel.cc stats-dialog.cc torrent.cc \
    3737           torrent-delegate.cc torrent-delegate-min.cc torrent-filter.cc \
    38            torrent-model.cc triconpushbutton.cc utils.cc watchdir.cc
     38           torrent-model.cc triconpushbutton.cc units.cc utils.cc watchdir.cc
    3939HEADERS += $$replace(SOURCES, .cc, .h)
    4040HEADERS += speed.h types.h
  • trunk/qt/speed.h

    r9868 r10931  
    1717{
    1818    private:
    19         double _kbps;
    20         Speed( double kbps ): _kbps(kbps) { }
     19        int _Bps;
     20        Speed( int Bps ): _Bps(Bps) { }
    2121    public:
    22         Speed( ): _kbps(0) { }
    23         double kbps( ) const { return _kbps; }
    24         double bps( ) const { return kbps()*1024.0; }
    25         bool isZero( ) const { return _kbps < 0.001; }
    26         static Speed fromKbps( double kbps ) { return Speed( kbps ); }
    27         static Speed fromBps( double bps ) { return Speed( bps/1024.0 ); }
    28         void setKbps( double kbps ) { _kbps = kbps; }
    29         void setBps( double bps ) { _kbps = bps/1024.0; }
    30         Speed operator+( const Speed& that ) const { return Speed( kbps() + that.kbps() ); }
    31         Speed& operator+=( const Speed& that ) { _kbps += that._kbps; return *this; }
    32         bool operator<( const Speed& that ) const { return kbps() < that.kbps(); }
     22        Speed( ): _Bps(0) { }
     23        double KiBps( ) const { return _Bps/1024.0; }
     24        int Bps( ) const { return _Bps; }
     25        bool isZero( ) const { return _Bps == 0; }
     26        static Speed fromKiBps( double KiBps ) { return Speed( KiBps*1024 ); }
     27        static Speed fromBps( int Bps ) { return Speed( Bps ); }
     28        void setKiBps( double KiBps ) { setBps( KiBps*1024 ); }
     29        void setBps( double Bps ) { _Bps = Bps; }
     30        Speed& operator+=( const Speed& that ) { _Bps += that._Bps; return *this; }
     31        Speed operator+( const Speed& that ) const { return Speed( _Bps + that._Bps ); }
     32        bool operator<( const Speed& that ) const { return _Bps < that._Bps; }
    3333};
    3434
  • trunk/qt/stats-dialog.cc

    r9868 r10931  
    1919#include "session.h"
    2020#include "stats-dialog.h"
    21 #include "utils.h"
     21#include "units.h"
    2222
    2323enum
     
    8686    const struct tr_session_stats& total( mySession.getCumulativeStats( ) );
    8787
    88     myCurrentUp->setText( Utils :: sizeToString( current.uploadedBytes ) );
    89     myCurrentDown->setText( Utils :: sizeToString( current.downloadedBytes ) );
    90     myCurrentRatio->setText( Utils :: ratioToString( current.ratio ) );
    91     myCurrentDuration->setText( Utils :: timeToString( current.secondsActive ) );
     88    myCurrentUp->setText( Units::sizeToString( current.uploadedBytes ) );
     89    myCurrentDown->setText( Units::sizeToString( current.downloadedBytes ) );
     90    myCurrentRatio->setText( Units::ratioToString( current.ratio ) );
     91    myCurrentDuration->setText( Units::timeToString( current.secondsActive ) );
    9292
    93     myTotalUp->setText( Utils :: sizeToString( total.uploadedBytes ) );
    94     myTotalDown->setText( Utils :: sizeToString( total.downloadedBytes ) );
    95     myTotalRatio->setText( Utils :: ratioToString( total.ratio ) );
    96     myTotalDuration->setText( Utils :: timeToString( total.secondsActive ) );
     93    myTotalUp->setText( Units::sizeToString( total.uploadedBytes ) );
     94    myTotalDown->setText( Units::sizeToString( total.downloadedBytes ) );
     95    myTotalRatio->setText( Units::ratioToString( total.ratio ) );
     96    myTotalDuration->setText( Units::timeToString( total.secondsActive ) );
    9797
    9898    myStartCount->setText( tr( "Started %n time(s)", 0, total.sessionCount ) );
  • trunk/qt/torrent-delegate-min.cc

    r10771 r10931  
    2727#include "torrent-delegate-min.h"
    2828#include "torrent-model.h"
    29 #include "utils.h"
    3029
    3130enum
  • trunk/qt/torrent-delegate.cc

    r10822 r10931  
    2727#include "torrent-delegate.h"
    2828#include "torrent-model.h"
    29 #include "utils.h"
     29#include "units.h"
    3030
    3131enum
     
    7575        /* %1 is the percentage of torrent metadata downloaded */
    7676        str = tr( "Magnetized transfer - retrieving metadata (%1%)" )
    77             .arg( Utils::percentToString( tor.metadataPercentDone() * 100.0 ) );
     77            .arg( Units::percentToString( tor.metadataPercentDone() * 100.0 ) );
    7878    }
    7979    else if( !isDone ) // downloading
     
    8282           %2 is how much we'll have when done,
    8383           %3 is a percentage of the two */
    84         str = tr( "%1 of %2 (%3%)" ).arg( Utils::sizeToString( haveTotal ) )
    85                                     .arg( Utils::sizeToString( tor.sizeWhenDone( ) ) )
    86                                     .arg( Utils::percentToString( tor.percentDone( ) * 100.0 ) );
     84        str = tr( "%1 of %2 (%3%)" ).arg( Units::sizeToString( haveTotal ) )
     85                                    .arg( Units::sizeToString( tor.sizeWhenDone( ) ) )
     86                                    .arg( Units::percentToString( tor.percentDone( ) * 100.0 ) );
    8787    }
    8888    else if( !isSeed ) // partial seed
     
    9797               %6 is the ratio we want to reach before we stop uploading */
    9898            str = tr( "%1 of %2 (%3%), uploaded %4 (Ratio: %5 Goal: %6)" )
    99                   .arg( Utils::sizeToString( haveTotal ) )
    100                   .arg( Utils::sizeToString( tor.totalSize( ) ) )
    101                   .arg( Utils::percentToString( tor.percentComplete( ) * 100.0 ) )
    102                   .arg( Utils::sizeToString( tor.uploadedEver( ) ) )
    103                   .arg( Utils::ratioToString( tor.ratio( ) ) )
    104                   .arg( Utils::ratioToString( seedRatio ) );
     99                  .arg( Units::sizeToString( haveTotal ) )
     100                  .arg( Units::sizeToString( tor.totalSize( ) ) )
     101                  .arg( Units::percentToString( tor.percentComplete( ) * 100.0 ) )
     102                  .arg( Units::sizeToString( tor.uploadedEver( ) ) )
     103                  .arg( Units::ratioToString( tor.ratio( ) ) )
     104                  .arg( Units::ratioToString( seedRatio ) );
    105105        }
    106106        else
     
    112112               %5 is our upload-to-download ratio */
    113113            str = tr( "%1 of %2 (%3%), uploaded %4 (Ratio: %5)" )
    114                   .arg( Utils::sizeToString( haveTotal ) )
    115                   .arg( Utils::sizeToString( tor.totalSize( ) ) )
    116                   .arg( Utils::percentToString( tor.percentComplete( ) * 100.0 ) )
    117                   .arg( Utils::sizeToString( tor.uploadedEver( ) ) )
    118                   .arg( Utils::ratioToString( tor.ratio( ) ) );
     114                  .arg( Units::sizeToString( haveTotal ) )
     115                  .arg( Units::sizeToString( tor.totalSize( ) ) )
     116                  .arg( Units::percentToString( tor.percentComplete( ) * 100.0 ) )
     117                  .arg( Units::sizeToString( tor.uploadedEver( ) ) )
     118                  .arg( Units::ratioToString( tor.ratio( ) ) );
    119119        }
    120120    }
     
    128128               %4 is the ratio we want to reach before we stop uploading */
    129129            str = tr( "%1, uploaded %2 (Ratio: %3 Goal %4)" )
    130                   .arg( Utils::sizeToString( haveTotal ) )
    131                   .arg( Utils::sizeToString( tor.uploadedEver( ) ) )
    132                   .arg( Utils::ratioToString( tor.ratio( ) ) )
    133                   .arg( Utils::ratioToString( seedRatio ) );
     130                  .arg( Units::sizeToString( haveTotal ) )
     131                  .arg( Units::sizeToString( tor.uploadedEver( ) ) )
     132                  .arg( Units::ratioToString( tor.ratio( ) ) )
     133                  .arg( Units::ratioToString( seedRatio ) );
    134134        }
    135135        else /* seeding w/o a ratio */
     
    139139               %3 is our upload-to-download ratio */
    140140            str = tr( "%1, uploaded %2 (Ratio: %3)" )
    141                   .arg( Utils::sizeToString( haveTotal ) )
    142                   .arg( Utils::sizeToString( tor.uploadedEver( ) ) )
    143                   .arg( Utils::ratioToString( tor.ratio( ) ) );
     141                  .arg( Units::sizeToString( haveTotal ) )
     142                  .arg( Units::sizeToString( tor.uploadedEver( ) ) )
     143                  .arg( Units::ratioToString( tor.ratio( ) ) );
    144144        }
    145145    }
     
    150150        str += tr( " - " );
    151151        if( tor.hasETA( ) )
    152             str += tr( "%1 left" ).arg( Utils::timeToString( tor.getETA( ) ) );
     152            str += tr( "%1 left" ).arg( Units::timeToString( tor.getETA( ) ) );
    153153        else
    154154            str += tr( "Remaining time unknown" );
     
    167167
    168168    if( haveDown )
    169         downStr = Utils :: speedToString( tor.downloadSpeed( ) );
     169        downStr = Units::speedToString( tor.downloadSpeed( ) );
    170170    if( haveUp )
    171         upStr = Utils :: speedToString( tor.uploadSpeed( ) );
     171        upStr = Units::speedToString( tor.uploadSpeed( ) );
    172172
    173173    if( haveDown && haveUp )
     
    191191    {
    192192        case TR_STATUS_CHECK:
    193             str = tr( "Verifying local data (%1% tested)" ).arg( Utils::percentToString( tor.getVerifyProgress()*100.0 ) );
     193            str = tr( "Verifying local data (%1% tested)" ).arg( Units::percentToString( tor.getVerifyProgress()*100.0 ) );
    194194            break;
    195195
     
    197197        case TR_STATUS_SEED:
    198198            if( !tor.isDownloading( ) )
    199                 str = tr( "Ratio: %1, " ).arg( Utils::ratioToString( tor.ratio( ) ) );
     199                str = tr( "Ratio: %1, " ).arg( Units::ratioToString( tor.ratio( ) ) );
    200200            str += shortTransferString( tor );
    201201            break;
     
    232232            else
    233233                str = tr( "Downloading metadata from %n peer(s) (%1% done)", 0, tor.peersWeAreDownloadingFrom( ) )
    234                         .arg( Utils::percentToString( 100.0 * tor.metadataPercentDone( ) ) );
     234                        .arg( Units::percentToString( 100.0 * tor.metadataPercentDone( ) ) );
    235235            break;
    236236
  • trunk/qt/torrent.h

    r10872 r10931  
    285285        bool hasFileSubstring( const QString& substr ) const;
    286286        bool hasTrackerSubstring( const QString& substr ) const;
    287         Speed uploadLimit( ) const { return Speed::fromKbps( getInt( UP_LIMIT ) ); }
    288         Speed downloadLimit( ) const { return Speed::fromKbps( getInt( DOWN_LIMIT ) ); }
     287        Speed uploadLimit( ) const { return Speed::fromBps( getInt( UP_LIMIT ) ); }
     288        Speed downloadLimit( ) const { return Speed::fromBps( getInt( DOWN_LIMIT ) ); }
    289289        bool uploadIsLimited( ) const { return getBool( UP_LIMITED ); }
    290290        bool downloadIsLimited( ) const { return getBool( DOWN_LIMITED ); }
  • trunk/qt/utils.cc

    r10822 r10931  
    2929#include "utils.h"
    3030
     31/***
     32****
     33***/
     34
    3135QString
    3236Utils :: remoteFileChooser( QWidget * parent, const QString& title, const QString& myPath, bool dir, bool local )
     
    4549
    4650    return path;
    47 }
    48 
    49 QString
    50 Utils :: sizeToString( double bytes )
    51 {
    52     if( !bytes )
    53         return tr( "None" );
    54     else {
    55         char buf[128];
    56         tr_formatter_size( buf, bytes, sizeof( buf ) );
    57         return buf;
    58     }
    59 }
    60 
    61 QString
    62 Utils :: speedToString( const Speed& speed )
    63 {
    64     if( speed.isZero( ) )
    65         return tr( "None" );
    66     else {
    67         char buf[128];
    68         tr_formatter_speed( buf, speed.bps( ), sizeof( buf ) );
    69         return buf;
    70     }
    71 }
    72 
    73 QString
    74 Utils :: percentToString( double x )
    75 {
    76     char buf[128];
    77     return QString( tr_strpercent( buf, x, sizeof(buf) ) );
    78 }
    79 
    80 QString
    81 Utils :: ratioToString( double ratio )
    82 {
    83     char buf[128];
    84     return QString::fromUtf8( tr_strratio( buf, sizeof(buf), ratio, "\xE2\x88\x9E" ) );
    85 }
    86 
    87 QString
    88 Utils :: timeToString( int seconds )
    89 {
    90     int days, hours, minutes;
    91     QString d, h, m, s;
    92     QString str;
    93 
    94     if( seconds < 0 )
    95         seconds = 0;
    96 
    97     days = seconds / 86400;
    98     hours = ( seconds % 86400 ) / 3600;
    99     minutes = ( seconds % 3600 ) / 60;
    100     seconds %= 60;
    101 
    102     d = tr( "%Ln day(s)", 0, days );
    103     h = tr( "%Ln hour(s)", 0, hours );
    104     m = tr( "%Ln minute(s)", 0, minutes );
    105     s = tr( "%Ln second(s)", 0, seconds );
    106 
    107     if( days )
    108     {
    109         if( days >= 4 || !hours )
    110             str = d;
    111         else
    112             str = tr( "%1, %2" ).arg( d ).arg( h );
    113     }
    114     else if( hours )
    115     {
    116         if( hours >= 4 || !minutes )
    117             str = h;
    118         else
    119             str = tr( "%1, %2" ).arg( h ).arg( m );
    120     }
    121     else if( minutes )
    122     {
    123         if( minutes >= 4 || !seconds )
    124             str = m;
    125         else
    126             str = tr( "%1, %2" ).arg( m ).arg( s );
    127     }
    128     else
    129     {
    130         str = s;
    131     }
    132 
    133     return str;
    13451}
    13552
  • trunk/qt/utils.h

    r10822 r10931  
    2727        Utils( ) { }
    2828        virtual ~Utils( ) { }
     29
    2930    public:
    3031        static QString remoteFileChooser( QWidget * parent, const QString& title, const QString& myPath, bool dir, bool local );
    31         static QString sizeToString( double bytes );
    32         static QString speedToString( const Speed& speed );
    33         static QString percentToString( double x );
    34         static QString ratioToString( double ratio );
    35         static QString timeToString( int seconds );
    3632        static const QIcon& guessMimeIcon( const QString& filename );
    3733
  • trunk/utils/show.c

    r10854 r10931  
    2929#define TIMEOUT_SECS 30
    3030
     31#define MEM_K 1024
     32#define MEM_B_STR "B"
     33#define MEM_K_STR "KiB"
     34#define MEM_M_STR "MiB"
     35#define MEM_G_STR "GiB"
     36
     37#define DISK_K 1000
     38#define DISK_B_STR "B"
     39#define DISK_K_STR "kB"
     40#define DISK_M_STR "MB"
     41#define DISK_G_STR "GB"
     42
     43#define SPEED_K 1000
     44#define SPEED_B_STR "B/s"
     45#define SPEED_K_STR "kB/s"
     46#define SPEED_M_STR "MB/s"
     47#define SPEED_G_STR "GB/s"
     48
    3149static tr_option options[] =
    3250{
     
    87105        printf( "  Comment: %s\n", inf->comment );
    88106    printf( "  Piece Count: %d\n", inf->pieceCount );
    89     printf( "  Piece Size: %s\n", tr_formatter_size( buf, inf->pieceSize, sizeof( buf ) ) );
     107    printf( "  Piece Size: %s\n", tr_formatter_mem( buf, inf->pieceSize, sizeof( buf ) ) );
    90108    printf( "  Total Size: %s\n", tr_formatter_size( buf, inf->totalSize, sizeof( buf ) ) );
    91109    printf( "  Privacy: %s\n", inf->isPrivate ? "Private torrent" : "Public torrent" );
     
    232250
    233251    tr_setMessageLevel( TR_MSG_ERR );
    234     tr_formatter_size_init ( 1024, "B", "KiB", "MiB", "GiB" );
    235     tr_formatter_speed_init( 1024, "B/s", "KiB/s", "MiB/s", "GiB/s" );
     252    tr_formatter_mem_init  ( MEM_K, MEM_B_STR, MEM_K_STR, MEM_G_STR );
     253    tr_formatter_size_init ( DISK_K, DISK_B_STR, DIST_K_STR, DISK_G_STR );
     254    tr_formatter_size_init ( SPEED_K, SPEED_B_STR, SPEED_K_STR, SPEED_G_STR );
    236255
    237256    if( parseCommandLine( argc, (const char**)argv ) )
  • trunk/web/index.html

    r10812 r10931  
    273273                                                                        <label for="limit_download" class="item">Download Rate:</label>
    274274                                                                        <input type="text" name="download_rate" id="download_rate"/>
    275                                                                         <label class="suffix">KB/s</label>
     275                                                                        <label class="suffix">kB/s</label>
    276276                                                                </div>
    277277                                                                <div class="formdiv checkbox">
     
    279279                                                                        <label for="limit_upload" class="item">Upload Rate:</label>
    280280                                                                        <input type="text" name="upload_rate" id="upload_rate"/>
    281                                                                         <label class="suffix">KB/s</label>
     281                                                                        <label class="suffix">kB/s</label>
    282282                                                                </div>
    283283                                                        </div>
     
    288288                                                                        <label for="turtle_download_rate" class="item">Download Rate:</label>
    289289                                                                        <input type="text" name="turtle_download_rate" id="turtle_download_rate"/>
    290                                                                         <label class="suffix">KB/s</label>
     290                                                                        <label class="suffix">kB/s</label>
    291291                                                                </div>
    292292                                                                <div class="formdiv">
    293293                                                                        <label for="turtle_upload_rate" class="item">Upload Rate:</label>
    294294                                                                        <input type="text" name="turtle_upload_rate" id="turtle_upload_rate"/>
    295                                                                         <label class="suffix">KB/s</label>
     295                                                                        <label class="suffix">kB/s</label>
    296296                                                                </div>
    297297                                                                <div class="formdiv checkbox">
     
    414414                                                        <ul id="footer_download_rate_menu">
    415415                                                                <li id="unlimited_download_rate">Unlimited</li>
    416                                                                 <li id="limited_download_rate">Limit (10 KB/s)</li>
     416                                                                <li id="limited_download_rate">Limit (10 kB/s)</li>
    417417                                                                <li class="separator"></li>
    418                                                                 <li>5 KB/s</li>
    419                                                                 <li>10 KB/s</li>
    420                                                                 <li>20 KB/s</li>
    421                                                                 <li>30 KB/s</li>
    422                                                                 <li>40 KB/s</li>
    423                                                                 <li>50 KB/s</li>
    424                                                                 <li>75 KB/s</li>
    425                                                                 <li>100 KB/s</li>
    426                                                                 <li>150 KB/s</li>
    427                                                                 <li>200 KB/s</li>
    428                                                                 <li>250 KB/s</li>
    429                                                                 <li>500 KB/s</li>
    430                                                                 <li>750 KB/s</li>
     418                                                                <li>5 kB/s</li>
     419                                                                <li>10 kB/s</li>
     420                                                                <li>20 kB/s</li>
     421                                                                <li>30 kB/s</li>
     422                                                                <li>40 kB/s</li>
     423                                                                <li>50 kB/s</li>
     424                                                                <li>75 kB/s</li>
     425                                                                <li>100 kB/s</li>
     426                                                                <li>150 kB/s</li>
     427                                                                <li>200 kB/s</li>
     428                                                                <li>250 kB/s</li>
     429                                                                <li>500 kB/s</li>
     430                                                                <li>750 kB/s</li>
    431431                                                        </ul>
    432432                                                </li>
     
    434434                                                        <ul id="footer_upload_rate_menu">
    435435                                                                <li id="unlimited_upload_rate">Unlimited</li>
    436                                                                 <li id="limited_upload_rate">Limit (10 KB/s)</li>
     436                                                                <li id="limited_upload_rate">Limit (10 kB/s)</li>
    437437                                                                <li class="separator"></li>
    438                                                                 <li>5 KB/s</li>
    439                                                                 <li>10 KB/s</li>
    440                                                                 <li>20 KB/s</li>
    441                                                                 <li>30 KB/s</li>
    442                                                                 <li>40 KB/s</li>
    443                                                                 <li>50 KB/s</li>
    444                                                                 <li>75 KB/s</li>
    445                                                                 <li>100 KB/s</li>
    446                                                                 <li>150 KB/s</li>
    447                                                                 <li>200 KB/s</li>
    448                                                                 <li>250 KB/s</li>
    449                                                                 <li>500 KB/s</li>
    450                                                                 <li>750 KB/s</li>
     438                                                                <li>5 kB/s</li>
     439                                                                <li>10 kB/s</li>
     440                                                                <li>20 kB/s</li>
     441                                                                <li>30 kB/s</li>
     442                                                                <li>40 kB/s</li>
     443                                                                <li>50 kB/s</li>
     444                                                                <li>75 kB/s</li>
     445                                                                <li>100 kB/s</li>
     446                                                                <li>150 kB/s</li>
     447                                                                <li>200 kB/s</li>
     448                                                                <li>250 kB/s</li>
     449                                                                <li>500 kB/s</li>
     450                                                                <li>750 kB/s</li>
    451451                                                        </ul>
    452452                                                </li>
  • trunk/web/javascript/formatter.js

    r10835 r10931  
    88Transmission.fmt = (function()
    99{
    10         var KB_val = 1024;
    11         var MB_val = 1024 * 1024;
    12         var GB_val = 1024 * 1024 * 1024;
    13         var KB_str = 'KiB';
    14         var MB_str = 'MiB';
    15         var GB_str = 'GiB';
     10        var speed_B_str = 'B';
     11        var speed_K_str = 'kB/s';
     12        var speed_M_str = 'MB/s';
     13        var speed_G_str = 'GB/s';
     14
     15        var size_B_str = 'B';
     16        var size_K_str = 'KiB';
     17        var size_M_str = 'MiB';
     18        var size_G_str = 'GiB';
    1619
    1720        return {
    18                 MODE_IEC: 1,
    19                 MODE_SI: 2,
     21                speed_K: 1000,
     22
     23                size_K: 1024,
    2024
    2125                /*
     
    4347                },
    4448
    45                 setMode: function( mode ) {
    46                         if( mode == MODE_IEC ) {
    47                                 this.KB_val = 1024;
    48                                 this.MB_val = this.KB_val * 1024;
    49                                 this.GB_val = this.MB_val * 1024;
    50                                 this.KB_str = 'KiB';
    51                                 this.MB_str = 'MiB';
    52                                 this.GB_str = 'GiB';
    53                         } else {
    54                                 this.KB_val = 1000;
    55                                 this.MB_val = this.KB_val * 1000;
    56                                 this.GB_val = this.MB_val * 1000;
    57                                 this.KB_str = 'kB';
    58                                 this.MB_str = 'MB';
    59                                 this.GB_str = 'GB';
    60                         }
    61                 },
    62 
    6349                /**
    6450                 * Formats the bytes into a string value with B, KiB, MiB, or GiB units.
     
    6955                size: function( bytes )
    7056                {
     57                        var size_K = this.size_K;
     58                        var size_M = size_K * size_K;
     59                        var size_G = size_K * size_K * size_K;
     60
    7161                        if( !bytes )
    7262                                return 'None';
     63                        if( bytes < size_K )
     64                                return bytes.toTruncFixed(0) + size_B_str;
    7365
    74                         if( bytes < KB_val )
    75                                 return bytes.toFixed(0) + ' B';
     66                        if( bytes < ( size_K * 100 ) )
     67                                return (bytes/size_K).toTruncFixed(2) + ' ' + size_K_str;
     68                        if( bytes < size_M )
     69                                return (bytes/size_K).toTruncFixed(1) + ' ' + size_K_str;
    7670
    77                         if( bytes < ( KB_val * 100 ) )
    78                                 return (bytes/KB_val).toFixed(2) + ' ' + KB_str;
    79                         if( bytes < MB_val )
    80                                 return (bytes/KB_val).toFixed(1) + ' ' + KB_str;
     71                        if( bytes < ( size_M * 100 ) )
     72                                return (bytes/size_M).toTruncFixed(2) + ' ' + size_M_str;
     73                        if( bytes < size_G )
     74                                return (bytes/size_M).toTruncFixed(1) + ' ' + size_M_str;
    8175
    82                         if( bytes < ( MB_val * 100 ) )
    83                                 return (bytes/MB_val).toFixed(2) + ' ' + MB_str;
    84                         if( bytes < GB_val )
    85                                 return (bytes/MB_val).toFixed(1) + ' ' + MB_str;
    86 
    87                         if( bytes < ( GB_val * 100 ) )
    88                                 return (bytes/GB_val).toFixed(2) + ' ' + GB_str;
     76                        if( bytes < ( size_G * 100 ) )
     77                                return (bytes/size_G).toTruncFixed(2) + ' ' + size_G_str;
    8978                        else
    90                                 return (bytes/GB_val).toFixed(1) + ' ' + GB_str;
     79                                return (bytes/size_G).toTruncFixed(1) + ' ' + size_G_str;
    9180                },
    9281
    9382                speed: function( bytes )
    9483                {
    95                         if( !bytes )
     84                        var speed_K = this.speed_K;
     85                        var speed_M = speed_K * speed_K;
     86                        var speed_G = speed_K * speed_K * speed_K;
     87
     88                        if( bytes==undefined || bytes==0 )
    9689                                return 'None';
     90
     91                        if( bytes < speed_K )
     92                                return bytes.toTruncFixed(0) + ' ' + speed_B_str;
     93
     94                        if( bytes < ( speed_K * 100 ) )
     95                                return (bytes/speed_K).toTruncFixed(2) + ' ' + speed_K_str;
     96                        if( bytes < speed_M )
     97                                return (bytes/speed_K).toTruncFixed(1) + ' ' + speed_K_str;
     98
     99                        if( bytes < ( speed_M * 100 ) )
     100                                return (bytes/speed_M).toTruncFixed(2) + ' ' + speed_M_str;
     101                        if( bytes < speed_G )
     102                                return (bytes/speed_M).toTruncFixed(1) + ' ' + speed_M_str;
     103
     104                        if( bytes < ( speed_G * 100 ) )
     105                                return (bytes/speed_G).toTruncFixed(2) + ' ' + speed_G_str;
    97106                        else
    98                                 return this.size( bytes ) + '/s';
     107                                return (bytes/speed_G).toTruncFixed(1) + ' ' + speed_G_str;
    99108                },
    100109
  • trunk/web/javascript/transmission.js

    r10825 r10931  
    641641                }
    642642
     643                var speed_K = Transmission.fmt.speed_K;
     644                var up_bytes        = parseInt( $('#prefs_form #upload_rate'  )[0].value ) * speed_K;
     645                var dn_bytes        = parseInt( $('#prefs_form #download_rate')[0].value ) * speed_K;
     646                var turtle_up_bytes = parseInt( $('#prefs_form #turtle_upload_rate'  )[0].value ) * speed_K;
     647                var turtle_dn_bytes = parseInt( $('#prefs_form #turtle_download_rate')[0].value ) * speed_K;
     648
    643649                // pass the new prefs upstream to the RPC server
    644650                var o = { };
    645651                o[RPC._StartAddedTorrent]    = $('#prefs_form #auto_start')[0].checked;
    646652                o[RPC._PeerPort]             = parseInt( $('#prefs_form #port')[0].value );
    647                 o[RPC._UpSpeedLimit]         = parseInt( $('#prefs_form #upload_rate')[0].value );
    648                 o[RPC._DownSpeedLimit]       = parseInt( $('#prefs_form #download_rate')[0].value );
     653                o[RPC._UpSpeedLimit]         = up_bytes;
     654                o[RPC._DownSpeedLimit]       = dn_bytes;
    649655                o[RPC._DownloadDir]          = $('#prefs_form #download_location')[0].value;
    650                 o[RPC._UpSpeedLimited]       = $('#prefs_form #limit_upload')[0].checked;
     656                o[RPC._UpSpeedLimited]       = $('#prefs_form #limit_upload'  )[0].checked;
    651657                o[RPC._DownSpeedLimited]     = $('#prefs_form #limit_download')[0].checked;
    652658                o[RPC._Encryption]           = $('#prefs_form #encryption')[0].checked
    653659                                                   ? RPC._EncryptionRequired
    654660                                                   : RPC._EncryptionPreferred;
    655                 o[RPC._TurtleDownSpeedLimit] = parseInt( $('#prefs_form #turtle_download_rate')[0].value );
    656                 o[RPC._TurtleUpSpeedLimit]   = parseInt( $('#prefs_form #turtle_upload_rate')[0].value );
     661                o[RPC._TurtleDownSpeedLimit] = turtle_dn_bytes;
     662                o[RPC._TurtleUpSpeedLimit]   = turtle_up_bytes;
    657663                o[RPC._TurtleTimeEnabled]    = $('#prefs_form #turtle_schedule')[0].checked;
    658664                o[RPC._TurtleTimeBegin]      = parseInt( $('#prefs_form #turtle_start_time').val() );
     
    927933                this._prefs = prefs;
    928934
    929                 var down_limit    = prefs[RPC._DownSpeedLimit];
    930                 var down_limited  = prefs[RPC._DownSpeedLimited];
    931                 var up_limit      = prefs[RPC._UpSpeedLimit];
    932                 var up_limited    = prefs[RPC._UpSpeedLimited];
     935                var up_limited        = prefs[RPC._UpSpeedLimited];
     936                var dn_limited        = prefs[RPC._DownSpeedLimited];
     937                var up_limit_b        = prefs[RPC._UpSpeedLimit];
     938                var dn_limit_b        = prefs[RPC._DownSpeedLimit];
     939                var up_limit_k        = up_limit_b                       / Transmission.fmt.speed_K;
     940                var dn_limit_k        = dn_limit_b                       / Transmission.fmt.speed_K;
     941                var turtle_up_limit_k = prefs[RPC._TurtleUpSpeedLimit]   / Transmission.fmt.speed_K;
     942                var turtle_dn_limit_k = prefs[RPC._TurtleDownSpeedLimit] / Transmission.fmt.speed_K;
    933943
    934944                $('div.download_location input')[0].value = prefs[RPC._DownloadDir];
    935945                $('div.port input')[0].value              = prefs[RPC._PeerPort];
    936946                $('div.auto_start input')[0].checked      = prefs[RPC._StartAddedTorrent];
    937                 $('input#limit_download')[0].checked      = down_limited;
    938                 $('input#download_rate')[0].value         = down_limit;
     947                $('input#limit_download')[0].checked      = dn_limited;
     948                $('input#download_rate')[0].value         = dn_limit_k;
    939949                $('input#limit_upload')[0].checked        = up_limited;
    940                 $('input#upload_rate')[0].value           = up_limit;
     950                $('input#upload_rate')[0].value           = up_limit_k;
    941951                $('input#refresh_rate')[0].value          = prefs[Prefs._RefreshRate];
    942952                $('div.encryption input')[0].checked      = prefs[RPC._Encryption] == RPC._EncryptionRequired;
    943                 $('input#turtle_download_rate')[0].value  = prefs[RPC._TurtleDownSpeedLimit];
    944                 $('input#turtle_upload_rate')[0].value    = prefs[RPC._TurtleUpSpeedLimit];
     953                $('input#turtle_download_rate')[0].value  = turtle_dn_limit_k;
     954                $('input#turtle_upload_rate')[0].value    = turtle_up_limit_k;
    945955                $('input#turtle_schedule')[0].checked     = prefs[RPC._TurtleTimeEnabled];
    946956                $('select#turtle_start_time').val(          prefs[RPC._TurtleTimeBegin] );
     
    951961                if (!iPhone)
    952962                {
    953                         setInnerHTML( $('#limited_download_rate')[0], 'Limit (' + Transmission.fmt.speed(down_limit) + ')' );
    954                         var key = down_limited ? '#limited_download_rate'
     963                        setInnerHTML( $('#limited_download_rate')[0], 'Limit (' + Transmission.fmt.speed(dn_limit_b) + ')' );
     964                        var key = dn_limited ? '#limited_download_rate'
    955965                                               : '#unlimited_download_rate';
    956966                        $(key).deselectMenuSiblings().selectMenuItem();
    957967
    958                         setInnerHTML( $('#limited_download_rate')[0], 'Limit (' + Transmission.fmt.speed(up_limit) + ')' );
     968                        setInnerHTML( $('#limited_upload_rate')[0], 'Limit (' + Transmission.fmt.speed(up_limit_b) + ')' );
    959969                        key = up_limited ? '#limited_upload_rate'
    960970                                         : '#unlimited_upload_rate';
     
    10651075                        case 'footer_download_rate_menu':
    10661076                                var args = { };
    1067                                 var rate = ($element[0].innerHTML).replace(/[^0-9]/ig, '');
    10681077                                if ($element.is('#unlimited_download_rate')) {
    10691078                                        $element.deselectMenuSiblings().selectMenuItem();
    10701079                                        args[RPC._DownSpeedLimited] = false;
    10711080                                } else {
    1072                                         setInnerHTML( $('#limited_download_rate')[0], 'Limit (' + Transmission.fmt.speed(rate) + ')' );
     1081                                        var rate_str = ($element[0].innerHTML).replace(/[^0-9]/ig, '');
     1082                                        var rate_b = parseInt( rate_str ) * Transmission.fmt.speed_K;
     1083                                        setInnerHTML( $('#limited_download_rate')[0], 'Limit (' + Transmission.fmt.speed(rate_b) + ')' );
    10731084                                        $('#limited_download_rate').deselectMenuSiblings().selectMenuItem();
    1074                                         $('div.preference input#download_rate')[0].value = rate;
    1075                                         args[RPC._DownSpeedLimit] = parseInt( rate );
     1085                                        $('div.preference input#download_rate')[0].value = rate_str;
     1086                                        args[RPC._DownSpeedLimit] = rate_b;
    10761087                                        args[RPC._DownSpeedLimited] = true;
    10771088                                }
     
    10831094                        case 'footer_upload_rate_menu':
    10841095                                var args = { };
    1085                                 var rate = ($element[0].innerHTML).replace(/[^0-9]/ig, '');
    10861096                                if ($element.is('#unlimited_upload_rate')) {
    10871097                                        $element.deselectMenuSiblings().selectMenuItem();
    10881098                                        args[RPC._UpSpeedLimited] = false;
    10891099                                } else {
    1090                                         setInnerHTML( $('#limited_upload_rate')[0], 'Limit (' + Transmission.fmt.speed(rate) + ')' );
     1100                                        var rate_str = ($element[0].innerHTML).replace(/[^0-9]/ig, '');
     1101                                        var rate_b = parseInt( rate_str ) * Transmission.fmt.speed_K;
     1102                                        setInnerHTML( $('#limited_upload_rate')[0], 'Limit (' + Transmission.fmt.speed(rate_b) + ')' );
    10911103                                        $('#limited_upload_rate').deselectMenuSiblings().selectMenuItem();
    1092                                         $('div.preference input#upload_rate')[0].value = rate;
    1093                                         args[RPC._UpSpeedLimit] = parseInt( rate );
     1104                                        $('div.preference input#upload_rate')[0].value = rate_str;
     1105                                        args[RPC._UpSpeedLimit] = rate_b;
    10941106                                        args[RPC._UpSpeedLimited] = true;
    10951107                                }
Note: See TracChangeset for help on using the changeset viewer.