source: trunk/gtk/tr-window.c @ 8238

Last change on this file since 8238 was 8238, checked in by charles, 13 years ago

(trunk gtk) #1522: Lack of fast bw limit settings and display

  • Property svn:keywords set to Date Rev Author Id
File size: 39.4 KB
Line 
1/******************************************************************************
2 * $Id: tr-window.c 8238 2009-04-15 04:28:04Z charles $
3 *
4 * Copyright (c) 2005-2008 Transmission authors and contributors
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *****************************************************************************/
24
25#include <string.h>
26
27#include <gtk/gtk.h>
28#include <glib/gi18n.h>
29
30#include <libtransmission/transmission.h>
31
32#include "actions.h"
33#include "conf.h"
34#include "hig.h"
35#include "sexy-icon-entry.h"
36#include "torrent-cell-renderer.h"
37#include "tr-prefs.h"
38#include "tr-torrent.h"
39#include "tr-window.h"
40#include "util.h"
41
42#if !GTK_CHECK_VERSION( 2, 8, 0 )
43static void
44gtk_tree_view_column_queue_resize( GtkTreeViewColumn * column ) /* yuck */
45{
46    const int spacing = gtk_tree_view_column_get_spacing( column );
47
48    gtk_tree_view_column_set_spacing( column, spacing + 1 );
49    gtk_tree_view_column_set_spacing( column, spacing );
50}
51
52#endif
53
54typedef enum
55{
56    FILTER_TEXT_MODE_NAME,
57    FILTER_TEXT_MODE_FILES,
58    FILTER_TEXT_MODE_TRACKER,
59    FILTER_TEXT_MODE_QTY
60}
61filter_text_mode_t;
62
63typedef enum
64{
65    FILTER_MODE_ALL,
66    FILTER_MODE_ACTIVE,
67    FILTER_MODE_DOWNLOADING,
68    FILTER_MODE_SEEDING,
69    FILTER_MODE_PAUSED,
70    FILTER_MODE_QTY
71}
72filter_mode_t;
73
74typedef struct
75{
76    GtkWidget *           ratio_on_item;
77    GtkWidget *           ratio_off_item;
78    GtkWidget *           downlimit_on_item;
79    GtkWidget *           downlimit_off_item;
80    GtkWidget *           uplimit_on_item;
81    GtkWidget *           uplimit_off_item;
82    GtkWidget *           scroll;
83    GtkWidget *           view;
84    GtkWidget *           toolbar;
85    GtkWidget *           filter;
86    GtkWidget *           status;
87    GtkWidget *           status_menu;
88    GtkWidget *           ul_lb;
89    GtkWidget *           dl_lb;
90    GtkWidget *           stats_lb;
91    GtkWidget *           gutter_lb;
92    GtkWidget *           alt_speed_image[2]; /* 0==off, 1==on */
93    GtkWidget *           alt_speed_button;
94    GtkWidget *           options_menu;
95    GtkTreeSelection *    selection;
96    GtkCellRenderer *     renderer;
97    GtkTreeViewColumn *   column;
98    GtkTreeModel *        filter_model;
99    TrCore *              core;
100    gulong                pref_handler_id;
101    filter_mode_t         filter_mode;
102    filter_text_mode_t    filter_text_mode;
103    char *                filter_text;
104    GtkToggleButton     * filter_toggles[FILTER_MODE_QTY];
105}
106PrivateData;
107
108static const char*
109getFilterName( int mode )
110{
111    switch( mode )
112    {
113        case FILTER_MODE_ACTIVE:      return "show-active";
114        case FILTER_MODE_DOWNLOADING: return "show-downloading";
115        case FILTER_MODE_SEEDING:     return "show-seeding";
116        case FILTER_MODE_PAUSED:      return "show-paused";
117        default:                      return "show-active"; /* the fallback */
118    }
119}
120static int
121getFilterModeFromName( const char * name )
122{
123    if( !strcmp( name, "show-active"      ) ) return FILTER_MODE_ACTIVE;
124    if( !strcmp( name, "show-downloading" ) ) return FILTER_MODE_DOWNLOADING;
125    if( !strcmp( name, "show-seeding"     ) ) return FILTER_MODE_SEEDING;
126    if( !strcmp( name, "show-paused"      ) ) return FILTER_MODE_PAUSED;
127    return FILTER_MODE_ALL; /* the fallback */
128}
129
130#define PRIVATE_DATA_KEY "private-data"
131#define FILTER_MODE_KEY "tr-filter-mode"
132#define FILTER_TEXT_MODE_KEY "tr-filter-text-mode"
133
134static PrivateData*
135get_private_data( TrWindow * w )
136{
137    return g_object_get_data ( G_OBJECT( w ), PRIVATE_DATA_KEY );
138}
139
140/***
141****
142***/
143
144static void
145on_popup_menu( GtkWidget * self UNUSED,
146               GdkEventButton * event )
147{
148    GtkWidget * menu = action_get_widget ( "/main-window-popup" );
149
150    gtk_menu_popup ( GTK_MENU( menu ), NULL, NULL, NULL, NULL,
151                    ( event ? event->button : 0 ),
152                    ( event ? event->time : 0 ) );
153}
154
155static void
156view_row_activated( GtkTreeView       * tree_view UNUSED,
157                    GtkTreePath       * path      UNUSED,
158                    GtkTreeViewColumn * column    UNUSED,
159                    gpointer            user_data UNUSED )
160{
161    action_activate( "show-torrent-properties" );
162}
163
164static gboolean is_row_visible( GtkTreeModel *,
165                                GtkTreeIter  *,
166                                gpointer );
167
168static GtkWidget*
169makeview( PrivateData * p,
170          TrCore *      core )
171{
172    GtkWidget *         view;
173    GtkTreeViewColumn * col;
174    GtkTreeSelection *  sel;
175    GtkCellRenderer *   r;
176    GtkTreeModel *      filter_model;
177
178    view = gtk_tree_view_new( );
179    gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( view ), FALSE );
180    gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW( view ), TRUE );
181
182    p->selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
183
184    p->column = col = GTK_TREE_VIEW_COLUMN (g_object_new (GTK_TYPE_TREE_VIEW_COLUMN,                 
185        "title", _("Torrent"),
186        "resizable", TRUE,
187        "sizing", GTK_TREE_VIEW_COLUMN_FIXED,
188        NULL));
189
190    p->renderer = r = torrent_cell_renderer_new( );
191    gtk_tree_view_column_pack_start( col, r, FALSE );
192    gtk_tree_view_column_add_attribute( col, r, "torrent", MC_TORRENT_RAW );
193   
194    gtk_tree_view_append_column( GTK_TREE_VIEW( view ), col );
195    g_object_set( r, "xpad", GUI_PAD_SMALL, "ypad", GUI_PAD_SMALL, NULL );
196
197    gtk_tree_view_set_rules_hint( GTK_TREE_VIEW( view ), TRUE );
198    sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
199    gtk_tree_selection_set_mode( GTK_TREE_SELECTION( sel ),
200                                 GTK_SELECTION_MULTIPLE );
201
202    g_signal_connect( view, "popup-menu",
203                      G_CALLBACK( on_popup_menu ), NULL );
204    g_signal_connect( view, "button-press-event",
205                      G_CALLBACK( on_tree_view_button_pressed ),
206                      (void *) on_popup_menu );
207    g_signal_connect( view, "button-release-event",
208                      G_CALLBACK( on_tree_view_button_released ), NULL );
209    g_signal_connect( view, "row-activated",
210                      G_CALLBACK( view_row_activated ), NULL );
211
212
213    filter_model = p->filter_model = gtk_tree_model_filter_new(
214                       tr_core_model( core ), NULL );
215
216    gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER(
217                                                filter_model ),
218                                            is_row_visible,
219                                            p, NULL );
220
221    gtk_tree_view_set_model( GTK_TREE_VIEW( view ), filter_model );
222
223    return view;
224}
225
226static void syncAltSpeedButton( PrivateData * p );
227static void setFilter( PrivateData * p, int mode );
228
229static void
230prefsChanged( TrCore * core UNUSED,
231              const char *  key,
232              gpointer      wind )
233{
234    PrivateData * p = get_private_data( GTK_WINDOW( wind ) );
235
236    if( !strcmp( key, PREF_KEY_MINIMAL_VIEW ) )
237    {
238        g_object_set( p->renderer, "minimal", pref_flag_get( key ), NULL );
239        /* since the cell size has changed, we need gtktreeview to revalidate
240         * its fixed-height mode values.  Unfortunately there's not an API call
241         * for that, but it *does* revalidate when it thinks the style's been tweaked */
242        g_signal_emit_by_name( p->view, "style-set", NULL, NULL );
243    }
244    else if( !strcmp( key, PREF_KEY_FILTER_MODE ) )
245    {
246        setFilter( p, getFilterModeFromName( pref_string_get( key ) ) );
247    }
248    else if( !strcmp( key, PREF_KEY_STATUSBAR ) )
249    {
250        const gboolean isEnabled = pref_flag_get( key );
251        g_object_set( p->status, "visible", isEnabled, NULL );
252    }
253    else if( !strcmp( key, PREF_KEY_FILTERBAR ) )
254    {
255        const gboolean isEnabled = pref_flag_get( key );
256        g_object_set( p->filter, "visible", isEnabled, NULL );
257    }
258    else if( !strcmp( key, PREF_KEY_TOOLBAR ) )
259    {
260        const gboolean isEnabled = pref_flag_get( key );
261        g_object_set( p->toolbar, "visible", isEnabled, NULL );
262    }
263    else if( !strcmp( key, PREF_KEY_STATUSBAR_STATS ) )
264    {
265        tr_window_update( (TrWindow*)wind );
266    }
267    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_ENABLED ) )
268    {
269        syncAltSpeedButton( p );
270    }
271}
272
273static void
274privateFree( gpointer vprivate )
275{
276    PrivateData * p = vprivate;
277
278    g_signal_handler_disconnect( p->core, p->pref_handler_id );
279    g_free( p->filter_text );
280    g_free( p );
281}
282
283static void
284onYinYangReleased( GtkWidget * w           UNUSED,
285                   GdkEventButton * button UNUSED,
286                   gpointer                vprivate )
287{
288    PrivateData * p = vprivate;
289
290    gtk_menu_popup( GTK_MENU(
291                       p->status_menu ), NULL, NULL, NULL, NULL, 0,
292                   gtk_get_current_event_time( ) );
293}
294
295#define STATS_MODE "stats-mode"
296
297static struct
298{
299    const char *  val, *i18n;
300} stats_modes[] = {
301    { "total-ratio",      N_( "Total Ratio" )                },
302    { "session-ratio",    N_( "Session Ratio" )              },
303    { "total-transfer",   N_( "Total Transfer" )             },
304    { "session-transfer", N_( "Session Transfer" )           }
305};
306
307static void
308status_menu_toggled_cb( GtkCheckMenuItem * menu_item,
309                        gpointer           vprivate )
310{
311    if( gtk_check_menu_item_get_active( menu_item ) )
312    {
313        PrivateData * p = vprivate;
314        const char *  val = g_object_get_data( G_OBJECT(
315                                                   menu_item ), STATS_MODE );
316        tr_core_set_pref( p->core, PREF_KEY_STATUSBAR_STATS, val );
317    }
318}
319
320static void
321syncAltSpeedButton( PrivateData * p )
322{
323    const char * tip;
324    const gboolean b = pref_flag_get( TR_PREFS_KEY_ALT_SPEED_ENABLED );
325    GtkWidget * w = p->alt_speed_button;
326
327    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
328
329    gtk_button_set_image( GTK_BUTTON( w ), p->alt_speed_image[b?1:0] );
330    gtk_button_set_alignment( GTK_BUTTON( w ), 0.5, 0.5 );
331
332    tip = b ? _( "Click to disable Speed Limit Mode" )
333            : _( "Click to enable Speed Limit Mode" );
334    gtr_widget_set_tooltip_text( w, tip );
335}
336
337static void
338alt_speed_toggled_cb( GtkToggleButton * button, gpointer vprivate )
339{
340    PrivateData * p = vprivate;
341    const gboolean b = gtk_toggle_button_get_active( button );
342    tr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED,  b );
343}
344   
345/***
346****  FILTER
347***/
348
349static int
350checkFilterText( filter_text_mode_t    filter_text_mode,
351                 const tr_info       * torInfo,
352                 const char          * text )
353{
354    tr_file_index_t i;
355    int             ret = 0;
356    char *          pch;
357
358    switch( filter_text_mode )
359    {
360        case FILTER_TEXT_MODE_FILES:
361            for( i = 0; i < torInfo->fileCount && !ret; ++i )
362            {
363                pch = g_utf8_casefold( torInfo->files[i].name, -1 );
364                ret = !text || strstr( pch, text ) != NULL;
365                g_free( pch );
366            }
367            break;
368
369        case FILTER_TEXT_MODE_TRACKER:
370            pch = g_utf8_casefold( torInfo->trackers[0].announce, -1 );
371            ret = !text || ( strstr( pch, text ) != NULL );
372            g_free( pch );
373            break;
374
375        default: /* NAME */
376            pch = g_utf8_casefold( torInfo->name, -1 );
377            ret = !text || ( strstr( pch, text ) != NULL );
378            g_free( pch );
379            break;
380    }
381
382    return ret;
383}
384
385static int
386checkFilterMode( filter_mode_t filter_mode,
387                 tr_torrent *  tor )
388{
389    int ret = 0;
390
391    switch( filter_mode )
392    {
393        case FILTER_MODE_DOWNLOADING:
394            ret = tr_torrentGetActivity( tor ) == TR_STATUS_DOWNLOAD;
395            break;
396
397        case FILTER_MODE_SEEDING:
398            ret = tr_torrentGetActivity( tor ) == TR_STATUS_SEED;
399            break;
400
401        case FILTER_MODE_PAUSED:
402            ret = tr_torrentGetActivity( tor ) == TR_STATUS_STOPPED;
403            break;
404
405        case FILTER_MODE_ACTIVE:
406        {
407            const tr_stat * s = tr_torrentStatCached( tor );
408            ret = s->peersSendingToUs > 0
409               || s->peersGettingFromUs > 0
410               || tr_torrentGetActivity( tor ) == TR_STATUS_CHECK;
411            break;
412        }
413
414        default: /* all */
415            ret = 1;
416    }
417
418    return ret;
419}
420
421static gboolean
422is_row_visible( GtkTreeModel * model,
423                GtkTreeIter *  iter,
424                gpointer       vprivate )
425{
426    PrivateData * p = vprivate;
427    tr_torrent *  tor;
428
429    gtk_tree_model_get( model, iter, MC_TORRENT_RAW, &tor, -1 );
430
431    return checkFilterMode( p->filter_mode, tor )
432           && checkFilterText( p->filter_text_mode, tr_torrentInfo( tor ), p->filter_text );
433}
434
435static void updateTorrentCount( PrivateData * p );
436
437static void
438refilter( PrivateData * p )
439{
440    gtk_tree_model_filter_refilter( GTK_TREE_MODEL_FILTER( p->filter_model ) );
441
442    updateTorrentCount( p );
443}
444
445static void
446filter_text_toggled_cb( GtkCheckMenuItem * menu_item,
447                        gpointer           vprivate )
448{
449    if( gtk_check_menu_item_get_active( menu_item ) )
450    {
451        PrivateData * p = vprivate;
452        p->filter_text_mode =
453            GPOINTER_TO_UINT( g_object_get_data( G_OBJECT( menu_item ),
454                                                 FILTER_TEXT_MODE_KEY ) );
455        refilter( p );
456    }
457}
458
459static void
460setFilter( PrivateData * p, int mode )
461{
462    if( mode != (int)p->filter_mode )
463    {
464        int i;
465
466        /* refilter */
467        p->filter_mode = mode;
468        refilter( p );
469
470        /* update the prefs */
471        tr_core_set_pref( p->core, PREF_KEY_FILTER_MODE, getFilterName( mode ) );
472
473        /* update the togglebuttons */
474        for( i=0; i<FILTER_MODE_QTY; ++i )
475            gtk_toggle_button_set_active( p->filter_toggles[i], i==mode );
476    }
477}
478 
479
480static void
481filter_toggled_cb( GtkToggleButton * toggle, gpointer vprivate )
482{
483    if( gtk_toggle_button_get_active( toggle ) )
484    {
485        PrivateData * p = vprivate;
486        const int mode = GPOINTER_TO_UINT( g_object_get_data( G_OBJECT( toggle ), FILTER_MODE_KEY ) );
487        setFilter( p, mode );
488    }
489}
490
491static void
492filter_entry_changed( GtkEditable * e,
493                      gpointer      vprivate )
494{
495    char *        pch;
496    PrivateData * p = vprivate;
497
498    pch = gtk_editable_get_chars( e, 0, -1 );
499    g_free( p->filter_text );
500    p->filter_text = g_utf8_casefold( pch, -1 );
501    refilter( p );
502    g_free( pch );
503}
504
505static void
506entry_icon_released( SexyIconEntry         * entry  UNUSED,
507                     SexyIconEntryPosition          icon_pos,
508                     int                     button UNUSED,
509                     gpointer                       menu )
510{
511    if( icon_pos == SEXY_ICON_ENTRY_PRIMARY )
512        gtk_menu_popup ( GTK_MENU(
513                            menu ), NULL, NULL, NULL, NULL, 0,
514                        gtk_get_current_event_time( ) );
515}
516
517#if GTK_CHECK_VERSION( 2, 12, 0 )
518
519static void
520findMaxAnnounceTime( GtkTreeModel *      model,
521                     GtkTreePath  * path UNUSED,
522                     GtkTreeIter *       iter,
523                     gpointer            gmaxTime )
524{
525    tr_torrent *    tor;
526    const tr_stat * torStat;
527    time_t *        maxTime = gmaxTime;
528
529    gtk_tree_model_get( model, iter, MC_TORRENT_RAW, &tor, -1 );
530    torStat = tr_torrentStatCached( tor );
531    *maxTime = MAX( *maxTime, torStat->manualAnnounceTime );
532}
533
534static gboolean
535onAskTrackerQueryTooltip( GtkWidget *            widget UNUSED,
536                          gint                   x UNUSED,
537                          gint                   y UNUSED,
538                          gboolean               keyboard_tip UNUSED,
539                          GtkTooltip *           tooltip,
540                          gpointer               gdata )
541{
542    const time_t now = time( NULL );
543    time_t       maxTime = 0;
544    PrivateData * p = gdata;
545
546    gtk_tree_selection_selected_foreach( p->selection,
547                                         findMaxAnnounceTime,
548                                         &maxTime );
549    if( maxTime <= now )
550    {
551        return FALSE;
552    }
553    else
554    {
555        char      buf[128];
556        char      timebuf[64];
557        const int seconds = maxTime - now;
558
559        tr_strltime( timebuf, seconds, sizeof( timebuf ) );
560        g_snprintf( buf, sizeof( buf ),
561                    _( "Tracker will allow requests in %s" ), timebuf );
562        gtk_tooltip_set_text( tooltip, buf );
563        return TRUE;
564    }
565}
566
567#endif
568
569static gboolean
570onAltSpeedToggledIdle( gpointer vp )
571{
572    PrivateData * p = vp;
573    gboolean b = tr_sessionUsesAltSpeed( tr_core_session( p->core ) );
574    tr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED, b );
575
576    return FALSE;
577}
578
579static void
580onAltSpeedToggled( tr_session * s UNUSED, tr_bool isEnabled UNUSED, tr_bool byUser UNUSED, void * p )
581{
582    g_idle_add( onAltSpeedToggledIdle, p );
583}
584
585#define ENABLED_KEY "enabled-key"
586#define SPEED_KEY "speed-key"
587
588static void
589onSpeedLimitToggled( GtkCheckMenuItem * check, tr_direction direction, gpointer vp ) 
590{
591    PrivateData * p = vp;
592    if( gtk_check_menu_item_get_active( check ) )
593    {
594        const gboolean isEnabled = g_object_get_data( G_OBJECT( check ), ENABLED_KEY ) != 0;
595        const char * key = direction == TR_UP ? TR_PREFS_KEY_USPEED_ENABLED : TR_PREFS_KEY_DSPEED_ENABLED;
596        tr_core_set_pref_bool( p->core, key, isEnabled );
597    }
598}
599static void
600onSpeedLimitSet( GtkCheckMenuItem * check, tr_direction direction, gpointer vp ) 
601{
602    PrivateData * p = vp;
603    gpointer d = g_object_get_data( G_OBJECT( check ), SPEED_KEY );
604    const int kb = GPOINTER_TO_INT( d );
605    const char * key = direction == TR_UP ? TR_PREFS_KEY_USPEED : TR_PREFS_KEY_DSPEED;
606    tr_core_set_pref_int( p->core, key, kb );
607}
608static void
609onUploadLimitedToggled( GtkCheckMenuItem * check, gpointer p ) 
610{
611    onSpeedLimitToggled( check, TR_UP, p );
612}
613static void
614onUploadLimitSet( GtkCheckMenuItem * check, gpointer vp ) 
615{
616    PrivateData * p = vp;
617    onSpeedLimitSet( check, TR_UP, p );
618    tr_core_set_pref_bool( p->core, TR_PREFS_KEY_USPEED_ENABLED, TRUE );
619}
620static void
621onDownloadLimitedToggled( GtkCheckMenuItem * check, gpointer p ) 
622{
623    onSpeedLimitToggled( check, TR_DOWN, p );
624}
625static void
626onDownloadLimitSet( GtkCheckMenuItem * check, gpointer vp ) 
627{
628    PrivateData * p = vp;
629    onSpeedLimitSet( check, TR_DOWN, p );
630    tr_core_set_pref_bool( p->core, TR_PREFS_KEY_DSPEED_ENABLED, TRUE );
631}
632static void
633onRatioToggled( GtkCheckMenuItem * check, gpointer vp ) 
634{
635    PrivateData * p = vp;
636    if( gtk_check_menu_item_get_active( check ) )
637    {
638        const gboolean isEnabled = g_object_get_data( G_OBJECT( check ), ENABLED_KEY ) != 0;
639        tr_core_set_pref_bool( p->core, TR_PREFS_KEY_RATIO_ENABLED, isEnabled );
640    }
641}
642static void
643onRatioSet( GtkCheckMenuItem * check, gpointer vp ) 
644{
645    PrivateData * p = vp;
646    gpointer d = g_object_get_data( G_OBJECT( check ), SPEED_KEY );
647    const int ratio = GPOINTER_TO_INT( d );
648    tr_core_set_pref_double( p->core, TR_PREFS_KEY_RATIO, ratio/100.0 );
649}
650
651static GtkWidget*
652createOptionsMenu( PrivateData * p )
653{
654    int i, n;
655    GtkWidget *sub, *w, *up, *down;
656    GtkWidget * top = gtk_menu_new( );
657    const int stockSpeeds[] = { 5, 10, 20, 30, 40, 50, 75, 100, 150, 200, 250, 500, 750 };
658    const int stockRatios[] = { 25, 50, 75, 100, 150, 200, 300 };
659
660    down = gtk_menu_item_new_with_label( _( "Limit Download Speed" ) );
661    gtk_menu_shell_append( GTK_MENU_SHELL( top ), down );
662    gtk_widget_show( down );
663
664    sub = gtk_menu_new( );
665
666    w = p->downlimit_off_item = gtk_radio_menu_item_new_with_label( NULL, _( "Unlimited" ) );
667    gtk_menu_shell_append( GTK_MENU_SHELL( sub ), w );
668    gtk_widget_show( w );
669    g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( 0 ) );
670    g_signal_connect( w, "toggled", G_CALLBACK(onDownloadLimitedToggled), p );
671
672    w = p->downlimit_on_item = gtk_radio_menu_item_new_with_label_from_widget( GTK_RADIO_MENU_ITEM( w ), _( "Limit at XXX" ) );
673    gtk_menu_shell_append( GTK_MENU_SHELL( sub ), w );
674    gtk_widget_show( w );
675    g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( 1 ) );
676    g_signal_connect( w, "toggled", G_CALLBACK(onDownloadLimitedToggled), p );
677
678    w = gtk_separator_menu_item_new( );
679    gtk_menu_shell_append( GTK_MENU_SHELL( sub ), w );
680    gtk_widget_show( w );
681
682    for( i=0, n=G_N_ELEMENTS(stockSpeeds); i<n; ++i ) {
683        char buf[128];
684        tr_strlspeed( buf, stockSpeeds[i], sizeof( buf ) );
685        w = gtk_menu_item_new_with_label( buf );
686        gtk_menu_shell_append( GTK_MENU_SHELL( sub ), w );
687        gtk_widget_show( w );
688        g_object_set_data( G_OBJECT( w ), SPEED_KEY, GINT_TO_POINTER( stockSpeeds[i] ) );
689        g_signal_connect( w, "activate", G_CALLBACK(onDownloadLimitSet), p );
690    }
691
692    gtk_menu_item_set_submenu( GTK_MENU_ITEM( down ), sub );
693
694    up = gtk_menu_item_new_with_label( _( "Limit Upload Speed" ) );
695    gtk_menu_shell_append( GTK_MENU_SHELL( top ), up );
696    gtk_widget_show( up );
697
698    sub = gtk_menu_new( );
699
700    w = p->uplimit_off_item = gtk_radio_menu_item_new_with_label( NULL, _( "Unlimited" ) );
701    gtk_menu_shell_append( GTK_MENU_SHELL( sub ), w );
702    gtk_widget_show( w );
703    g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( 0 ) );
704    g_signal_connect( w, "toggled", G_CALLBACK(onUploadLimitedToggled), p );
705
706    w = p->uplimit_on_item = gtk_radio_menu_item_new_with_label_from_widget( GTK_RADIO_MENU_ITEM( w ), _( "Limit at XXX" ) );
707    gtk_menu_shell_append( GTK_MENU_SHELL( sub ), w );
708    gtk_widget_show( w );
709    g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( 1 ) );
710    g_signal_connect( w, "toggled", G_CALLBACK(onUploadLimitedToggled), p );
711
712    w = gtk_separator_menu_item_new( );
713    gtk_menu_shell_append( GTK_MENU_SHELL( sub ), w );
714    gtk_widget_show( w );
715
716    for( i=0, n=G_N_ELEMENTS(stockSpeeds); i<n; ++i ) {
717        char buf[128];
718        tr_strlspeed( buf, stockSpeeds[i], sizeof( buf ) );
719        w = gtk_menu_item_new_with_label( buf );
720        gtk_menu_shell_append( GTK_MENU_SHELL( sub ), w );
721        gtk_widget_show( w );
722        g_object_set_data( G_OBJECT( w ), SPEED_KEY, GINT_TO_POINTER( stockSpeeds[i] ) );
723        g_signal_connect( w, "activate", G_CALLBACK(onUploadLimitSet), p );
724    }
725    gtk_menu_item_set_submenu( GTK_MENU_ITEM( up ), sub );
726
727    w = gtk_separator_menu_item_new( );
728    gtk_menu_shell_append( GTK_MENU_SHELL( top ), w );
729    gtk_widget_show( w );
730
731    up = gtk_menu_item_new_with_label( _( "Stop Seeding at Ratio" ) );
732    gtk_menu_shell_append( GTK_MENU_SHELL( top ), up );
733    gtk_widget_show( up );
734
735    sub = gtk_menu_new( );
736
737    w = p->ratio_off_item = gtk_radio_menu_item_new_with_label( NULL, _( "Seed Forever" ) );
738    gtk_menu_shell_append( GTK_MENU_SHELL( sub ), w );
739    gtk_widget_show( w );
740    g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( 0 ) );
741    g_signal_connect( w, "toggled", G_CALLBACK(onRatioToggled), p );
742
743    w = p->ratio_on_item = gtk_radio_menu_item_new_with_label_from_widget( GTK_RADIO_MENU_ITEM( w ), _( "Stop at Ratio (XXX)" ) );
744    gtk_menu_shell_append( GTK_MENU_SHELL( sub ), w );
745    gtk_widget_show( w );
746    g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( 1 ) );
747    g_signal_connect( w, "toggled", G_CALLBACK(onRatioToggled), p );
748
749    w = gtk_separator_menu_item_new( );
750    gtk_menu_shell_append( GTK_MENU_SHELL( sub ), w );
751    gtk_widget_show( w );
752
753    for( i=0, n=G_N_ELEMENTS(stockRatios); i<n; ++i ) {
754        char buf[128];
755        tr_strlratio( buf, stockRatios[i]/100.0, sizeof( buf ) );
756        w = gtk_menu_item_new_with_label( buf );
757        gtk_menu_shell_append( GTK_MENU_SHELL( sub ), w );
758        gtk_widget_show( w );
759        g_object_set_data( G_OBJECT( w ), SPEED_KEY, GINT_TO_POINTER( stockRatios[i] ) );
760        g_signal_connect( w, "activate", G_CALLBACK(onRatioSet), p );
761    }
762    gtk_menu_item_set_submenu( GTK_MENU_ITEM( up ), sub );
763
764    return top;
765}
766
767static void
768onOptionsClicked( GtkButton * button UNUSED, gpointer vp )
769{
770    char buf1[512];
771    char buf2[512];
772    gboolean b;
773    PrivateData * p = vp;
774
775    tr_strlspeed( buf1, pref_int_get( TR_PREFS_KEY_DSPEED ), sizeof( buf1 ) );
776    g_snprintf( buf2, sizeof( buf2 ), _( "Limited to %s" ), buf1 );
777    gtk_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( p->downlimit_on_item ) ) ), buf2 );
778
779    b = pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED );
780    gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( b ? p->downlimit_on_item : p->downlimit_off_item ), TRUE );
781
782    tr_strlspeed( buf1, pref_int_get( TR_PREFS_KEY_USPEED ), sizeof( buf1 ) );
783    g_snprintf( buf2, sizeof( buf2 ), _( "Limited to %s" ), buf1 );
784    gtk_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( p->uplimit_on_item ) ) ), buf2 );
785
786    b = pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED );
787    gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( b ? p->uplimit_on_item : p->uplimit_off_item ), TRUE );
788
789    tr_strlratio( buf1, pref_double_get( TR_PREFS_KEY_RATIO ), sizeof( buf1 ) );
790    g_snprintf( buf2, sizeof( buf2 ), _( "Stop at Ratio (%s)" ), buf1 );
791    gtk_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( p->ratio_on_item ) ) ), buf2 );
792
793    b = pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED );
794    gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( b ? p->ratio_on_item : p->ratio_off_item ), TRUE );
795
796    gtk_menu_popup ( GTK_MENU( p->options_menu ), NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time( ) );
797}
798
799/***
800****  PUBLIC
801***/
802
803GtkWidget *
804tr_window_new( GtkUIManager * ui_mgr, TrCore * core )
805{
806    int           i, n;
807    const char *  pch;
808    PrivateData * p;
809    GtkWidget   *mainmenu, *toolbar, *filter, *list, *status;
810    GtkWidget *   vbox, *w, *self, *h, *c, *s, *image, *menu;
811    GtkWindow *   win;
812    GSList *      l;
813
814    const char *  filter_names[FILTER_MODE_QTY] = {
815        /* show all torrents */
816        N_( "A_ll" ),
817        /* show only torrents that have connected peers */
818        N_( "_Active" ),
819        /* show only torrents that are trying to download */
820        N_( "_Downloading" ),
821        /* show only torrents that are trying to upload */
822        N_( "_Seeding" ),
823        /* show only torrents that are paused */
824        N_( "_Paused" )
825    };
826    const char *  filter_text_names[FILTER_TEXT_MODE_QTY] = {
827        N_( "Name" ), N_( "Files" ), N_( "Tracker" )
828    };
829
830    p = g_new0( PrivateData, 1 );
831    p->filter_text_mode = FILTER_TEXT_MODE_NAME;
832    p->filter_text = NULL;
833
834    /* make the window */
835    self = gtk_window_new ( GTK_WINDOW_TOPLEVEL );
836    g_object_set_data_full( G_OBJECT(
837                                self ), PRIVATE_DATA_KEY, p, privateFree );
838    win = GTK_WINDOW( self );
839    gtk_window_set_title( win, g_get_application_name( ) );
840    gtk_window_set_role( win, "tr-main" );
841    gtk_window_set_default_size( win,
842                                 pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
843                                 pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
844    gtk_window_move( win, pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
845                     pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
846    gtk_window_add_accel_group( win, gtk_ui_manager_get_accel_group( ui_mgr ) );
847
848    /* window's main container */
849    vbox = gtk_vbox_new ( FALSE, 0 );
850    gtk_container_add ( GTK_CONTAINER( self ), vbox );
851
852    /* main menu */
853    w = mainmenu = action_get_widget( "/main-window-menu" );
854    w = action_get_widget( "/main-window-menu/torrent-menu/update-tracker" );
855#if GTK_CHECK_VERSION( 2, 12, 0 )
856    g_signal_connect( w, "query-tooltip",
857                      G_CALLBACK( onAskTrackerQueryTooltip ), p );
858#endif
859
860    /* toolbar */
861    w = toolbar = p->toolbar = action_get_widget( "/main-window-toolbar" );
862
863    /* filter */
864    h = filter = p->filter = gtk_hbox_new( FALSE, 0 );
865    gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
866    for( i = 0; i < FILTER_MODE_QTY; ++i )
867    {
868        const char * mnemonic = _( filter_names[i] );
869        w = gtk_toggle_button_new_with_mnemonic( mnemonic );
870        g_object_set_data( G_OBJECT( w ), FILTER_MODE_KEY, GINT_TO_POINTER( i ) );
871        gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
872        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), i == FILTER_MODE_ALL );
873        p->filter_toggles[i] = GTK_TOGGLE_BUTTON( w );
874        g_signal_connect( w, "toggled", G_CALLBACK( filter_toggled_cb ), p );
875        gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
876    }
877
878    s = sexy_icon_entry_new( );
879    sexy_icon_entry_add_clear_button( SEXY_ICON_ENTRY( s ) );
880    image = gtk_image_new_from_stock( GTK_STOCK_FIND, GTK_ICON_SIZE_MENU );
881    sexy_icon_entry_set_icon( SEXY_ICON_ENTRY(
882                                 s ), SEXY_ICON_ENTRY_PRIMARY,
883                             GTK_IMAGE( image ) );
884    sexy_icon_entry_set_icon_highlight( SEXY_ICON_ENTRY(
885                                            s ), SEXY_ICON_ENTRY_PRIMARY,
886                                        TRUE );
887    gtk_box_pack_end( GTK_BOX( h ), s, FALSE, FALSE, 0 );
888    g_signal_connect( s, "changed", G_CALLBACK( filter_entry_changed ), p );
889
890    /* status menu */
891    menu = p->status_menu = gtk_menu_new( );
892    l = NULL;
893    pch = pref_string_get( PREF_KEY_STATUSBAR_STATS );
894    for( i = 0, n = G_N_ELEMENTS( stats_modes ); i < n; ++i )
895    {
896        const char * val = stats_modes[i].val;
897        w = gtk_radio_menu_item_new_with_label( l, _( stats_modes[i].i18n ) );
898        l = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM( w ) );
899        gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ),
900                                       !strcmp( val, pch ) );
901        g_object_set_data( G_OBJECT(
902                               w ), STATS_MODE,
903                           (gpointer)stats_modes[i].val );
904        g_signal_connect( w, "toggled", G_CALLBACK(
905                              status_menu_toggled_cb ), p );
906        gtk_menu_shell_append( GTK_MENU_SHELL( menu ), w );
907        gtk_widget_show( w );
908    }
909
910    /* status */
911    h = status = p->status = gtk_hbox_new( FALSE, GUI_PAD );
912    gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
913
914        w = gtk_button_new( );
915        gtk_container_add( GTK_CONTAINER( w ), gtk_image_new_from_stock( "options", GTK_ICON_SIZE_SMALL_TOOLBAR ) );
916        gtk_box_pack_start( GTK_BOX( h ), w, 0, 0, 0 );
917        gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
918        p->options_menu = createOptionsMenu( p );
919        g_signal_connect( w, "clicked", G_CALLBACK(onOptionsClicked), p );
920
921        p->alt_speed_image[0] = gtk_image_new_from_stock( "alt-speed-off", -1 );
922        p->alt_speed_image[1]  = gtk_image_new_from_stock( "alt-speed-on", -1 );
923        w = p->alt_speed_button = gtk_toggle_button_new( );
924        gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
925        g_object_ref( G_OBJECT( p->alt_speed_image[0] ) );
926        g_object_ref( G_OBJECT( p->alt_speed_image[1] ) );
927        g_signal_connect( w, "toggled", G_CALLBACK(alt_speed_toggled_cb ), p );
928        gtk_box_pack_start( GTK_BOX( h ), w, 0, 0, 0 );
929
930        w = p->gutter_lb = gtk_label_new( "N Torrents" );
931        gtk_box_pack_start( GTK_BOX( h ), w, 1, 1, GUI_PAD_BIG );
932
933        w = p->ul_lb = gtk_label_new( NULL );
934        gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
935        w = gtk_image_new_from_stock( GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU );
936        gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
937
938        w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
939        gtk_widget_set_size_request( w, GUI_PAD, 0u );
940        gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
941        w = p->dl_lb = gtk_label_new( NULL );
942        gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
943
944        w = gtk_image_new_from_stock( GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU );
945        gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
946        w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
947        gtk_widget_set_size_request( w, GUI_PAD, 0u );
948        gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
949        w = p->stats_lb = gtk_label_new( NULL );
950        gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
951
952        w = gtk_image_new_from_stock( GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU );
953        c = gtk_event_box_new( );
954        gtk_container_add( GTK_CONTAINER( c ), w );
955        w = c;
956        gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
957        g_signal_connect( w, "button-release-event", G_CALLBACK( onYinYangReleased ), p );
958
959    menu = gtk_menu_new( );
960    l = NULL;
961    for( i = 0; i < FILTER_TEXT_MODE_QTY; ++i )
962    {
963        const char * name = _( filter_text_names[i] );
964        GtkWidget *  w = gtk_radio_menu_item_new_with_label ( l, name );
965        l = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM( w ) );
966        g_object_set_data( G_OBJECT( w ), FILTER_TEXT_MODE_KEY,
967                           GINT_TO_POINTER( i ) );
968        g_signal_connect( w, "toggled",
969                          G_CALLBACK( filter_text_toggled_cb ), p );
970        gtk_menu_shell_append( GTK_MENU_SHELL( menu ), w );
971        gtk_widget_show( w );
972    }
973    g_signal_connect( s, "icon-released",
974                      G_CALLBACK( entry_icon_released ), menu );
975
976    /* workarea */
977    p->view = makeview( p, core );
978    w = list = p->scroll = gtk_scrolled_window_new( NULL, NULL );
979    gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ),
980                                    GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
981    gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ),
982                                         GTK_SHADOW_IN );
983    gtk_container_add( GTK_CONTAINER( w ), p->view );
984
985    /* layout the widgets */
986    {
987        const char * str = pref_string_get( PREF_KEY_MAIN_WINDOW_LAYOUT_ORDER );
988        char ** tokens = g_strsplit( str, ",", -1 );
989        for( i=0; tokens && tokens[i]; ++i )
990        {
991            const char * key = tokens[i];
992
993            if( !strcmp( key, "menu" ) )
994                gtk_box_pack_start( GTK_BOX( vbox ), mainmenu, FALSE, FALSE, 0 );
995            else if( !strcmp( key, "toolbar" ) )
996                gtk_box_pack_start( GTK_BOX( vbox ), toolbar, FALSE, FALSE, 0 );
997            else if( !strcmp( key, "filter" ) )
998                gtk_box_pack_start( GTK_BOX( vbox ), filter, FALSE, FALSE, 0 );
999            else if( !strcmp( key, "list" ) )
1000                gtk_box_pack_start( GTK_BOX( vbox ), list, TRUE, TRUE, 0 );
1001            else if( !strcmp( key, "statusbar" ) )
1002                gtk_box_pack_start( GTK_BOX( vbox ), status, FALSE, FALSE, 0 );
1003        }
1004        g_strfreev( tokens );
1005    }
1006
1007    /* show all but the window */
1008    gtk_widget_show_all( vbox );
1009
1010    /* listen for prefs changes that affect the window */
1011    p->core = core;
1012    prefsChanged( core, PREF_KEY_MINIMAL_VIEW, self );
1013    prefsChanged( core, PREF_KEY_FILTERBAR, self );
1014    prefsChanged( core, PREF_KEY_STATUSBAR, self );
1015    prefsChanged( core, PREF_KEY_STATUSBAR_STATS, self );
1016    prefsChanged( core, PREF_KEY_TOOLBAR, self );
1017    prefsChanged( core, PREF_KEY_FILTER_MODE, self );
1018    prefsChanged( core, TR_PREFS_KEY_ALT_SPEED_ENABLED, self );
1019    p->pref_handler_id = g_signal_connect( core, "prefs-changed",
1020                                           G_CALLBACK( prefsChanged ), self );
1021
1022    tr_sessionSetAltSpeedFunc( tr_core_session( core ), onAltSpeedToggled, p );
1023
1024    filter_entry_changed( GTK_EDITABLE( s ), p );
1025    return self;
1026}
1027
1028static void
1029updateTorrentCount( PrivateData * p )
1030{
1031    if( p && p->core )
1032    {
1033        char      buf[128];
1034        const int torrentCount = gtk_tree_model_iter_n_children(
1035            tr_core_model( p->core ), NULL );
1036        const int visibleCount = gtk_tree_model_iter_n_children(
1037            p->filter_model, NULL );
1038
1039        if( torrentCount != visibleCount )
1040            g_snprintf( buf, sizeof( buf ),
1041                        ngettext( "%1$'d of %2$'d Torrent",
1042                                  "%1$'d of %2$'d Torrents",
1043                                  torrentCount ),
1044                        visibleCount, torrentCount );
1045        else
1046            g_snprintf( buf, sizeof( buf ), ngettext( "%'d Torrent",
1047                                                      "%'d Torrents",
1048                                                      torrentCount ),
1049                        torrentCount );
1050        gtk_label_set_text( GTK_LABEL( p->gutter_lb ), buf );
1051    }
1052}
1053
1054static void
1055updateStats( PrivateData * p )
1056{
1057    const char *            pch;
1058    char                    up[32], down[32], ratio[32], buf[128];
1059    struct tr_session_stats stats;
1060    tr_session *            session = tr_core_session( p->core );
1061
1062    /* update the stats */
1063    pch = pref_string_get( PREF_KEY_STATUSBAR_STATS );
1064    if( !strcmp( pch, "session-ratio" ) )
1065    {
1066        tr_sessionGetStats( session, &stats );
1067        tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
1068        g_snprintf( buf, sizeof( buf ), _( "Ratio: %s" ), ratio );
1069    }
1070    else if( !strcmp( pch, "session-transfer" ) )
1071    {
1072        tr_sessionGetStats( session, &stats );
1073        tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
1074        tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
1075        /* Translators: "size|" is here for disambiguation.  Please remove it from your translation.
1076           %1$s is the size of the data we've downloaded
1077           %2$s is the size of the data we've uploaded */
1078        g_snprintf( buf, sizeof( buf ), Q_(
1079                        "size|Down: %1$s, Up: %2$s" ), down, up );
1080    }
1081    else if( !strcmp( pch, "total-transfer" ) )
1082    {
1083        tr_sessionGetCumulativeStats( session, &stats );
1084        tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
1085        tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
1086        /* Translators: "size|" is here for disambiguation.  Please remove it from your translation.
1087           %1$s is the size of the data we've downloaded
1088           %2$s is the size of the data we've uploaded */
1089        g_snprintf( buf, sizeof( buf ), Q_(
1090                        "size|Down: %1$s, Up: %2$s" ), down, up );
1091    }
1092    else     /* default is total-ratio */
1093    {
1094        tr_sessionGetCumulativeStats( session, &stats );
1095        tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
1096        g_snprintf( buf, sizeof( buf ), _( "Ratio: %s" ), ratio );
1097    }
1098    gtk_label_set_text( GTK_LABEL( p->stats_lb ), buf );
1099}
1100
1101static void
1102updateSpeeds( PrivateData * p )
1103{
1104    tr_session * session = tr_core_session( p->core );
1105
1106    if( session != NULL )
1107    {
1108        char buf[128];
1109        double d;
1110
1111        d = tr_sessionGetPieceSpeed( session, TR_DOWN );
1112        tr_strlspeed( buf, d, sizeof( buf ) );
1113        gtk_label_set_text( GTK_LABEL( p->dl_lb ), buf );
1114
1115        d = tr_sessionGetPieceSpeed( session, TR_UP );
1116        tr_strlspeed( buf, d, sizeof( buf ) );
1117        gtk_label_set_text( GTK_LABEL( p->ul_lb ), buf );
1118    }
1119}
1120
1121void
1122tr_window_update( TrWindow * self )
1123{
1124    PrivateData * p = get_private_data( self );
1125
1126    if( p && p->core && tr_core_session( p->core ) )
1127    {
1128        updateSpeeds( p );
1129        updateTorrentCount( p );
1130        updateStats( p );
1131        refilter( p );
1132    }
1133}
1134
1135GtkTreeSelection*
1136tr_window_get_selection( TrWindow * w )
1137{
1138    return get_private_data( w )->selection;
1139}
1140
Note: See TracBrowser for help on using the repository browser.