Changeset 6935


Ignore:
Timestamp:
Oct 20, 2008, 5:54:56 PM (12 years ago)
Author:
charles
Message:

#1369: clarify the different torrent status & callbacks' APIs and typenames

Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/cli/cli.c

    r6897 r6935  
    174174
    175175static void
    176 torrentStateChanged( tr_torrent   * torrent   UNUSED,
    177                      cp_status_t    status    UNUSED,
    178                      void         * user_data UNUSED )
     176torrentCompletenessChanged( tr_torrent       * torrent       UNUSED,
     177                            tr_completeness    completeness  UNUSED,
     178                            void             * user_data    UNUSED )
    179179{
    180180    system( finishCall );
     
    185185static void
    186186scrapeDoneFunc( struct tr_handle    * session UNUSED,
    187                 long                          response_code,
    188                 const void *                  response,
    189                 size_t                        response_byte_count,
    190                 void *                        host )
     187                long                  response_code,
     188                const void *          response,
     189                size_t                response_byte_count,
     190                void *                host )
    191191{
    192192    tr_benc top, *files;
     
    261261              size_t          buflen )
    262262{
    263     if( st->status & TR_STATUS_CHECK_WAIT )
     263    if( st->activity & TR_STATUS_CHECK_WAIT )
    264264    {
    265265        tr_snprintf( buf, buflen, "Waiting to verify local files" );
    266266    }
    267     else if( st->status & TR_STATUS_CHECK )
     267    else if( st->activity & TR_STATUS_CHECK )
    268268    {
    269269        tr_snprintf( buf, buflen,
     
    272272                     100.0 * st->percentDone );
    273273    }
    274     else if( st->status & TR_STATUS_DOWNLOAD )
     274    else if( st->activity & TR_STATUS_DOWNLOAD )
    275275    {
    276276        char ratioStr[80];
     
    288288            ratioStr );
    289289    }
    290     else if( st->status & TR_STATUS_SEED )
     290    else if( st->activity & TR_STATUS_SEED )
    291291    {
    292292        char ratioStr[80];
     
    474474    signal( SIGHUP, sigHandler );
    475475#endif
    476     tr_torrentSetStatusCallback( tor, torrentStateChanged, NULL );
     476    tr_torrentSetCompletenessCallback( tor, torrentCompletenessChanged, NULL );
    477477    tr_torrentStart( tor );
    478478
     
    513513
    514514        st = tr_torrentStat( tor );
    515         if( st->status & TR_STATUS_STOPPED )
     515        if( st->activity & TR_STATUS_STOPPED )
    516516            break;
    517517
  • trunk/gtk/dialogs.c

    r6873 r6935  
    7171                     gpointer             activeTorrentCount )
    7272{
    73     int status = -1;
    74 
    75     gtk_tree_model_get( model, iter, MC_STATUS, &status, -1 );
    76     if( status != TR_STATUS_STOPPED )
     73    int activity = -1;
     74    gtk_tree_model_get( model, iter, MC_ACTIVITY, &activity, -1 );
     75    if( activity != TR_STATUS_STOPPED )
    7776        *(int*)activeTorrentCount += 1;
    7877    return FALSE; /* keep iterating */
  • trunk/gtk/main.c

    r6873 r6935  
    179179                         gpointer            user_data )
    180180{
    181     int                  status = 0;
     181    int                  activity = 0;
    182182    struct counts_data * counts = user_data;
    183183
    184184    ++counts->totalCount;
    185185
    186     gtk_tree_model_get( model, iter, MC_STATUS, &status, -1 );
    187 
    188     if( TR_STATUS_IS_ACTIVE( status ) )
     186    gtk_tree_model_get( model, iter, MC_ACTIVITY, &activity, -1 );
     187
     188    if( TR_STATUS_IS_ACTIVE( activity ) )
    189189        ++counts->activeCount;
    190190    else
  • trunk/gtk/torrent-cell-renderer.c

    r6862 r6935  
    8080
    8181    /* add time when downloading */
    82     if( torStat->status == TR_STATUS_DOWNLOAD )
     82    if( torStat->activity == TR_STATUS_DOWNLOAD )
    8383    {
    8484        const int eta = torStat->eta;
     
    139139    GString * gstr = g_string_new( NULL );
    140140
    141     switch( torStat->status )
     141    switch( torStat->activity )
    142142    {
    143143        case TR_STATUS_STOPPED:
     
    160160        {
    161161            char buf[128];
    162             if( torStat->status != TR_STATUS_DOWNLOAD )
     162            if( torStat->activity != TR_STATUS_DOWNLOAD )
    163163            {
    164164                tr_strlratio( buf, torStat->ratio, sizeof( buf ) );
     
    181181getStatusString( const tr_stat * torStat )
    182182{
    183     const int isActive = torStat->status != TR_STATUS_STOPPED;
    184     const int isChecking = torStat->status == TR_STATUS_CHECK
    185                            || torStat->status == TR_STATUS_CHECK_WAIT;
     183    const int isActive = torStat->activity != TR_STATUS_STOPPED;
     184    const int isChecking = torStat->activity == TR_STATUS_CHECK
     185                        || torStat->activity == TR_STATUS_CHECK_WAIT;
    186186
    187187    GString * gstr = g_string_new( NULL );
     
    191191        g_string_assign( gstr, torStat->errorString );
    192192    }
    193     else switch( torStat->status )
     193    else switch( torStat->activity )
    194194        {
    195195            case TR_STATUS_STOPPED:
     
    377377        int                                 w, h;
    378378        struct TorrentCellRendererPrivate * p = self->priv;
    379         GtkCellRenderer *                   text_renderer =
    380             torStat->error != 0
    381             ? p->
    382             text_renderer_err
    383             : p->
    384             text_renderer;
    385         const gboolean                      isActive = torStat->status !=
    386                                                        TR_STATUS_STOPPED;
     379        GtkCellRenderer * text_renderer = torStat->error != 0
     380                                        ? p->text_renderer_err
     381                                        : p->text_renderer;
     382        const gboolean isActive = torStat->activity != TR_STATUS_STOPPED;
    387383
    388384        my_bg = *background_area;
  • trunk/gtk/tr-core.c

    r6934 r6935  
    378378
    379379    /* first by state */
    380     gtk_tree_model_get( model, a, MC_STATUS, &sa, -1 );
    381     gtk_tree_model_get( model, b, MC_STATUS, &sb, -1 );
     380    gtk_tree_model_get( model, a, MC_ACTIVITY, &sa, -1 );
     381    gtk_tree_model_get( model, b, MC_ACTIVITY, &sb, -1 );
    382382    ret = sa - sb;
    383383
     
    715715
    716716static gboolean
    717 statsForeach( GtkTreeModel *      model,
     717statsForeach( GtkTreeModel * model,
    718718              GtkTreePath  * path UNUSED,
    719               GtkTreeIter *      iter,
    720               gpointer            gstats )
     719              GtkTreeIter  * iter,
     720              gpointer       gstats )
    721721{
    722722    tr_torrent *        tor;
    723723    struct core_stats * stats = gstats;
    724     int                 status;
     724    int                 activity;
    725725
    726726    gtk_tree_model_get( model, iter, MC_TORRENT_RAW, &tor, -1 );
    727     status = tr_torrentGetStatus( tor );
    728 
    729     if( status == TR_STATUS_DOWNLOAD )
     727    activity = tr_torrentGetActivity( tor );
     728
     729    if( activity == TR_STATUS_DOWNLOAD )
    730730        ++stats->downloadCount;
    731     else if( status == TR_STATUS_SEED )
     731    else if( activity == TR_STATUS_SEED )
    732732        ++stats->seedingCount;
    733733
     
    796796                                       MC_TORRENT,       gtor,
    797797                                       MC_TORRENT_RAW,   tor,
    798                                        MC_STATUS,        torStat->status,
     798                                       MC_ACTIVITY,      torStat->activity,
    799799                                       -1 );
    800800
     
    10101010                gpointer       data UNUSED )
    10111011{
    1012     int         oldStatus;
    1013     int         newStatus;
     1012    int         oldActivity;
     1013    int         newActivity;
    10141014    TrTorrent * gtor;
    10151015
     
    10171017    gtk_tree_model_get( model, iter,
    10181018                        MC_TORRENT, &gtor,
    1019                         MC_STATUS, &oldStatus,
     1019                        MC_ACTIVITY, &oldActivity,
    10201020                        -1 );
    1021     newStatus = tr_torrentGetStatus( tr_torrent_handle( gtor ) );
    1022     if( newStatus != oldStatus )
     1021    newActivity = tr_torrentGetActivity( tr_torrent_handle( gtor ) );
     1022    if( newActivity != oldActivity )
    10231023        gtk_list_store_set( GTK_LIST_STORE( model ), iter,
    1024                             MC_STATUS, newStatus,
     1024                            MC_ACTIVITY, newActivity,
    10251025                            -1 );
    10261026
     
    11861186        tr_torrent * tor = NULL;
    11871187        while(( tor = tr_torrentNext( session, tor )))
    1188             if(( active = ( tr_torrentGetStatus( tor ) != TR_STATUS_STOPPED )))
     1188            if(( active = ( tr_torrentGetActivity( tor ) != TR_STATUS_STOPPED )))
    11891189                break;
    11901190        if( !active )
  • trunk/gtk/tr-core.h

    r6795 r6935  
    218218    MC_TORRENT,
    219219    MC_TORRENT_RAW,
    220     MC_STATUS,
     220    MC_ACTIVITY,
    221221    MC_ROW_COUNT
    222222};
  • trunk/gtk/tr-torrent.c

    r6836 r6935  
    163163
    164164static void
    165 statusChangedCallback( tr_torrent   * tor UNUSED,
    166                        cp_status_t        status,
    167                        void *             user_data )
    168 {
    169     if( status == TR_CP_COMPLETE )
     165completenessChangedCallback( tr_torrent       * tor UNUSED,
     166                             tr_completeness    completeness,
     167                             void *             user_data )
     168{
     169    if( completeness == TR_CP_COMPLETE )
    170170        g_idle_add( notifyInMainThread, user_data );
    171171}
    172172
    173173static TrTorrent *
    174 maketorrent( tr_torrent * handle )
    175 {
    176     TrTorrent * tor = g_object_new( TR_TORRENT_TYPE, NULL );
    177 
    178     tor->priv->handle = handle;
    179     tr_torrentSetStatusCallback( handle, statusChangedCallback, tor );
    180     return tor;
     174maketorrent( tr_torrent * tor )
     175{
     176    TrTorrent * gtor = g_object_new( TR_TORRENT_TYPE, NULL );
     177
     178    gtor->priv->handle = tor;
     179    tr_torrentSetCompletenessCallback( tor, completenessChangedCallback, gtor );
     180    return gtor;
    181181}
    182182
     
    259259    const int       eta = st->eta;
    260260
    261     switch( st->status )
     261    switch( st->activity )
    262262    {
    263263        case TR_STATUS_CHECK_WAIT:
  • trunk/gtk/tr-window.c

    r6829 r6935  
    319319    {
    320320        case FILTER_MODE_DOWNLOADING:
    321             ret = tr_torrentGetStatus( tor ) == TR_STATUS_DOWNLOAD;
     321            ret = tr_torrentGetActivity( tor ) == TR_STATUS_DOWNLOAD;
    322322            break;
    323323
    324324        case FILTER_MODE_SEEDING:
    325             ret = tr_torrentGetStatus( tor ) == TR_STATUS_SEED;
     325            ret = tr_torrentGetActivity( tor ) == TR_STATUS_SEED;
    326326            break;
    327327
    328328        case FILTER_MODE_PAUSED:
    329             ret = tr_torrentGetStatus( tor ) == TR_STATUS_STOPPED;
     329            ret = tr_torrentGetActivity( tor ) == TR_STATUS_STOPPED;
    330330            break;
    331331
  • trunk/libtransmission/completion.c

    r6840 r6935  
    293293}
    294294
    295 cp_status_t
     295tr_completeness
    296296tr_cpGetStatus( const tr_completion * cp )
    297297{
  • trunk/libtransmission/completion.h

    r6840 r6935  
    3737/* General */
    3838
    39 cp_status_t                tr_cpGetStatus( const tr_completion * );
     39tr_completeness            tr_cpGetStatus( const tr_completion * );
    4040
    4141uint64_t                   tr_cpHaveTotal( const tr_completion * );
  • trunk/libtransmission/rpcimpl.c

    r6857 r6935  
    378378        tr_bencDictAddInt( d, key, st->startDate );
    379379    else if( !strcmp( key, "status" ) )
    380         tr_bencDictAddInt( d, key, st->status );
     380        tr_bencDictAddInt( d, key, st->activity );
    381381    else if( !strcmp( key, "swarmSpeed" ) )
    382382        tr_bencDictAddInt( d, key, (int)( st->swarmSpeed * 1024 ) );
  • trunk/libtransmission/torrent.c

    r6931 r6935  
    544544    }
    545545
    546     tor->cpStatus = tr_cpGetStatus( tor->completion );
     546    tor->completeness = tr_cpGetStatus( tor->completion );
    547547
    548548    tor->tracker = tr_trackerNew( tor );
     
    740740}
    741741
    742 tr_torrent_status
    743 tr_torrentGetStatus( tr_torrent * tor )
     742tr_torrent_activity
     743tr_torrentGetActivity( tr_torrent * tor )
    744744{
    745745    tr_torrentRecheckCompleteness( tor );
     
    751751    if( !tor->isRunning )
    752752        return TR_STATUS_STOPPED;
    753     if( tor->cpStatus == TR_CP_INCOMPLETE )
     753    if( tor->completeness == TR_CP_INCOMPLETE )
    754754        return TR_STATUS_DOWNLOAD;
    755755
     
    774774    s = &tor->stats;
    775775    s->id = tor->uniqueId;
    776     s->status = tr_torrentGetStatus( tor );
     776    s->activity = tr_torrentGetActivity( tor );
    777777    s->error  = tor->error;
    778778    memcpy( s->errorString, tor->errorString,
     
    809809    s->sizeWhenDone = tr_cpSizeWhenDone( tor->completion );
    810810
    811     s->recheckProgress = s->status == TR_STATUS_CHECK
    812                          ? 1.0 -
     811    s->recheckProgress = s->activity == TR_STATUS_CHECK
     812                       ? 1.0 -
    813813                         ( tr_torrentCountUncheckedPieces( tor ) /
    814814                           (double) tor->info.pieceCount )
    815                          : 0.0;
     815                       : 0.0;
    816816
    817817    s->swarmSpeed = tr_rcRate( tor->swarmSpeed );
     
    11021102    *tor->errorString = '\0';
    11031103    tr_torrentResetTransferStats( tor );
    1104     tor->cpStatus = tr_cpGetStatus( tor->completion );
     1104    tor->completeness = tr_cpGetStatus( tor->completion );
    11051105    tr_torrentSaveResume( tor );
    11061106    tor->startDate = time( NULL );
     
    12261226        tr_globalLock( handle );
    12271227
    1228         tr_torrentClearStatusCallback( tor );
     1228        tr_torrentClearCompletenessCallback( tor );
    12291229        tr_runInEventThread( handle, closeTorrent, tor );
    12301230
     
    12661266
    12671267static void
    1268 fireStatusChange( tr_torrent * tor,
    1269                   cp_status_t  status )
     1268fireCompletenessChange( tr_torrent      * tor,
     1269                        tr_completeness    status )
    12701270{
    12711271    assert( tor );
    1272     assert(
    1273         status == TR_CP_INCOMPLETE || status == TR_CP_DONE || status ==
    1274         TR_CP_COMPLETE );
    1275 
    1276     if( tor->status_func )
    1277         tor->status_func( tor, status, tor->status_func_user_data );
    1278 }
    1279 
    1280 void
    1281 tr_torrentSetStatusCallback( tr_torrent *          tor,
    1282                              tr_torrent_status_func func,
    1283                              void *                user_data )
     1272    assert( ( status == TR_CP_INCOMPLETE )
     1273         || ( status == TR_CP_DONE )
     1274         || ( status == TR_CP_COMPLETE ) );
     1275
     1276    if( tor->completeness_func )
     1277        tor->completeness_func( tor, status, tor->completeness_func_user_data );
     1278}
     1279
     1280void
     1281tr_torrentSetCompletenessCallback( tr_torrent                    * tor,
     1282                                   tr_torrent_completeness_func    func,
     1283                                   void                          * user_data )
    12841284{
    12851285    assert( tor );
    1286     tor->status_func = func;
    1287     tor->status_func_user_data = user_data;
    1288 }
    1289 
    1290 void
    1291 tr_torrentClearStatusCallback( tr_torrent * torrent )
    1292 {
    1293     tr_torrentSetStatusCallback( torrent, NULL, NULL );
     1286    tor->completeness_func = func;
     1287    tor->completeness_func_user_data = user_data;
     1288}
     1289
     1290void
     1291tr_torrentClearCompletenessCallback( tr_torrent * torrent )
     1292{
     1293    tr_torrentSetCompletenessCallback( torrent, NULL, NULL );
    12941294}
    12951295
     
    12971297tr_torrentRecheckCompleteness( tr_torrent * tor )
    12981298{
    1299     cp_status_t cpStatus;
     1299    tr_completeness completeness;
    13001300
    13011301    tr_torrentLock( tor );
    13021302
    1303     cpStatus = tr_cpGetStatus( tor->completion );
    1304 
    1305     if( cpStatus != tor->cpStatus )
     1303    completeness = tr_cpGetStatus( tor->completion );
     1304
     1305    if( completeness != tor->completeness )
    13061306    {
    13071307        const int recentChange = tor->downloadedCur != 0;
     
    13101310        {
    13111311            tr_torinf( tor, _( "State changed from \"%1$s\" to \"%2$s\"" ),
    1312                       getCompletionString( tor->cpStatus ),
    1313                       getCompletionString( cpStatus ) );
     1312                      getCompletionString( tor->completeness ),
     1313                      getCompletionString( completeness ) );
    13141314        }
    13151315
    1316         tor->cpStatus = cpStatus;
    1317         fireStatusChange( tor, cpStatus );
    1318 
    1319         if( recentChange && ( cpStatus == TR_CP_COMPLETE ) )
     1316        tor->completeness = completeness;
     1317        fireCompletenessChange( tor, completeness );
     1318
     1319        if( recentChange && ( completeness == TR_CP_COMPLETE ) )
    13201320        {
    13211321            tr_trackerCompleted( tor->tracker );
     
    13331333tr_torrentIsSeed( const tr_torrent * tor )
    13341334{
    1335     return tor->cpStatus == TR_CP_COMPLETE || tor->cpStatus == TR_CP_DONE;
     1335    return tor->completeness == TR_CP_COMPLETE || tor->completeness == TR_CP_DONE;
    13361336}
    13371337
  • trunk/libtransmission/torrent.h

    r6932 r6935  
    195195
    196196    struct tr_bitfield *       checkedPieces;
    197     cp_status_t                cpStatus;
     197    tr_completeness            completeness;
    198198
    199199    struct tr_tracker *        tracker;
     
    212212    time_t                     startDate;
    213213
    214     tr_torrent_status_func *   status_func;
    215     void *                     status_func_user_data;
     214    tr_torrent_completeness_func *   completeness_func;
     215    void *                     completeness_func_user_data;
    216216
    217217    unsigned int               isRunning  : 1;
  • trunk/libtransmission/transmission.h

    r6933 r6935  
    390390    TR_RPC_TORRENT_STOPPED,
    391391    TR_RPC_TORRENT_REMOVING,
    392     TR_RPC_TORRENT_CHANGED,
     392    TR_RPC_TORRENT_CHANGED, /* catch-all for the "torrent-set" rpc method */
    393393    TR_RPC_SESSION_CHANGED
    394394}
     
    408408tr_rpc_callback_status;
    409409
    410 typedef tr_rpc_callback_status ( *tr_rpc_func )( tr_session *
    411                                                                       handle,
    412                                                  tr_rpc_callback_type type,
    413                                                  struct tr_torrent *
    414                                                                       tor_or_null,
    415                                                  void *
    416                                                                       user_data );
    417 
    418 void          tr_sessionSetRPCCallback( tr_session * handle,
    419                                         tr_rpc_func  func,
    420                                         void *       user_data );
     410typedef tr_rpc_callback_status (*tr_rpc_func)(tr_session          * session,
     411                                              tr_rpc_callback_type  type,
     412                                              struct tr_torrent   * tor_or_null,
     413                                              void                * user_data );
     414
     415/**
     416 * Register to be notified whenever something is changed via RPC,
     417 * such as a torrent being added, removed, started, stopped, etc.
     418 *
     419 * func is invoked FROM LIBTRANSMISSION'S THREAD!
     420 * This means func must be fast (to avoid blocking peers),
     421 * shouldn't call libtransmission functions (to avoid deadlock),
     422 * and shouldn't modify client-level memory without using a mutex!
     423 */
     424void tr_sessionSetRPCCallback( tr_session   * session,
     425                               tr_rpc_func    func,
     426                               void         * user_data );
    421427
    422428/**
     
    970976{
    971977    TR_CP_INCOMPLETE,   /* doesn't have all the desired pieces */
    972     TR_CP_DONE,         /* has all the pieces but the DND ones */
     978    TR_CP_DONE,         /* has all the desired pieces, but not all pieces */
    973979    TR_CP_COMPLETE      /* has every piece */
    974980}
    975 cp_status_t;
    976 
    977 typedef void ( tr_torrent_status_func )( tr_torrent * torrent,
    978                                          cp_status_t  status,
    979                                          void *       user_data );
    980 
    981 /**
    982  * Register to be notified whenever a torrent's state changes.
     981tr_completeness;
     982
     983typedef void ( tr_torrent_completeness_func )( tr_torrent       * torrent,
     984                                               tr_completeness    completeness,
     985                                               void             * user_data );
     986
     987/**
     988 * Register to be notified whenever a torrent's "completeness"
     989 * changes.  This will be called, for example, when a torrent
     990 * finishes downloading and changes from TR_CP_INCOMPLETE to
     991 * either TR_CP_COMPLETE or TR_CP_DONE.
    983992 *
    984993 * func is invoked FROM LIBTRANSMISSION'S THREAD!
     
    986995 * shouldn't call libtransmission functions (to avoid deadlock),
    987996 * and shouldn't modify client-level memory without using a mutex!
    988  */
    989 void tr_torrentSetStatusCallback( tr_torrent *           torrent,
    990                                   tr_torrent_status_func func,
    991                                   void *                 user_data );
    992 
    993 void tr_torrentClearStatusCallback( tr_torrent * torrent );
     997 *
     998 * @see tr_completeness
     999 */
     1000void tr_torrentSetCompletenessCallback(
     1001         tr_torrent                    * torrent,
     1002         tr_torrent_completeness_func    func,
     1003         void                          * user_data );
     1004
     1005void tr_torrentClearCompletenessCallback( tr_torrent * torrent );
    9941006
    9951007
     
    11551167};
    11561168
     1169/**
     1170 * What the torrent is doing right now.
     1171 *
     1172 * Note: these values will become a straight enum at some point in the future.
     1173 * Do not rely on their current `bitfield' implementation
     1174 */
    11571175typedef enum
    11581176{
     
    11631181    TR_STATUS_STOPPED      = ( 1 << 4 )  /* Torrent is stopped */
    11641182}
    1165 tr_torrent_status;
     1183tr_torrent_activity;
    11661184
    11671185#define TR_STATUS_IS_ACTIVE( s ) ( ( s ) != TR_STATUS_STOPPED )
     
    11751193tr_lockfile_state_t;
    11761194
    1177 tr_torrent_status tr_torrentGetStatus( tr_torrent * );
     1195tr_torrent_activity tr_torrentGetActivity( tr_torrent * );
    11781196
    11791197enum
     
    11991217    int    id;
    12001218
    1201     /** The torrent's current status */
    1202     tr_torrent_status    status;
     1219    /** What is this torrent doing right now? */
     1220    tr_torrent_activity activity;
    12031221
    12041222    /** Our current announce URL, or NULL if none.
  • trunk/macosx/Torrent.m

    r6887 r6935  
    6161@end
    6262
    63 void completenessChangeCallback(tr_torrent * torrent, cp_status_t status, void * torrentData)
     63void completenessChangeCallback(tr_torrent * torrent, tr_completeness status, void * torrentData)
    6464{
    6565    [(Torrent *)torrentData performSelectorOnMainThread: @selector(completenessChange:)
     
    951951- (BOOL) isActive
    952952{
    953     return fStat->status != TR_STATUS_STOPPED;
     953    return fStat->activity != TR_STATUS_STOPPED;
    954954}
    955955
    956956- (BOOL) isSeeding
    957957{
    958     return fStat->status == TR_STATUS_SEED;
     958    return fStat->activity == TR_STATUS_SEED;
    959959}
    960960
    961961- (BOOL) isChecking
    962962{
    963     return fStat->status == TR_STATUS_CHECK || fStat->status == TR_STATUS_CHECK_WAIT;
     963    return fStat->activity == TR_STATUS_CHECK || fStat->activity == TR_STATUS_CHECK_WAIT;
    964964}
    965965
    966966- (BOOL) isCheckingWaiting
    967967{
    968     return fStat->status == TR_STATUS_CHECK_WAIT;
     968    return fStat->activity == TR_STATUS_CHECK_WAIT;
    969969}
    970970
     
    11081108   
    11091109    //add time when downloading
    1110     if (fStat->status == TR_STATUS_DOWNLOAD || ([self isSeeding]
     1110    if (fStat->activity == TR_STATUS_DOWNLOAD || ([self isSeeding]
    11111111        && (fRatioSetting == NSOnState || (fRatioSetting == NSMixedState && [fDefaults boolForKey: @"RatioCheck"]))))
    11121112    {
    1113         int eta = fStat->status == TR_STATUS_DOWNLOAD ? [self eta] : [self etaRatio];
     1113        int eta = fStat->activity == TR_STATUS_DOWNLOAD ? [self eta] : [self etaRatio];
    11141114        string = [string stringByAppendingFormat: @" - %@", [self etaString: eta]];
    11151115    }
     
    11311131    else
    11321132    {
    1133         switch (fStat->status)
     1133        switch (fStat->activity)
    11341134        {
    11351135            case TR_STATUS_STOPPED:
     
    11941194    if ([self isActive] && ![self isChecking])
    11951195    {
    1196         if (fStat->status == TR_STATUS_DOWNLOAD)
     1196        if (fStat->activity == TR_STATUS_DOWNLOAD)
    11971197            string = [string stringByAppendingFormat: @" - %@: %@, %@: %@",
    11981198                        NSLocalizedString(@"DL", "Torrent -> status string"), [NSString stringForSpeed: [self downloadRate]],
     
    12101210    NSString * string;
    12111211   
    1212     switch (fStat->status)
     1212    switch (fStat->activity)
    12131213    {
    12141214        case TR_STATUS_STOPPED:
     
    12601260- (NSString *) stateString
    12611261{
    1262     switch (fStat->status)
     1262    switch (fStat->activity)
    12631263    {
    12641264        case TR_STATUS_STOPPED:
     
    17081708    }
    17091709   
    1710     tr_torrentSetStatusCallback(fHandle, completenessChangeCallback, self);
     1710    tr_torrentSetCompletenessCallback(fHandle, completenessChangeCallback, self);
    17111711   
    17121712    fNameString = [[NSString alloc] initWithUTF8String: fInfo->name];
Note: See TracChangeset for help on using the changeset viewer.