Changeset 8282


Ignore:
Timestamp:
Apr 24, 2009, 3:24:43 PM (13 years ago)
Author:
charles
Message:

(trunk gtk) more cleanup from yesterday's property dialog rewrite

Location:
trunk/gtk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/details.c

    r8281 r8282  
    177177set_int_combo_if_different( GtkWidget * w, guint tag, int column, int value )
    178178{
     179    int i;
     180    int currentValue;
     181    GtkTreeIter iter;
    179182    GtkComboBox * combobox = GTK_COMBO_BOX( w );
    180183    GtkTreeModel * model = gtk_combo_box_get_model( combobox );
    181     GtkTreeIter iter;
    182     int i;
    183     int currentValue;
    184184
    185185    /* do the value and current value match? */
     
    222222    /* honorLimitsCheck */
    223223    if( n ) {
    224         const gboolean baseline = tr_torrentUsesSessionLimits( torrents[0] );
     224        const tr_bool baseline = tr_torrentUsesSessionLimits( torrents[0] );
    225225        int i;
    226226        for( i=1; i<n; ++i )
     
    234234    /* downLimitedCheck */
    235235    if( n ) {
    236         const gboolean baseline = tr_torrentUsesSpeedLimit( torrents[0], TR_DOWN );
     236        const tr_bool baseline = tr_torrentUsesSpeedLimit( torrents[0], TR_DOWN );
    237237        int i;
    238238        for( i=1; i<n; ++i )
     
    258258    /* upLimitedCheck */
    259259    if( n ) {
    260         const gboolean baseline = tr_torrentUsesSpeedLimit( torrents[0], TR_UP );
     260        const tr_bool baseline = tr_torrentUsesSpeedLimit( torrents[0], TR_UP );
    261261        int i;
    262262        for( i=1; i<n; ++i )
     
    298298    /* seedCustomRadio */
    299299    if( n ) {
    300         guint tag;
     300        guint t;
    301301        const int baseline = tr_torrentGetRatioMode( torrents[0] );
    302302        int i;
     
    307307            GtkWidget * w;
    308308            switch( baseline ) {
    309                 case TR_RATIOLIMIT_SINGLE: w = di->seedCustomRadio; tag = di->seedCustomRadioTag; break;
    310                 case TR_RATIOLIMIT_GLOBAL: w = di->seedGlobalRadio; tag = di->seedGlobalRadioTag; break;
    311                 case TR_RATIOLIMIT_UNLIMITED: w = di->seedForeverRadio; tag = di->seedForeverRadioTag; break;
     309                case TR_RATIOLIMIT_SINGLE: w = di->seedCustomRadio;
     310                                           t = di->seedCustomRadioTag; break;
     311                case TR_RATIOLIMIT_GLOBAL: w = di->seedGlobalRadio;
     312                                           t = di->seedGlobalRadioTag; break;
     313                case TR_RATIOLIMIT_UNLIMITED: w = di->seedForeverRadio;
     314                                              t = di->seedForeverRadioTag; break;
    312315            }
    313             set_togglebutton_if_different( w, tag, TRUE );
     316            set_togglebutton_if_different( w, t, TRUE );
    314317        }
    315318    }
     
    465468
    466469static void
    467 onPriorityComboChanged( GtkComboBox * w, struct DetailsImpl * di )
     470onPriorityChanged( GtkComboBox * w, struct DetailsImpl * di )
    468471{
    469472    GtkTreeIter iter;
     
    481484{
    482485    int i;
    483     int selIndex;
    484486    guint tag;
    485487    GtkWidget * w;
     
    495497    };
    496498
    497     /* build a store for encryption */
    498     selIndex = -1;
    499499    store = gtk_list_store_new( 2, G_TYPE_INT, G_TYPE_STRING );
    500500    for( i=0; i<(int)G_N_ELEMENTS(items); ++i ) {
     
    506506    }
    507507
    508     /* build the widget */
    509508    w = gtk_combo_box_new_with_model( GTK_TREE_MODEL( store ) );
    510509    r = gtk_cell_renderer_text_new( );
    511510    gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( w ), r, TRUE );
    512511    gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( w ), r, "text", 1, NULL );
    513     tag = g_signal_connect( w, "changed", G_CALLBACK( onPriorityComboChanged ), di );
     512    tag = g_signal_connect( w, "changed", G_CALLBACK( onPriorityChanged ), di );
    514513    di->bandwidthComboTag = tag;
    515514
     
    533532    hig_workarea_add_section_title( t, &row, _( "Speed" ) );
    534533
    535     tb = hig_workarea_add_wide_checkbutton( t, &row, _( "Honor global _limits" ), FALSE );
     534    tb = hig_workarea_add_wide_checkbutton( t, &row, _( "Honor global _limits" ), 0 );
    536535    d->honorLimitsCheck = tb;
    537536    tag = g_signal_connect( tb, "toggled", G_CALLBACK( global_speed_toggled_cb ), d );
     
    599598    group = gtk_radio_button_get_group( GTK_RADIO_BUTTON( w ) );
    600599    gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
    601     w = gtk_spin_button_new_with_range( 0.5, INT_MAX, .05 );
     600    w = gtk_spin_button_new_with_range( 0, INT_MAX, .05 );
    602601    gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 2 );
    603602    tag = g_signal_connect( w, "value-changed", G_CALLBACK( ratio_spun_cb ), d );
     
    659658            if( baseline != (int)stats[i]->activity )
    660659                break;
    661         str = i==n ? activityString(baseline) : _( "Mixed" );
     660        if( i==n )
     661            str = activityString( baseline );
     662        else
     663            str = mixed;
    662664    }
    663665    gtk_label_set_text( GTK_LABEL( di->state_lb ), str );
     
    690692        double verifiedPieces = 0;
    691693        for( i=0; i<n; ++i ) {
     694            const double v = stats[i]->haveValid;
    692695            haveUnchecked += stats[i]->haveUnchecked;
    693             haveValid += stats[i]->haveValid;
    694             verifiedPieces += stats[i]->haveValid / tr_torrentInfo(torrents[i])->pieceSize;
     696            haveValid += v;
     697            verifiedPieces += v / tr_torrentInfo(torrents[i])->pieceSize;
    695698        }
    696699        tr_strlsize( buf1, haveValid + haveUnchecked, sizeof( buf1 ) );
     
    712715        uint64_t sum = 0;
    713716        for( i=0; i<n; ++i ) sum += stats[i]->downloadedEver;
    714         tr_strlsize( buf, sum, sizeof( buf ) );
    715         str = buf;
     717        str = tr_strlsize( buf, sum, sizeof( buf ) );
    716718    }
    717719    gtk_label_set_text( GTK_LABEL( di->dl_lb ), str );
     
    724726        uint64_t sum = 0;
    725727        for( i=0; i<n; ++i ) sum += stats[i]->uploadedEver;
    726         tr_strlsize( buf, sum, sizeof( buf ) );
    727         str = buf;
     728        str = tr_strlsize( buf, sum, sizeof( buf ) );
    728729    }
    729730    gtk_label_set_text( GTK_LABEL( di->ul_lb ), str );
     
    736737        uint64_t sum = 0;
    737738        for( i=0; i<n; ++i ) sum += stats[i]->corruptEver;
    738         tr_strlsize( buf, sum, sizeof( buf ) );
    739         str = buf;
     739        str = tr_strlsize( buf, sum, sizeof( buf ) );
    740740    }
    741741    gtk_label_set_text( GTK_LABEL( di->failed_lb ), str );
     
    752752            down += stats[i]->downloadedEver;
    753753        }
    754         tr_strlratio( buf, tr_getRatio( up, down ), sizeof( buf ) );
    755         str = buf;
     754        str = tr_strlratio( buf, tr_getRatio( up, down ), sizeof( buf ) );
    756755    }
    757756    gtk_label_set_text( GTK_LABEL( di->ratio_lb ), str );
     
    765764        for( i=0; i<n; ++i )
    766765            swarmSpeed += stats[i]->swarmSpeed;
    767         tr_strlspeed( buf, swarmSpeed, sizeof( buf ) );
    768         str = buf;
     766        str = tr_strlspeed( buf, swarmSpeed, sizeof( buf ) );
    769767    }
    770768    gtk_label_set_text( GTK_LABEL( di->swarm_lb ), str );
     
    779777            if( strcmp( baseline, stats[i]->errorString ) )
    780778                break;
    781         str = i==n ? baseline : mixed;
     779        if( i==n )
     780            str = baseline;
     781        else
     782            str = mixed;
    782783    }
    783784    if( !str || !*str )
     
    794795            if( baseline != stats[i]->addedDate )
    795796                break;
    796         if( i==n ) {
    797             char * tmp = gtr_localtime( baseline );
    798             g_strlcpy( buf, tmp, sizeof( buf ) );
    799             g_free( tmp );
    800             str = buf;
    801         } else {
     797        if( i==n )
     798            str = gtr_localtime2( buf, baseline, sizeof( buf ) );
     799        else
    802800            str = mixed;
    803         }
    804801    }
    805802    gtk_label_set_text( GTK_LABEL( di->date_added_lb ), str );
     
    814811            if( baseline != stats[i]->activityDate )
    815812                break;
    816         if( i!=n )
     813        if( i==n )
     814            str = gtr_localtime2( buf, baseline, sizeof( buf ) );
     815        else
    817816            str = mixed;
    818         else {
    819             char * tmp = gtr_localtime( baseline );
    820             g_strlcpy( buf, tmp, sizeof( buf ) );
    821             str = buf;
    822             tr_free( tmp );
    823         }
    824817    }
    825818    gtk_label_set_text( GTK_LABEL( di->last_activity_lb ), str );
     
    861854
    862855    l = di->swarm_lb = gtk_label_new( NULL );
    863     hig_workarea_add_row( t, &row, _( "Swarm rate:" ), l, NULL );
     856    hig_workarea_add_row( t, &row, _( "Swarm speed:" ), l, NULL );
    864857
    865858    l = di->error_lb = gtk_label_new( NULL );
     
    894887    const char * none = _( "None" );
    895888    const char * mixed = _( "Mixed" );
     889    const char * unknown = _( "Unknown" );
    896890    const tr_info ** infos = g_new( const tr_info*, n );
    897891
     
    908902        for( i=0; i<n; ++i )
    909903            sum += infos[i]->pieceCount;
    910         g_snprintf( buf, sizeof( buf ), ngettext( "%'d Piece", "%'d Pieces", sum ), sum );
     904        g_snprintf( buf, sizeof( buf ),
     905                    ngettext( "%'d Piece", "%'d Pieces", sum ), sum );
    911906        for( i=1; i<n; ++i )
    912907            if( baseline != (int)infos[i]->pieceSize )
     
    915910            char tmp1[64];
    916911            char tmp2[64];
    917             tr_strlcpy( tmp1, buf, sizeof( tmp1 ) );
     912            g_strlcpy( tmp1, buf, sizeof( tmp1 ) );
    918913            tr_strlsize( tmp2, baseline, sizeof( tmp2 ) );
    919914            g_snprintf( buf, sizeof( buf ), _( "%1$s @ %2$s" ), tmp1, tmp2 );
     
    982977    }
    983978    if( !str || !*str )
    984         str = _( "Unknown" );
     979        str = unknown;
    985980    gtk_label_set_text( GTK_LABEL( di->creator_lb ), str );
    986981
     
    994989            if( baseline != infos[i]->dateCreated )
    995990                break;
    996         if( i!=n )
     991        if( i==n )
     992            str = gtr_localtime2( buf, baseline, sizeof( buf ) );
     993        else
    997994            str = mixed;
    998         else {
    999             char * tmp = gtr_localtime( baseline );
    1000             tr_strlcpy( buf, tmp, sizeof( buf ) );
    1001             str = buf;
    1002             g_free( tmp );
    1003         }
    1004995    }
    1005996    gtk_label_set_text( GTK_LABEL( di->date_created_lb ), str );
     
    11901181
    11911182static void
    1192 init_peer( GtkListStore        * store,
    1193            GtkTreeIter         * iter,
    1194            const char          * key,
    1195            const tr_peer_stat  * peer )
     1183initPeerRow( GtkListStore        * store,
     1184             GtkTreeIter         * iter,
     1185             const char          * key,
     1186             const tr_peer_stat  * peer )
    11961187{
    11971188    int q[4];
     
    12961287            const tr_peer_stat * s = &peers[i][j];
    12971288            char key[128];
    1298             g_snprintf( key, sizeof( key ), "%d.%s", tr_torrentId(tor), s->addr );
     1289            g_snprintf( key, sizeof(key), "%d.%s", tr_torrentId(tor), s->addr );
    12991290            if( g_hash_table_lookup( hash, key ) == NULL ) {
    1300                 GtkTreePath * path;
     1291                GtkTreePath * p;
    13011292                gtk_list_store_append( store, &iter );
    1302                 init_peer( store, &iter, key, s );
    1303                 /* fprintf( stderr, "adding peer key %s\n", key ); */
    1304                 path = gtk_tree_model_get_path( model, &iter );
     1293                initPeerRow( store, &iter, key, s );
     1294                p = gtk_tree_model_get_path( model, &iter );
    13051295                g_hash_table_insert( hash, g_strdup( key ),
    1306                                      gtk_tree_row_reference_new( model, path ) );
    1307                 gtk_tree_path_free( path );
     1296                                     gtk_tree_row_reference_new( model, p ) );
     1297                gtk_tree_path_free( p );
    13081298            }
    13091299        }
     
    13181308            char key[128];
    13191309            GtkTreeRowReference * ref;
    1320             GtkTreePath * path;
    1321             g_snprintf( key, sizeof( key ), "%d.%s", tr_torrentId(tor), s->addr );
     1310            GtkTreePath * p;
     1311            g_snprintf( key, sizeof(key), "%d.%s", tr_torrentId(tor), s->addr );
    13221312            ref = g_hash_table_lookup( hash, key );
    1323             assert( ref != NULL );
    1324             path = gtk_tree_row_reference_get_path( ref );
    1325             assert( path );
    1326             gtk_tree_model_get_iter( model, &iter, path );
     1313            p = gtk_tree_row_reference_get_path( ref );
     1314            gtk_tree_model_get_iter( model, &iter, p );
    13271315            refreshPeerRow( store, &iter, s );
    1328             gtk_tree_path_free( path );
     1316            gtk_tree_path_free( p );
    13291317        }
    13301318    }
     
    13421330                char * key;
    13431331                gtk_tree_model_get( model, &iter, PEER_COL_KEY, &key, -1 );
    1344                 /* fprintf( stderr, "removing key %s\n", key ); */
    13451332                g_hash_table_remove( hash, key );
    13461333                more = gtk_list_store_remove( store, &iter );
     
    13821369            char key[256];
    13831370            const char * url = inf->webseeds[j];
    1384             g_snprintf( key, sizeof( key ), "%d.%s", tr_torrentId( tor ), url );
     1371            g_snprintf( key, sizeof(key), "%d.%s", tr_torrentId( tor ), url );
    13851372            if( g_hash_table_lookup( hash, key ) == NULL ) {
    1386                 GtkTreePath * path;
     1373                GtkTreePath * p;
    13871374                gtk_list_store_append( store, &iter );
    13881375                gtk_list_store_set( store, &iter, WEBSEED_COL_URL, url, -1 );
    1389                 path = gtk_tree_model_get_path( model, &iter );
     1376                p = gtk_tree_model_get_path( model, &iter );
    13901377                g_hash_table_insert( hash, g_strdup( key ),
    1391                                      gtk_tree_row_reference_new( model, path ) );
    1392                 gtk_tree_path_free( path );
     1378                                     gtk_tree_row_reference_new( model, p ) );
     1379                gtk_tree_path_free( p );
    13931380            }
    13941381        }
     
    14041391            char key[256];
    14051392            const char * url = inf->webseeds[j];
    1406             GtkTreePath * path;
     1393            GtkTreePath * p;
    14071394            GtkTreeRowReference * ref;
    1408             g_snprintf( key, sizeof( key ), "%d.%s", tr_torrentId( tor ), url );
     1395            g_snprintf( key, sizeof(key), "%d.%s", tr_torrentId( tor ), url );
    14091396            ref = g_hash_table_lookup( hash, key );
    1410             path = gtk_tree_row_reference_get_path( ref );
    1411             gtk_tree_model_get_iter( model, &iter, path );
    1412             gtk_list_store_set( store, &iter, WEBSEED_COL_DOWNLOAD_RATE, (int)(100.0*speeds[j]), -1 );
    1413             gtk_tree_path_free( path );
     1397            p = gtk_tree_row_reference_get_path( ref );
     1398            gtk_tree_model_get_iter( model, &iter, p );
     1399            gtk_list_store_set( store, &iter, WEBSEED_COL_DOWNLOAD_RATE, (int)speeds[j], -1 );
     1400            gtk_tree_path_free( p );
    14141401        }
    14151402        tr_free( speeds );
     
    14341421    }
    14351422
     1423    /* most of the time there are no webseeds...
     1424       if that's the case, don't waste space showing an empty list */
    14361425    if( total > 0 )
    14371426        gtk_widget_show( di->webseed_view );
     
    14991488        for( pch = str; pch && *pch; ++pch )
    15001489        {
    1501             const char * txt = NULL;
     1490            const char * s = NULL;
    15021491            switch( *pch )
    15031492            {
    1504                 case 'O': txt = _( "Optimistic unchoke" ); break;
    1505                 case 'D': txt = _( "Downloading from this peer" ); break;
    1506                 case 'd': txt = _( "We would download from this peer if they would let us" ); break;
    1507                 case 'U': txt = _( "Uploading to peer" ); break;
    1508                 case 'u': txt = _( "We would upload to this peer if they asked" ); break;
    1509                 case 'K': txt = _( "Peer has unchoked us, but we're not interested" ); break;
    1510                 case '?': txt = _( "We unchoked this peer, but they're not interested" ); break;
    1511                 case 'E': txt = _( "Encrypted connection" ); break;
    1512                 case 'X': txt = _( "Peer was discovered through Peer Exchange (PEX)" ); break;
    1513                 case 'I': txt = _( "Peer is an incoming connection" ); break;
     1493                case 'O': s = _( "Optimistic unchoke" ); break;
     1494                case 'D': s = _( "Downloading from this peer" ); break;
     1495                case 'd': s = _( "We would download from this peer if they would let us" ); break;
     1496                case 'U': s = _( "Uploading to peer" ); break;
     1497                case 'u': s = _( "We would upload to this peer if they asked" ); break;
     1498                case 'K': s = _( "Peer has unchoked us, but we're not interested" ); break;
     1499                case '?': s = _( "We unchoked this peer, but they're not interested" ); break;
     1500                case 'E': s = _( "Encrypted connection" ); break;
     1501                case 'X': s = _( "Peer was discovered through Peer Exchange (PEX)" ); break;
     1502                case 'I': s = _( "Peer is an incoming connection" ); break;
    15141503            }
    1515             if( txt )
    1516                 g_string_append_printf( gstr, "%c: %s\n", *pch, txt );
     1504            if( s )
     1505                g_string_append_printf( gstr, "%c: %s\n", *pch, s );
    15171506        }
    15181507        if( gstr->len ) /* remove the last linefeed */
     
    16011590    for( i=0; i<G_N_ELEMENTS( view_columns ); ++i )
    16021591    {
    1603         const int           col = view_columns[i];
    1604         const char *        t = getPeerColumnName( col );
    1605         int                 sort_col = col;
     1592        const int col = view_columns[i];
     1593        const char * t = getPeerColumnName( col );
     1594        int sort_col = col;
    16061595
    16071596        switch( col )
     
    16801669    gtk_container_set_border_width( GTK_CONTAINER( vbox ), GUI_PAD_BIG );
    16811670
    1682     if( webtree == NULL )
    1683         gtk_box_pack_start( GTK_BOX( vbox ), sw, TRUE, TRUE, 0 );
    1684     else {
    1685         GtkWidget * vpaned = gtk_vpaned_new( );
    1686         gtk_paned_pack1( GTK_PANED( vpaned ), webtree, FALSE, TRUE );
    1687         gtk_paned_pack2( GTK_PANED( vpaned ), sw, TRUE, TRUE );
    1688         gtk_box_pack_start( GTK_BOX( vbox ), vpaned, TRUE, TRUE, 0 );
    1689     }
     1671    v = gtk_vpaned_new( );
     1672    gtk_paned_pack1( GTK_PANED( v ), webtree, FALSE, TRUE );
     1673    gtk_paned_pack2( GTK_PANED( v ), sw, TRUE, TRUE );
     1674    gtk_box_pack_start( GTK_BOX( vbox ), v, TRUE, TRUE, 0 );
    16901675
    16911676    hbox = gtk_hbox_new( FALSE, GUI_PAD );
     
    17631748        else if( baseline==0 )
    17641749            str = noneSent;
    1765         else {
    1766             char * tmp = gtr_localtime( baseline );
    1767             g_strlcpy( buf, tmp, sizeof( buf ) );
    1768             g_free( tmp );
    1769             str = buf;
    1770         }
     1750        else
     1751            str = gtr_localtime2( buf, baseline, sizeof( buf ) );
    17711752    }
    17721753    gtk_label_set_text( GTK_LABEL( di->last_scrape_time_lb ), str );
     
    18191800        else if( baseline==0 )
    18201801            str = noneSent;
    1821         else {
    1822             char * tmp = gtr_localtime( baseline );
    1823             g_strlcpy( buf, tmp, sizeof( buf ) );
    1824             g_free( tmp );
    1825             str = buf;
    1826         }
     1802        else
     1803            str = gtr_localtime2( buf, baseline, sizeof( buf ) );
    18271804    }
    18281805    gtk_label_set_text( GTK_LABEL( di->last_announce_time_lb ), str );
     
    20011978torrent_inspector_new( GtkWindow * parent, TrCore * core )
    20021979{
    2003     guint tag;
    2004     struct DetailsImpl * data;
    20051980    GtkWidget * d, * n, * w, * l;
     1981    struct DetailsImpl * di = g_new0( struct DetailsImpl, 1 );
    20061982
    20071983    /* create the dialog */
    2008     data = g_new0( struct DetailsImpl, 1 );
    2009     data->core = core;
     1984    di->core = core;
    20101985    d = gtk_dialog_new_with_buttons( NULL, parent, 0,
    20111986                                     GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
     
    20151990    gtk_dialog_set_has_separator( GTK_DIALOG( d ), FALSE );
    20161991    gtk_container_set_border_width( GTK_CONTAINER( d ), GUI_PAD );
    2017     g_object_set_data_full( G_OBJECT( d ), DETAILS_KEY, data, details_free );
     1992    g_object_set_data_full( G_OBJECT( d ), DETAILS_KEY, di, details_free );
    20181993
    20191994    n = gtk_notebook_new( );
    20201995    gtk_container_set_border_width( GTK_CONTAINER( n ), GUI_PAD );
    20211996
    2022     w = activity_page_new( data );
     1997    w = activity_page_new( di );
    20231998    l = gtk_label_new( _( "Activity" ) );
    20241999    gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, l );
    20252000
    2026     w = peer_page_new( data );
     2001    w = peer_page_new( di );
    20272002    l = gtk_label_new( _( "Peers" ) );
    20282003    gtk_notebook_append_page( GTK_NOTEBOOK( n ),  w, l );
    20292004
    2030     w = tracker_page_new( data );
     2005    w = tracker_page_new( di );
    20312006    l = gtk_label_new( _( "Tracker" ) );
    20322007    gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, l );
    20332008
    2034     w = info_page_new( data );
     2009    w = info_page_new( di );
    20352010    l = gtk_label_new( _( "Information" ) );
    20362011    gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, l );
    20372012
    2038     w = file_list_new( data->core, 0 );
     2013    w = file_list_new( core, 0 );
    20392014    gtk_container_set_border_width( GTK_CONTAINER( w ), GUI_PAD_BIG );
    20402015    l = gtk_label_new( _( "Files" ) );
    20412016    gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, l );
    2042     data->file_list = w;
    2043 
    2044     w = options_page_new( data );
     2017    di->file_list = w;
     2018
     2019    w = options_page_new( di );
    20452020    l = gtk_label_new( _( "Options" ) );
    20462021    gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, l );
     
    20482023    gtk_box_pack_start( GTK_BOX( GTK_DIALOG( d )->vbox ), n, TRUE, TRUE, 0 );
    20492024
    2050     tag = gtr_timeout_add_seconds( UPDATE_INTERVAL_SECONDS, periodic_refresh, data );
    2051     data->periodic_refresh_tag = tag;
    2052     periodic_refresh( data );
     2025    di->periodic_refresh_tag = gtr_timeout_add_seconds( UPDATE_INTERVAL_SECONDS,
     2026                                                        periodic_refresh, di );
     2027    periodic_refresh( di );
    20532028    gtk_widget_show_all( GTK_DIALOG( d )->vbox );
    20542029    return d;
     
    20582033torrent_inspector_set_torrents( GtkWidget * w, GSList * ids )
    20592034{
    2060     struct DetailsImpl * data = g_object_get_data( G_OBJECT( w ), DETAILS_KEY );
     2035    struct DetailsImpl * di = g_object_get_data( G_OBJECT( w ), DETAILS_KEY );
    20612036    const int len = g_slist_length( ids );
    20622037    char title[256];
    20632038
    2064     g_slist_free( data->ids );
    2065     data->ids = g_slist_copy( ids );
     2039    g_slist_free( di->ids );
     2040    di->ids = g_slist_copy( ids );
    20662041
    20672042    if( len == 1 )
    20682043    {
    20692044        const int id = GPOINTER_TO_INT( ids->data );
    2070         tr_session * session = tr_core_session( data->core );
     2045        tr_session * session = tr_core_session( di->core );
    20712046        tr_torrent * tor = tr_torrentFindFromId( session, id );
    20722047        const tr_info * inf = tr_torrentInfo( tor );
    20732048        g_snprintf( title, sizeof( title ), _( "%s Properties" ), inf->name );
    20742049
    2075         file_list_set_torrent( data->file_list, id );
    2076         tracker_list_set_torrent( data->tracker_list, id );
     2050        file_list_set_torrent( di->file_list, id );
     2051        tracker_list_set_torrent( di->tracker_list, id );
    20772052       
    20782053    }
    20792054   else
    20802055   {
    2081         file_list_clear( data->file_list );
    2082         tracker_list_clear( data->tracker_list );
     2056        file_list_clear( di->file_list );
     2057        tracker_list_clear( di->tracker_list );
    20832058        g_snprintf( title, sizeof( title ), _( "%'d Torrent Properties" ), len );
    20842059    }
     
    20862061    gtk_window_set_title( GTK_WINDOW( w ), title );
    20872062
    2088     refresh( data );
    2089 }
     2063    refresh( di );
     2064}
  • trunk/gtk/util.c

    r8233 r8282  
    200200}
    201201
     202char *
     203gtr_localtime2( char * buf, time_t time, size_t buflen )
     204{
     205    char * tmp = gtr_localtime( time );
     206    g_strlcpy( buf, tmp, sizeof( buflen ) );
     207    g_free( tmp );
     208    return buf;
     209}
     210
    202211int
    203212mkdir_p( const char * path,
  • trunk/gtk/util.h

    r8097 r8282  
    6161
    6262char*       gtr_localtime( time_t time );
     63
     64char*       gtr_localtime2( char * buf, time_t time, size_t buflen );
    6365
    6466/* create a directory and any missing parent directories */
Note: See TracChangeset for help on using the changeset viewer.