Changeset 8882


Ignore:
Timestamp:
Aug 7, 2009, 8:49:06 PM (13 years ago)
Author:
charles
Message:

(trunk gtk) fix #2292: wrong speed in bottom bar

Location:
trunk/gtk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/torrent-cell-renderer.c

    r8875 r8882  
    2828{
    2929    P_TORRENT = 1,
     30    P_UPLOAD_SPEED,
     31    P_DOWNLOAD_SPEED,
    3032    P_BAR_HEIGHT,
    3133    P_MINIMAL
     
    129131static char*
    130132getShortTransferString( const tr_stat * torStat,
    131                         char *          buf,
     133                        double          uploadSpeed,
     134                        double          downloadSpeed,
     135                        char          * buf,
    132136                        size_t          buflen )
    133137{
     
    137141
    138142    if( haveDown )
    139         tr_strlspeed( downStr, torStat->pieceDownloadSpeed, sizeof( downStr ) );
     143        tr_strlspeed( downStr, downloadSpeed, sizeof( downStr ) );
    140144    if( haveUp )
    141         tr_strlspeed( upStr, torStat->pieceUploadSpeed, sizeof( upStr ) );
     145        tr_strlspeed( upStr, uploadSpeed, sizeof( upStr ) );
    142146
    143147    if( haveDown && haveUp )
     
    161165
    162166static char*
    163 getShortStatusString( const tr_stat * torStat )
     167getShortStatusString( const tr_stat * torStat,
     168                      double          uploadSpeed,
     169                      double          downloadSpeed )
    164170{
    165171    GString * gstr = g_string_new( NULL );
     
    191197                g_string_append( gstr, ", " );
    192198            }
    193             getShortTransferString( torStat, buf, sizeof( buf ) );
     199            getShortTransferString( torStat, uploadSpeed, downloadSpeed, buf, sizeof( buf ) );
    194200            g_string_append( gstr, buf );
    195201            break;
     
    204210
    205211static char*
    206 getStatusString( const tr_stat * torStat )
     212getStatusString( const tr_stat * torStat,
     213                 const double    uploadSpeed,
     214                 const double    downloadSpeed )
    207215{
    208216    const int isActive = torStat->activity != TR_STATUS_STOPPED;
     
    225233            case TR_STATUS_CHECK:
    226234            {
    227                 char * pch = getShortStatusString( torStat );
     235                char * pch = getShortStatusString( torStat, uploadSpeed, downloadSpeed );
    228236                g_string_assign( gstr, pch );
    229237                g_free( pch );
     
    255263    {
    256264        char buf[256];
    257         getShortTransferString( torStat, buf, sizeof( buf ) );
     265        getShortTransferString( torStat, uploadSpeed, downloadSpeed, buf, sizeof( buf ) );
    258266        g_string_append_printf( gstr, " - %s", buf );
    259267    }
     
    275283    GtkCellRenderer  * progress_renderer;
    276284    GtkCellRenderer  * icon_renderer;
    277     int                bar_height;
    278     gboolean           minimal;
     285    int bar_height;
     286
     287    /* use this instead of tr_stat.pieceUploadSpeed so that the model can
     288       control when the speed displays get updated.  this is done to keep
     289       the individual torrents' speeds and the status bar's overall speed
     290       in sync even if they refresh at slightly different times */
     291    int upload_speed;
     292
     293    /* @see upload_speed */
     294    int download_speed;
     295
     296    gboolean minimal;
    279297};
    280298
     
    328346    icon = get_icon( tor, MINIMAL_ICON_SIZE, widget );
    329347    name = tr_torrentInfo( tor )->name;
    330     status = getShortStatusString( st );
     348    status = getShortStatusString( st, p->upload_speed, p->download_speed );
    331349
    332350    /* get the idealized cell dimensions */
     
    385403    icon = get_icon( tor, FULL_ICON_SIZE, widget );
    386404    name = inf->name;
    387     status = getStatusString( st );
     405    status = getStatusString( st, p->upload_speed, p->download_speed );
    388406    progress = getProgressString( tor, inf, st );
    389407
     
    488506    icon = get_icon( tor, MINIMAL_ICON_SIZE, widget );
    489507    name = tr_torrentInfo( tor )->name;
    490     status = getShortStatusString( st );
     508    status = getShortStatusString( st, p->upload_speed, p->download_speed );
    491509
    492510    /* get the cell dimensions */
     
    583601    icon = get_icon( tor, FULL_ICON_SIZE, widget );
    584602    name = inf->name;
    585     status = getStatusString( st );
     603    status = getStatusString( st, p->upload_speed, p->download_speed );
    586604    progress = getProgressString( tor, inf, st );
    587605
     
    692710
    693711static void
    694 torrent_cell_renderer_set_property( GObject *      object,
     712torrent_cell_renderer_set_property( GObject      * object,
    695713                                    guint          property_id,
    696714                                    const GValue * v,
    697                                     GParamSpec *   pspec )
    698 {
    699     TorrentCellRenderer *               self = TORRENT_CELL_RENDERER(
    700         object );
     715                                    GParamSpec   * pspec )
     716{
     717    TorrentCellRenderer * self = TORRENT_CELL_RENDERER( object );
    701718    struct TorrentCellRendererPrivate * p = self->priv;
    702719
    703720    switch( property_id )
    704721    {
    705         case P_TORRENT:
    706             p->tor = g_value_get_pointer( v ); break;
    707 
    708         case P_BAR_HEIGHT:
    709             p->bar_height = g_value_get_int( v ); break;
    710 
    711         case P_MINIMAL:
    712             p->minimal  = g_value_get_boolean( v ); break;
    713 
    714         default:
    715             G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, pspec );
    716             break;
    717     }
    718 }
    719 
    720 static void
    721 torrent_cell_renderer_get_property( GObject *    object,
    722                                     guint        property_id,
    723                                     GValue *     v,
    724                                     GParamSpec * pspec )
    725 {
    726     const TorrentCellRenderer *         self = TORRENT_CELL_RENDERER(
    727         object );
     722        case P_TORRENT:        p->tor            = g_value_get_pointer( v ); break;
     723        case P_UPLOAD_SPEED:   p->upload_speed   = g_value_get_int( v ); break;
     724        case P_DOWNLOAD_SPEED: p->download_speed = g_value_get_int( v ); break;
     725        case P_BAR_HEIGHT:     p->bar_height     = g_value_get_int( v ); break;
     726        case P_MINIMAL:        p->minimal        = g_value_get_boolean( v ); break;
     727        default: G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, pspec ); break;
     728    }
     729}
     730
     731static void
     732torrent_cell_renderer_get_property( GObject     * object,
     733                                    guint         property_id,
     734                                    GValue      * v,
     735                                    GParamSpec  * pspec )
     736{
     737    const TorrentCellRenderer * self = TORRENT_CELL_RENDERER( object );
    728738    struct TorrentCellRendererPrivate * p = self->priv;
    729739
    730740    switch( property_id )
    731741    {
    732         case P_TORRENT:
    733             g_value_set_pointer( v, p->tor ); break;
    734 
    735         case P_BAR_HEIGHT:
    736             g_value_set_int( v, p->bar_height ); break;
    737 
    738         case P_MINIMAL:
    739             g_value_set_boolean( v, p->minimal ); break;
    740 
    741         default:
    742             G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, pspec );
    743             break;
     742        case P_TORRENT:        g_value_set_pointer( v, p->tor ); break;
     743        case P_UPLOAD_SPEED:   g_value_set_int( v, p->upload_speed ); break;
     744        case P_DOWNLOAD_SPEED: g_value_set_int( v, p->download_speed ); break;
     745        case P_BAR_HEIGHT:     g_value_set_int( v, p->bar_height ); break;
     746        case P_MINIMAL:        g_value_set_boolean( v, p->minimal ); break;
     747        default: G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, pspec ); break;
    744748    }
    745749}
     
    785789                                                          "tr_torrent*",
    786790                                                          G_PARAM_READWRITE ) );
     791
     792    g_object_class_install_property( gobject_class, P_UPLOAD_SPEED,
     793                                    g_param_spec_int( "piece-upload-speed", NULL,
     794                                                      "tr_stat.pieceUploadSpeed",
     795                                                      0, INT_MAX, 0,
     796                                                      G_PARAM_READWRITE ) );
     797
     798    g_object_class_install_property( gobject_class, P_DOWNLOAD_SPEED,
     799                                    g_param_spec_int( "piece-download-speed", NULL,
     800                                                      "tr_stat.pieceDownloadSpeed",
     801                                                      0, INT_MAX, 0,
     802                                                      G_PARAM_READWRITE ) );
    787803
    788804    g_object_class_install_property( gobject_class, P_BAR_HEIGHT,
  • trunk/gtk/tr-core.c

    r8871 r8882  
    257257                   gpointer       user_data UNUSED )
    258258{
    259     int            i;
    260     tr_torrent *   ta, *tb;
     259    int i, aUp, aDown, bUp, bDown;
     260    tr_torrent *ta, *tb;
    261261    const tr_stat *sa, *sb;
    262262
    263     gtk_tree_model_get( model, a, MC_TORRENT_RAW, &ta, -1 );
    264     gtk_tree_model_get( model, b, MC_TORRENT_RAW, &tb, -1 );
     263    gtk_tree_model_get( model, a, MC_SPEED_UP, &aUp,
     264                                  MC_SPEED_DOWN, &aDown,
     265                                  MC_TORRENT_RAW, &ta,
     266                                  -1 );
     267    gtk_tree_model_get( model, b, MC_SPEED_UP, &bUp,
     268                                  MC_SPEED_DOWN, &bDown,
     269                                  MC_TORRENT_RAW, &tb,
     270                                  -1 );
     271
     272    if(( i = ((aUp+aDown)-(bUp+bDown)) ))
     273        return i;
    265274
    266275    sa = tr_torrentStatCached( ta );
    267276    sb = tr_torrentStatCached( tb );
    268 
    269     if( ( i = compareDouble( sa->pieceUploadSpeed + sa->pieceDownloadSpeed,
    270                              sb->pieceUploadSpeed + sb->pieceDownloadSpeed ) ) )
    271         return i;
    272 
    273277    if( sa->uploadedEver != sb->uploadedEver )
    274278        return sa->uploadedEver < sa->uploadedEver ? -1 : 1;
     
    609613              gpointer g_class UNUSED )
    610614{
    611     TrCore *               self = (TrCore *) instance;
    612     GtkListStore *         store;
     615    GtkListStore * store;
    613616    struct TrCorePrivate * p;
     617    TrCore * self = (TrCore *) instance;
    614618
    615619    /* column types for the model used to store torrent information */
    616620    /* keep this in sync with the enum near the bottom of tr_core.h */
    617     GType                  types[] = {
    618         G_TYPE_STRING,    /* name */
    619         G_TYPE_STRING,    /* collated name */
    620         TR_TORRENT_TYPE,  /* TrTorrent object */
    621         G_TYPE_POINTER,   /* tr_torrent* */
    622         G_TYPE_INT        /* tr_stat()->status */
    623     };
     621    GType types[] = { G_TYPE_STRING,    /* name */
     622                      G_TYPE_STRING,    /* collated name */
     623                      TR_TORRENT_TYPE,  /* TrTorrent object */
     624                      G_TYPE_POINTER,   /* tr_torrent* */
     625                      G_TYPE_INT,       /* tr_stat.pieceUploadSpeed */
     626                      G_TYPE_INT,       /* tr_stat.pieceDownloadSpeed */
     627                      G_TYPE_INT };     /* tr_stat.status */
    624628
    625629    p = self->priv = G_TYPE_INSTANCE_GET_PRIVATE( self,
     
    752756{
    753757    const tr_info * inf = tr_torrent_info( gtor );
    754     const tr_stat * torStat = tr_torrent_stat( gtor );
     758    const tr_stat * st = tr_torrent_stat( gtor );
    755759    tr_torrent *    tor = tr_torrent_handle( gtor );
    756760    char *          collated = doCollate( inf->name );
     
    763767                                       MC_TORRENT,       gtor,
    764768                                       MC_TORRENT_RAW,   tor,
    765                                        MC_ACTIVITY,      torStat->activity,
     769                                       MC_SPEED_UP,      (int)st->pieceUploadSpeed,
     770                                       MC_SPEED_DOWN,    (int)st->pieceDownloadSpeed,
     771                                       MC_ACTIVITY,      st->activity,
    766772                                       -1 );
    767773
     
    10241030
    10251031static gboolean
    1026 update_foreach( GtkTreeModel *      model,
     1032update_foreach( GtkTreeModel * model,
    10271033                GtkTreePath  * path UNUSED,
    1028                 GtkTreeIter *      iter,
     1034                GtkTreeIter  * iter,
    10291035                gpointer       data UNUSED )
    10301036{
    1031     int         oldActivity;
    1032     int         newActivity;
     1037    int oldActivity, newActivity;
     1038    int oldUpSpeed, newUpSpeed;
     1039    int oldDownSpeed, newDownSpeed;
     1040    const tr_stat * st;
    10331041    TrTorrent * gtor;
    10341042
    1035     /* maybe update the status column in the model */
     1043    /* get the old states */
    10361044    gtk_tree_model_get( model, iter,
    10371045                        MC_TORRENT, &gtor,
    10381046                        MC_ACTIVITY, &oldActivity,
     1047                        MC_SPEED_UP, &oldUpSpeed,
     1048                        MC_SPEED_DOWN, &oldDownSpeed,
    10391049                        -1 );
    1040     newActivity = tr_torrentGetActivity( tr_torrent_handle( gtor ) );
    1041     if( newActivity != oldActivity )
     1050
     1051    /* get the new states */
     1052    st = tr_torrentStat( tr_torrent_handle( gtor ) );
     1053    newActivity = st->activity;
     1054    newUpSpeed = st->pieceUploadSpeed;
     1055    newDownSpeed = st->pieceDownloadSpeed;
     1056
     1057    /* updating the model triggers off resort/refresh,
     1058       so don't do it unless something's actually changed... */
     1059    if( ( newActivity != oldActivity ) ||
     1060        ( newUpSpeed != oldUpSpeed ) ||
     1061        ( newDownSpeed != oldDownSpeed ) )
     1062    {
    10421063        gtk_list_store_set( GTK_LIST_STORE( model ), iter,
    10431064                            MC_ACTIVITY, newActivity,
     1065                            MC_SPEED_UP, newUpSpeed,
     1066                            MC_SPEED_DOWN, newDownSpeed,
    10441067                            -1 );
     1068    }
    10451069
    10461070    /* cleanup */
  • trunk/gtk/tr-core.h

    r8871 r8882  
    200200    MC_TORRENT,
    201201    MC_TORRENT_RAW,
     202    MC_SPEED_UP,
     203    MC_SPEED_DOWN,
    202204    MC_ACTIVITY,
    203205    MC_ROW_COUNT
  • trunk/gtk/tr-window.c

    r8763 r8882  
    197197    gtk_tree_view_column_pack_start( col, r, FALSE );
    198198    gtk_tree_view_column_add_attribute( col, r, "torrent", MC_TORRENT_RAW );
     199    gtk_tree_view_column_add_attribute( col, r, "piece-upload-speed", MC_SPEED_UP );
     200    gtk_tree_view_column_add_attribute( col, r, "piece-download-speed", MC_SPEED_DOWN );
    199201   
    200202    gtk_tree_view_append_column( GTK_TREE_VIEW( view ), col );
     
    11531155    {
    11541156        char buf[128];
    1155         double d;
    1156 
    1157         d = tr_sessionGetPieceSpeed( session, TR_DOWN );
    1158         tr_strlspeed( buf, d, sizeof( buf ) );
     1157        int up=0, down=0;
     1158        GtkTreeIter iter;
     1159        GtkTreeModel * model = tr_core_model( p->core );
     1160
     1161        if( gtk_tree_model_get_iter_first( model, &iter ) ) do
     1162        {
     1163            int u, d;
     1164            gtk_tree_model_get( model, &iter, MC_SPEED_UP, &u,
     1165                                              MC_SPEED_DOWN, &d,
     1166                                              -1 );
     1167            up += u;
     1168            down += d;
     1169        }
     1170        while( gtk_tree_model_iter_next( model, &iter ) );
     1171
     1172        tr_strlspeed( buf, down, sizeof( buf ) );
    11591173        gtk_label_set_text( GTK_LABEL( p->dl_lb ), buf );
    1160         g_object_set( p->dl_hbox, "visible", d>=0.01, NULL );
    1161 
    1162         d = tr_sessionGetPieceSpeed( session, TR_UP );
    1163         tr_strlspeed( buf, d, sizeof( buf ) );
     1174        g_object_set( p->dl_hbox, "visible", down>0, NULL );
     1175
     1176        tr_strlspeed( buf, up, sizeof( buf ) );
    11641177        gtk_label_set_text( GTK_LABEL( p->ul_lb ), buf );
    1165         g_object_set( p->ul_hbox, "visible", d>=0.01, NULL );
     1178        g_object_set( p->ul_hbox, "visible", up>0, NULL );
    11661179    }
    11671180}
Note: See TracChangeset for help on using the changeset viewer.