Changeset 10818


Ignore:
Timestamp:
Jun 22, 2010, 4:34:16 AM (12 years ago)
Author:
charles
Message:

(trunk) add tr_formatter_size() and tr_formatter_speed() so that all the client apps don't have to reinvent the wheel

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/daemon/remote.c

    r10798 r10818  
    136136
    137137static char*
    138 strlsize( char *  buf, int64_t size, size_t  buflen )
    139 {
    140     if( !size )
    141         tr_strlcpy( buf, "None", buflen );
    142     else if( size < (int64_t)KiB )
    143         tr_snprintf( buf, buflen, "%'" PRId64 " bytes", (int64_t)size );
     138strlsize( char * buf, int64_t bytes, size_t buflen )
     139{
     140    if( !bytes )
     141        tr_strlcpy( buf, _( "None" ), buflen );
    144142    else
    145     {
    146         double displayed_size;
    147         if( size < (int64_t)MiB )
    148         {
    149             displayed_size = (double) size / KiB;
    150             tr_snprintf( buf, buflen, "%'.1f KiB", displayed_size );
    151         }
    152         else if( size < (int64_t)GiB )
    153         {
    154             displayed_size = (double) size / MiB;
    155             tr_snprintf( buf, buflen, "%'.1f MiB", displayed_size );
    156         }
    157         else
    158         {
    159             displayed_size = (double) size / GiB;
    160             tr_snprintf( buf, buflen, "%'.1f GiB", displayed_size );
    161         }
    162     }
     143        tr_formatter_size( buf, bytes, buflen );
     144
     145    return buf;
     146}
     147
     148static char*
     149strlspeed( char * buf, int64_t bytes_per_second, size_t buflen )
     150{
     151    if( !bytes_per_second )
     152        tr_strlcpy( buf, _( "None" ), buflen );
     153    else
     154        tr_formatter_speed( buf, bytes_per_second, buflen );
     155
    163156    return buf;
    164157}
     
    800793                printf( "  ETA: %s\n", tr_strltime( buf, i, sizeof( buf ) ) );
    801794            if( tr_bencDictFindInt( t, "rateDownload", &i ) )
    802                 printf( "  Download Speed: %.1f KiB/s\n", i / 1024.0 );
     795                printf( "  Download Speed: %s\n", strlspeed( buf, i, sizeof( buf ) ) );
    803796            if( tr_bencDictFindInt( t, "rateUpload", &i ) )
    804                 printf( "  Upload Speed: %.1f KiB/s\n", i / 1024.0 );
     797                printf( "  Upload Speed: %s\n", strlspeed( buf, i, sizeof( buf ) ) );
    805798            if( tr_bencDictFindInt( t, "haveUnchecked", &i )
    806799              && tr_bencDictFindInt( t, "haveValid", &j ) )
     
    10741067                printf( "  Download Limit: " );
    10751068                if( boolVal )
    1076                     printf( "%" PRId64 " KiB/s\n", i );
     1069                    printf( "%s\n", strlspeed( buf, i*1024, sizeof( buf ) ) );
    10771070                else
    10781071                    printf( "Unlimited\n" );
     
    10831076                printf( "  Upload Limit: " );
    10841077                if( boolVal )
    1085                     printf( "%" PRId64 " KiB/s\n", i );
     1078                    printf( "%s\n", strlspeed( buf, i*1024, sizeof( buf ) ) );
    10861079                else
    10871080                    printf( "Unlimited\n" );
     
    13891382            {
    13901383                char buf[128];
     1384                char buf2[128];
     1385                char buf3[128];
    13911386
    13921387                printf( "LIMITS\n" );
     
    14001395
    14011396                if( altEnabled )
    1402                     tr_snprintf( buf, sizeof( buf ), "%"PRId64" KiB/s", altUp );
     1397                    strlspeed( buf, altUp*1024, sizeof( buf ) );
    14031398                else if( upEnabled )
    1404                     tr_snprintf( buf, sizeof( buf ), "%"PRId64" KiB/s", upLimit );
     1399                    strlspeed( buf, upLimit*1024, sizeof( buf ) );
    14051400                else
    14061401                    tr_strlcpy( buf, "Unlimited", sizeof( buf ) );
    1407                 printf( "  Upload speed limit: %s  (%s limit: %"PRId64" KiB/s; %s turtle limit: %"PRId64" KiB/s)\n",
     1402                printf( "  Upload speed limit: %s  (%s limit: %s; %s turtle limit: %s)\n",
    14081403                        buf,
    1409                         (upEnabled?"Enabled":"Disabled"), upLimit,
    1410                         (altEnabled?"Enabled":"Disabled"), altUp );
     1404                        upEnabled ? "Enabled" : "Disabled",
     1405                        strlspeed( buf2, upLimit*1024, sizeof( buf2 ) ),
     1406                        altEnabled ? "Enabled" : "Disabled",
     1407                        strlspeed( buf3, altUp*1024, sizeof( buf3 ) ) );
    14111408
    14121409                if( altEnabled )
    1413                     tr_snprintf( buf, sizeof( buf ), "%"PRId64" KiB/s", altDown );
     1410                    strlspeed( buf, altDown*1024, sizeof( buf ) );
    14141411                else if( downEnabled )
    1415                     tr_snprintf( buf, sizeof( buf ), "%"PRId64" KiB/s", downLimit );
     1412                    strlspeed( buf, downLimit*1024, sizeof( buf ) );
    14161413                else
    14171414                    tr_strlcpy( buf, "Unlimited", sizeof( buf ) );
    1418                 printf( "  Download speed limit: %s  (%s limit: %"PRId64" KiB/s; %s turtle limit: %"PRId64" KiB/s)\n",
     1415                printf( "  Download speed limit: %s  (%s limit: %s; %s turtle limit: %s)\n",
    14191416                        buf,
    1420                         (downEnabled?"Enabled":"Disabled"), downLimit,
    1421                         (altEnabled?"Enabled":"Disabled"), altDown );
     1417                        downEnabled ? "Enabled" : "Disabled",
     1418                        strlspeed( buf2, downLimit*1024, sizeof( buf2 ) ),
     1419                        altEnabled ? "Enabled" : "Disabled",
     1420                        strlspeed( buf2, altDown*1024, sizeof( buf2 ) ) );
    14221421
    14231422                if( altTimeEnabled ) {
     
    21572156    }
    21582157
     2158    tr_formatter_size_init ( 1024, _("B"), _("KiB"), _("MiB"), _("GiB") );
     2159    tr_formatter_speed_init ( 1024, _("B/s"), _("KiB/s"), _("MiB/s"), _("GiB/s") );
     2160
    21592161    getHostAndPort( &argc, argv, &host, &port );
    21602162    if( host == NULL )
  • trunk/gtk/main.c

    r10759 r10818  
    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") );
    535537
    536538    /* initialize gtk */
  • trunk/gtk/util.c

    r10717 r10818  
    106106}
    107107
    108 static double KiB = 1024.0;
    109 static double MiB = ( 1024.0 * 1024.0 );
    110 static double GiB = ( 1024.0 * 1024.0 * 1024.0 );
    111 
    112108char*
    113109tr_strlsize( char * buf, guint64 bytes, size_t buflen )
     
    115111    if( !bytes )
    116112        g_strlcpy( buf, _( "None" ), buflen );
    117     else if( bytes < KiB )
    118         g_snprintf( buf, buflen, ngettext( "%'u byte", "%'u bytes", (guint)bytes ), (guint)bytes );
    119     else if( bytes < MiB )
    120         g_snprintf( buf, buflen, _( "%'.1f KiB" ), bytes / KiB );
    121     else if( bytes < GiB )
    122         g_snprintf( buf, buflen, _( "%'.1f MiB" ), bytes / MiB );
    123113    else
    124         g_snprintf( buf, buflen, _( "%'.1f GiB" ), bytes / GiB );
     114        tr_formatter_size( buf, bytes, buflen );
     115
    125116    return buf;
    126117}
     
    129120tr_strlspeed( char * buf, double kb_sec, size_t buflen )
    130121{
    131     const double speed = kb_sec;
    132 
    133     if( speed < 1000.0 )  /* 0.0 KiB to 999.9 KiB */
    134         g_snprintf( buf, buflen, _( "%'.1f KiB/s" ), speed );
    135     else if( speed < 102400.0 ) /* 0.98 MiB to 99.99 MiB */
    136         g_snprintf( buf, buflen, _( "%'.2f MiB/s" ), ( speed / KiB ) );
    137     else if( speed < 1024000.0 ) /* 100.0 MiB to 999.9 MiB */
    138         g_snprintf( buf, buflen, _( "%'.1f MiB/s" ), ( speed / MiB ) );
    139     else /* insane speeds */
    140         g_snprintf( buf, buflen, _( "%'.2f GiB/s" ), ( speed / GiB ) );
     122    const int64_t bytes_per_second = kb_sec * 1024.0;
     123
     124    if( bytes_per_second < 1 )
     125        g_strlcpy( buf, _( "None" ), buflen );
     126    else
     127        tr_formatter_speed( buf, bytes_per_second, buflen );
    141128
    142129    return buf;
  • trunk/libtransmission/utils.c

    r10814 r10818  
    15031503#endif
    15041504}
     1505
     1506/***
     1507****
     1508****
     1509****
     1510***/
     1511
     1512struct formatter_units
     1513{
     1514    double KB_val;
     1515    double MB_val;
     1516    double GB_val;
     1517    const char * B_str;
     1518    const char * KB_str;
     1519    const char * MB_str;
     1520    const char * GB_str;
     1521};
     1522
     1523static void
     1524formatter_init( struct formatter_units * units,
     1525                double kilo,
     1526                const char * b, const char * kb,
     1527                const char * mb, const char * gb )
     1528{
     1529    units->B_str  = tr_strdup( b );
     1530    units->KB_str = tr_strdup( kb );
     1531    units->MB_str = tr_strdup( mb );
     1532    units->GB_str = tr_strdup( gb );
     1533
     1534    units->KB_val = kilo;
     1535    units->MB_val = kilo * kilo;
     1536    units->GB_val = kilo * kilo * kilo;
     1537}
     1538
     1539static char*
     1540formatter_get_size_str( const struct formatter_units * u,
     1541                        char * buf, uint64_t bytes, size_t buflen )
     1542{
     1543    int precision;
     1544    double val;
     1545    const char * units;
     1546
     1547         if( bytes < u->KB_val ) { val = bytes;             units = u->B_str; }
     1548    else if( bytes < u->MB_val ) { val = bytes / u->KB_val; units = u->KB_str; }
     1549    else if( bytes < u->GB_val ) { val = bytes / u->MB_val; units = u->MB_str; }
     1550    else                         { val = bytes / u->GB_val; units = u->GB_str; }
     1551
     1552    precision = val < 100 ? 2 : 1;
     1553    tr_snprintf( buf, buflen, "%.*f %s", precision, val, units );
     1554    return buf;
     1555}
     1556
     1557static struct formatter_units size_units = { 0, 0, 0, NULL, NULL, NULL, NULL };
     1558
     1559void
     1560tr_formatter_size_init( double kilo, const char * b, const char * kb,
     1561                                     const char * mb, const char * gb )
     1562{
     1563    formatter_init( &size_units, kilo, b, kb, mb, gb );
     1564}
     1565
     1566char*
     1567tr_formatter_size( char * buf, uint64_t bytes, size_t buflen )
     1568{
     1569    return formatter_get_size_str( &size_units, buf, bytes, buflen );
     1570}
     1571
     1572static struct formatter_units speed_units = { 0, 0, 0, NULL, NULL, NULL, NULL };
     1573
     1574void
     1575tr_formatter_speed_init( double kilo, const char * b, const char * kb,
     1576                                      const char * mb, const char * gb )
     1577{
     1578    formatter_init( &speed_units, kilo, b, kb, mb, gb );
     1579}
     1580
     1581char*
     1582tr_formatter_speed( char * buf, uint64_t bytes_per_second, size_t buflen )
     1583{
     1584    return formatter_get_size_str( &speed_units, buf, bytes_per_second, buflen );
     1585}
  • trunk/libtransmission/utils.h

    r10814 r10818  
    556556***/
    557557
     558/* example: tr_formatter_size_init( 1024, _("B"), _("KiB"), _("MiB"), _("GiB") ); */
     559
     560void tr_formatter_size_init( double kilo, const char * b, const char * kb,
     561                                          const char * mb, const char * gb );
     562
     563void tr_formatter_speed_init( double kilo, const char * b, const char * kb,
     564                                           const char * mb, const char * gb );
     565
     566/* format a size into a user-readable string. */
     567char* tr_formatter_size( char * buf, uint64_t bytes, size_t buflen );
     568
     569/* format a speed into a user-readable string. */
     570char* tr_formatter_speed( char * buf, uint64_t bytes_per_second, size_t buflen );
     571
     572/***
     573****
     574***/
     575
    558576#ifdef __cplusplus
    559577}
  • trunk/qt/app.cc

    r10775 r10818  
    2727#include <libtransmission/transmission.h>
    2828#include <libtransmission/tr-getopt.h>
     29#include <libtransmission/utils.h>
    2930#include <libtransmission/version.h>
    3031
     
    9798    t->load( QString(MY_NAME) + "_" + QLocale::system().name() );
    9899    installTranslator( t );
     100
     101    // 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")) );
    99112
    100113    // set the default icon
  • trunk/qt/utils.cc

    r10817 r10818  
    2424
    2525#include <libtransmission/transmission.h>
    26 #include <libtransmission/utils.h>
     26#include <libtransmission/utils.h> // tr_formatter
    2727
    2828#include "qticonloader.h"
     
    4747}
    4848
    49 #define KILOBYTE_FACTOR 1024.0
    50 #define MEGABYTE_FACTOR ( 1024.0 * 1024.0 )
    51 #define GIGABYTE_FACTOR ( 1024.0 * 1024.0 * 1024.0 )
    52 
    53 QString
    54 Utils :: sizeToString( double size )
    55 {
    56     QString str;
    57 
    58     if( !size )
    59     {
    60         str = tr( "None" );
    61     }
    62     else if( size < KILOBYTE_FACTOR )
    63     {
    64         const int i = (int)size;
    65         str = tr( "%Ln byte(s)", 0, i );
    66     }
    67     else
    68     {
    69         double displayed_size;
    70 
    71         if( size < (int64_t)MEGABYTE_FACTOR )
    72         {
    73             displayed_size = (double)size / KILOBYTE_FACTOR;
    74             str = tr( "%L1 KiB" ).arg( displayed_size,  0, 'f', 1 );
    75         }
    76         else if( size < (int64_t)GIGABYTE_FACTOR )
    77         {
    78             displayed_size = (double)size / MEGABYTE_FACTOR;
    79             str = tr( "%L1 MiB" ).arg( displayed_size,  0, 'f', 1 );
    80         }
    81         else
    82         {
    83             displayed_size = (double) size / GIGABYTE_FACTOR;
    84             str = tr( "%L1 GiB" ).arg( displayed_size,  0, 'f', 1 );
    85         }
    86     }
    87 
    88     return str;
     49QString
     50Utils :: 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
     61QString
     62Utils :: 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    }
    8971}
    9072
     
    168150}
    169151
    170 QString
    171 Utils :: speedToString( const Speed& speed )
    172 {
    173     const double kbps( speed.kbps( ) );
    174     QString str;
    175 
    176     if( kbps < 1000.0 )  /* 0.0 KiB to 999.9 KiB */
    177         str = tr( "%L1 KiB/s" ).arg( kbps, 0, 'f', 1 );
    178     else if( kbps < 102400.0 ) /* 0.98 MiB to 99.99 MiB */
    179         str = tr( "%L1 MiB/s" ).arg( kbps / KILOBYTE_FACTOR, 0, 'f', 2 );
    180     else // insane speeds
    181         str = tr( "%L1 GiB/s" ).arg( kbps / MEGABYTE_FACTOR, 0, 'f', 1 );
    182 
    183     return str;
    184 }
    185 
    186152void
    187153Utils :: toStderr( const QString& str )
  • trunk/qt/utils.h

    r10722 r10818  
    2929    public:
    3030        static QString remoteFileChooser( QWidget * parent, const QString& title, const QString& myPath, bool dir, bool local );
    31         static QString sizeToString( double size );
     31        static QString sizeToString( double bytes );
    3232        static QString speedToString( const Speed& speed );
    3333        static QString ratioToString( double ratio );
  • trunk/utils/show.c

    r10785 r10818  
    6363}
    6464
    65 static const double KiB = 1024.0;
    66 static const double MiB = 1024.0 * 1024.0;
    67 static const double GiB = 1024.0 * 1024.0 * 1024.0;
    68 
    69 static char*
    70 strlsize( char *  buf, int64_t size, size_t  buflen )
    71 {
    72     if( !size )
    73         tr_strlcpy( buf, "None", buflen );
    74     else if( size < (int64_t)KiB )
    75         tr_snprintf( buf, buflen, "%'" PRId64 " bytes", (int64_t)size );
    76     else
    77     {
    78         double displayed_size;
    79         if( size < (int64_t)MiB )
    80         {
    81             displayed_size = (double) size / KiB;
    82             tr_snprintf( buf, buflen, "%'.1f KiB", displayed_size );
    83         }
    84         else if( size < (int64_t)GiB )
    85         {
    86             displayed_size = (double) size / MiB;
    87             tr_snprintf( buf, buflen, "%'.1f MiB", displayed_size );
    88         }
    89         else
    90         {
    91             displayed_size = (double) size / GiB;
    92             tr_snprintf( buf, buflen, "%'.1f GiB", displayed_size );
    93         }
    94     }
    95     return buf;
    96 }
    97 
    9865static void
    9966showInfo( const tr_info * inf )
     
    12087        printf( "  Comment: %s\n", inf->comment );
    12188    printf( "  Piece Count: %d\n", inf->pieceCount );
    122     printf( "  Piece Size: %s\n", strlsize( buf, inf->pieceSize, sizeof( buf ) ) );
    123     printf( "  Total Size: %s\n", strlsize( buf, inf->totalSize, sizeof( buf ) ) );
     89    printf( "  Piece Size: %s\n", tr_formatter_size( buf, inf->pieceSize, sizeof( buf ) ) );
     90    printf( "  Total Size: %s\n", tr_formatter_size( buf, inf->totalSize, sizeof( buf ) ) );
    12491    printf( "  Privacy: %s\n", inf->isPrivate ? "Private torrent" : "Public torrent" );
    12592
     
    146113    printf( "\nFILES\n\n" );
    147114    for( i=0; i<(int)inf->fileCount; ++i )
    148         printf( "  %s (%s)\n", inf->files[i].name, strlsize( buf, inf->files[i].length, sizeof( buf ) ) );
     115        printf( "  %s (%s)\n", inf->files[i].name, tr_formatter_size( buf, inf->files[i].length, sizeof( buf ) ) );
    149116}
    150117
     
    265232
    266233    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") );
    267236
    268237    if( parseCommandLine( argc, (const char**)argv ) )
Note: See TracChangeset for help on using the changeset viewer.