Changeset 8205


Ignore:
Timestamp:
Apr 10, 2009, 5:44:17 PM (12 years ago)
Author:
charles
Message:

(1.5x gtk) minor backports:
(1) remove dead code
(2) minor improvements to the filterbar buttons
(3) various minor formatting changes to reduce the diffs between 1.52 and trunk

Location:
branches/1.5x/gtk
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • branches/1.5x/gtk/actions.c

    r7910 r8205  
    4545static GtkRadioActionEntry sort_radio_entries[] =
    4646{
    47     { "sort-by-activity", NULL,      N_( "Sort by _Activity" ),        NULL,
    48       NULL, 0 },
    49     { "sort-by-name",     NULL,        N_( "Sort by _Name" ),     NULL,
    50       NULL, 1 },
    51     { "sort-by-progress", NULL,        N_( "Sort by _Progress" ), NULL,
    52       NULL, 2 },
    53     { "sort-by-ratio",    NULL,        N_( "Sort by _Ratio" ),    NULL,
    54       NULL, 3 },
    55     { "sort-by-state",    NULL,        N_( "Sort by _State" ),    NULL,
    56       NULL, 4 },
    57     { "sort-by-tracker",  NULL,        N_( "Sort by _Tracker" ),  NULL,
    58       NULL, 5 },
    59     { "sort-by-age",      NULL,        N_( "Sort by A_ge" ),      NULL,
    60       NULL, 6 }
     47    { "sort-by-activity", NULL, N_( "Sort by _Activity" ), NULL, NULL, 0 },
     48    { "sort-by-name",     NULL, N_( "Sort by _Name" ),     NULL, NULL, 1 },
     49    { "sort-by-progress", NULL, N_( "Sort by _Progress" ), NULL, NULL, 2 },
     50    { "sort-by-ratio",    NULL, N_( "Sort by _Ratio" ),    NULL, NULL, 3 },
     51    { "sort-by-state",    NULL, N_( "Sort by _State" ),    NULL, NULL, 4 },
     52    { "sort-by-tracker",  NULL, N_( "Sort by _Tracker" ),  NULL, NULL, 5 },
     53    { "sort-by-age",      NULL, N_( "Sort by A_ge" ),      NULL, NULL, 6 }
    6154};
    6255
     
    7568static GtkToggleActionEntry show_toggle_entries[] =
    7669{
    77     { "toggle-main-window", NULL,
    78       N_( "_Main Window" ), NULL, NULL, G_CALLBACK( action_cb ), TRUE },
    79     { "toggle-message-log", NULL,
    80       N_( "Message _Log" ), NULL, NULL, G_CALLBACK( action_cb ), FALSE }
     70    { "toggle-main-window", NULL, N_( "_Main Window" ), NULL, NULL, G_CALLBACK( action_cb ), TRUE },
     71    { "toggle-message-log", NULL, N_( "Message _Log" ), NULL, NULL, G_CALLBACK( action_cb ), FALSE }
    8172};
    8273
  • branches/1.5x/gtk/conf.c

    r8048 r8205  
    402402    if( g_file_get_contents( oldfile, &contents, &contents_len, NULL )
    403403      && !tr_bencLoad( contents, contents_len, &top, NULL )
    404       && top.type == TYPE_DICT )
     404      && tr_bencIsDict( &top ) )
    405405    {
    406406        unsigned int i;
  • branches/1.5x/gtk/details.c

    r7950 r8205  
    3333
    3434/****
    35 *****  PIECES VIEW
    36 ****/
    37 
    38 /* define SHOW_PIECES */
    39 
    40 #ifdef SHOW_PIECES
    41 static int
    42 getGridSize( int   pieceCount,
    43              int * n_rows,
    44              int * n_cols )
    45 {
    46     const int MAX_ACROSS = 16;
    47 
    48     if( pieceCount >= ( MAX_ACROSS * MAX_ACROSS ) )
    49     {
    50         *n_rows = *n_cols = MAX_ACROSS;
    51         return MAX_ACROSS * MAX_ACROSS;
    52     }
    53     else
    54     {
    55         int i;
    56         for( i = 0; ( i * i ) < pieceCount; ++i ) ;
    57         *n_rows = *n_cols = i;
    58         return pieceCount;
    59     }
    60 }
    61 
    62  #define TO16( a ) ( (guint16)( ( a << 8 ) | ( a ) ) )
    63  #define RGB_2_GDK( R, G, B ) { 0, TO16( R ), TO16( G ), TO16( B ) }
    64 
    65 enum { DRAW_AVAIL, DRAW_PROG };
    66 
    67 static void
    68 release_gobject_array( gpointer data )
    69 {
    70     int       i;
    71     GObject **objects = (GObject**) data;
    72 
    73     for( i = 0; objects[i] != NULL; ++i )
    74         g_object_unref ( G_OBJECT( objects[i] ) );
    75     g_free ( objects );
    76 }
    77 
    78 static gboolean
    79 refresh_pieces( GtkWidget *            da,
    80                 GdkEventExpose * event UNUSED,
    81                 gpointer               gtor )
    82 {
    83     tr_torrent *       tor = tr_torrent_handle( TR_TORRENT( gtor ) );
    84     const tr_info *    info = tr_torrent_info( TR_TORRENT( gtor ) );
    85     int                mode =
    86         GPOINTER_TO_INT ( g_object_get_data ( G_OBJECT( da ), "draw-mode" ) );
    87 
    88     GdkColormap *      colormap = gtk_widget_get_colormap ( da );
    89     const int          widget_w = da->allocation.width;
    90     const int          widget_h = da->allocation.height;
    91     int                n_rows, n_cols;
    92     const int          n_cells = getGridSize ( info->pieceCount,  &n_rows,
    93                                                &n_cols );
    94     const GdkRectangle grid_bounds = { 0, 0, widget_w, widget_h };
    95     const double       piece_w = grid_bounds.width / (double)n_cols;
    96     const double       piece_h = grid_bounds.height / (double)n_rows;
    97     const int          piece_w_int = (int) ( piece_w + 1 ); /* pad for roundoff
    98                                                               */
    99     const int          piece_h_int = (int) ( piece_h + 1 ); /* pad for roundoff
    100                                                               */
    101     const gboolean     rtl = gtk_widget_get_direction( da ) ==
    102                              GTK_TEXT_DIR_RTL;
    103 
    104     guint8 *           prev_color = NULL;
    105     gboolean           first_time = FALSE;
    106 
    107     int                i, x, y;
    108     int8_t *           pieces = NULL;
    109     float *            completeness = NULL;
    110 
    111     /**
    112     ***  Get the Graphics Contexts...
    113     **/
    114 
    115     enum { ALL, LOTS, SOME, FEW, NONE,
    116            BLACK, GRAY, BLINK,
    117            N_COLORS };
    118     GdkGC **           gcs = (GdkGC**) g_object_get_data ( G_OBJECT(
    119                                                                da ),
    120                                                            "graphics-contexts" );
    121     if( gcs == NULL )
    122     {
    123         const GdkColor colors[N_COLORS] = {
    124             RGB_2_GDK ( 114, 159, 207 ), /* all */
    125             RGB_2_GDK (  52, 101, 164 ), /* lots */
    126             RGB_2_GDK (  32,  74, 135 ), /* some */
    127             RGB_2_GDK (  85,  87, 83 ), /* few */
    128             RGB_2_GDK ( 238, 238, 236 ), /* none - tango aluminum highlight */
    129             RGB_2_GDK (  46,  52, 54 ), /* black - tango slate shadow */
    130             RGB_2_GDK ( 186, 189, 182 ), /* gray - tango aluminum shadow */
    131             RGB_2_GDK ( 252, 233, 79 ), /* blink - tango butter highlight */
    132         };
    133 
    134         gcs = g_new ( GdkGC *, N_COLORS + 1 );
    135 
    136         for( i = 0; i < N_COLORS; ++i )
    137         {
    138             gcs[i] = gdk_gc_new ( da->window );
    139             gdk_gc_set_colormap ( gcs[i], colormap );
    140             gdk_gc_set_rgb_fg_color ( gcs[i], &colors[i] );
    141             gdk_gc_set_rgb_bg_color ( gcs[i], &colors[i] );
    142         }
    143 
    144         gcs[N_COLORS] = NULL; /* a sentinel in the release function */
    145         g_object_set_data_full ( G_OBJECT( da ), "graphics-contexts",
    146                                  gcs, release_gobject_array );
    147     }
    148 
    149     /**
    150     ***  Get the cells' previous colors...
    151     ***  (this is used for blinking when the color changes)
    152     **/
    153 
    154     prev_color = (guint8*) g_object_get_data ( G_OBJECT( da ), "prev-color" );
    155     if( prev_color == NULL )
    156     {
    157         first_time = TRUE;
    158         prev_color = g_new0 ( guint8, n_cells );
    159         g_object_set_data_full ( G_OBJECT(
    160                                      da ), "prev-color", prev_color, g_free );
    161     }
    162 
    163     /**
    164     ***  Get the piece data values...
    165     **/
    166 
    167     switch( mode )
    168     {
    169         case DRAW_AVAIL:
    170             pieces = g_new ( int8_t, n_cells );
    171             tr_torrentAvailability ( tor, pieces, n_cells );
    172             break;
    173 
    174         case DRAW_PROG:
    175             completeness = g_new ( float, n_cells );
    176             tr_torrentAmountFinished ( tor, completeness, n_cells );
    177             break;
    178 
    179         default:
    180             g_error( "no mode defined!" );
    181     }
    182 
    183     /**
    184     ***  Draw...
    185     **/
    186 
    187     i = 0;
    188     for( y = 0; y < n_rows; ++y )
    189     {
    190         for( x = 0; x < n_cols; ++x )
    191         {
    192             int draw_x = grid_bounds.x + (int)( x * piece_w );
    193             int draw_y = grid_bounds.y + (int)( y * piece_h );
    194             int color = BLACK;
    195             int border = BLACK;
    196 
    197             if( rtl )
    198                 draw_x = grid_bounds.x + grid_bounds.width -
    199                          (int)( ( x + 1 ) * piece_w );
    200             else
    201                 draw_x = grid_bounds.x + (int)( x * piece_w );
    202             draw_y = grid_bounds.y + (int)( y * piece_h );
    203 
    204             if( i < n_cells )
    205             {
    206                 border = GRAY;
    207 
    208                 if( mode == DRAW_AVAIL )
    209                 {
    210                     const int8_t val = pieces[i];
    211                     if( val <  0 ) color = ALL;
    212                     else if( val == 0 ) color = NONE;
    213                     else if( val <= 4 ) color = FEW;
    214                     else if( val <= 8 ) color = SOME;
    215                     else color = LOTS;
    216                 }
    217                 else /* completeness */
    218                 {
    219                     const float val = completeness[i];
    220                     if( val >= 1.00 ) color = ALL;
    221                     else if( val >= 0.66 ) color = LOTS;
    222                     else if( val >= 0.33 ) color = SOME;
    223                     else if( val >= 0.01 ) color = FEW;
    224                     else color = NONE;
    225                 }
    226 
    227                 /* draw a "blink" for one interval when a piece changes */
    228                 if( first_time )
    229                     prev_color[i] = color;
    230                 else if( color != prev_color[i] )
    231                 {
    232                     prev_color[i] = color;
    233                     color = border = BLINK;
    234                 }
    235             }
    236 
    237             gdk_draw_rectangle ( da->window, gcs[color], TRUE,
    238                                  draw_x, draw_y,
    239                                  piece_w_int, piece_h_int );
    240 
    241             if( i < n_cells )
    242                 gdk_draw_rectangle ( da->window, gcs[border], FALSE,
    243                                      draw_x, draw_y,
    244                                      piece_w_int, piece_h_int );
    245 
    246             ++i;
    247         }
    248     }
    249 
    250     gdk_draw_rectangle ( da->window, gcs[GRAY], FALSE,
    251                          grid_bounds.x, grid_bounds.y,
    252                          grid_bounds.width - 1, grid_bounds.height - 1 );
    253 
    254     g_free ( pieces );
    255     g_free ( completeness );
    256     return FALSE;
    257 }
    258 
    259 #endif
    260 
    261 /****
    26235*****  PEERS TAB
    26336****/
     
    376149        GtkTreeIter iter;
    377150        gtk_list_store_append( store, &iter );
    378         peer_row_set ( store, &iter, &peers[i] );
     151        peer_row_set( store, &iter, &peers[i] );
    379152    }
    380153}
     
    383156peer_model_new( tr_torrent * tor )
    384157{
    385     GtkListStore * m = gtk_list_store_new ( N_PEER_COLS,
    386                                             G_TYPE_STRING, /* addr */
    387                                             G_TYPE_FLOAT, /* downloadFromRate */
    388                                             G_TYPE_FLOAT, /* uploadToRate */
    389                                             G_TYPE_STRING, /* client */
    390                                             G_TYPE_INT,   /* progress [0..100] */
    391                                             G_TYPE_BOOLEAN, /* isEncrypted */
    392                                             G_TYPE_STRING ); /* flagString */
     158    GtkListStore * m = gtk_list_store_new( N_PEER_COLS,
     159                                           G_TYPE_STRING, /* addr */
     160                                           G_TYPE_FLOAT, /* downloadFromRate */
     161                                           G_TYPE_FLOAT, /* uploadToRate */
     162                                           G_TYPE_STRING, /* client */
     163                                           G_TYPE_INT,   /* progress [0..100] */
     164                                           G_TYPE_BOOLEAN, /* isEncrypted */
     165                                           G_TYPE_STRING ); /* flagString */
    393166
    394167    int            n_peers = 0;
    395     tr_peer_stat * peers = tr_torrentPeers ( tor, &n_peers );
    396 
    397     qsort ( peers, n_peers, sizeof( tr_peer_stat ), compare_peers );
    398     append_peers_to_model ( m, peers, n_peers );
     168    tr_peer_stat * peers = tr_torrentPeers( tor, &n_peers );
     169
     170    qsort( peers, n_peers, sizeof( tr_peer_stat ), compare_peers );
     171    append_peers_to_model( m, peers, n_peers );
    399172    tr_torrentPeersFree( peers, 0 );
    400     return GTK_TREE_MODEL ( m );
     173    return GTK_TREE_MODEL( m );
    401174}
    402175
     
    410183    gboolean is_encrypted = FALSE;
    411184
    412     gtk_tree_model_get ( tree_model, iter, PEER_COL_IS_ENCRYPTED,
    413                          &is_encrypted,
    414                          -1 );
    415     g_object_set ( renderer, "xalign", (gfloat)0.0,
    416                    "yalign", (gfloat)0.5,
    417                    "stock-id", ( is_encrypted ? "transmission-lock" : NULL ),
    418                    NULL );
     185    gtk_tree_model_get( tree_model, iter, PEER_COL_IS_ENCRYPTED, &is_encrypted, -1 );
     186    g_object_set( renderer, "xalign", (gfloat)0.0,
     187                            "yalign", (gfloat)0.5,
     188                            "stock-id", ( is_encrypted ? "transmission-lock" : NULL ),
     189                            NULL );
     190}
     191
     192static void
     193render_speed( GtkCellRenderer  * renderer,
     194              GtkTreeModel     * tree_model,
     195              GtkTreeIter      * iter,
     196              int                col )
     197{
     198    float rate = 0.0;
     199    char str[64];
     200    gtk_tree_model_get( tree_model, iter, col, &rate, -1 );
     201    if( rate < 0.01 )
     202        *str = '\0';
     203    else
     204        tr_strlspeed( str, rate, sizeof( str ) );
     205    g_object_set( renderer, "text", str, NULL );
    419206}
    420207
    421208static void
    422209render_ul_rate( GtkTreeViewColumn  * column UNUSED,
    423                 GtkCellRenderer *          renderer,
    424                 GtkTreeModel *              tree_model,
    425                 GtkTreeIter *              iter,
     210                GtkCellRenderer    * renderer,
     211                GtkTreeModel       * tree_model,
     212                GtkTreeIter        * iter,
    426213                gpointer             data   UNUSED )
    427214{
    428     float rate = 0.0;
    429 
    430     gtk_tree_model_get ( tree_model, iter, PEER_COL_UPLOAD_RATE, &rate, -1 );
    431     if( rate < 0.01 )
    432         g_object_set ( renderer, "text", "", NULL );
    433     else
    434     {
    435         char speedStr[64];
    436         tr_strlspeed( speedStr, rate, sizeof( speedStr ) );
    437         g_object_set( renderer, "text", speedStr, NULL );
    438     }
     215    render_speed( renderer, tree_model, iter, PEER_COL_UPLOAD_RATE );
    439216}
    440217
    441218static void
    442219render_dl_rate( GtkTreeViewColumn  * column UNUSED,
    443                 GtkCellRenderer *          renderer,
    444                 GtkTreeModel *              tree_model,
    445                 GtkTreeIter *              iter,
     220                GtkCellRenderer    * renderer,
     221                GtkTreeModel       * tree_model,
     222                GtkTreeIter        * iter,
    446223                gpointer             data   UNUSED )
    447224{
    448     float rate = 0.0;
    449 
    450     gtk_tree_model_get ( tree_model, iter, PEER_COL_DOWNLOAD_RATE, &rate,
    451                          -1 );
    452     if( rate < 0.01 )
    453         g_object_set ( renderer, "text", "", NULL );
    454     else
    455     {
    456         char speedStr[64];
    457         tr_strlspeed( speedStr, rate, sizeof( speedStr ) );
    458         g_object_set( renderer, "text", speedStr, NULL );
    459     }
     225    render_speed( renderer, tree_model, iter, PEER_COL_DOWNLOAD_RATE );
    460226}
    461227
     
    469235    char * client = NULL;
    470236
    471     gtk_tree_model_get ( tree_model, iter, PEER_COL_CLIENT, &client,
    472                          -1 );
    473     g_object_set ( renderer, "text", ( client ? client : "" ), NULL );
    474     g_free ( client );
     237    gtk_tree_model_get( tree_model, iter, PEER_COL_CLIENT, &client, -1 );
     238    g_object_set( renderer, "text", ( client ? client : "" ), NULL );
     239    g_free( client );
    475240}
    476241
     
    511276    int             n_peers;
    512277    GtkTreeIter     iter;
    513     PeerData *      p = (PeerData*) g_object_get_data ( G_OBJECT(
    514                                                             top ),
    515                                                         "peer-data" );
    516     tr_torrent *    tor = tr_torrent_handle ( p->gtor );
     278    PeerData *      p = (PeerData*) g_object_get_data( G_OBJECT( top ), "peer-data" );
     279    tr_torrent *    tor = tr_torrent_handle( p->gtor );
    517280    GtkTreeModel *  model = p->model;
    518281    GtkListStore *  store = p->store;
     
    527290        {
    528291            GtkTreeIter iter;
    529             gtk_tree_model_iter_nth_child( GTK_TREE_MODEL(
    530                                                p->webseeds ), &iter, NULL,
    531                                            i );
    532             gtk_list_store_set( p->webseeds, &iter,
    533                                 WEBSEED_COL_DOWNLOAD_RATE, speeds[i],
    534                                 -1 );
     292            gtk_tree_model_iter_nth_child( GTK_TREE_MODEL( p->webseeds ), &iter, NULL, i );
     293            gtk_list_store_set( p->webseeds, &iter, WEBSEED_COL_DOWNLOAD_RATE, speeds[i], -1 );
    535294        }
    536295        tr_free( speeds );
     
    546305
    547306    n_peers = 0;
    548     peers = tr_torrentPeers ( tor, &n_peers );
    549     qsort ( peers, n_peers, sizeof( tr_peer_stat ), compare_peers );
    550 
    551     if( gtk_tree_model_get_iter_first ( model, &iter ) ) do
     307    peers = tr_torrentPeers( tor, &n_peers );
     308    qsort( peers, n_peers, sizeof( tr_peer_stat ), compare_peers );
     309
     310    if( gtk_tree_model_get_iter_first( model, &iter ) ) do
    552311        {
    553312            char *         addr = NULL;
    554313            tr_peer_stat * peer = NULL;
    555             gtk_tree_model_get ( model, &iter, PEER_COL_ADDRESS, &addr, -1 );
    556             peer = bsearch ( addr, peers, n_peers, sizeof( tr_peer_stat ),
    557                              compare_addr_to_peer );
    558             g_free ( addr );
     314            gtk_tree_model_get( model, &iter, PEER_COL_ADDRESS, &addr, -1 );
     315            peer = bsearch( addr, peers, n_peers, sizeof( tr_peer_stat ),
     316                            compare_addr_to_peer );
     317            g_free( addr );
    559318
    560319            if( peer ) /* update a pre-existing row */
     
    562321                const int pos = peer - peers;
    563322                const int n_rhs = n_peers - ( pos + 1 );
    564                 g_assert ( n_rhs >= 0 );
    565 
    566                 peer_row_set ( store, &iter, peer );
     323                g_assert( n_rhs >= 0 );
     324
     325                peer_row_set( store, &iter, peer );
    567326
    568327                /* remove it from the tr_peer_stat list */
    569                 g_memmove ( peer, peer + 1, sizeof( tr_peer_stat ) * n_rhs );
     328                g_memmove( peer, peer + 1, sizeof( tr_peer_stat ) * n_rhs );
    570329                --n_peers;
    571330            }
    572             else if( !gtk_list_store_remove ( store, &iter ) )
     331            else if( !gtk_list_store_remove( store, &iter ) )
    573332                break; /* we removed the model's last item */
    574333        }
    575         while( gtk_tree_model_iter_next ( model, &iter ) );
    576 
    577     append_peers_to_model ( store, peers, n_peers ); /* all these are new */
    578 
    579 #ifdef SHOW_PIECES
    580     if( GDK_IS_DRAWABLE ( p->completeness->window ) )
    581         refresh_pieces ( p->completeness, NULL, p->gtor );
    582 #endif
    583 
    584     fmtpeercount ( p->seeders_lb, stat->seeders );
    585     fmtpeercount ( p->leechers_lb, stat->leechers );
    586     fmtpeercount ( p->completed_lb, stat->timesCompleted );
     334        while( gtk_tree_model_iter_next( model, &iter ) );
     335
     336    append_peers_to_model( store, peers, n_peers ); /* all these are new */
     337
     338    fmtpeercount( p->seeders_lb, stat->seeders );
     339    fmtpeercount( p->leechers_lb, stat->leechers );
     340    fmtpeercount( p->completed_lb, stat->timesCompleted );
    587341
    588342    free( peers );
     
    617371            switch( *pch )
    618372            {
    619                 case 'O':
    620                     txt = _( "Optimistic unchoke" ); break;
    621 
    622                 case 'D':
    623                     txt = _( "Downloading from this peer" ); break;
    624 
    625                 case 'd':
    626                     txt = _(
    627                         "We would download from this peer if they would let us" );
    628                     break;
    629 
    630                 case 'U':
    631                     txt = _( "Uploading to peer" ); break;
    632 
    633                 case 'u':
    634                     txt = _( "We would upload to this peer if they asked" );
    635                     break;
    636 
    637                 case 'K':
    638                     txt = _(
    639                         "Peer has unchoked us, but we're not interested" );
    640                     break;
    641 
    642                 case '?':
    643                     txt = _(
    644                         "We unchoked this peer, but they're not interested" );
    645                     break;
    646 
    647                 case 'E':
    648                     txt = _( "Encrypted connection" ); break;
    649 
    650                 case 'X':
    651                     txt = _(
    652                         "Peer was discovered through Peer Exchange (PEX)" );
    653                     break;
    654 
    655                 case 'I':
    656                     txt = _( "Peer is an incoming connection" ); break;
     373                case 'O': txt = _( "Optimistic unchoke" ); break;
     374                case 'D': txt = _( "Downloading from this peer" ); break;
     375                case 'd': txt = _( "We would download from this peer if they would let us" ); break;
     376                case 'U': txt = _( "Uploading to peer" ); break;
     377                case 'u': txt = _( "We would upload to this peer if they asked" ); break;
     378                case 'K': txt = _( "Peer has unchoked us, but we're not interested" ); break;
     379                case '?': txt = _( "We unchoked this peer, but they're not interested" ); break;
     380                case 'E': txt = _( "Encrypted connection" ); break;
     381                case 'X': txt = _( "Peer was discovered through Peer Exchange (PEX)" ); break;
     382                case 'I': txt = _( "Peer is an incoming connection" ); break;
    657383            }
    658384            if( txt )
     
    679405    GtkWidget *     v, *w, *ret, *sw, *l, *vbox, *hbox;
    680406    GtkWidget *     webtree = NULL;
    681     tr_torrent *    tor = tr_torrent_handle ( gtor );
    682     PeerData *      p = g_new ( PeerData, 1 );
     407    tr_torrent *    tor = tr_torrent_handle( gtor );
     408    PeerData *      p = g_new( PeerData, 1 );
    683409    const tr_info * inf = tr_torrent_info( gtor );
    684410
     
    709435
    710436        t = _( webseed_column_names[WEBSEED_COL_URL] );
    711         r = gtk_cell_renderer_text_new ( );
     437        r = gtk_cell_renderer_text_new( );
    712438        g_object_set( G_OBJECT( r ), "ellipsize", PANGO_ELLIPSIZE_END, NULL );
    713439        c = gtk_tree_view_column_new_with_attributes( t, r, "text", WEBSEED_COL_URL, NULL );
     
    717443
    718444        t = _( webseed_column_names[WEBSEED_COL_DOWNLOAD_RATE] );
    719         r = gtk_cell_renderer_text_new ( );
    720         c = gtk_tree_view_column_new_with_attributes ( t, r, "text", WEBSEED_COL_DOWNLOAD_RATE, NULL );
    721         gtk_tree_view_column_set_cell_data_func ( c, r, render_dl_rate, NULL, NULL );
     445        r = gtk_cell_renderer_text_new( );
     446        c = gtk_tree_view_column_new_with_attributes( t, r, "text", WEBSEED_COL_DOWNLOAD_RATE, NULL );
     447        gtk_tree_view_column_set_cell_data_func( c, r, render_dl_rate, NULL, NULL );
    722448        gtk_tree_view_column_set_sort_column_id( c, WEBSEED_COL_DOWNLOAD_RATE );
    723449        gtk_tree_view_append_column( GTK_TREE_VIEW( v ), c );
    724450
    725         w = gtk_scrolled_window_new ( NULL, NULL );
    726         gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW( w ),
    727                                          GTK_POLICY_AUTOMATIC,
    728                                          GTK_POLICY_AUTOMATIC );
    729         gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW( w ),
    730                                               GTK_SHADOW_IN );
    731         gtk_container_add ( GTK_CONTAINER( w ), v );
     451        w = gtk_scrolled_window_new( NULL, NULL );
     452        gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
     453        gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ), GTK_SHADOW_IN );
     454        gtk_container_add( GTK_CONTAINER( w ), v );
    732455
    733456        webtree = w;
    734457    }
    735458
    736     m  = peer_model_new ( tor );
     459    m  = peer_model_new( tor );
    737460    v = GTK_WIDGET( g_object_new( GTK_TYPE_TREE_VIEW,
    738461                                  "model",  gtk_tree_model_sort_new_with_model( m ),
     
    749472#endif
    750473    gtk_widget_set_size_request( v, 550, 0 );
    751     g_object_unref ( G_OBJECT( m ) );
     474    g_object_unref( G_OBJECT( m ) );
    752475    g_signal_connect( v, "button-release-event",
    753476                      G_CALLBACK( on_tree_view_button_released ), NULL );
     
    763486        {
    764487            case PEER_COL_ADDRESS:
    765                 r = gtk_cell_renderer_text_new ( );
    766                 c = gtk_tree_view_column_new_with_attributes ( t, r, "text", col, NULL );
     488                r = gtk_cell_renderer_text_new( );
     489                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
    767490                break;
    768491
    769492            case PEER_COL_CLIENT:
    770                 r = gtk_cell_renderer_text_new ( );
    771                 c = gtk_tree_view_column_new_with_attributes ( t, r, "text", col, NULL );
    772                 gtk_tree_view_column_set_cell_data_func ( c, r, render_client, NULL, NULL );
     493                r = gtk_cell_renderer_text_new( );
     494                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
     495                gtk_tree_view_column_set_cell_data_func( c, r, render_client, NULL, NULL );
    773496                break;
    774497
    775498            case PEER_COL_PROGRESS:
    776                 r = gtk_cell_renderer_progress_new ( );
    777                 c = gtk_tree_view_column_new_with_attributes ( t, r, "value", PEER_COL_PROGRESS, NULL );
     499                r = gtk_cell_renderer_progress_new( );
     500                c = gtk_tree_view_column_new_with_attributes( t, r, "value", PEER_COL_PROGRESS, NULL );
    778501                break;
    779502
    780503            case PEER_COL_IS_ENCRYPTED:
    781                 r = gtk_cell_renderer_pixbuf_new ( );
    782                 c = gtk_tree_view_column_new_with_attributes ( t, r, NULL );
    783                 gtk_tree_view_column_set_sizing ( c, GTK_TREE_VIEW_COLUMN_FIXED );
    784                 gtk_tree_view_column_set_fixed_width ( c, 20 );
    785                 gtk_tree_view_column_set_cell_data_func ( c, r, render_encrypted, NULL, NULL );
     504                r = gtk_cell_renderer_pixbuf_new( );
     505                c = gtk_tree_view_column_new_with_attributes( t, r, NULL );
     506                gtk_tree_view_column_set_sizing( c, GTK_TREE_VIEW_COLUMN_FIXED );
     507                gtk_tree_view_column_set_fixed_width( c, 20 );
     508                gtk_tree_view_column_set_cell_data_func( c, r, render_encrypted, NULL, NULL );
    786509                break;
    787510
    788511            case PEER_COL_DOWNLOAD_RATE:
    789                 r = gtk_cell_renderer_text_new ( );
    790                 c = gtk_tree_view_column_new_with_attributes ( t, r, "text", col, NULL );
    791                 gtk_tree_view_column_set_cell_data_func ( c, r, render_dl_rate, NULL, NULL );
     512                r = gtk_cell_renderer_text_new( );
     513                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
     514                gtk_tree_view_column_set_cell_data_func( c, r, render_dl_rate, NULL, NULL );
    792515                break;
    793516
    794517            case PEER_COL_UPLOAD_RATE:
    795                 r = gtk_cell_renderer_text_new ( );
    796                 c = gtk_tree_view_column_new_with_attributes ( t, r, "text", col, NULL );
    797                 gtk_tree_view_column_set_cell_data_func ( c, r, render_ul_rate, NULL, NULL );
     518                r = gtk_cell_renderer_text_new( );
     519                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
     520                gtk_tree_view_column_set_cell_data_func( c, r, render_ul_rate, NULL, NULL );
    798521                break;
    799522
    800523            case PEER_COL_STATUS:
    801524                r = gtk_cell_renderer_text_new( );
    802                 c = gtk_tree_view_column_new_with_attributes ( t, r, "text", col, NULL );
     525                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
    803526                break;
    804527
    805528            default:
    806                 abort ( );
     529                abort( );
    807530        }
    808531
    809         gtk_tree_view_column_set_resizable ( c, FALSE );
    810         gtk_tree_view_column_set_sort_column_id ( c, col );
    811         gtk_tree_view_append_column ( GTK_TREE_VIEW( v ), c );
     532        gtk_tree_view_column_set_resizable( c, FALSE );
     533        gtk_tree_view_column_set_sort_column_id( c, col );
     534        gtk_tree_view_append_column( GTK_TREE_VIEW( v ), c );
    812535    }
    813536
     
    817540       'expander column. */
    818541    {
    819         GtkTreeViewColumn *c = gtk_tree_view_column_new ( );
    820         gtk_tree_view_column_set_visible ( c, FALSE );
    821         gtk_tree_view_append_column ( GTK_TREE_VIEW( v ), c );
    822         gtk_tree_view_set_expander_column ( GTK_TREE_VIEW( v ), c );
     542        GtkTreeViewColumn *c = gtk_tree_view_column_new( );
     543        gtk_tree_view_column_set_visible( c, FALSE );
     544        gtk_tree_view_append_column( GTK_TREE_VIEW( v ), c );
     545        gtk_tree_view_set_expander_column( GTK_TREE_VIEW( v ), c );
    823546    }
    824547
    825     w = sw = gtk_scrolled_window_new ( NULL, NULL );
    826     gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW( w ),
    827                                      GTK_POLICY_AUTOMATIC,
    828                                      GTK_POLICY_AUTOMATIC );
    829     gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW( w ),
    830                                           GTK_SHADOW_IN );
    831     gtk_container_add ( GTK_CONTAINER( w ), v );
    832 
    833 
    834     vbox = gtk_vbox_new ( FALSE, GUI_PAD );
    835     gtk_container_set_border_width ( GTK_CONTAINER( vbox ), GUI_PAD_BIG );
     548    w = sw = gtk_scrolled_window_new( NULL, NULL );
     549    gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ),
     550                                    GTK_POLICY_AUTOMATIC,
     551                                    GTK_POLICY_AUTOMATIC );
     552    gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ),
     553                                         GTK_SHADOW_IN );
     554    gtk_container_add( GTK_CONTAINER( w ), v );
     555
     556
     557    vbox = gtk_vbox_new( FALSE, GUI_PAD );
     558    gtk_container_set_border_width( GTK_CONTAINER( vbox ), GUI_PAD_BIG );
    836559
    837560    if( webtree == NULL )
     
    844567    }
    845568
    846     hbox = gtk_hbox_new ( FALSE, GUI_PAD );
    847     l = gtk_label_new ( NULL );
    848     gtk_label_set_markup ( GTK_LABEL( l ), _( "<b>Seeders:</b>" ) );
    849     gtk_box_pack_start ( GTK_BOX( hbox ), l, FALSE, FALSE, 0 );
    850     l = p->seeders_lb = gtk_label_new ( NULL );
    851     gtk_box_pack_start ( GTK_BOX( hbox ), l, FALSE, FALSE, 0 );
    852     gtk_box_pack_start( GTK_BOX( hbox ),
    853                         gtk_alignment_new ( 0.0f, 0.0f, 0.0f, 0.0f ),
    854                         TRUE, TRUE, 0 );
    855     l = gtk_label_new ( NULL );
    856     gtk_label_set_markup ( GTK_LABEL( l ), _( "<b>Leechers:</b>" ) );
    857     gtk_box_pack_start ( GTK_BOX( hbox ), l, FALSE, FALSE, 0 );
    858     l = p->leechers_lb = gtk_label_new ( NULL );
    859     gtk_box_pack_start ( GTK_BOX( hbox ), l, FALSE, FALSE, 0 );
    860     gtk_box_pack_start( GTK_BOX( hbox ),
    861                         gtk_alignment_new ( 0.0f, 0.0f, 0.0f, 0.0f ),
    862                         TRUE, TRUE, 0 );
    863     l = gtk_label_new ( NULL );
    864     gtk_label_set_markup ( GTK_LABEL( l ), _( "<b>Times Completed:</b>" ) );
    865     gtk_box_pack_start ( GTK_BOX( hbox ), l, FALSE, FALSE, 0 );
    866     l = p->completed_lb = gtk_label_new ( NULL );
    867     gtk_box_pack_start ( GTK_BOX( hbox ), l, FALSE, FALSE, 0 );
    868     gtk_box_pack_start ( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
     569    hbox = gtk_hbox_new( FALSE, GUI_PAD );
     570    l = gtk_label_new( NULL );
     571    gtk_label_set_markup( GTK_LABEL( l ), _( "<b>Seeders:</b>" ) );
     572    gtk_box_pack_start( GTK_BOX( hbox ), l, FALSE, FALSE, 0 );
     573    l = p->seeders_lb = gtk_label_new( NULL );
     574    gtk_box_pack_start( GTK_BOX( hbox ), l, FALSE, FALSE, 0 );
     575    gtk_box_pack_start( GTK_BOX( hbox ), gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f ), TRUE, TRUE, 0 );
     576    l = gtk_label_new( NULL );
     577    gtk_label_set_markup( GTK_LABEL( l ), _( "<b>Leechers:</b>" ) );
     578    gtk_box_pack_start( GTK_BOX( hbox ), l, FALSE, FALSE, 0 );
     579    l = p->leechers_lb = gtk_label_new( NULL );
     580    gtk_box_pack_start( GTK_BOX( hbox ), l, FALSE, FALSE, 0 );
     581    gtk_box_pack_start( GTK_BOX( hbox ), gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f ), TRUE, TRUE, 0 );
     582    l = gtk_label_new( NULL );
     583    gtk_label_set_markup( GTK_LABEL( l ), _( "<b>Times Completed:</b>" ) );
     584    gtk_box_pack_start( GTK_BOX( hbox ), l, FALSE, FALSE, 0 );
     585    l = p->completed_lb = gtk_label_new( NULL );
     586    gtk_box_pack_start( GTK_BOX( hbox ), l, FALSE, FALSE, 0 );
     587    gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
    869588
    870589    ret = vbox;
     
    872591    p->model = m;
    873592    p->store = GTK_LIST_STORE( m );
    874     g_object_set_data_full ( G_OBJECT( ret ), "peer-data", p, g_free );
     593    g_object_set_data_full( G_OBJECT( ret ), "peer-data", p, g_free );
    875594    return ret;
    876595}
     
    900619{
    901620    int             row = 0;
    902     GtkWidget *     t = hig_workarea_create ( );
     621    GtkWidget *     t = hig_workarea_create( );
    903622    GtkWidget *     l, *w, *fr;
    904623    char *          pch;
     
    909628    const tr_info * info = tr_torrentInfo( tor );
    910629
    911     hig_workarea_add_section_title ( t, &row, _( "Details" ) );
     630    hig_workarea_add_section_title( t, &row, _( "Details" ) );
    912631
    913632    g_snprintf( countStr, sizeof( countStr ),
     
    921640                countStr, sizeStr );
    922641
    923     l = gtk_label_new ( buf );
    924     hig_workarea_add_row ( t, &row, _( "Pieces:" ), l, NULL );
    925 
    926     l =
    927         g_object_new( GTK_TYPE_LABEL, "label", info->hashString,
    928                       "selectable",
    929                       TRUE,
     642    l = gtk_label_new( buf );
     643    hig_workarea_add_row( t, &row, _( "Pieces:" ), l, NULL );
     644
     645    l = g_object_new( GTK_TYPE_LABEL, "label", info->hashString,
     646                      "selectable", TRUE,
    930647                      "ellipsize", PANGO_ELLIPSIZE_END,
    931648                      NULL );
    932     hig_workarea_add_row ( t, &row, _( "Hash:" ), l, NULL );
     649    hig_workarea_add_row( t, &row, _( "Hash:" ), l, NULL );
    933650
    934651    pch = ( info->isPrivate )
    935652          ? _( "Private to this tracker -- PEX disabled" )
    936653          : _( "Public torrent" );
    937     l = gtk_label_new ( pch );
    938     hig_workarea_add_row ( t, &row, _( "Privacy:" ), l, NULL );
    939 
    940     b = gtk_text_buffer_new ( NULL );
     654    l = gtk_label_new( pch );
     655    hig_workarea_add_row( t, &row, _( "Privacy:" ), l, NULL );
     656
     657    b = gtk_text_buffer_new( NULL );
    941658    if( info->comment )
    942         gtk_text_buffer_set_text ( b, info->comment, -1 );
    943     w = gtk_text_view_new_with_buffer ( b );
    944     gtk_widget_set_size_request ( w, 0u, 100u );
    945     gtk_text_view_set_wrap_mode ( GTK_TEXT_VIEW( w ), GTK_WRAP_WORD );
    946     gtk_text_view_set_editable ( GTK_TEXT_VIEW( w ), FALSE );
    947     fr = gtk_frame_new ( NULL );
    948     gtk_frame_set_shadow_type ( GTK_FRAME( fr ), GTK_SHADOW_IN );
    949     gtk_container_add ( GTK_CONTAINER( fr ), w );
    950     w = hig_workarea_add_row ( t, &row, _( "Comment:" ), fr, NULL );
    951     gtk_misc_set_alignment ( GTK_MISC( w ), 0.0f, 0.0f );
    952 
    953     hig_workarea_add_section_divider ( t, &row );
    954     hig_workarea_add_section_title ( t, &row, _( "Origins" ) );
    955 
    956     l = gtk_label_new ( *info->creator ? info->creator : _( "Unknown" ) );
     659        gtk_text_buffer_set_text( b, info->comment, -1 );
     660    w = gtk_text_view_new_with_buffer( b );
     661    gtk_widget_set_size_request( w, 0u, 100u );
     662    gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( w ), GTK_WRAP_WORD );
     663    gtk_text_view_set_editable( GTK_TEXT_VIEW( w ), FALSE );
     664    fr = gtk_frame_new( NULL );
     665    gtk_frame_set_shadow_type( GTK_FRAME( fr ), GTK_SHADOW_IN );
     666    gtk_container_add( GTK_CONTAINER( fr ), w );
     667    w = hig_workarea_add_row( t, &row, _( "Comment:" ), fr, NULL );
     668    gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.0f );
     669
     670    hig_workarea_add_section_divider( t, &row );
     671    hig_workarea_add_section_title( t, &row, _( "Origins" ) );
     672
     673    l = gtk_label_new( *info->creator ? info->creator : _( "Unknown" ) );
    957674    gtk_label_set_ellipsize( GTK_LABEL( l ), PANGO_ELLIPSIZE_END );
    958     hig_workarea_add_row ( t, &row, _( "Creator:" ), l, NULL );
     675    hig_workarea_add_row( t, &row, _( "Creator:" ), l, NULL );
    959676
    960677    l = gtk_label_new( NULL );
    961678    refresh_time_lb( l, info->dateCreated );
    962     hig_workarea_add_row ( t, &row, _( "Date:" ), l, NULL );
    963 
    964     hig_workarea_add_section_divider ( t, &row );
    965     hig_workarea_add_section_title ( t, &row, _( "Location" ) );
    966 
    967     l =
    968         g_object_new( GTK_TYPE_LABEL, "label", tr_torrentGetDownloadDir(
    969                           tor ), "selectable", TRUE,
    970                       "ellipsize", PANGO_ELLIPSIZE_END, NULL );
    971     hig_workarea_add_row ( t, &row, _( "Destination folder:" ), l, NULL );
    972 
    973     l =
    974         g_object_new( GTK_TYPE_LABEL, "label", info->torrent, "selectable",
    975                       TRUE,
    976                       "ellipsize", PANGO_ELLIPSIZE_END,
    977                       NULL );
    978     hig_workarea_add_row ( t, &row, _( "Torrent file:" ), l, NULL );
    979 
    980     hig_workarea_finish ( t, &row );
     679    hig_workarea_add_row( t, &row, _( "Date:" ), l, NULL );
     680
     681    hig_workarea_add_section_divider( t, &row );
     682    hig_workarea_add_section_title( t, &row, _( "Location" ) );
     683
     684    l = g_object_new( GTK_TYPE_LABEL, "label", tr_torrentGetDownloadDir( tor ),
     685                                      "selectable", TRUE,
     686                                      "ellipsize", PANGO_ELLIPSIZE_END,
     687                                      NULL );
     688    hig_workarea_add_row( t, &row, _( "Destination folder:" ), l, NULL );
     689
     690    l = g_object_new( GTK_TYPE_LABEL, "label", info->torrent,
     691                                      "selectable", TRUE,
     692                                      "ellipsize", PANGO_ELLIPSIZE_END,
     693                                      NULL );
     694    hig_workarea_add_row( t, &row, _( "Torrent file:" ), l, NULL );
     695
     696    hig_workarea_finish( t, &row );
    981697    return t;
    982698}
     
    988704typedef struct
    989705{
    990     GtkWidget *  state_lb;
    991     GtkWidget *  progress_lb;
    992     GtkWidget *  have_lb;
    993     GtkWidget *  dl_lb;
    994     GtkWidget *  ul_lb;
    995     GtkWidget *  failed_lb;
    996     GtkWidget *  ratio_lb;
    997     GtkWidget *  err_lb;
    998     GtkWidget *  swarm_lb;
    999     GtkWidget *  date_added_lb;
    1000     GtkWidget *  last_activity_lb;
    1001     GtkWidget *  availability_da;
    1002     TrTorrent *  gtor;
     706    GtkWidget * state_lb;
     707    GtkWidget * progress_lb;
     708    GtkWidget * have_lb;
     709    GtkWidget * dl_lb;
     710    GtkWidget * ul_lb;
     711    GtkWidget * failed_lb;
     712    GtkWidget * ratio_lb;
     713    GtkWidget * err_lb;
     714    GtkWidget * swarm_lb;
     715    GtkWidget * date_added_lb;
     716    GtkWidget * last_activity_lb;
     717    GtkWidget * availability_da;
     718    TrTorrent * gtor;
    1003719}
    1004720Activity;
     
    1007723refresh_activity( GtkWidget * top )
    1008724{
    1009     Activity *      a = g_object_get_data ( G_OBJECT(
    1010                                                 top ), "activity-data" );
    1011     char *          pch;
    1012     char            sizeStr[64];
    1013     char            sizeStr2[64];
    1014     char            buf[128];
     725    int i;
     726    char * pch;
     727    char buf1[128];
     728    char buf2[128];
     729    Activity * a = g_object_get_data( G_OBJECT( top ), "activity-data" );
    1015730    const tr_stat * stat = tr_torrent_stat( a->gtor );
    1016731    const tr_info * info = tr_torrent_info( a->gtor );
    1017     const double    complete = stat->percentComplete * 100.0;
    1018     const double    done = stat->percentDone * 100.0;
    1019     const double    verifiedPieceCount = (double)stat->haveValid / info->pieceSize;
     732    const double complete = stat->percentComplete * 100.0;
     733    const double done = stat->percentDone * 100.0;
     734    const double verifiedPieceCount = (double)stat->haveValid / info->pieceSize;
    1020735
    1021736    pch = tr_torrent_status_str( a->gtor );
    1022     gtk_label_set_text ( GTK_LABEL( a->state_lb ), pch );
    1023     g_free ( pch );
     737    gtk_label_set_text( GTK_LABEL( a->state_lb ), pch );
     738    g_free( pch );
    1024739
    1025740    if( (int)complete == (int)done )
     
    1027742    else
    1028743        /* %1$.1f is percent of how much of what we want's been downloaded,
    1029            %2$.1f is percent of how much of the whole torrent we've downloaded
    1030            */
    1031         pch = g_strdup_printf( _(
    1032                                    "%1$.1f%% (%2$.1f%% selected)" ),
     744         * %2$.1f is percent of how much of the whole torrent we've downloaded */
     745        pch = g_strdup_printf( _( "%1$.1f%% (%2$.1f%% selected)" ),
    1033746                               complete, done );
    1034     gtk_label_set_text ( GTK_LABEL( a->progress_lb ), pch );
    1035     g_free ( pch );
    1036 
    1037     tr_strlsize( sizeStr,  stat->haveValid + stat->haveUnchecked,
    1038                 sizeof( sizeStr ) );
    1039     tr_strlsize( sizeStr2, stat->haveValid,
    1040                 sizeof( sizeStr2 ) );
     747    gtk_label_set_text( GTK_LABEL( a->progress_lb ), pch );
     748    g_free( pch );
     749
     750    i = (int) ceil( verifiedPieceCount );
     751    tr_strlsize( buf1, stat->haveValid + stat->haveUnchecked, sizeof( buf1 ) );
     752    tr_strlsize( buf2, stat->haveValid, sizeof( buf2 ) );
    1041753    /* %1$s is total size of what we've saved to disk
    1042        %2$s is how much of it's passed the checksum test
    1043        %3$s is how many pieces are verified */
    1044     g_snprintf( buf, sizeof( buf ), _( "%1$s (%2$s verified in %3$d pieces)" ),
    1045                 sizeStr, sizeStr2, (int)ceil(verifiedPieceCount) );
    1046     gtk_label_set_text( GTK_LABEL( a->have_lb ), buf );
    1047 
    1048     tr_strlsize( sizeStr, stat->downloadedEver, sizeof( sizeStr ) );
    1049     gtk_label_set_text( GTK_LABEL( a->dl_lb ), sizeStr );
    1050 
    1051     tr_strlsize( sizeStr, stat->uploadedEver, sizeof( sizeStr ) );
    1052     gtk_label_set_text( GTK_LABEL( a->ul_lb ), sizeStr );
    1053 
    1054     tr_strlsize( sizeStr, stat->corruptEver, sizeof( sizeStr ) );
    1055     gtk_label_set_text( GTK_LABEL( a->failed_lb ), sizeStr );
    1056 
    1057     tr_strlratio( buf, stat->ratio, sizeof( buf ) );
    1058     gtk_label_set_text( GTK_LABEL( a->ratio_lb ), buf );
    1059 
    1060     tr_strlspeed( buf, stat->swarmSpeed, sizeof( buf ) );
    1061     gtk_label_set_text ( GTK_LABEL( a->swarm_lb ), buf );
    1062 
    1063     gtk_label_set_text ( GTK_LABEL( a->err_lb ),
     754     * %2$s is how much of it's passed the checksum test
     755     * %3$s is how many pieces are verified */
     756    if( !i )
     757        pch = tr_strdup( buf1 );
     758    else
     759        pch = g_strdup_printf( _( "%1$s (%2$s verified in %3$d pieces)" ), buf1, buf2, i );
     760    gtk_label_set_text( GTK_LABEL( a->have_lb ), pch );
     761    g_free( pch );
     762
     763    tr_strlsize( buf1, stat->downloadedEver, sizeof( buf1 ) );
     764    gtk_label_set_text( GTK_LABEL( a->dl_lb ), buf1 );
     765
     766    tr_strlsize( buf1, stat->uploadedEver, sizeof( buf1 ) );
     767    gtk_label_set_text( GTK_LABEL( a->ul_lb ), buf1 );
     768
     769    tr_strlsize( buf1, stat->corruptEver, sizeof( buf1 ) );
     770    gtk_label_set_text( GTK_LABEL( a->failed_lb ), buf1 );
     771
     772    tr_strlratio( buf1, stat->ratio, sizeof( buf1 ) );
     773    gtk_label_set_text( GTK_LABEL( a->ratio_lb ), buf1 );
     774
     775    tr_strlspeed( buf1, stat->swarmSpeed, sizeof( buf1 ) );
     776    gtk_label_set_text( GTK_LABEL( a->swarm_lb ), buf1 );
     777
     778    gtk_label_set_text( GTK_LABEL( a->err_lb ),
    1064779                        *stat->errorString ? stat->errorString : _( "None" ) );
    1065780
     
    1067782
    1068783    refresh_time_lb( a->last_activity_lb, stat->activityDate );
    1069 
    1070 #ifdef SHOW_PIECES
    1071     if( GDK_IS_DRAWABLE ( a->availability_da->window ) )
    1072         refresh_pieces ( a->availability_da, NULL, a->gtor );
    1073 #endif
    1074784}
    1075785
     
    1077787activity_page_new( TrTorrent * gtor )
    1078788{
    1079     Activity * a = g_new ( Activity, 1 );
     789    Activity * a = g_new( Activity, 1 );
    1080790    int        row = 0;
    1081     GtkWidget *t = hig_workarea_create ( );
     791    GtkWidget *t = hig_workarea_create( );
    1082792    GtkWidget *l;
    1083793
    1084794    a->gtor = gtor;
    1085795
    1086     hig_workarea_add_section_title ( t, &row, _( "Transfer" ) );
    1087 
    1088     l = a->state_lb = gtk_label_new ( NULL );
    1089     hig_workarea_add_row ( t, &row, _( "State:" ), l, NULL );
    1090 
    1091     l = a->progress_lb = gtk_label_new ( NULL );
    1092     hig_workarea_add_row ( t, &row, _( "Progress:" ), l, NULL );
    1093 
    1094     l = a->have_lb = gtk_label_new ( NULL );
     796    hig_workarea_add_section_title( t, &row, _( "Transfer" ) );
     797
     798    l = a->state_lb = gtk_label_new( NULL );
     799    hig_workarea_add_row( t, &row, _( "State:" ), l, NULL );
     800
     801    l = a->progress_lb = gtk_label_new( NULL );
     802    hig_workarea_add_row( t, &row, _( "Progress:" ), l, NULL );
     803
     804    l = a->have_lb = gtk_label_new( NULL );
    1095805    /* "Have" refers to how much of the torrent we have */
    1096     hig_workarea_add_row ( t, &row, _( "Have:" ), l, NULL );
    1097 
    1098     l = a->dl_lb = gtk_label_new ( NULL );
    1099     hig_workarea_add_row ( t, &row, _( "Downloaded:" ), l, NULL );
    1100 
    1101     l = a->ul_lb = gtk_label_new ( NULL );
    1102     hig_workarea_add_row ( t, &row, _( "Uploaded:" ), l, NULL );
     806    hig_workarea_add_row( t, &row, _( "Have:" ), l, NULL );
     807
     808    l = a->dl_lb = gtk_label_new( NULL );
     809    hig_workarea_add_row( t, &row, _( "Downloaded:" ), l, NULL );
     810
     811    l = a->ul_lb = gtk_label_new( NULL );
     812    hig_workarea_add_row( t, &row, _( "Uploaded:" ), l, NULL );
    1103813
    1104814    /* how much downloaded data was corrupt */
    1105     l = a->failed_lb = gtk_label_new ( NULL );
    1106     hig_workarea_add_row ( t, &row, _( "Failed DL:" ), l, NULL );
    1107 
    1108     l = a->ratio_lb = gtk_label_new ( NULL );
    1109     hig_workarea_add_row ( t, &row, _( "Ratio:" ), l, NULL );
    1110 
    1111     l = a->swarm_lb = gtk_label_new ( NULL );
    1112     hig_workarea_add_row ( t, &row, _( "Swarm rate:" ), l, NULL );
    1113 
    1114     l = a->err_lb = gtk_label_new ( NULL );
    1115     hig_workarea_add_row ( t, &row, _( "Error:" ), l, NULL );
    1116 
    1117 #ifdef SHOW_PIECES
    1118     hig_workarea_add_section_divider ( t, &row );
    1119     hig_workarea_add_section_title ( t, &row, _( "Completion" ) );
    1120 
    1121     w = a->availability_da = gtk_drawing_area_new ( );
    1122     gtk_widget_set_size_request ( w, 0u, 100u );
    1123     g_object_set_data ( G_OBJECT( w ), "draw-mode",
    1124                        GINT_TO_POINTER( DRAW_PROG ) );
    1125     g_signal_connect ( w, "expose-event", G_CALLBACK(
    1126                            refresh_pieces ), gtor );
    1127     hig_workarea_add_wide_control( t, &row, w );
    1128 #endif
    1129 
    1130     hig_workarea_add_section_divider ( t, &row );
    1131     hig_workarea_add_section_title ( t, &row, _( "Dates" ) );
    1132 
    1133     l = a->date_added_lb = gtk_label_new ( NULL );
    1134     hig_workarea_add_row ( t, &row, _( "Started at:" ), l, NULL );
    1135 
    1136     l = a->last_activity_lb = gtk_label_new ( NULL );
    1137     hig_workarea_add_row ( t, &row, _( "Last activity at:" ), l, NULL );
    1138 
    1139     hig_workarea_add_section_divider ( t, &row );
    1140     hig_workarea_finish ( t, &row );
    1141     g_object_set_data_full ( G_OBJECT( t ), "activity-data", a, g_free );
     815    l = a->failed_lb = gtk_label_new( NULL );
     816    hig_workarea_add_row( t, &row, _( "Failed DL:" ), l, NULL );
     817
     818    l = a->ratio_lb = gtk_label_new( NULL );
     819    hig_workarea_add_row( t, &row, _( "Ratio:" ), l, NULL );
     820
     821    l = a->swarm_lb = gtk_label_new( NULL );
     822    hig_workarea_add_row( t, &row, _( "Swarm rate:" ), l, NULL );
     823
     824    l = a->err_lb = gtk_label_new( NULL );
     825    hig_workarea_add_row( t, &row, _( "Error:" ), l, NULL );
     826
     827    hig_workarea_add_section_divider( t, &row );
     828    hig_workarea_add_section_title( t, &row, _( "Dates" ) );
     829
     830    l = a->date_added_lb = gtk_label_new( NULL );
     831    hig_workarea_add_row( t, &row, _( "Started at:" ), l, NULL );
     832
     833    l = a->last_activity_lb = gtk_label_new( NULL );
     834    hig_workarea_add_row( t, &row, _( "Last activity at:" ), l, NULL );
     835
     836    hig_workarea_add_section_divider( t, &row );
     837    hig_workarea_finish( t, &row );
     838    g_object_set_data_full( G_OBJECT( t ), "activity-data", a, g_free );
    1142839    return t;
    1143840}
     
    1152849                  int               up_or_down )
    1153850{
    1154     tr_torrent * tor = tr_torrent_handle ( gtor );
    1155     gboolean    b = gtk_toggle_button_get_active( tb );
     851    tr_torrent * tor = tr_torrent_handle( gtor );
     852    const gboolean b = gtk_toggle_button_get_active( tb );
    1156853
    1157854    tr_torrentSetSpeedMode( tor, up_or_down, b ? TR_SPEEDLIMIT_SINGLE
    1158                             : TR_SPEEDLIMIT_GLOBAL );
    1159 }
    1160 
    1161 static void
    1162 ul_speed_toggled_cb( GtkToggleButton *tb,
    1163                      gpointer         gtor )
     855                                               : TR_SPEEDLIMIT_GLOBAL );
     856}
     857
     858static void
     859ul_speed_toggled_cb( GtkToggleButton * tb, gpointer gtor )
    1164860{
    1165861    speed_toggled_cb( tb, gtor, TR_UP );
     
    1167863
    1168864static void
    1169 dl_speed_toggled_cb( GtkToggleButton *tb,
    1170                      gpointer         gtor )
     865dl_speed_toggled_cb( GtkToggleButton * tb, gpointer gtor )
    1171866{
    1172867    speed_toggled_cb( tb, gtor, TR_DOWN );
     
    1174869
    1175870static void
    1176 sensitize_from_check_cb( GtkToggleButton *toggle,
    1177                          gpointer         w )
    1178 {
    1179     gtk_widget_set_sensitive ( GTK_WIDGET( w ),
     871sensitize_from_check_cb( GtkToggleButton * toggle, gpointer w )
     872{
     873    gtk_widget_set_sensitive( GTK_WIDGET( w ),
    1180874                              gtk_toggle_button_get_active( toggle ) );
    1181875}
    1182876
    1183877static void
    1184 setSpeedLimit( GtkSpinButton* spin,
    1185                gpointer       gtor,
    1186                int            up_or_down )
    1187 {
    1188     tr_torrent * tor = tr_torrent_handle ( gtor );
    1189     int          kb_sec = gtk_spin_button_get_value_as_int ( spin );
     878setSpeedLimit( GtkSpinButton * spin, gpointer gtor, int up_or_down )
     879{
     880    tr_torrent * tor = tr_torrent_handle( gtor );
     881    const int kb_sec = gtk_spin_button_get_value_as_int( spin );
    1190882
    1191883    tr_torrentSetSpeedLimit( tor, up_or_down, kb_sec );
     
    1193885
    1194886static void
    1195 ul_speed_spun_cb( GtkSpinButton *spin,
    1196                   gpointer       gtor )
     887ul_speed_spun_cb( GtkSpinButton * spin, gpointer gtor )
    1197888{
    1198889    setSpeedLimit( spin, gtor, TR_UP );
     
    1200891
    1201892static void
    1202 dl_speed_spun_cb( GtkSpinButton *spin,
    1203                   gpointer       gtor )
     893dl_speed_spun_cb( GtkSpinButton * spin, gpointer gtor )
    1204894{
    1205895    setSpeedLimit( spin, gtor, TR_DOWN );
     
    1207897
    1208898static void
    1209 max_peers_spun_cb( GtkSpinButton * spin,
    1210                    gpointer        gtor )
     899max_peers_spun_cb( GtkSpinButton * spin, gpointer gtor )
    1211900{
    1212901    const uint16_t n = gtk_spin_button_get_value( spin );
     
    1222911    gboolean     b;
    1223912    GtkWidget *  t, *w, *tb;
    1224     tr_torrent * tor = tr_torrent_handle ( gtor );
     913    tr_torrent * tor = tr_torrent_handle( gtor );
    1225914
    1226915    row = 0;
    1227     t = hig_workarea_create ( );
    1228     hig_workarea_add_section_title ( t, &row, _( "Limits" ) );
    1229 
    1230     tb =
    1231         gtk_check_button_new_with_mnemonic ( _(
    1232                                                 "Limit _download speed (KB/s):" ) );
     916    t = hig_workarea_create( );
     917    hig_workarea_add_section_title( t, &row, _( "Limits" ) );
     918
     919    tb = gtk_check_button_new_with_mnemonic( _( "Limit _download speed (KB/s):" ) );
    1233920    b = tr_torrentGetSpeedMode( tor, TR_DOWN ) == TR_SPEEDLIMIT_SINGLE;
    1234     gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON( tb ), b );
    1235     g_signal_connect ( tb, "toggled", G_CALLBACK(
    1236                            dl_speed_toggled_cb ), gtor );
     921    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( tb ), b );
     922    g_signal_connect( tb, "toggled", G_CALLBACK( dl_speed_toggled_cb ), gtor );
    1237923
    1238924    i = tr_torrentGetSpeedLimit( tor, TR_DOWN );
     
    1240926    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), i );
    1241927
    1242     g_signal_connect ( w, "value-changed", G_CALLBACK(
    1243                            dl_speed_spun_cb ), gtor );
    1244     g_signal_connect ( tb, "toggled", G_CALLBACK(
    1245                            sensitize_from_check_cb ), w );
    1246     sensitize_from_check_cb ( GTK_TOGGLE_BUTTON( tb ), w );
    1247     hig_workarea_add_row_w ( t, &row, tb, w, NULL );
    1248 
    1249     tb =
    1250         gtk_check_button_new_with_mnemonic ( _(
    1251                                                 "Limit _upload speed (KB/s):" ) );
     928    g_signal_connect( w, "value-changed", G_CALLBACK( dl_speed_spun_cb ), gtor );
     929    g_signal_connect( tb, "toggled", G_CALLBACK( sensitize_from_check_cb ), w );
     930    sensitize_from_check_cb( GTK_TOGGLE_BUTTON( tb ), w );
     931    hig_workarea_add_row_w( t, &row, tb, w, NULL );
     932
     933    tb = gtk_check_button_new_with_mnemonic( _( "Limit _upload speed (KB/s):" ) );
    1252934    b = tr_torrentGetSpeedMode( tor, TR_UP ) == TR_SPEEDLIMIT_SINGLE;
    1253     gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON( tb ), b );
    1254     g_signal_connect ( tb, "toggled", G_CALLBACK(
    1255                            ul_speed_toggled_cb ), gtor );
     935    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( tb ), b );
     936    g_signal_connect( tb, "toggled", G_CALLBACK( ul_speed_toggled_cb ), gtor );
    1256937
    1257938    i = tr_torrentGetSpeedLimit( tor, TR_UP );
     
    1259940    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), i );
    1260941
    1261     g_signal_connect ( w, "value-changed", G_CALLBACK(
    1262                            ul_speed_spun_cb ), gtor );
    1263     g_signal_connect ( tb, "toggled", G_CALLBACK(
    1264                            sensitize_from_check_cb ), w );
    1265     sensitize_from_check_cb ( GTK_TOGGLE_BUTTON( tb ), w );
    1266     hig_workarea_add_row_w ( t, &row, tb, w, NULL );
    1267 
    1268     hig_workarea_add_section_divider ( t, &row );
    1269     hig_workarea_add_section_title ( t, &row, _( "Peer Connections" ) );
     942    g_signal_connect( w, "value-changed", G_CALLBACK( ul_speed_spun_cb ), gtor );
     943    g_signal_connect( tb, "toggled", G_CALLBACK( sensitize_from_check_cb ), w );
     944    sensitize_from_check_cb( GTK_TOGGLE_BUTTON( tb ), w );
     945    hig_workarea_add_row_w( t, &row, tb, w, NULL );
     946
     947    hig_workarea_add_section_divider( t, &row );
     948    hig_workarea_add_section_title( t, &row, _( "Peer Connections" ) );
    1270949
    1271950    maxConnectedPeers = tr_torrentGetPeerLimit( tor );
     
    1276955                          max_peers_spun_cb ), gtor );
    1277956
    1278     hig_workarea_finish ( t, &row );
     957    hig_workarea_finish( t, &row );
    1279958    return t;
    1280959}
     
    13221001    const char *          s;
    13231002    struct tracker_page * page = g_new0( struct tracker_page, 1 );
    1324     const tr_info *       info = tr_torrent_info ( gtor );
     1003    const tr_info *       info = tr_torrent_info( gtor );
    13251004
    13261005    page->gtor = gtor;
     
    13551034    l = gtk_label_new( info->trackers[0].announce );
    13561035    gtk_label_set_ellipsize( GTK_LABEL( l ), PANGO_ELLIPSIZE_END );
    1357     hig_workarea_add_row ( t, &row, _( "Tracker:" ), l, NULL );
     1036    hig_workarea_add_row( t, &row, _( "Tracker:" ), l, NULL );
    13581037
    13591038    s = _( "Last announce at:" );
     
    13961075    else if( t < now )
    13971076        gtk_label_set_text( l, countdown_done );
    1398     else
    1399     {
    1400         char      buf[1024];
     1077    else {
     1078        char buf[512];
    14011079        const int seconds = t - now;
    14021080        tr_strltime( buf, seconds, sizeof( buf ) );
     
    14461124
    14471125static void
    1448 torrent_destroyed( gpointer               dialog,
    1449                    GObject * dead_torrent UNUSED )
    1450 {
    1451     gtk_widget_destroy ( GTK_WIDGET( dialog ) );
     1126torrent_destroyed( gpointer dialog, GObject * dead_torrent UNUSED )
     1127{
     1128    gtk_widget_destroy( GTK_WIDGET( dialog ) );
    14521129}
    14531130
     
    14551132remove_tag( gpointer tag )
    14561133{
    1457     g_source_remove ( GPOINTER_TO_UINT( tag ) ); /* stop the periodic refresh */
     1134    g_source_remove( GPOINTER_TO_UINT( tag ) ); /* stop the periodic refresh */
    14581135}
    14591136
     
    14721149    refresh_tracker   ( g_object_get_data ( G_OBJECT( data ), "tracker-top" ) );
    14731150    refresh_peers     ( g_object_get_data ( G_OBJECT( data ), "peers-top" ) );
    1474     refresh_activity  ( g_object_get_data ( G_OBJECT( data ),
    1475                                             "activity-top" ) );
     1151    refresh_activity  ( g_object_get_data ( G_OBJECT( data ), "activity-top" ) );
    14761152    refresh_options   ( g_object_get_data ( G_OBJECT( data ), "options-top" ) );
    14771153    return TRUE;
     
    14831159{
    14841160    guint           tag;
    1485     GtkWidget *     d, *n, *w;
    1486     tr_torrent *    tor = tr_torrent_handle ( gtor );
     1161    GtkWidget *     d, *n, *w, *lb;
    14871162    char            title[512];
    1488     const tr_info * info = tr_torrent_info ( gtor );
     1163    tr_torrent *    tor = tr_torrent_handle( gtor );
     1164    const tr_info * info = tr_torrent_info( gtor );
    14891165
    14901166    /* create the dialog */
    14911167    g_snprintf( title, sizeof( title ), _( "%s Properties" ), info->name );
    1492     d = gtk_dialog_new_with_buttons ( title, parent, 0,
    1493                                       GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
    1494                                       NULL );
    1495     gtk_window_set_role ( GTK_WINDOW( d ), "tr-info" );
    1496     g_signal_connect ( d, "response", G_CALLBACK ( response_cb ), gtor );
     1168    d = gtk_dialog_new_with_buttons( title, parent, 0,
     1169                                     GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
     1170                                     NULL );
     1171    gtk_window_set_role( GTK_WINDOW( d ), "tr-info" );
     1172    g_signal_connect( d, "response", G_CALLBACK( response_cb ), gtor );
    14971173    gtk_dialog_set_has_separator( GTK_DIALOG( d ), FALSE );
    14981174    gtk_container_set_border_width( GTK_CONTAINER( d ), GUI_PAD );
    1499     g_object_weak_ref ( G_OBJECT( gtor ), torrent_destroyed, d );
     1175    g_object_weak_ref( G_OBJECT( gtor ), torrent_destroyed, d );
    15001176
    15011177
    15021178    /* add the notebook */
    1503     n = gtk_notebook_new ( );
    1504     gtk_container_set_border_width ( GTK_CONTAINER ( n ), GUI_PAD );
    1505 
    1506     w = activity_page_new ( gtor );
    1507     g_object_set_data ( G_OBJECT( d ), "activity-top", w );
    1508     gtk_notebook_append_page ( GTK_NOTEBOOK( n ), w,
    1509                               gtk_label_new ( _( "Activity" ) ) );
    1510 
    1511     w = peer_page_new ( gtor );
    1512     g_object_set_data ( G_OBJECT( d ), "peers-top", w );
    1513     gtk_notebook_append_page ( GTK_NOTEBOOK( n ),  w,
    1514                               gtk_label_new ( _( "Peers" ) ) );
     1179    n = gtk_notebook_new( );
     1180    gtk_container_set_border_width( GTK_CONTAINER( n ), GUI_PAD );
     1181
     1182    w = activity_page_new( gtor );
     1183    lb = gtk_label_new( _( "Activity" ) );
     1184    gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, lb );
     1185    g_object_set_data( G_OBJECT( d ), "activity-top", w );
     1186
     1187    w = peer_page_new( gtor );
     1188    lb = gtk_label_new( _( "Peers" ) );
     1189    gtk_notebook_append_page( GTK_NOTEBOOK( n ),  w, lb );
     1190    g_object_set_data( G_OBJECT( d ), "peers-top", w );
    15151191
    15161192    w = tracker_page_new( gtor );
     1193    lb = gtk_label_new( _( "Tracker" ) );
     1194    gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, lb );
    15171195    g_object_set_data( G_OBJECT( d ), "tracker-top", w );
    1518     gtk_notebook_append_page( GTK_NOTEBOOK( n ), w,
    1519                              gtk_label_new( _( "Tracker" ) ) );
    1520 
    1521     gtk_notebook_append_page ( GTK_NOTEBOOK( n ),
    1522                               info_page_new ( tor ),
    1523                               gtk_label_new ( _( "Information" ) ) );
     1196
     1197    w = info_page_new( tor );
     1198    lb = gtk_label_new( _( "Information" ) );
     1199    gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, lb );
    15241200
    15251201    w = file_list_new( gtor );
    15261202    gtk_container_set_border_width( GTK_CONTAINER( w ), GUI_PAD_BIG );
    1527     g_object_set_data ( G_OBJECT( d ), "files-top", w );
    1528     gtk_notebook_append_page ( GTK_NOTEBOOK( n ), w,
    1529                               gtk_label_new ( _( "Files" ) ) );
    1530 
    1531     w = options_page_new ( gtor );
    1532     g_object_set_data ( G_OBJECT( d ), "options-top", w );
    1533     gtk_notebook_append_page ( GTK_NOTEBOOK( n ), w,
    1534                               gtk_label_new ( _( "Options" ) ) );
     1203    lb = gtk_label_new( _( "Files" ) );
     1204    gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, lb );
     1205    g_object_set_data( G_OBJECT( d ), "files-top", w );
     1206
     1207    w = options_page_new( gtor );
     1208    lb = gtk_label_new( _( "Options" ) );
     1209    gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, lb );
     1210    g_object_set_data( G_OBJECT( d ), "options-top", w );
    15351211
    15361212    gtk_box_pack_start( GTK_BOX( GTK_DIALOG( d )->vbox ), n, TRUE, TRUE, 0 );
    15371213
    15381214    tag = gtr_timeout_add_seconds( UPDATE_INTERVAL_SECONDS, periodic_refresh, d );
    1539     g_object_set_data_full ( G_OBJECT( d ), "tag",
    1540                              GUINT_TO_POINTER( tag ), remove_tag );
    1541 
    1542     /* return the results */
    1543     periodic_refresh ( d );
    1544     gtk_widget_show_all ( GTK_DIALOG( d )->vbox );
     1215    g_object_set_data_full( G_OBJECT( d ), "tag", GUINT_TO_POINTER( tag ), remove_tag );
     1216    periodic_refresh( d );
     1217    gtk_widget_show_all( GTK_DIALOG( d )->vbox );
    15451218    return d;
    15461219}
  • branches/1.5x/gtk/file-list.c

    r7664 r8205  
    158158#if 0
    159159    gtk_tree_store_set( store, &iter, FC_INDEX, index,
    160                         FC_LABEL, file,
    161                         FC_KEY, mykey,
    162                         FC_STOCK, stock,
    163                         FC_PRIORITY, priority,
    164                         FC_ENABLED, enabled,
    165                         FC_IS_FILE, is_file,
    166                         FC_SIZE, size,
    167                         FC_HAVE, 0,
    168                         -1 );
     160                                      FC_LABEL, file,
     161                                      FC_KEY, mykey,
     162                                      FC_STOCK, stock,
     163                                      FC_PRIORITY, priority,
     164                                      FC_ENABLED, enabled,
     165                                      FC_IS_FILE, is_file,
     166                                      FC_SIZE, size,
     167                                      FC_HAVE, 0,
     168                                      -1 );
    169169#else
    170170    gtk_tree_store_set( store, &iter, FC_INDEX, index, -1 );
  • branches/1.5x/gtk/hig.c

    r7664 r8205  
    8888    GtkWidget * r = rowNew( w );
    8989
    90     gtk_table_attach( GTK_TABLE(
    91                           t ), r, 0, 2, *row, *row + 1, GTK_FILL, 0, 0, 0 );
     90    gtk_table_attach( GTK_TABLE( t ), r, 0, 2, *row, *row + 1, GTK_FILL, 0, 0, 0 );
    9291    ++ * row;
    9392}
     
    113112    GtkWidget * w = rowNew( l );
    114113
    115     gtk_table_attach( GTK_TABLE(
    116                           t ), w, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0,
    117                       0 );
     114    gtk_table_attach( GTK_TABLE( t ), w, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0 );
    118115}
    119116
  • branches/1.5x/gtk/main.c

    r8048 r8205  
    3535#include <glib/gi18n.h>
    3636#include <glib/gstdio.h>
    37 
    38 #include <gdk/gdk.h>
    39 #ifdef GDK_WINDOWING_X11
    40  #include <X11/Xatom.h>
    41  #include <gdk/gdkx.h>
    42 #endif
    4337
    4438#include <libtransmission/transmission.h>
     
    353347    gboolean            startpaused = FALSE;
    354348    gboolean            startminimized = FALSE;
    355     char *              domain = MY_NAME;
     349    const char *        domain = MY_NAME;
    356350    char *              configDir = NULL;
    357351    tr_lockfile_state_t tr_state;
     
    389383    gerr = NULL;
    390384    if( !gtk_init_with_args( &argc, &argv, _( "[torrent files]" ), entries,
    391                              domain, &gerr ) )
     385                             (char*)domain, &gerr ) )
    392386    {
    393387        fprintf( stderr, "%s\n", gerr->message );
     
    900894{
    901895    GtkTargetEntry targets[] = {
    902         { "STRING",          0, 0 },
    903         { "text/plain",      0, 0 },
    904         { "text/uri-list",   0, 0 },
     896        { (char*)"STRING",          0, 0 },
     897        { (char*)"text/plain",      0, 0 },
     898        { (char*)"text/uri-list",   0, 0 },
    905899    };
    906900
     
    10521046    else if( !strcmp( key, TR_PREFS_KEY_PEER_PORT ) )
    10531047    {
    1054         const int port = pref_int_get( key );
    1055         tr_sessionSetPeerPort( tr, port );
     1048        tr_sessionSetPeerPort( tr, pref_int_get( key ) );
    10561049    }
    10571050    else if( !strcmp( key, TR_PREFS_KEY_BLOCKLIST_ENABLED ) )
    10581051    {
    1059         const gboolean flag = pref_flag_get( key );
    1060         tr_blocklistSetEnabled( tr, flag );
     1052        tr_blocklistSetEnabled( tr, pref_flag_get( key ) );
    10611053    }
    10621054    else if( !strcmp( key, PREF_KEY_SHOW_TRAY_ICON ) )
     
    10651057        if( show && !cbdata->icon )
    10661058            cbdata->icon = tr_icon_new( cbdata->core );
    1067         else if( !show && cbdata->icon )
    1068         {
     1059        else if( !show && cbdata->icon ) {
    10691060            g_object_unref( cbdata->icon );
    10701061            cbdata->icon = NULL;
     
    10731064    else if( !strcmp( key, TR_PREFS_KEY_DSPEED_ENABLED ) )
    10741065    {
    1075         const gboolean b = pref_flag_get( key );
    1076         tr_sessionSetSpeedLimitEnabled( tr, TR_DOWN, b );
     1066        tr_sessionSetSpeedLimitEnabled( tr, TR_DOWN, pref_flag_get( key ) );
    10771067    }
    10781068    else if( !strcmp( key, TR_PREFS_KEY_DSPEED ) )
    10791069    {
    1080         const int limit = pref_int_get( key );
    1081         tr_sessionSetSpeedLimit( tr, TR_DOWN, limit );
     1070        tr_sessionSetSpeedLimit( tr, TR_DOWN, pref_int_get( key ) );
    10821071    }
    10831072    else if( !strcmp( key, TR_PREFS_KEY_USPEED_ENABLED ) )
    10841073    {
    1085         const gboolean b = pref_flag_get( key );
    1086         tr_sessionSetSpeedLimitEnabled( tr, TR_UP, b );
     1074        tr_sessionSetSpeedLimitEnabled( tr, TR_UP, pref_flag_get( key ) );
    10871075    }
    10881076    else if( !strcmp( key, TR_PREFS_KEY_USPEED ) )
    10891077    {
    1090         const int limit = pref_int_get( key );
    1091         tr_sessionSetSpeedLimit( tr, TR_UP, limit );
     1078        tr_sessionSetSpeedLimit( tr, TR_UP, pref_int_get( key ) );
    10921079    }
    10931080    else if( !strncmp( key, "sched-", 6 ) )
     
    11131100    else if( !strcmp( key, TR_PREFS_KEY_RPC_WHITELIST ) )
    11141101    {
    1115         const char * s = pref_string_get( key );
    1116         tr_sessionSetRPCWhitelist( tr, s );
     1102        tr_sessionSetRPCWhitelist( tr, pref_string_get( key ) );
    11171103    }
    11181104    else if( !strcmp( key, TR_PREFS_KEY_RPC_WHITELIST_ENABLED ) )
     
    11221108    else if( !strcmp( key, TR_PREFS_KEY_RPC_USERNAME ) )
    11231109    {
    1124         const char * s = pref_string_get( key );
    1125         tr_sessionSetRPCUsername( tr, s );
     1110        tr_sessionSetRPCUsername( tr, pref_string_get( key ) );
    11261111    }
    11271112    else if( !strcmp( key, TR_PREFS_KEY_RPC_PASSWORD ) )
    11281113    {
    1129         const char * s = pref_string_get( key );
    1130         tr_sessionSetRPCPassword( tr, s );
     1114        tr_sessionSetRPCPassword( tr, pref_string_get( key ) );
    11311115    }
    11321116    else if( !strcmp( key, TR_PREFS_KEY_RPC_AUTH_REQUIRED ) )
    11331117    {
    1134         const gboolean enabled = pref_flag_get( key );
    1135         tr_sessionSetRPCPasswordEnabled( tr, enabled );
     1118        tr_sessionSetRPCPasswordEnabled( tr, pref_flag_get( key ) );
    11361119    }
    11371120    else if( !strcmp( key, TR_PREFS_KEY_PROXY ) )
    11381121    {
    1139         const char * s = pref_string_get( key );
    1140         tr_sessionSetProxy( tr, s );
     1122        tr_sessionSetProxy( tr, pref_string_get( key ) );
    11411123    }
    11421124    else if( !strcmp( key, TR_PREFS_KEY_PROXY_TYPE ) )
    11431125    {
    1144         const int i = pref_int_get( key );
    1145         tr_sessionSetProxyType( tr, i );
     1126        tr_sessionSetProxyType( tr, pref_int_get( key ) );
    11461127    }
    11471128    else if( !strcmp( key, TR_PREFS_KEY_PROXY_ENABLED ) )
    11481129    {
    1149         const gboolean enabled = pref_flag_get( key );
    1150         tr_sessionSetProxyEnabled( tr, enabled );
     1130        tr_sessionSetProxyEnabled( tr, pref_flag_get( key ) );
    11511131    }
    11521132    else if( !strcmp( key, TR_PREFS_KEY_PROXY_AUTH_ENABLED ) )
    11531133    {
    1154         const gboolean enabled = pref_flag_get( key );
    1155         tr_sessionSetProxyAuthEnabled( tr, enabled );
     1134        tr_sessionSetProxyAuthEnabled( tr, pref_flag_get( key ) );
    11561135    }
    11571136    else if( !strcmp( key, TR_PREFS_KEY_PROXY_USERNAME ) )
    11581137    {
    1159         const char * s = pref_string_get( key );
    1160         tr_sessionSetProxyUsername( tr, s );
     1138        tr_sessionSetProxyUsername( tr, pref_string_get( key ) );
    11611139    }
    11621140    else if( !strcmp( key, TR_PREFS_KEY_PROXY_PASSWORD ) )
    11631141    {
    1164         const char * s = pref_string_get( key );
    1165         tr_sessionSetProxyPassword( tr, s );
     1142        tr_sessionSetProxyPassword( tr, pref_string_get( key ) );
    11661143    }
    11671144    else if( !strcmp( key, TR_PREFS_KEY_PROXY_PORT ) )
     
    11711148    else if( !strcmp( key, TR_PREFS_KEY_RPC_PASSWORD ) )
    11721149    {
    1173         const char * s = pref_string_get( key );
    1174         tr_sessionSetProxyPassword( tr, s );
     1150        tr_sessionSetProxyPassword( tr, pref_string_get( key ) );
    11751151    }
    11761152}
  • branches/1.5x/gtk/tr-core.c

    r7861 r8205  
    125125}
    126126
    127 static void
    128 tr_core_marshal_prompt( GClosure *     closure,
    129                         GValue * ret   UNUSED,
    130                         guint          count,
    131                         const GValue * vals,
    132                         gpointer hint  UNUSED,
    133                         gpointer       marshal )
    134 {
    135     typedef void ( *TRMarshalPrompt )( gpointer, tr_ctor *, gpointer );
    136     TRMarshalPrompt callback;
    137     GCClosure *     cclosure = (GCClosure*) closure;
    138     gpointer        ctor;
    139     gpointer        inst, gdata;
    140 
    141     g_return_if_fail( count == 2 );
    142 
    143     inst      = g_value_peek_pointer( vals );
    144     ctor      = g_value_peek_pointer( vals + 1 );
    145     gdata     = closure->data;
    146 
    147     callback = (TRMarshalPrompt)( marshal ? marshal : cclosure->callback );
    148     callback( inst, ctor, gdata );
    149 }
    150 
    151127static int
    152128isDisposed( const TrCore * core )
     
    185161
    186162    core_class = TR_CORE_CLASS( g_class );
     163
    187164    core_class->blocksig = g_signal_new( "blocklist-status",
    188                                          G_TYPE_FROM_CLASS(
    189                                              g_class ),
     165                                         G_TYPE_FROM_CLASS( g_class ),
    190166                                         G_SIGNAL_RUN_LAST, 0, NULL, NULL,
    191167                                         tr_core_marshal_blocklist,
    192168                                         G_TYPE_NONE,
    193169                                         2, G_TYPE_BOOLEAN, G_TYPE_STRING );
    194     core_class->errsig = g_signal_new( "error", G_TYPE_FROM_CLASS( g_class ),
     170
     171    core_class->errsig = g_signal_new( "error",
     172                                       G_TYPE_FROM_CLASS( g_class ),
    195173                                       G_SIGNAL_RUN_LAST, 0, NULL, NULL,
    196174                                       tr_core_marshal_err, G_TYPE_NONE,
    197175                                       2, G_TYPE_INT, G_TYPE_STRING );
     176
    198177    core_class->promptsig = g_signal_new( "add-torrent-prompt",
    199                                           G_TYPE_FROM_CLASS(
    200                                               g_class ),
     178                                          G_TYPE_FROM_CLASS( g_class ),
    201179                                          G_SIGNAL_RUN_LAST, 0, NULL, NULL,
    202                                           tr_core_marshal_prompt,
     180                                          g_cclosure_marshal_VOID__POINTER,
    203181                                          G_TYPE_NONE,
    204182                                          1, G_TYPE_POINTER );
    205     core_class->quitsig = g_signal_new( "quit", G_TYPE_FROM_CLASS( g_class ),
     183
     184    core_class->quitsig = g_signal_new( "quit",
     185                                        G_TYPE_FROM_CLASS( g_class ),
    206186                                        G_SIGNAL_RUN_LAST, 0, NULL, NULL,
    207187                                        g_cclosure_marshal_VOID__VOID,
    208188                                        G_TYPE_NONE, 0 );
     189
    209190    core_class->prefsig = g_signal_new( "prefs-changed",
    210191                                        G_TYPE_FROM_CLASS( g_class ),
     
    247228
    248229static int
    249 compareDouble( double a,
    250                double b )
     230compareDouble( double a, double b )
    251231{
    252232    if( a < b ) return -1;
     
    256236
    257237static int
    258 compareRatio( double a,
    259               double b )
     238compareRatio( double a, double b )
    260239{
    261240    if( (int)a == TR_RATIO_INF && (int)b == TR_RATIO_INF ) return 0;
     
    266245
    267246static int
    268 compareTime( time_t a,
    269              time_t b )
     247compareTime( time_t a, time_t b )
    270248{
    271249    if( a < b ) return -1;
     
    275253
    276254static int
    277 compareByRatio( GtkTreeModel *           model,
    278                 GtkTreeIter *            a,
    279                 GtkTreeIter *            b,
     255compareByRatio( GtkTreeModel * model,
     256                GtkTreeIter  * a,
     257                GtkTreeIter  * b,
    280258                gpointer       user_data UNUSED )
    281259{
     
    293271
    294272static int
    295 compareByActivity( GtkTreeModel *           model,
    296                    GtkTreeIter *            a,
    297                    GtkTreeIter *            b,
     273compareByActivity( GtkTreeModel * model,
     274                   GtkTreeIter  * a,
     275                   GtkTreeIter  * b,
    298276                   gpointer       user_data UNUSED )
    299277{
     
    390368
    391369static int
    392 compareByTracker( GtkTreeModel *             model,
    393                   GtkTreeIter *              a,
    394                   GtkTreeIter *              b,
    395                   gpointer         user_data UNUSED )
     370compareByTracker( GtkTreeModel * model,
     371                  GtkTreeIter  * a,
     372                  GtkTreeIter  * b,
     373                  gpointer       user_data UNUSED )
    396374{
    397375    const tr_torrent *ta, *tb;
     
    988966    if( findTorrentInModel( core, id, &iter ) )
    989967    {
    990         TrTorrent *    gtor;
     968        TrTorrent * gtor;
    991969        GtkTreeModel * model = tr_core_model( core );
    992970        gtk_tree_model_get( model, &iter, MC_TORRENT, &gtor, -1 );
  • branches/1.5x/gtk/tr-window.c

    r7994 r8205  
    9393    filter_text_mode_t    filter_text_mode;
    9494    char *                filter_text;
     95    GtkToggleButton     * filter_toggles[FILTER_MODE_QTY];
    9596}
    9697PrivateData;
     
    9899#define PRIVATE_DATA_KEY "private-data"
    99100
    100 #define FILTER_MODE_KEY "tr-filter-mode"
    101101#define FILTER_TEXT_MODE_KEY "tr-filter-text-mode"
    102 #define FILTER_TOGGLES_KEY "tr-filter-toggles"
    103102
    104103static PrivateData*
     
    340339        {
    341340            const tr_stat * s = tr_torrentStatCached( tor );
    342             ret = s->peersSendingToUs > 0 || s->peersGettingFromUs > 0;
     341            ret = s->peersSendingToUs > 0
     342               || s->peersGettingFromUs > 0
     343               || tr_torrentGetActivity( tor ) == TR_STATUS_CHECK;
    343344            break;
    344345        }
     
    393394                   gpointer          vprivate )
    394395{
    395     PrivateData *       p = vprivate;
    396     GSList *            l;
    397     GSList *            toggles = g_object_get_data( G_OBJECT(
    398                                                          toggle ),
    399                                                      FILTER_TOGGLES_KEY );
    400     const gboolean      isActive = gtk_toggle_button_get_active( toggle );
    401     const filter_mode_t mode =
    402         GPOINTER_TO_UINT( g_object_get_data( G_OBJECT( toggle ),
    403                                              FILTER_MODE_KEY ) );
    404 
    405     /* update the filter */
    406     if( isActive )
    407     {
     396    int mode = -1;
     397    PrivateData * p = vprivate;
     398
     399    if( gtk_toggle_button_get_active( toggle ) )
     400    {
     401        int i;
     402        for( i=0; i<FILTER_MODE_QTY; ++i )
     403            if( p->filter_toggles[i] == toggle )
     404                mode = i;
     405            else
     406                gtk_toggle_button_set_active( p->filter_toggles[i], FALSE );
     407    }
     408
     409    if( mode >= 0 ) {
    408410        p->filter_mode = mode;
    409411        refilter( p );
    410412    }
    411 
    412     /* deactivate the other toggles */
    413     for( l = toggles; l != NULL; l = l->next )
    414     {
    415         GtkToggleButton * walk = GTK_TOGGLE_BUTTON( l->data );
    416         if( isActive && ( toggle != walk ) )
    417             gtk_toggle_button_set_active( walk, FALSE );
    418     }
    419 
    420     /* at least one button must always be set */
    421     if( !isActive && ( p->filter_mode == mode ) )
    422         gtk_toggle_button_set_active( toggle, TRUE );
    423413}
    424414
     
    515505    GtkWindow *   win;
    516506    GSList *      l;
    517     GSList *      toggles;
    518507
    519508    const char *  filter_names[FILTER_MODE_QTY] = {
     
    568557
    569558    /* filter */
    570     toggles = NULL;
    571559    h = filter = p->filter = gtk_hbox_new( FALSE, 0 );
    572560    gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
     
    575563        const char * mnemonic = _( filter_names[i] );
    576564        w = gtk_toggle_button_new_with_mnemonic( mnemonic );
    577         g_object_set_data( G_OBJECT( w ), FILTER_MODE_KEY,
    578                           GINT_TO_POINTER( i ) );
    579565        gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
    580         gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(
    581                                           w ), i == FILTER_MODE_ALL );
    582         toggles = g_slist_prepend( toggles, w );
     566        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), i == FILTER_MODE_ALL );
     567        p->filter_toggles[i] = GTK_TOGGLE_BUTTON( w );
    583568        g_signal_connect( w, "toggled", G_CALLBACK( filter_toggled_cb ), p );
    584569        gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
    585570    }
    586     for( l = toggles; l != NULL; l = l->next )
    587         g_object_set_data( G_OBJECT( l->data ), FILTER_TOGGLES_KEY, toggles );
    588571    s = sexy_icon_entry_new( );
    589572    sexy_icon_entry_add_clear_button( SEXY_ICON_ENTRY( s ) );
    590573    image = gtk_image_new_from_stock( GTK_STOCK_FIND, GTK_ICON_SIZE_MENU );
    591     sexy_icon_entry_set_icon( SEXY_ICON_ENTRY(
    592                                  s ), SEXY_ICON_ENTRY_PRIMARY,
    593                              GTK_IMAGE( image ) );
    594     sexy_icon_entry_set_icon_highlight( SEXY_ICON_ENTRY(
    595                                             s ), SEXY_ICON_ENTRY_PRIMARY,
    596                                         TRUE );
     574    sexy_icon_entry_set_icon( SEXY_ICON_ENTRY( s ), SEXY_ICON_ENTRY_PRIMARY, GTK_IMAGE( image ) );
     575    sexy_icon_entry_set_icon_highlight( SEXY_ICON_ENTRY( s ), SEXY_ICON_ENTRY_PRIMARY, TRUE );
    597576    gtk_box_pack_end( GTK_BOX( h ), s, FALSE, FALSE, 0 );
    598577    g_signal_connect( s, "changed", G_CALLBACK( filter_entry_changed ), p );
  • branches/1.5x/gtk/util.c

    r8165 r8205  
    570570        if( !opened )
    571571        {
    572             char * argv[] = { "xdg-open", (char*)path, NULL };
     572            char * argv[] = { (char*)"xdg-open", (char*)path, NULL };
    573573            g_spawn_async( NULL, argv, NULL, G_SPAWN_SEARCH_PATH,
    574574                           NULL, NULL, NULL, NULL );
     
    657657
    658658guint
    659 gtr_timeout_add_seconds( guint        interval,
    660                          GSourceFunc  function,
    661                          gpointer     data )
     659gtr_timeout_add_seconds( guint seconds, GSourceFunc function, gpointer data )
    662660{
    663661#if GLIB_CHECK_VERSION( 2,14,0 )
    664     return g_timeout_add_seconds( interval, function, data );
     662    return g_timeout_add_seconds( seconds, function, data );
    665663#else
    666     return g_timeout_add( interval*1000, function, data );
     664    return g_timeout_add( seconds*1000, function, data );
    667665#endif
    668666}
Note: See TracChangeset for help on using the changeset viewer.