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

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

(trunk, gtk ) #2361: Turtle toggle button is not visible using old GTK 2.6.x library

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