Changeset 8281


Ignore:
Timestamp:
Apr 24, 2009, 12:05:53 PM (13 years ago)
Author:
charles
Message:

(gtk) clean up yesterday's properties dialog rewrite a bit.

Location:
trunk/gtk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/details.c

    r8279 r8281  
    1212
    1313#include <assert.h>
    14 #include <errno.h>
    1514#include <math.h> /* ceil() */
    1615#include <stddef.h>
    17 #include <stdio.h>
     16#include <stdio.h> /* sscanf */
    1817#include <stdlib.h>
    1918#include <glib/gi18n.h>
     
    2120
    2221#include <libtransmission/transmission.h>
    23 #include <libtransmission/utils.h> /* tr_httpIsValidURL */
     22#include <libtransmission/utils.h> /* tr_free */
    2423
    2524#include "actions.h"
    2625#include "details.h"
    2726#include "file-list.h"
    28 #include "tr-torrent.h"
    2927#include "tracker-list.h"
    3028#include "hig.h"
     
    230228                break;
    231229        if( i == n )
    232             set_togglebutton_if_different( di->honorLimitsCheck, di->honorLimitsCheckTag, baseline );
     230            set_togglebutton_if_different( di->honorLimitsCheck,
     231                                           di->honorLimitsCheckTag, baseline );
    233232    }
    234233   
     
    241240                break;
    242241        if( i == n )
    243             set_togglebutton_if_different( di->downLimitedCheck, di->downLimitedCheckTag, baseline );
     242            set_togglebutton_if_different( di->downLimitedCheck,
     243                                           di->downLimitedCheckTag, baseline );
    244244    }
    245245
     
    252252                break;
    253253        if( i == n )
    254             set_int_spin_if_different( di->downLimitSpin, di->downLimitSpinTag, baseline );
     254            set_int_spin_if_different( di->downLimitSpin,
     255                                       di->downLimitSpinTag, baseline );
    255256    }
    256257   
     
    263264                break;
    264265        if( i == n )
    265             set_togglebutton_if_different( di->upLimitedCheck, di->upLimitedCheckTag, baseline );
     266            set_togglebutton_if_different( di->upLimitedCheck,
     267                                           di->upLimitedCheckTag, baseline );
    266268    }
    267269
     
    274276                break;
    275277        if( i == n )
    276             set_int_spin_if_different( di->upLimitSpin, di->upLimitSpinTag, baseline );
     278            set_int_spin_if_different( di->upLimitSpin,
     279                                       di->upLimitSpinTag, baseline );
    277280    }
    278281
     
    285288                break;
    286289        if( i == n )
    287             set_int_combo_if_different( di->bandwidthCombo, di->bandwidthComboTag, 0, baseline );
     290            set_int_combo_if_different( di->bandwidthCombo,
     291                                        di->bandwidthComboTag, 0, baseline );
    288292        else
    289293            unset_combo( di->bandwidthCombo, di->bandwidthComboTag );
     
    319323                break;
    320324        if( i == n )
    321             set_double_spin_if_different( di->seedCustomSpin, di->seedCustomSpinTag, baseline );
     325            set_double_spin_if_different( di->seedCustomSpin,
     326                                          di->seedCustomSpinTag, baseline );
    322327    }
    323328}
     
    378383
    379384static void
    380 up_speed_toggled_cb( GtkToggleButton * tb, gpointer data )
    381 {
    382     torrent_set_bool( data, "uploadLimited", gtk_toggle_button_get_active( tb ) );
    383 }
    384 
    385 static void
    386 down_speed_toggled_cb( GtkToggleButton *tb, gpointer data )
    387 {
    388     torrent_set_bool( data, "downloadLimited", gtk_toggle_button_get_active( tb ) );
    389 }
    390 
    391 static void
    392 global_speed_toggled_cb( GtkToggleButton * tb, gpointer data )
    393 {
    394     torrent_set_bool( data, "honorsSessionLimits", gtk_toggle_button_get_active( tb ) );
    395 }
    396 
    397 #define RATIO_MODE_KEY "ratio-mode"
    398 
    399 static void
    400 ratio_mode_changed_cb( GtkToggleButton * tb, struct DetailsImpl * data )
     385up_speed_toggled_cb( GtkToggleButton * tb, gpointer d )
     386{
     387    torrent_set_bool( d, "uploadLimited", gtk_toggle_button_get_active( tb ) );
     388}
     389
     390static void
     391down_speed_toggled_cb( GtkToggleButton *tb, gpointer d )
     392{
     393    torrent_set_bool( d, "downloadLimited", gtk_toggle_button_get_active( tb ) );
     394}
     395
     396static void
     397global_speed_toggled_cb( GtkToggleButton * tb, gpointer d )
     398{
     399    torrent_set_bool( d, "honorsSessionLimits", gtk_toggle_button_get_active( tb ) );
     400}
     401
     402#define RATIO_KEY "ratio-mode"
     403
     404static void
     405ratio_mode_changed_cb( GtkToggleButton * tb, struct DetailsImpl * d )
    401406{
    402407    if( gtk_toggle_button_get_active( tb ) )
    403408    {
    404         const int mode = GPOINTER_TO_INT( g_object_get_data( G_OBJECT( tb ), RATIO_MODE_KEY ) );
    405         torrent_set_int( data, "seedRatioMode", mode );
    406     }
    407 }
    408 
    409 static void
    410 up_speed_spun_cb( GtkSpinButton * spin, struct DetailsImpl * di )
    411 {
    412     torrent_set_int( di, "uploadLimit", gtk_spin_button_get_value_as_int( spin ) );
    413 }
    414 
    415 static void
    416 down_speed_spun_cb( GtkSpinButton * spin, struct DetailsImpl * di )
    417 {
    418     torrent_set_int( di, "downloadLimit", gtk_spin_button_get_value_as_int( spin ) );
    419 }
    420 
    421 static void
    422 ratio_spun_cb( GtkSpinButton * spin, struct DetailsImpl * di )
    423 {
    424     torrent_set_real( di, "seedRatioLimit", gtk_spin_button_get_value( spin ) );
    425 }
    426 
    427 static void
    428 max_peers_spun_cb( GtkSpinButton * spin, struct DetailsImpl * di )
    429 {
    430     torrent_set_int( di, "peer-limit", gtk_spin_button_get_value( spin ) );
     409        GObject * o = G_OBJECT( tb );
     410        const int mode = GPOINTER_TO_INT( g_object_get_data( o, RATIO_KEY ) );
     411        torrent_set_int( d, "seedRatioMode", mode );
     412    }
     413}
     414
     415static void
     416up_speed_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
     417{
     418    torrent_set_int( di, "uploadLimit", gtk_spin_button_get_value_as_int( s ) );
     419}
     420
     421static void
     422down_speed_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
     423{
     424    torrent_set_int( di, "downloadLimit", gtk_spin_button_get_value_as_int( s ) );
     425}
     426
     427static void
     428ratio_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
     429{
     430    torrent_set_real( di, "seedRatioLimit", gtk_spin_button_get_value( s ) );
     431}
     432
     433static void
     434max_peers_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
     435{
     436    torrent_set_int( di, "peer-limit", gtk_spin_button_get_value( s ) );
    431437}
    432438
     
    449455prefsChanged( TrCore * core UNUSED, const char *  key, gpointer rb )
    450456{
    451     if( !strcmp( key, TR_PREFS_KEY_RATIO_ENABLED ) || !strcmp( key, TR_PREFS_KEY_RATIO ) )
     457    if( !strcmp( key, TR_PREFS_KEY_RATIO_ENABLED ) ||
     458        !strcmp( key, TR_PREFS_KEY_RATIO ) )
    452459    {
    453460        char * s = get_global_ratio_radiobutton_string( );
     
    494501        GtkTreeIter iter;
    495502        gtk_list_store_append( store, &iter );
    496         gtk_list_store_set( store, &iter, 0, items[i].value, 1, _( items[i].text ), -1 );
     503        gtk_list_store_set( store, &iter, 0, items[i].value,
     504                                          1, _( items[i].text ),
     505                                         -1 );
    497506    }
    498507
     
    524533    hig_workarea_add_section_title( t, &row, _( "Speed" ) );
    525534
    526         tb = hig_workarea_add_wide_checkbutton( t, &row, _( "Honor global _limits" ), FALSE );
    527         d->honorLimitsCheck = tb;
    528         tag = g_signal_connect( tb, "toggled", G_CALLBACK( global_speed_toggled_cb ), d );
    529         d->honorLimitsCheckTag = tag;
    530 
    531         tb = gtk_check_button_new_with_mnemonic( _( "Limit _download speed (KB/s):" ) );
    532         gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( tb ), FALSE );
    533         d->downLimitedCheck = tb;
    534         tag = g_signal_connect( tb, "toggled", G_CALLBACK( down_speed_toggled_cb ), d );
    535         d->downLimitedCheckTag = tag;
    536 
    537         w = gtk_spin_button_new_with_range( 1, INT_MAX, 5 );
    538         gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), i );
    539         tag = g_signal_connect( w, "value-changed", G_CALLBACK( down_speed_spun_cb ), d );
    540         d->downLimitSpinTag = tag;
    541         hig_workarea_add_row_w( t, &row, tb, w, NULL );
    542         d->downLimitSpin = w;
    543 
    544         tb = gtk_check_button_new_with_mnemonic( _( "Limit _upload speed (KB/s):" ) );
    545         d->upLimitedCheck = tb;
    546         tag = g_signal_connect( tb, "toggled", G_CALLBACK( up_speed_toggled_cb ), d );
    547         d->upLimitedCheckTag = tag;
    548 
    549         w = gtk_spin_button_new_with_range( 1, INT_MAX, 5 );
    550         gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), i );
    551         tag = g_signal_connect( w, "value-changed", G_CALLBACK( up_speed_spun_cb ), d );
    552         d->upLimitSpinTag = tag;
    553         hig_workarea_add_row_w( t, &row, tb, w, NULL );
    554         d->upLimitSpin = w;
    555 
    556         w = new_priority_combo( d );
    557         hig_workarea_add_row( t, &row, _( "_Bandwidth priority:" ), w, NULL );
    558         d->bandwidthCombo = w;
     535    tb = hig_workarea_add_wide_checkbutton( t, &row, _( "Honor global _limits" ), FALSE );
     536    d->honorLimitsCheck = tb;
     537    tag = g_signal_connect( tb, "toggled", G_CALLBACK( global_speed_toggled_cb ), d );
     538    d->honorLimitsCheckTag = tag;
     539
     540    tb = gtk_check_button_new_with_mnemonic( _( "Limit _download speed (KB/s):" ) );
     541    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( tb ), FALSE );
     542    d->downLimitedCheck = tb;
     543    tag = g_signal_connect( tb, "toggled", G_CALLBACK( down_speed_toggled_cb ), d );
     544    d->downLimitedCheckTag = tag;
     545
     546    w = gtk_spin_button_new_with_range( 1, INT_MAX, 5 );
     547    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), i );
     548    tag = g_signal_connect( w, "value-changed", G_CALLBACK( down_speed_spun_cb ), d );
     549    d->downLimitSpinTag = tag;
     550    hig_workarea_add_row_w( t, &row, tb, w, NULL );
     551    d->downLimitSpin = w;
     552
     553    tb = gtk_check_button_new_with_mnemonic( _( "Limit _upload speed (KB/s):" ) );
     554    d->upLimitedCheck = tb;
     555    tag = g_signal_connect( tb, "toggled", G_CALLBACK( up_speed_toggled_cb ), d );
     556    d->upLimitedCheckTag = tag;
     557
     558    w = gtk_spin_button_new_with_range( 1, INT_MAX, 5 );
     559    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), i );
     560    tag = g_signal_connect( w, "value-changed", G_CALLBACK( up_speed_spun_cb ), d );
     561    d->upLimitSpinTag = tag;
     562    hig_workarea_add_row_w( t, &row, tb, w, NULL );
     563    d->upLimitSpin = w;
     564
     565    w = new_priority_combo( d );
     566    hig_workarea_add_row( t, &row, _( "_Bandwidth priority:" ), w, NULL );
     567    d->bandwidthCombo = w;
    559568
    560569    hig_workarea_add_section_divider( t, &row );
    561570    hig_workarea_add_section_title( t, &row, _( "Seed-Until Ratio" ) );
    562571
    563         group = NULL;
    564         s = get_global_ratio_radiobutton_string( );
    565         w = gtk_radio_button_new_with_mnemonic( group, s );
    566         tag = g_signal_connect( d->core, "prefs-changed", G_CALLBACK( prefsChanged ), w );
    567         d->prefs_changed_tag = tag;
    568         group = gtk_radio_button_get_group( GTK_RADIO_BUTTON( w ) );
    569         hig_workarea_add_wide_control( t, &row, w );
    570         g_free( s );
    571         g_object_set_data( G_OBJECT( w ), RATIO_MODE_KEY, GINT_TO_POINTER( TR_RATIOLIMIT_GLOBAL ) );
    572         tag = g_signal_connect( w, "toggled", G_CALLBACK( ratio_mode_changed_cb ), d );
    573         d->seedGlobalRadio = w;
    574         d->seedGlobalRadioTag = tag;
    575 
    576         w = gtk_radio_button_new_with_mnemonic( group, _( "Seed _regardless of ratio" ) );
    577         group = gtk_radio_button_get_group( GTK_RADIO_BUTTON( w ) );
    578         hig_workarea_add_wide_control( t, &row, w );
    579         g_object_set_data( G_OBJECT( w ), RATIO_MODE_KEY, GINT_TO_POINTER( TR_RATIOLIMIT_UNLIMITED ) );
    580         tag = g_signal_connect( w, "toggled", G_CALLBACK( ratio_mode_changed_cb ), d );
    581         d->seedForeverRadio = w;
    582         d->seedForeverRadioTag = tag;
    583 
    584         h = gtk_hbox_new( FALSE, GUI_PAD );
    585         w = gtk_radio_button_new_with_mnemonic( group, _( "_Stop seeding when a torrent's ratio reaches" ) );
    586         d->seedCustomRadio = w;
    587         g_object_set_data( G_OBJECT( w ), RATIO_MODE_KEY, GINT_TO_POINTER( TR_RATIOLIMIT_SINGLE ) );
    588         tag = g_signal_connect( w, "toggled", G_CALLBACK( ratio_mode_changed_cb ), d );
    589         d->seedCustomRadioTag = tag;
    590         group = gtk_radio_button_get_group( GTK_RADIO_BUTTON( w ) );
    591         gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
    592         w = gtk_spin_button_new_with_range( 0.5, INT_MAX, .05 );
    593         gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 2 );
    594         tag = g_signal_connect( w, "value-changed", G_CALLBACK( ratio_spun_cb ), d );
    595         gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
    596         hig_workarea_add_wide_control( t, &row, h );
    597         d->seedCustomSpin = w;
    598         d->seedCustomSpinTag = tag;
     572    group = NULL;
     573    s = get_global_ratio_radiobutton_string( );
     574    w = gtk_radio_button_new_with_mnemonic( group, s );
     575    tag = g_signal_connect( d->core, "prefs-changed", G_CALLBACK( prefsChanged ), w );
     576    d->prefs_changed_tag = tag;
     577    group = gtk_radio_button_get_group( GTK_RADIO_BUTTON( w ) );
     578    hig_workarea_add_wide_control( t, &row, w );
     579    g_free( s );
     580    g_object_set_data( G_OBJECT( w ), RATIO_KEY, GINT_TO_POINTER( TR_RATIOLIMIT_GLOBAL ) );
     581    tag = g_signal_connect( w, "toggled", G_CALLBACK( ratio_mode_changed_cb ), d );
     582    d->seedGlobalRadio = w;
     583    d->seedGlobalRadioTag = tag;
     584
     585    w = gtk_radio_button_new_with_mnemonic( group, _( "Seed _regardless of ratio" ) );
     586    group = gtk_radio_button_get_group( GTK_RADIO_BUTTON( w ) );
     587    hig_workarea_add_wide_control( t, &row, w );
     588    g_object_set_data( G_OBJECT( w ), RATIO_KEY, GINT_TO_POINTER( TR_RATIOLIMIT_UNLIMITED ) );
     589    tag = g_signal_connect( w, "toggled", G_CALLBACK( ratio_mode_changed_cb ), d );
     590    d->seedForeverRadio = w;
     591    d->seedForeverRadioTag = tag;
     592
     593    h = gtk_hbox_new( FALSE, GUI_PAD );
     594    w = gtk_radio_button_new_with_mnemonic( group, _( "_Stop seeding when a torrent's ratio reaches" ) );
     595    d->seedCustomRadio = w;
     596    g_object_set_data( G_OBJECT( w ), RATIO_KEY, GINT_TO_POINTER( TR_RATIOLIMIT_SINGLE ) );
     597    tag = g_signal_connect( w, "toggled", G_CALLBACK( ratio_mode_changed_cb ), d );
     598    d->seedCustomRadioTag = tag;
     599    group = gtk_radio_button_get_group( GTK_RADIO_BUTTON( w ) );
     600    gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
     601    w = gtk_spin_button_new_with_range( 0.5, INT_MAX, .05 );
     602    gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 2 );
     603    tag = g_signal_connect( w, "value-changed", G_CALLBACK( ratio_spun_cb ), d );
     604    gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
     605    hig_workarea_add_wide_control( t, &row, h );
     606    d->seedCustomSpin = w;
     607    d->seedCustomSpinTag = tag;
    599608   
    600609    hig_workarea_add_section_divider( t, &row );
    601610    hig_workarea_add_section_title( t, &row, _( "Peer Connections" ) );
    602611
    603         w = gtk_spin_button_new_with_range( 1, 3000, 5 );
    604         hig_workarea_add_row( t, &row, _( "_Maximum peers:" ), w, w );
    605         g_signal_connect( w, "value-changed", G_CALLBACK( max_peers_spun_cb ), d );
    606         d->maxPeersSpin = w;
     612    w = gtk_spin_button_new_with_range( 1, 3000, 5 );
     613    hig_workarea_add_row( t, &row, _( "_Maximum peers:" ), w, w );
     614    g_signal_connect( w, "value-changed", G_CALLBACK( max_peers_spun_cb ), d );
     615    d->maxPeersSpin = w;
    607616
    608617    hig_workarea_finish( t, &row );
     
    689698        i = (int) ceil( verifiedPieces );
    690699        g_snprintf( buf, sizeof( buf ), ngettext( "%1$s (%2$s verified in %3$d piece)",
    691                                                   "%1$s (%2$s verified in %3$d pieces)", verifiedPieces ),
     700                                                  "%1$s (%2$s verified in %3$d pieces)",
     701                                                  verifiedPieces ),
    692702                                        buf1, buf2, i );
    693703        str = buf;
     
    736746        str = none;
    737747    else {
    738         uint64_t downloadedEver = 0;
    739         uint64_t uploadedEver = 0;
     748        uint64_t up = 0;
     749        uint64_t down = 0;
    740750        for( i=0; i<n; ++i ) {
    741             downloadedEver += stats[i]->downloadedEver;
    742             uploadedEver += stats[i]->uploadedEver;
     751            up += stats[i]->uploadedEver;
     752            down += stats[i]->downloadedEver;
    743753        }
    744         tr_strlratio( buf, tr_getRatio( uploadedEver, downloadedEver ), sizeof( buf ) );
     754        tr_strlratio( buf, tr_getRatio( up, down ), sizeof( buf ) );
    745755        str = buf;
    746756    }
     
    932942            if( baseline != infos[i]->isPrivate )
    933943                break;
    934         if( i==n )
    935             str = baseline ? _( "Private to this tracker -- PEX disabled" ) : _( "Public torrent" );
     944        if( i!=n )
     945            str = mixed;
     946        else if( baseline )
     947            str = _( "Private to this tracker -- PEX disabled" );
    936948        else
    937             str = mixed;
     949            str = _( "Public torrent" );
    938950    }
    939951    gtk_label_set_text( GTK_LABEL( di->privacy_lb ), str );
     
    945957    else {
    946958        const char * baseline = infos[0]->comment ? infos[0]->comment : "";
    947         for( i=1; i<n; ++i ) {
    948             const char * tmp = infos[i]->comment ? infos[i]->comment : "";
    949             if( strcmp( baseline, tmp ) )
    950                 break;
    951         }
     959        for( i=1; i<n; ++i )
     960            if( strcmp( baseline, infos[i]->comment ? infos[i]->comment : "" ) )
     961                break;
    952962        if( i==n )
    953963            str = baseline;
     
    963973    else {
    964974        const char * baseline = infos[0]->creator ? infos[0]->creator : "";
    965         for( i=1; i<n; ++i ) {
    966             const char * tmp = infos[i]->creator ? infos[i]->creator : "";
    967             if( strcmp( baseline, tmp ) )
    968                 break;
    969         }
     975        for( i=1; i<n; ++i )
     976            if( strcmp( baseline, infos[i]->creator ? infos[i]->creator : "" ) )
     977                break;
    970978        if( i==n )
    971979            str = baseline;
     
    10221030        str = mixed;
    10231031    gtk_label_set_text( GTK_LABEL( di->torrentfile_lb ), str );
     1032
     1033    g_free( infos );
    10241034}
    10251035
     
    10991109enum
    11001110{
     1111    WEBSEED_COL_KEY,
     1112    WEBSEED_COL_WAS_UPDATED,
    11011113    WEBSEED_COL_URL,
    11021114    WEBSEED_COL_DOWNLOAD_RATE,
    1103     WEBSEED_COL_WAS_UPDATED,
    11041115    N_WEBSEED_COLS
    11051116};
     
    11201131{
    11211132    return gtk_list_store_new( N_WEBSEED_COLS,
    1122                                G_TYPE_STRING,
    1123                                G_TYPE_FLOAT,
    1124                                G_TYPE_BOOLEAN );
     1133                               G_TYPE_STRING,   /* key */
     1134                               G_TYPE_BOOLEAN,  /* was-updated */
     1135                               G_TYPE_STRING,   /* url */
     1136                               G_TYPE_FLOAT);   /* download rate */
    11251137}
    11261138
    11271139enum
    11281140{
     1141    PEER_COL_KEY,
     1142    PEER_COL_WAS_UPDATED,
    11291143    PEER_COL_ADDRESS,
    11301144    PEER_COL_ADDRESS_COLLATED,
     
    11371151    PEER_COL_IS_ENCRYPTED,
    11381152    PEER_COL_STATUS,
    1139     PEER_COL_WAS_UPDATED,
    1140     PEER_COL_KEY,
    11411153    N_PEER_COLS
    11421154};
     
    11631175{
    11641176    return gtk_list_store_new( N_PEER_COLS,
     1177                               G_TYPE_STRING,   /* key */
     1178                               G_TYPE_BOOLEAN,  /* was-updated */
    11651179                               G_TYPE_STRING,   /* address */
    11661180                               G_TYPE_STRING,   /* collated address */
     
    11721186                               G_TYPE_INT,      /* progress [0..100] */
    11731187                               G_TYPE_BOOLEAN,  /* isEncrypted */
    1174                                G_TYPE_STRING,   /* flagString */
    1175                                G_TYPE_BOOLEAN,  /* was-updated */
    1176                                G_TYPE_STRING);  /* key */
    1177 }
    1178 
    1179 static void
    1180 init_peer( GtkListStore * store, GtkTreeIter * iter, const char * key, const tr_peer_stat * peer )
    1181 {
    1182     int quads[4];
    1183     char upload_speed[128];
     1188                               G_TYPE_STRING);  /* flagString */
     1189}
     1190
     1191static void
     1192init_peer( GtkListStore        * store,
     1193           GtkTreeIter         * iter,
     1194           const char          * key,
     1195           const tr_peer_stat  * peer )
     1196{
     1197    int q[4];
     1198    char up_speed[128];
     1199    char down_speed[128];
    11841200    char collated_name[128];
    1185     char download_speed[128];
    11861201    const char * client = peer->client;
    11871202
     
    11891204        client = "";
    11901205
    1191     tr_strlspeed( upload_speed, peer->rateToPeer, sizeof( upload_speed ) );
    1192     tr_strlspeed( download_speed, peer->rateToClient, sizeof( download_speed ) );
    1193     if( sscanf( peer->addr, "%d.%d.%d.%d", quads, quads+1, quads+2, quads+3 ) != 4 )
     1206    tr_strlspeed( up_speed, peer->rateToPeer, sizeof( up_speed ) );
     1207    tr_strlspeed( down_speed, peer->rateToClient, sizeof( down_speed ) );
     1208    if( sscanf( peer->addr, "%d.%d.%d.%d", q, q+1, q+2, q+3 ) != 4 )
    11941209        g_strlcpy( collated_name, peer->addr, sizeof( collated_name ) );
    11951210    else
    11961211        g_snprintf( collated_name, sizeof( collated_name ),
    1197                     "%03d.%03d.%03d.%03d", quads[0], quads[1], quads[2], quads[3] );
     1212                    "%03d.%03d.%03d.%03d", q[0], q[1], q[2], q[3] );
    11981213
    11991214    gtk_list_store_set( store, iter,
     
    12131228                  gpointer             data   UNUSED )
    12141229{
    1215     gboolean is_encrypted = FALSE;
    1216 
    1217     gtk_tree_model_get( tree_model, iter, PEER_COL_IS_ENCRYPTED, &is_encrypted, -1 );
     1230    gboolean b = FALSE;
     1231
     1232    gtk_tree_model_get( tree_model, iter, PEER_COL_IS_ENCRYPTED, &b, -1 );
    12181233    g_object_set( renderer, "xalign", (gfloat)0.0,
    12191234                            "yalign", (gfloat)0.5,
    1220                             "stock-id", ( is_encrypted ? "transmission-lock" : NULL ),
     1235                            "stock-id", ( b ? "transmission-lock" : NULL ),
    12211236                            NULL );
     1237}
     1238
     1239static void
     1240refreshPeerRow( GtkListStore        * store,
     1241                GtkTreeIter         * iter,
     1242                const tr_peer_stat  * peer )
     1243{
     1244    char up_speed[128];
     1245    char down_speed[128];
     1246
     1247    if( peer->rateToPeer > 0.01 )
     1248        tr_strlspeed( up_speed, peer->rateToPeer, sizeof( up_speed ) );
     1249    else
     1250        *up_speed = '\0';
     1251
     1252    if( peer->rateToClient > 0.01 )
     1253        tr_strlspeed( down_speed, peer->rateToClient, sizeof( down_speed ) );
     1254    else
     1255        *down_speed = '\0';
     1256
     1257    gtk_list_store_set( store, iter,
     1258                        PEER_COL_PROGRESS, (int)( 100.0 * peer->progress ),
     1259                        PEER_COL_DOWNLOAD_RATE_DOUBLE, peer->rateToClient,
     1260                        PEER_COL_DOWNLOAD_RATE_STRING, down_speed,
     1261                        PEER_COL_UPLOAD_RATE_DOUBLE, peer->rateToPeer,
     1262                        PEER_COL_UPLOAD_RATE_STRING, up_speed,
     1263                        PEER_COL_STATUS, peer->flagStr,
     1264                        PEER_COL_WAS_UPDATED, TRUE,
     1265                        -1 );
     1266}
     1267
     1268static void
     1269refreshPeerList( struct DetailsImpl * di, tr_torrent ** torrents, int n )
     1270{
     1271    int i;
     1272    int * peerCount;
     1273    GtkTreeIter iter;
     1274    GHashTable * hash = di->peer_hash;
     1275    GtkListStore * store = di->peer_store;
     1276    GtkTreeModel * model = GTK_TREE_MODEL( store );
     1277    struct tr_peer_stat ** peers;
     1278
     1279    /* step 1: get all the peers */
     1280    peers = g_new( struct tr_peer_stat*, n );
     1281    peerCount = g_new( int, n );
     1282    for( i=0; i<n; ++i )
     1283        peers[i] = tr_torrentPeers( torrents[i], &peerCount[i] );
     1284
     1285    /* step 2: mark all the peers in the list as not-updated */
     1286    model = GTK_TREE_MODEL( store );
     1287    if( gtk_tree_model_get_iter_first( model, &iter ) ) do
     1288        gtk_list_store_set( store, &iter, PEER_COL_WAS_UPDATED, FALSE, -1 );
     1289    while( gtk_tree_model_iter_next( model, &iter ) );
     1290
     1291    /* step 3: add any new peers */
     1292    for( i=0; i<n; ++i ) {
     1293        int j;
     1294        const tr_torrent * tor = torrents[i];
     1295        for( j=0; j<peerCount[i]; ++j ) {
     1296            const tr_peer_stat * s = &peers[i][j];
     1297            char key[128];
     1298            g_snprintf( key, sizeof( key ), "%d.%s", tr_torrentId(tor), s->addr );
     1299            if( g_hash_table_lookup( hash, key ) == NULL ) {
     1300                GtkTreePath * path;
     1301                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 );
     1305                g_hash_table_insert( hash, g_strdup( key ),
     1306                                     gtk_tree_row_reference_new( model, path ) );
     1307                gtk_tree_path_free( path );
     1308            }
     1309        }
     1310    }
     1311
     1312    /* step 4: update the peers */
     1313    for( i=0; i<n; ++i ) {
     1314        int j;
     1315        const tr_torrent * tor = torrents[i];
     1316        for( j=0; j<peerCount[i]; ++j ) {
     1317            const tr_peer_stat * s = &peers[i][j];
     1318            char key[128];
     1319            GtkTreeRowReference * ref;
     1320            GtkTreePath * path;
     1321            g_snprintf( key, sizeof( key ), "%d.%s", tr_torrentId(tor), s->addr );
     1322            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 );
     1327            refreshPeerRow( store, &iter, s );
     1328            gtk_tree_path_free( path );
     1329        }
     1330    }
     1331
     1332    /* step 5: remove peers that have disappeared */
     1333    model = GTK_TREE_MODEL( store );
     1334    if( gtk_tree_model_get_iter_first( model, &iter ) ) {
     1335        gboolean more = TRUE;
     1336        while( more ) {
     1337            gboolean b;
     1338            gtk_tree_model_get( model, &iter, PEER_COL_WAS_UPDATED, &b, -1 );
     1339            if( b )
     1340                more = gtk_tree_model_iter_next( model, &iter );
     1341            else {
     1342                char * key;
     1343                gtk_tree_model_get( model, &iter, PEER_COL_KEY, &key, -1 );
     1344                /* fprintf( stderr, "removing key %s\n", key ); */
     1345                g_hash_table_remove( hash, key );
     1346                more = gtk_list_store_remove( store, &iter );
     1347                g_free( key );
     1348            }
     1349        }
     1350    }
     1351
     1352    /* step 6: cleanup */
     1353    for( i=0; i<n; ++i )
     1354        tr_torrentPeersFree( peers[i], peerCount[i] );
     1355    tr_free( peers );
     1356    tr_free( peerCount );
     1357}
     1358
     1359static void
     1360refreshWebseedList( struct DetailsImpl * di, tr_torrent ** torrents, int n )
     1361{
     1362    int i;
     1363    int total = 0;
     1364    GtkTreeIter iter;
     1365    GHashTable * hash = di->webseed_hash;
     1366    GtkListStore * store = di->webseed_store;
     1367    GtkTreeModel * model = GTK_TREE_MODEL( store );
     1368   
     1369
     1370    /* step 1: mark all webseeds as not-updated */
     1371    if( gtk_tree_model_get_iter_first( model, &iter ) ) do
     1372        gtk_list_store_set( store, &iter, WEBSEED_COL_WAS_UPDATED, FALSE, -1 );
     1373    while( gtk_tree_model_iter_next( model, &iter ) );
     1374
     1375    /* step 2: add any new webseeds */
     1376    for( i=0; i<n; ++i ) {
     1377        int j;
     1378        const tr_torrent * tor = torrents[i];
     1379        const tr_info * inf = tr_torrentInfo( tor );
     1380        total += inf->webseedCount;
     1381        for( j=0; j<inf->webseedCount; ++j ) {
     1382            char key[256];
     1383            const char * url = inf->webseeds[j];
     1384            g_snprintf( key, sizeof( key ), "%d.%s", tr_torrentId( tor ), url );
     1385            if( g_hash_table_lookup( hash, key ) == NULL ) {
     1386                GtkTreePath * path;
     1387                gtk_list_store_append( store, &iter );
     1388                gtk_list_store_set( store, &iter, WEBSEED_COL_URL, url, -1 );
     1389                path = gtk_tree_model_get_path( model, &iter );
     1390                g_hash_table_insert( hash, g_strdup( key ),
     1391                                     gtk_tree_row_reference_new( model, path ) );
     1392                gtk_tree_path_free( path );
     1393            }
     1394        }
     1395    }
     1396
     1397    /* step 3: update the webseeds */
     1398    for( i=0; i<n; ++i ) {
     1399        int j;
     1400        const tr_torrent * tor = torrents[i];
     1401        const tr_info * inf = tr_torrentInfo( tor );
     1402        float * speeds = tr_torrentWebSpeeds( tor );
     1403        for( j=0; j<inf->webseedCount; ++j ) {
     1404            char key[256];
     1405            const char * url = inf->webseeds[j];
     1406            GtkTreePath * path;
     1407            GtkTreeRowReference * ref;
     1408            g_snprintf( key, sizeof( key ), "%d.%s", tr_torrentId( tor ), url );
     1409            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 );
     1414        }
     1415        tr_free( speeds );
     1416    }
     1417
     1418    /* step 4: remove webseeds that have disappeared */
     1419    if( gtk_tree_model_get_iter_first( model, &iter ) ) {
     1420        gboolean more = TRUE;
     1421        while( more ) {
     1422            gboolean b;
     1423            gtk_tree_model_get( model, &iter, WEBSEED_COL_WAS_UPDATED, &b, -1 );
     1424            if( b )
     1425                more = gtk_tree_model_iter_next( model, &iter );
     1426            else {
     1427                char * key;
     1428                gtk_tree_model_get( model, &iter, WEBSEED_COL_KEY, &key, -1 );
     1429                g_hash_table_remove( hash, key );
     1430                more = gtk_list_store_remove( store, &iter );
     1431                g_free( key );
     1432            }
     1433        }
     1434    }
     1435
     1436    if( total > 0 )
     1437        gtk_widget_show( di->webseed_view );
     1438    else
     1439        gtk_widget_hide( di->webseed_view );
     1440}
     1441
     1442static void
     1443refreshPeers( struct DetailsImpl * di, tr_torrent ** torrents, int n )
     1444{
     1445    int i;
     1446    char buf[512];
     1447    const char * none = _( "None" );
     1448
     1449    /* seeders_lb */
     1450    /* leechers_lb */
     1451    /* completed_lb */
     1452    if( n<=0 ) {
     1453        gtk_label_set_text( GTK_LABEL( di->seeders_lb ), none );
     1454        gtk_label_set_text( GTK_LABEL( di->leechers_lb ), none );
     1455        gtk_label_set_text( GTK_LABEL( di->completed_lb ), none );
     1456    } else {
     1457        int seeders = 0;
     1458        int leechers = 0;
     1459        int completed = 0;
     1460        for( i=0; i<n; ++i ) {
     1461            const tr_stat * s = tr_torrentStat( torrents[i] );
     1462            seeders = s->seeders;
     1463            leechers = s->leechers;
     1464            completed += s->timesCompleted;
     1465        }
     1466        g_snprintf( buf, sizeof( buf ), "%'d", seeders );
     1467        gtk_label_set_text( GTK_LABEL( di->seeders_lb ), buf );
     1468        g_snprintf( buf, sizeof( buf ), "%'d", leechers );
     1469        gtk_label_set_text( GTK_LABEL( di->leechers_lb ), buf );
     1470        g_snprintf( buf, sizeof( buf ), "%'d", completed );
     1471        gtk_label_set_text( GTK_LABEL( di->completed_lb ), buf );
     1472    }
     1473
     1474    refreshPeerList( di, torrents, n );
     1475    refreshWebseedList( di, torrents, n );
    12221476}
    12231477
    12241478#if GTK_CHECK_VERSION( 2,12,0 )
    12251479static gboolean
    1226 onPeerViewQueryTooltip( GtkWidget *            widget,
    1227                         gint                   x,
    1228                         gint                   y,
    1229                         gboolean               keyboard_tip,
    1230                         GtkTooltip *          tooltip,
    1231                         gpointer     user_data UNUSED )
     1480onPeerViewQueryTooltip( GtkWidget   * widget,
     1481                        gint          x,
     1482                        gint          y,
     1483                        gboolean      keyboard_tip,
     1484                        GtkTooltip  * tooltip,
     1485                        gpointer      user_data UNUSED )
    12321486{
    12331487    gboolean       show_tip = FALSE;
     
    12741528#endif
    12751529
    1276 static void
    1277 refreshPeerRow( GtkListStore * store, GtkTreeIter * iter, const tr_peer_stat * peer )
    1278 {
    1279     char upload_speed[128];
    1280     char download_speed[128];
    1281 
    1282     if( peer->rateToPeer > 0.01 )
    1283         tr_strlspeed( upload_speed, peer->rateToPeer, sizeof( upload_speed ) );
    1284     else
    1285         *upload_speed = '\0';
    1286 
    1287     if( peer->rateToClient > 0.01 )
    1288         tr_strlspeed( download_speed, peer->rateToClient, sizeof( download_speed ) );
    1289     else
    1290         *download_speed = '\0';
    1291 
    1292     gtk_list_store_set( store, iter,
    1293                         PEER_COL_PROGRESS, (int)( 100.0 * peer->progress ),
    1294                         PEER_COL_DOWNLOAD_RATE_DOUBLE, peer->rateToClient,
    1295                         PEER_COL_DOWNLOAD_RATE_STRING, download_speed,
    1296                         PEER_COL_UPLOAD_RATE_DOUBLE, peer->rateToPeer,
    1297                         PEER_COL_UPLOAD_RATE_STRING, upload_speed,
    1298                         PEER_COL_STATUS, peer->flagStr,
    1299                         PEER_COL_WAS_UPDATED, TRUE,
    1300                         -1 );
    1301 }
    1302 
    1303 static void
    1304 refreshPeerList( struct DetailsImpl * di, tr_torrent ** torrents, int n )
    1305 {
    1306     int i;
    1307     int * peerCount;
    1308     GtkTreeIter iter;
    1309     GtkTreeModel * model;
    1310     struct tr_peer_stat ** peers;
    1311 
    1312     /* step 1: get all the peers */
    1313     peers = g_new( struct tr_peer_stat*, n );
    1314     peerCount = g_new( int, n );
    1315     for( i=0; i<n; ++i )
    1316         peers[i] = tr_torrentPeers( torrents[i], &peerCount[i] );
    1317 
    1318     /* step 2: mark all the peers in the list as not-updated */
    1319     model = GTK_TREE_MODEL( di->peer_store );
    1320     if( gtk_tree_model_get_iter_first( model, &iter ) ) do
    1321         gtk_list_store_set( di->peer_store, &iter, PEER_COL_WAS_UPDATED, FALSE, -1 );
    1322     while( gtk_tree_model_iter_next( model, &iter ) );
    1323 
    1324     /* step 3: add any new peers */
    1325     for( i=0; i<n; ++i ) {
    1326         int j;
    1327         const tr_torrent * tor = torrents[i];
    1328         for( j=0; j<peerCount[i]; ++j ) {
    1329             const tr_peer_stat * s = &peers[i][j];
    1330             char key[128];
    1331             g_snprintf( key, sizeof( key ), "%d.%s", tr_torrentId(tor), s->addr );
    1332             if( g_hash_table_lookup( di->peer_hash, key ) == NULL ) {
    1333                 GtkTreePath * path;
    1334                 gtk_list_store_append( di->peer_store, &iter );
    1335                 init_peer( di->peer_store, &iter, key, s );
    1336                 /* fprintf( stderr, "adding peer key %s\n", key ); */
    1337                 path = gtk_tree_model_get_path( model, &iter );
    1338                 g_hash_table_insert( di->peer_hash, g_strdup( key ), gtk_tree_row_reference_new( model, path ) );
    1339                 gtk_tree_path_free( path );
    1340             }
    1341         }
    1342     }
    1343 
    1344     /* step 4: update the peers */
    1345     for( i=0; i<n; ++i ) {
    1346         int j;
    1347         const tr_torrent * tor = torrents[i];
    1348         for( j=0; j<peerCount[i]; ++j ) {
    1349             const tr_peer_stat * s = &peers[i][j];
    1350             char key[128];
    1351             GtkTreeRowReference * ref;
    1352             GtkTreePath * path;
    1353             g_snprintf( key, sizeof( key ), "%d.%s", tr_torrentId(tor), s->addr );
    1354             ref = g_hash_table_lookup( di->peer_hash, key );
    1355             assert( ref != NULL );
    1356             path = gtk_tree_row_reference_get_path( ref );
    1357             assert( path );
    1358             gtk_tree_model_get_iter( model, &iter, path );
    1359             refreshPeerRow( di->peer_store, &iter, s );
    1360             gtk_tree_path_free( path );
    1361         }
    1362     }
    1363 
    1364     /* step 5: remove peers that have disappeared */
    1365     model = GTK_TREE_MODEL( di->peer_store );
    1366     if( gtk_tree_model_get_iter_first( model, &iter ) ) {
    1367         gboolean more = TRUE;
    1368         while( more ) {
    1369             gboolean wasUpdated;
    1370             gtk_tree_model_get( model, &iter, PEER_COL_WAS_UPDATED, &wasUpdated, -1 );
    1371             if( wasUpdated )
    1372                 more = gtk_tree_model_iter_next( model, &iter );
    1373             else {
    1374                 char * key;
    1375                 gtk_tree_model_get( model, &iter, PEER_COL_KEY, &key, -1 );
    1376                 /* fprintf( stderr, "removing key %s\n", key ); */
    1377                 g_hash_table_remove( di->peer_hash, key );
    1378                 more = gtk_list_store_remove( di->peer_store, &iter );
    1379                 g_free( key );
    1380             }
    1381         }
    1382     }
    1383 
    1384     /* step 6: cleanup */
    1385     for( i=0; i<n; ++i )
    1386         tr_torrentPeersFree( peers[i], peerCount[i] );
    1387     tr_free( peers );
    1388     tr_free( peerCount );
    1389 }
    1390 
    1391 static void
    1392 refreshWebseedList( struct DetailsImpl * di, tr_torrent ** torrents, int n )
    1393 {
    1394     int i;
    1395     int total = 0;
    1396     GtkTreeIter iter;
    1397     GHashTable * hash = di->webseed_hash;
    1398     GtkListStore * store = di->webseed_store;
    1399     GtkTreeModel * model = GTK_TREE_MODEL( store );
    1400 
    1401     /* step 1: mark all webseeds as not-updated */
    1402     if( gtk_tree_model_get_iter_first( model, &iter ) ) do
    1403         gtk_list_store_set( store, &iter, WEBSEED_COL_WAS_UPDATED, FALSE, -1 );
    1404     while( gtk_tree_model_iter_next( model, &iter ) );
    1405 
    1406     /* step 2: add any new webseeds */
    1407     for( i=0; i<n; ++i ) {
    1408         int j;
    1409         const tr_torrent * tor = torrents[i];
    1410         const tr_info * inf = tr_torrentInfo( tor );
    1411         total += inf->webseedCount;
    1412         for( j=0; j<inf->webseedCount; ++j ) {
    1413             char key[256];
    1414             const char * url = inf->webseeds[j];
    1415             g_snprintf( key, sizeof( key ), "%d.%s", tr_torrentId( tor ), url );
    1416             if( g_hash_table_lookup( hash, key ) == NULL ) {
    1417                 GtkTreePath * path;
    1418                 gtk_list_store_append( store, &iter );
    1419                 gtk_list_store_set( store, &iter, WEBSEED_COL_URL, url, -1 );
    1420                 path = gtk_tree_model_get_path( model, &iter );
    1421                 g_hash_table_insert( hash, g_strdup( key ), gtk_tree_row_reference_new( model, path ) );
    1422                 gtk_tree_path_free( path );
    1423             }
    1424         }
    1425     }
    1426 
    1427     /* step 3: update the webseeds */
    1428     for( i=0; i<n; ++i ) {
    1429         int j;
    1430         const tr_torrent * tor = torrents[i];
    1431         const tr_info * inf = tr_torrentInfo( tor );
    1432         float * speeds = tr_torrentWebSpeeds( tor );
    1433         for( j=0; j<inf->webseedCount; ++j ) {
    1434             char key[256];
    1435             const char * url = inf->webseeds[j];
    1436             GtkTreePath * path;
    1437             GtkTreeRowReference * ref;
    1438             g_snprintf( key, sizeof( key ), "%d.%s", tr_torrentId( tor ), url );
    1439             ref = g_hash_table_lookup( hash, key );
    1440             path = gtk_tree_row_reference_get_path( ref );
    1441             gtk_tree_model_get_iter( model, &iter, path );
    1442             gtk_list_store_set( store, &iter, WEBSEED_COL_DOWNLOAD_RATE, (int)(100.0*speeds[j]), -1 );
    1443             gtk_tree_path_free( path );
    1444         }
    1445         tr_free( speeds );
    1446     }
    1447 
    1448     /* step 4: remove webseeds that have disappeared */
    1449     if( gtk_tree_model_get_iter_first( model, &iter ) ) {
    1450         gboolean more = TRUE;
    1451         while( more ) {
    1452             gboolean wasUpdated;
    1453             gtk_tree_model_get( model, &iter, WEBSEED_COL_WAS_UPDATED, &wasUpdated, -1 );
    1454             if( wasUpdated )
    1455                 more = gtk_tree_model_iter_next( model, &iter );
    1456             else {
    1457                 char * key;
    1458                 gtk_tree_model_get( model, &iter, PEER_COL_KEY, &key, -1 );
    1459                 g_hash_table_remove( hash, key );
    1460                 more = gtk_list_store_remove( store, &iter );
    1461                 g_free( key );
    1462             }
    1463         }
    1464     }
    1465 
    1466     if( total > 0 )
    1467         gtk_widget_show( di->webseed_view );
    1468     else
    1469         gtk_widget_hide( di->webseed_view );
    1470 }
    1471 
    1472 static void
    1473 refreshPeers( struct DetailsImpl * di, tr_torrent ** torrents, int n )
    1474 {
    1475     int i;
    1476     char buf[512];
    1477     const char * none = _( "None" );
    1478 
    1479     /* seeders_lb */
    1480     /* leechers_lb */
    1481     /* completed_lb */
    1482     if( n<=0 ) {
    1483         gtk_label_set_text( GTK_LABEL( di->seeders_lb ), none );
    1484         gtk_label_set_text( GTK_LABEL( di->leechers_lb ), none );
    1485         gtk_label_set_text( GTK_LABEL( di->completed_lb ), none );
    1486     } else {
    1487         int seeders = 0;
    1488         int leechers = 0;
    1489         int completed = 0;
    1490         for( i=0; i<n; ++i ) {
    1491             const tr_stat * s = tr_torrentStat( torrents[i] );
    1492             seeders = s->seeders;
    1493             leechers = s->leechers;
    1494             completed += s->timesCompleted;
    1495         }
    1496         g_snprintf( buf, sizeof( buf ), "%'d", seeders );
    1497         gtk_label_set_text( GTK_LABEL( di->seeders_lb ), buf );
    1498         g_snprintf( buf, sizeof( buf ), "%'d", leechers );
    1499         gtk_label_set_text( GTK_LABEL( di->leechers_lb ), buf );
    1500         g_snprintf( buf, sizeof( buf ), "%'d", completed );
    1501         gtk_label_set_text( GTK_LABEL( di->completed_lb ), buf );
    1502     }
    1503 
    1504     refreshPeerList( di, torrents, n );
    1505     refreshWebseedList( di, torrents, n );
    1506 }
    1507 
    15081530static GtkWidget*
    15091531peer_page_new( struct DetailsImpl * di )
    15101532{
    15111533    guint i;
     1534    const char * str;
    15121535    GtkListStore *store;
    15131536    GtkWidget *v, *w, *ret, *sw, *l, *vbox, *hbox;
    15141537    GtkWidget *webtree = NULL;
    1515 
    1516     /* TODO: make this configurable? */
     1538    GtkTreeViewColumn * c;
     1539    GtkCellRenderer *   r;
    15171540    int view_columns[] = { PEER_COL_IS_ENCRYPTED,
    15181541                           PEER_COL_UPLOAD_RATE_STRING,
     
    15241547
    15251548
    1526     {
    1527         GtkListStore * store;
    1528         GtkTreeViewColumn * c;
    1529         GtkCellRenderer *   r;
    1530         const char *        t;
    1531         GtkWidget *         w;
    1532         GtkWidget *         v;
    1533 
    1534         store = di->webseed_store = webseed_model_new( );
    1535         v = gtk_tree_view_new_with_model( GTK_TREE_MODEL( store ) );
    1536         g_signal_connect( v, "button-release-event", G_CALLBACK( on_tree_view_button_released ), NULL );
    1537         gtk_tree_view_set_rules_hint( GTK_TREE_VIEW( v ), TRUE );
    1538         //p->webseeds = GTK_LIST_STORE( GTK_TREE_MODEL( store ) );
    1539         g_object_unref( G_OBJECT( store ) );
    1540 
    1541         t = getWebseedColumnNames( WEBSEED_COL_URL );
    1542         r = gtk_cell_renderer_text_new( );
    1543         g_object_set( G_OBJECT( r ), "ellipsize", PANGO_ELLIPSIZE_END, NULL );
    1544         c = gtk_tree_view_column_new_with_attributes( t, r, "text", WEBSEED_COL_URL, NULL );
    1545         g_object_set( G_OBJECT( c ), "expand", TRUE, NULL );
    1546         gtk_tree_view_column_set_sort_column_id( c, WEBSEED_COL_URL );
    1547         gtk_tree_view_append_column( GTK_TREE_VIEW( v ), c );
    1548 
    1549         t = getWebseedColumnNames( WEBSEED_COL_DOWNLOAD_RATE );
    1550         r = gtk_cell_renderer_text_new( );
    1551         c = gtk_tree_view_column_new_with_attributes( t, r, "text", WEBSEED_COL_DOWNLOAD_RATE, NULL );
    1552         gtk_tree_view_column_set_sort_column_id( c, WEBSEED_COL_DOWNLOAD_RATE );
    1553         gtk_tree_view_append_column( GTK_TREE_VIEW( v ), c );
    1554 
    1555         w = gtk_scrolled_window_new( NULL, NULL );
    1556         gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
    1557         gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ), GTK_SHADOW_IN );
    1558         gtk_container_add( GTK_CONTAINER( w ), v );
    1559 
    1560         webtree = w;
    1561         di->webseed_view = w;
    1562     }
     1549    /* webseeds */
     1550
     1551    store = di->webseed_store = webseed_model_new( );
     1552    v = gtk_tree_view_new_with_model( GTK_TREE_MODEL( store ) );
     1553    g_signal_connect( v, "button-release-event", G_CALLBACK( on_tree_view_button_released ), NULL );
     1554    gtk_tree_view_set_rules_hint( GTK_TREE_VIEW( v ), TRUE );
     1555    g_object_unref( G_OBJECT( store ) );
     1556
     1557    str = getWebseedColumnNames( WEBSEED_COL_URL );
     1558    r = gtk_cell_renderer_text_new( );
     1559    g_object_set( G_OBJECT( r ), "ellipsize", PANGO_ELLIPSIZE_END, NULL );
     1560    c = gtk_tree_view_column_new_with_attributes( str, r, "text", WEBSEED_COL_URL, NULL );
     1561    g_object_set( G_OBJECT( c ), "expand", TRUE, NULL );
     1562    gtk_tree_view_column_set_sort_column_id( c, WEBSEED_COL_URL );
     1563    gtk_tree_view_append_column( GTK_TREE_VIEW( v ), c );
     1564
     1565    str = getWebseedColumnNames( WEBSEED_COL_DOWNLOAD_RATE );
     1566    r = gtk_cell_renderer_text_new( );
     1567    c = gtk_tree_view_column_new_with_attributes( str, r, "text", WEBSEED_COL_DOWNLOAD_RATE, NULL );
     1568    gtk_tree_view_column_set_sort_column_id( c, WEBSEED_COL_DOWNLOAD_RATE );
     1569    gtk_tree_view_append_column( GTK_TREE_VIEW( v ), c );
     1570
     1571    w = gtk_scrolled_window_new( NULL, NULL );
     1572    gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ),
     1573                                    GTK_POLICY_AUTOMATIC,
     1574                                    GTK_POLICY_AUTOMATIC );
     1575    gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ),
     1576                                         GTK_SHADOW_IN );
     1577    gtk_container_add( GTK_CONTAINER( w ), v );
     1578
     1579    webtree = w;
     1580    di->webseed_view = w;
     1581
     1582    /* peers */
    15631583
    15641584    store  = di->peer_store = peer_store_new( );
     
    15791599                      G_CALLBACK( on_tree_view_button_released ), NULL );
    15801600
    1581     for( i = 0; i < G_N_ELEMENTS( view_columns ); ++i )
     1601    for( i=0; i<G_N_ELEMENTS( view_columns ); ++i )
    15821602    {
    15831603        const int           col = view_columns[i];
    15841604        const char *        t = getPeerColumnName( col );
    15851605        int                 sort_col = col;
    1586         GtkTreeViewColumn * c;
    1587         GtkCellRenderer *   r;
    15881606
    15891607        switch( col )
     
    16771695    l = di->seeders_lb = gtk_label_new( NULL );
    16781696    gtk_box_pack_start( GTK_BOX( hbox ), l, FALSE, FALSE, 0 );
    1679     gtk_box_pack_start( GTK_BOX( hbox ), gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f ), TRUE, TRUE, 0 );
     1697    w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
     1698    gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
    16801699    l = gtk_label_new( NULL );
    16811700    gtk_label_set_markup( GTK_LABEL( l ), _( "<b>Leechers:</b>" ) );
     
    16831702    l = di->leechers_lb = gtk_label_new( NULL );
    16841703    gtk_box_pack_start( GTK_BOX( hbox ), l, FALSE, FALSE, 0 );
    1685     gtk_box_pack_start( GTK_BOX( hbox ), gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f ), TRUE, TRUE, 0 );
     1704    w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
     1705    gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
    16861706    l = gtk_label_new( NULL );
    16871707    gtk_label_set_markup( GTK_LABEL( l ), _( "<b>Times Completed:</b>" ) );
     
    17121732*****  TRACKER
    17131733****/
    1714 
    1715 #define TRACKER_PAGE "tracker-page"
    1716 
    1717 struct tracker_page
    1718 {
    1719     GtkTreeView * view;
    1720     GtkListStore * store;
    1721     GtkTreeSelection * sel;
    1722 
    1723     GtkWidget * add_button;
    1724     GtkWidget * remove_button;
    1725     GtkWidget * save_button;
    1726     GtkWidget * revert_button;
    1727 
    1728 };
    17291734
    17301735static void
     
    18801885
    18811886
    1882     /* tracker list */
     1887    g_free( stats );
    18831888}
    18841889
     
    19761981
    19771982static void
    1978 details_impl_free( gpointer gdata )
     1983details_free( gpointer gdata )
    19791984{
    19801985    struct DetailsImpl * data = gdata;
     
    19962001torrent_inspector_new( GtkWindow * parent, TrCore * core )
    19972002{
    1998     char title[512];
     2003    guint tag;
    19992004    struct DetailsImpl * data;
    20002005    GtkWidget * d, * n, * w, * l;
     
    20032008    data = g_new0( struct DetailsImpl, 1 );
    20042009    data->core = core;
    2005     /*FIXME g_snprintf( title, sizeof( title ), _( "%s Properties" ), info->name );*/
    2006     d = gtk_dialog_new_with_buttons( title, parent, 0,
     2010    d = gtk_dialog_new_with_buttons( NULL, parent, 0,
    20072011                                     GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
    20082012                                     NULL );
     
    20112015    gtk_dialog_set_has_separator( GTK_DIALOG( d ), FALSE );
    20122016    gtk_container_set_border_width( GTK_CONTAINER( d ), GUI_PAD );
    2013     g_object_set_data_full( G_OBJECT( d ), DETAILS_KEY, data, details_impl_free );
     2017    g_object_set_data_full( G_OBJECT( d ), DETAILS_KEY, data, details_free );
    20142018
    20152019    n = gtk_notebook_new( );
     
    20442048    gtk_box_pack_start( GTK_BOX( GTK_DIALOG( d )->vbox ), n, TRUE, TRUE, 0 );
    20452049
    2046     data->periodic_refresh_tag = gtr_timeout_add_seconds( UPDATE_INTERVAL_SECONDS, periodic_refresh, data );
     2050    tag = gtr_timeout_add_seconds( UPDATE_INTERVAL_SECONDS, periodic_refresh, data );
     2051    data->periodic_refresh_tag = tag;
    20472052    periodic_refresh( data );
    20482053    gtk_widget_show_all( GTK_DIALOG( d )->vbox );
     
    20542059{
    20552060    struct DetailsImpl * data = g_object_get_data( G_OBJECT( w ), DETAILS_KEY );
     2061    const int len = g_slist_length( ids );
     2062    char title[256];
    20562063
    20572064    g_slist_free( data->ids );
    20582065    data->ids = g_slist_copy( ids );
    20592066
    2060     if( g_slist_length( ids ) == 1 ) {
     2067    if( len == 1 )
     2068    {
    20612069        const int id = GPOINTER_TO_INT( ids->data );
     2070        tr_session * session = tr_core_session( data->core );
     2071        tr_torrent * tor = tr_torrentFindFromId( session, id );
     2072        const tr_info * inf = tr_torrentInfo( tor );
     2073        g_snprintf( title, sizeof( title ), _( "%s Properties" ), inf->name );
     2074
    20622075        file_list_set_torrent( data->file_list, id );
    20632076        tracker_list_set_torrent( data->tracker_list, id );
    2064     } else {
     2077       
     2078    }
     2079   else
     2080   {
    20652081        file_list_clear( data->file_list );
    20662082        tracker_list_clear( data->tracker_list );
    2067     }
     2083        g_snprintf( title, sizeof( title ), _( "%'d Torrent Properties" ), len );
     2084    }
     2085
     2086    gtk_window_set_title( GTK_WINDOW( w ), title );
    20682087
    20692088    refresh( data );
  • trunk/gtk/file-list.c

    r8279 r8281  
    320320
    321321        /* clean up the temporary variables */
     322        tr_torrentFilesFree( data->refresh_file_stat, fileCount );
    322323        data->refresh_file_stat = NULL;
    323         tr_torrentFilesFree( data->refresh_file_stat, fileCount );
    324324        data->tor = NULL;
    325325    }
  • trunk/gtk/tracker-list.c

    r8279 r8281  
    2525#include "file-list.h"
    2626#include "tracker-list.h"
    27 #include "tr-torrent.h"
    2827#include "hig.h"
    2928#include "util.h"
     
    335334    buttons = gtk_vbox_new( TRUE, GUI_PAD );
    336335
    337     //m = tracker_model_new( tr_torrent_handle( gtor ) );
    338     //page->store = GTK_LIST_STORE( m );
    339336    w = gtk_tree_view_new( );
    340337    g_signal_connect( w, "button-release-event",
Note: See TracChangeset for help on using the changeset viewer.