source: trunk/gtk/tr_window.c @ 4322

Last change on this file since 4322 was 4322, checked in by charles, 15 years ago

(gtk) minor filter improvement

  • Property svn:keywords set to Date Rev Author Id
File size: 22.8 KB
Line 
1/******************************************************************************
2 * $Id: tr_window.c 4322 2007-12-24 19:12:52Z charles $
3 *
4 * Copyright (c) 2005-2007 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   gtk_tree_view_column_set_spacing( column, spacing+1 );
48   gtk_tree_view_column_set_spacing( column, spacing );
49}
50#endif
51
52typedef enum
53{
54    FILTER_TEXT_MODE_NAME,
55    FILTER_TEXT_MODE_FILES,
56    FILTER_TEXT_MODE_TRACKER,
57    FILTER_TEXT_MODE_QTY
58}
59filter_text_mode_t;
60
61typedef enum
62{
63    FILTER_MODE_ALL,
64    FILTER_MODE_ACTIVE,
65    FILTER_MODE_DOWNLOADING,
66    FILTER_MODE_SEEDING,
67    FILTER_MODE_PAUSED,
68    FILTER_MODE_QTY
69}
70filter_mode_t;
71
72typedef struct
73{
74    GtkWidget * scroll;
75    GtkWidget * view;
76    GtkWidget * toolbar;
77    GtkWidget * filter;
78    GtkWidget * status;
79    GtkWidget * status_menu;
80    GtkWidget * ul_lb;
81    GtkWidget * dl_lb;
82    GtkWidget * stats_lb;
83    GtkWidget * gutter_lb;
84    GtkTreeSelection  * selection;
85    GtkCellRenderer   * renderer;
86    GtkTreeViewColumn * column;
87    GtkTreeModel * filter_model;
88    TrCore * core;
89    gulong pref_handler_id;
90    filter_mode_t filter_mode;
91    filter_text_mode_t filter_text_mode;
92    char * filter_text;
93}
94PrivateData;
95
96#define PRIVATE_DATA_KEY "private-data"
97
98#define FILTER_MODE_KEY "tr-filter-mode"
99#define FILTER_TEXT_MODE_KEY "tr-filter-text-mode"
100#define FILTER_TOGGLES_KEY "tr-filter-toggles"
101
102PrivateData*
103get_private_data( TrWindow * w )
104{
105    return (PrivateData*) g_object_get_data (G_OBJECT(w), PRIVATE_DATA_KEY);
106}
107
108/***
109****
110***/
111
112static void
113on_popup_menu ( GtkWidget * self UNUSED, GdkEventButton * event )
114{
115    GtkWidget * menu = action_get_widget ( "/main-window-popup" );
116    gtk_menu_popup (GTK_MENU(menu), NULL, NULL, NULL, NULL,
117                    (event ? event->button : 0),
118                    (event ? event->time : 0));
119}
120
121static void
122view_row_activated ( GtkTreeView       * tree_view  UNUSED,
123                     GtkTreePath       * path       UNUSED,
124                     GtkTreeViewColumn * column     UNUSED,
125                     gpointer            user_data  UNUSED )
126{
127    action_activate( "show-torrent-details" );
128}
129
130static gboolean is_row_visible( GtkTreeModel *, GtkTreeIter  *, gpointer );
131
132static GtkWidget*
133makeview( PrivateData * p, TrCore * core )
134{
135    GtkWidget         * view;
136    GtkTreeViewColumn * col;
137    GtkTreeSelection  * sel;
138    GtkCellRenderer   * r;
139    GtkTreeModel      * filter_model;
140
141    view = gtk_tree_view_new();
142    gtk_tree_view_set_headers_visible( GTK_TREE_VIEW(view), FALSE );
143
144    p->selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(view) );
145
146    p->renderer = r = torrent_cell_renderer_new( );
147    p->column = col = gtk_tree_view_column_new_with_attributes(
148        _("Torrent"), r, "torrent", MC_TORRENT_RAW, NULL );
149    g_object_set( G_OBJECT(col), "resizable", TRUE,
150                                 "sizing", GTK_TREE_VIEW_COLUMN_FIXED,
151                                 NULL );
152    gtk_tree_view_append_column( GTK_TREE_VIEW( view ), col );
153    g_object_set( r, "xpad", GUI_PAD_SMALL, "ypad", GUI_PAD_SMALL, NULL );
154
155    gtk_tree_view_set_rules_hint( GTK_TREE_VIEW( view ), TRUE );
156    sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
157    gtk_tree_selection_set_mode( GTK_TREE_SELECTION( sel ),
158                                 GTK_SELECTION_MULTIPLE );
159
160    g_signal_connect( view, "popup-menu",
161                      G_CALLBACK(on_popup_menu), NULL );
162    g_signal_connect( view, "button-press-event",
163                      G_CALLBACK(on_tree_view_button_pressed),
164                      (void *) on_popup_menu);
165    g_signal_connect( view, "row-activated",
166                      G_CALLBACK(view_row_activated), NULL);
167
168
169    filter_model = p->filter_model = gtk_tree_model_filter_new( tr_core_model( core ), NULL );
170
171    gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( filter_model ),
172                                            is_row_visible,
173                                            p, NULL );
174
175    gtk_tree_view_set_model( GTK_TREE_VIEW( view ), filter_model );
176
177    return view;
178}
179
180static void
181realized_cb ( GtkWidget * wind, gpointer unused UNUSED )
182{
183    PrivateData * p = get_private_data( GTK_WINDOW( wind ) );
184    sizingmagic( GTK_WINDOW(wind),
185                 GTK_SCROLLED_WINDOW( p->scroll ),
186                 GTK_POLICY_NEVER,
187                 GTK_POLICY_ALWAYS );
188}
189
190static void
191prefsChanged( TrCore * core UNUSED, const char * key, gpointer wind )
192{
193    PrivateData * p = get_private_data( GTK_WINDOW( wind ) );
194
195    if( !strcmp( key, PREF_KEY_MINIMAL_VIEW ) )
196    {
197       g_object_set( p->renderer, "minimal", pref_flag_get( key ), NULL );
198       gtk_tree_view_column_queue_resize( p->column );
199    }
200    else if( !strcmp( key, PREF_KEY_STATUS_BAR ) )
201    {
202        const gboolean isEnabled = pref_flag_get( key );
203        g_object_set( p->status, "visible", isEnabled, NULL );
204    }
205    else if( !strcmp( key, PREF_KEY_FILTER_BAR ) )
206    {
207        const gboolean isEnabled = pref_flag_get( key );
208        g_object_set( p->filter, "visible", isEnabled, NULL );
209    }
210    else if( !strcmp( key, PREF_KEY_TOOLBAR ) )
211    {
212        const gboolean isEnabled = pref_flag_get( key );
213        g_object_set( p->toolbar, "visible", isEnabled, NULL );
214    }
215    else if( !strcmp( key, PREF_KEY_STATUS_BAR_STATS ) )
216    {
217        tr_window_update( (TrWindow*)wind );
218    }
219}
220
221static void
222privateFree( gpointer vprivate )
223{
224    PrivateData * p = ( PrivateData * ) vprivate;
225    g_signal_handler_disconnect( p->core, p->pref_handler_id );
226    g_free( p );
227}
228
229static void
230onYinYangReleased( GtkWidget * w UNUSED, GdkEventButton * button UNUSED, gpointer vprivate )
231{
232    PrivateData * p = ( PrivateData * ) vprivate;
233    gtk_menu_popup( GTK_MENU( p->status_menu ), 0, 0, 0, 0, 0, gtk_get_current_event_time( ) );
234}
235
236#define STATS_MODE "stats-mode"
237
238static struct {
239    const char *val, *i18n;
240} stats_modes[] = {
241    { "total-ratio",      N_("Total Ratio") },
242    { "session-ratio",    N_("Session Ratio") },
243    { "total-transfer",   N_("Total Transfer") },
244    { "session-transfer", N_("Session Transfer") }
245};
246
247static void
248status_menu_toggled_cb( GtkCheckMenuItem  * menu_item,
249                        gpointer            vprivate )
250{
251    if( gtk_check_menu_item_get_active( menu_item ) )
252    {
253        PrivateData * p = (PrivateData*) vprivate;
254        const char * val = g_object_get_data( G_OBJECT( menu_item ), STATS_MODE );
255        tr_core_set_pref( p->core, PREF_KEY_STATUS_BAR_STATS, val );
256    }
257}
258
259/***
260****  FILTER
261***/
262
263static int
264checkFilterText( filter_text_mode_t    filter_text_mode,
265                 const tr_info       * torInfo,
266                 const char          * text )
267{
268    int i;
269    int ret = 0;
270    char * pch;
271
272    switch( filter_text_mode )
273    {
274        case FILTER_TEXT_MODE_FILES:
275            for( i=0; i<torInfo->fileCount && !ret; ++i ) {
276                pch = g_ascii_strdown( torInfo->files[i].name, -1 );
277                ret = !text || strstr( pch, text ) != NULL;
278                g_free( pch );
279            }
280            break;
281
282        case FILTER_TEXT_MODE_TRACKER:
283            pch = g_ascii_strdown( torInfo->primaryAddress, -1 );
284            ret = !text || ( strstr( pch, text ) != NULL );
285            g_free( pch );
286            break;
287
288        default: /* NAME */
289            pch = g_ascii_strdown( torInfo->name, -1 );
290            ret = !text || ( strstr( pch, text ) != NULL );
291            g_free( pch );
292            break;
293    }
294
295    return ret;
296}
297
298static int
299checkFilterMode( filter_mode_t       filter_mode,
300                 const tr_stat     * torStat )
301{
302    int ret = 0;
303    const int haveDown = ((int)( torStat->rateDownload * 1024 )) > 1.0;
304    const int haveUp = ((int)( torStat->rateUpload * 1024 )) > 1.0;
305
306    switch( filter_mode )
307    {
308        case FILTER_MODE_ACTIVE:
309            ret = haveUp || haveDown;
310            break;
311        case FILTER_MODE_DOWNLOADING:
312            ret = torStat->status == TR_STATUS_DOWNLOAD;
313            break;
314        case FILTER_MODE_SEEDING:
315            ret =    ( torStat->status == TR_STATUS_DONE )
316                  || ( torStat->status == TR_STATUS_SEED );
317            break;
318        case FILTER_MODE_PAUSED:
319            ret = torStat->status == TR_STATUS_STOPPED;
320            break;
321        default: /* all */
322            ret = 1;
323    }
324
325    return ret;
326}
327
328static gboolean
329is_row_visible( GtkTreeModel   * model,
330                GtkTreeIter    * iter,
331                gpointer         vprivate )
332{
333    PrivateData * p = vprivate;
334    tr_torrent * tor;
335    gtk_tree_model_get( model, iter, MC_TORRENT_RAW, &tor, -1 );
336
337    return checkFilterMode( p->filter_mode, tr_torrentStatCached( tor ) )
338        && checkFilterText( p->filter_text_mode, tr_torrentInfo( tor ), p->filter_text );
339}
340
341static void updateTorrentCount( PrivateData * p );
342
343static void
344refilter( PrivateData * p )
345{
346    gtk_tree_model_filter_refilter( GTK_TREE_MODEL_FILTER( p->filter_model ) );
347
348    updateTorrentCount( p );
349}
350
351static void
352filter_text_toggled_cb( GtkCheckMenuItem  * menu_item,
353                        gpointer            vprivate )
354{
355    if( gtk_check_menu_item_get_active( menu_item ) )
356    {
357        PrivateData * p = (PrivateData*) vprivate;
358        p->filter_text_mode = GPOINTER_TO_UINT( g_object_get_data( G_OBJECT( menu_item ),
359                                                                   FILTER_TEXT_MODE_KEY ) );
360        refilter( p );
361    }
362}
363
364static void
365filter_toggled_cb( GtkToggleButton * toggle, gpointer vprivate )
366{
367    PrivateData * p = (PrivateData*) vprivate;
368    GSList * l;
369    GSList * toggles = g_object_get_data( G_OBJECT( toggle ), FILTER_TOGGLES_KEY );
370    const gboolean isActive = gtk_toggle_button_get_active( toggle );
371    const filter_mode_t mode = GPOINTER_TO_UINT( g_object_get_data( G_OBJECT( toggle ), FILTER_MODE_KEY ) );
372
373    /* update the filter */
374    if( isActive ) {
375        p->filter_mode = mode;
376        refilter( p );
377    }
378
379    /* deactivate the other toggles */
380    for( l=toggles; l!=NULL; l=l->next ) {
381        GtkToggleButton * walk = GTK_TOGGLE_BUTTON( l->data );
382        if( isActive && ( toggle != walk ) )
383            gtk_toggle_button_set_active( walk, FALSE );
384    }
385
386    /* at least one button must always be set */
387    if( !isActive && ( p->filter_mode == mode ) )
388        gtk_toggle_button_set_active( toggle, TRUE );
389}
390
391static void
392filter_entry_changed( GtkEditable * e, gpointer vprivate )
393{
394    char * pch;
395    PrivateData * p = (PrivateData*) vprivate;
396    g_free( p->filter_text );
397    pch = gtk_editable_get_chars( e, 0, -1 );
398    p->filter_text = g_ascii_strdown( pch, -1 );
399    refilter( p );
400    g_free( pch );
401}
402
403static void
404entry_icon_released( SexyIconEntry         * entry UNUSED,
405                     SexyIconEntryPosition   icon_pos,
406                     int                     button UNUSED,
407                     gpointer                menu )
408{
409    if ( icon_pos == SEXY_ICON_ENTRY_PRIMARY )
410        gtk_menu_popup ( GTK_MENU( menu ), 0, 0, 0, 0, 0, gtk_get_current_event_time( ) );
411}
412
413static void
414entry_icon_released_2( SexyIconEntry         * entry,
415                       SexyIconEntryPosition   icon_pos,
416                       int                     button UNUSED,
417                       gpointer                vprivate UNUSED )
418{
419    if ( icon_pos == SEXY_ICON_ENTRY_SECONDARY )
420        gtk_editable_delete_text( GTK_EDITABLE( entry ), 0, -1 );
421}
422
423
424/***
425****  PUBLIC
426***/
427
428GtkWidget *
429tr_window_new( GtkUIManager * ui_manager, TrCore * core )
430{
431    int i, n;
432    int status_stats_mode;
433    char * pch;
434    PrivateData * p = g_new( PrivateData, 1 );
435    GtkWidget *vbox, *w, *self, *h, *c, *s, *image, *menu;
436    GSList * l;
437    GSList * toggles;
438    const char * filter_names[FILTER_MODE_QTY] = {
439        N_( "A_ll"), N_("_Active"),
440        N_("_Downloading"), N_("_Seeding"), N_("_Paused")
441    };
442    const char * filter_text_names[FILTER_TEXT_MODE_QTY] = {
443        N_("Name"), N_("Files"), N_("Tracker")
444    };
445
446    p->filter_mode = FILTER_MODE_ALL;
447    p->filter_text_mode = FILTER_TEXT_MODE_NAME;
448    p->filter_text = NULL;
449
450    /* make the window */
451    self = gtk_window_new (GTK_WINDOW_TOPLEVEL);
452    g_object_set_data_full(G_OBJECT(self), PRIVATE_DATA_KEY, p, privateFree );
453    gtk_window_set_title( GTK_WINDOW( self ), g_get_application_name());
454    gtk_window_set_role( GTK_WINDOW( self ), "tr-main" );
455    gtk_window_add_accel_group (GTK_WINDOW(self),
456                                gtk_ui_manager_get_accel_group (ui_manager));
457    g_signal_connect( self, "realize", G_CALLBACK(realized_cb), NULL);
458
459    /* window's main container */
460    vbox = gtk_vbox_new (FALSE, 0);
461    gtk_container_add (GTK_CONTAINER(self), vbox);
462
463    /* main menu */
464    w = action_get_widget( "/main-window-menu" );
465    gtk_box_pack_start( GTK_BOX(vbox), w, FALSE, FALSE, 0 ); 
466
467    /* toolbar */
468    w = p->toolbar = action_get_widget( "/main-window-toolbar" );
469    gtk_box_pack_start( GTK_BOX(vbox), w, FALSE, FALSE, 0 ); 
470
471    /* status menu */
472    menu = p->status_menu = gtk_menu_new( );
473    status_stats_mode = 0;
474    l = NULL;
475    pch = pref_string_get( PREF_KEY_STATUS_BAR_STATS );
476    for( i=0, n=G_N_ELEMENTS(stats_modes); i<n; ++i )
477    {
478        const char * val = stats_modes[i].val;
479        w = gtk_radio_menu_item_new_with_label( l, _( stats_modes[i].i18n ) );
480        l = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(w) );
481        gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(w), !strcmp( val, pch ) );
482        g_object_set_data( G_OBJECT(w), STATS_MODE, (gpointer)stats_modes[i].val );
483        g_signal_connect( w, "toggled", G_CALLBACK(status_menu_toggled_cb), p );
484        gtk_menu_shell_append( GTK_MENU_SHELL(menu), w );
485        gtk_widget_show( w );
486    }
487    g_free( pch );
488
489    /* statusbar */
490    h = p->status = gtk_hbox_new( FALSE, GUI_PAD );
491    gtk_container_set_border_width( GTK_CONTAINER(h), GUI_PAD );
492     
493    w = p->ul_lb = gtk_label_new( NULL );
494    gtk_box_pack_end( GTK_BOX(h), w, FALSE, FALSE, 0 );
495    w = gtk_image_new_from_stock( "tr-arrow-up", (GtkIconSize)-1 );
496    gtk_box_pack_end( GTK_BOX(h), w, FALSE, FALSE, 0 );
497    w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
498    gtk_widget_set_usize( w, GUI_PAD, 0u );
499    gtk_box_pack_end( GTK_BOX(h), w, FALSE, FALSE, 0 );
500    w = p->dl_lb = gtk_label_new( NULL );
501    gtk_box_pack_end( GTK_BOX(h), w, FALSE, FALSE, 0 );
502    w = gtk_image_new_from_stock( "tr-arrow-down", (GtkIconSize)-1 );
503    gtk_box_pack_end( GTK_BOX(h), w, FALSE, FALSE, 0 );
504
505    w = gtk_image_new_from_stock( "tr-yin-yang", (GtkIconSize)-1 );
506    c = gtk_event_box_new( );
507    gtk_container_add( GTK_CONTAINER(c), w );
508    w = c;
509    g_signal_connect( w, "button-release-event", G_CALLBACK(onYinYangReleased), p );
510    gtk_box_pack_start( GTK_BOX(h), w, FALSE, FALSE, 0 );
511    w = p->stats_lb = gtk_label_new( NULL );
512    gtk_box_pack_start( GTK_BOX(h), w, FALSE, FALSE, 0 );
513    gtk_box_pack_start( GTK_BOX(vbox), h, FALSE, FALSE, 0 );
514
515    w = gtk_hseparator_new( );
516    gtk_box_pack_start( GTK_BOX(vbox), w, FALSE, FALSE, 0 ); 
517
518    /* filter */
519    toggles = NULL;
520    h = p->filter = gtk_hbox_new( FALSE, 0 );
521    gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
522    for( i=0; i<FILTER_MODE_QTY; ++i ) {
523        const char * mnemonic = _( filter_names[i] );
524        w = gtk_toggle_button_new_with_mnemonic( mnemonic );
525        g_object_set_data( G_OBJECT( w ), FILTER_MODE_KEY, GINT_TO_POINTER( i ) );
526        gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
527        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), i==FILTER_MODE_ALL );
528        toggles = g_slist_prepend( toggles, w );
529        g_signal_connect( w, "toggled", G_CALLBACK(filter_toggled_cb), p );
530        gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 ); 
531    }
532    for( l=toggles; l!=NULL; l=l->next )
533        g_object_set_data( G_OBJECT( l->data ), FILTER_TOGGLES_KEY, toggles );
534    s = sexy_icon_entry_new( );
535    image = gtk_image_new_from_stock(GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU );
536    sexy_icon_entry_set_icon( SEXY_ICON_ENTRY(s), SEXY_ICON_ENTRY_SECONDARY, GTK_IMAGE(image) );
537    sexy_icon_entry_set_icon_highlight( SEXY_ICON_ENTRY(s), SEXY_ICON_ENTRY_SECONDARY, TRUE );
538    image = gtk_image_new_from_stock( "tr-search-pulldown", GTK_ICON_SIZE_MENU );
539    sexy_icon_entry_set_icon( SEXY_ICON_ENTRY(s), SEXY_ICON_ENTRY_PRIMARY, GTK_IMAGE(image) );
540    sexy_icon_entry_set_icon_highlight( SEXY_ICON_ENTRY(s), SEXY_ICON_ENTRY_PRIMARY, TRUE );
541    gtk_box_pack_end( GTK_BOX( h ), s, FALSE, FALSE, 0 );
542    gtk_box_pack_start( GTK_BOX(vbox), h, FALSE, FALSE, 0 ); 
543    g_signal_connect( s, "changed", G_CALLBACK( filter_entry_changed ), p );
544
545    menu = gtk_menu_new( );
546    l = NULL;
547    for( i=0; i<FILTER_TEXT_MODE_QTY; ++i )
548    {
549        const char * name = _( filter_text_names[i] );
550        GtkWidget * w = gtk_radio_menu_item_new_with_label ( l, name );
551        l = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM( w ) );
552        g_object_set_data( G_OBJECT( w ), FILTER_TEXT_MODE_KEY, GINT_TO_POINTER( i ) );
553        g_signal_connect( w, "toggled", G_CALLBACK( filter_text_toggled_cb ), p );
554        gtk_menu_shell_append( GTK_MENU_SHELL( menu ), w );
555        gtk_widget_show( w );
556    }
557    g_signal_connect( s, "icon-released", G_CALLBACK(entry_icon_released), menu );
558    g_signal_connect( s, "icon-released", G_CALLBACK( entry_icon_released_2 ), p );
559
560
561    /* workarea */
562    p->view = makeview( p, core );
563    w = p->scroll = gtk_scrolled_window_new( NULL, NULL );
564    gtk_container_add( GTK_CONTAINER(w), p->view );
565    gtk_box_pack_start_defaults( GTK_BOX(vbox), w );
566    gtk_container_set_focus_child( GTK_CONTAINER( vbox ), w );
567
568    /* spacer */
569    w = gtk_alignment_new (0.0f, 0.0f, 0.0f, 0.0f);
570    gtk_widget_set_usize (w, 0u, 6u);
571    gtk_box_pack_start( GTK_BOX(vbox), w, FALSE, FALSE, 0 ); 
572
573    /* status */
574    h = gtk_hbox_new( FALSE, GUI_PAD );
575    w = p->gutter_lb = gtk_label_new( "N transfers" );
576    gtk_box_pack_start_defaults( GTK_BOX(h), w );
577    gtk_box_pack_start( GTK_BOX(vbox), h, FALSE, FALSE, 0 ); 
578
579    /* show all but the window */
580    gtk_widget_show_all( vbox );
581
582    /* listen for prefs changes that affect the window */
583    p->core = core;
584    prefsChanged( core, PREF_KEY_MINIMAL_VIEW, self );
585    prefsChanged( core, PREF_KEY_FILTER_BAR, self );
586    prefsChanged( core, PREF_KEY_STATUS_BAR, self );
587    prefsChanged( core, PREF_KEY_STATUS_BAR_STATS, self );
588    prefsChanged( core, PREF_KEY_TOOLBAR, self );
589    p->pref_handler_id = g_signal_connect( core, "prefs-changed",
590                                           G_CALLBACK(prefsChanged), self );
591
592    return self;
593}
594
595static void
596updateTorrentCount( PrivateData * p )
597{
598    if( p && p->core )
599    {
600        char buf[128];
601        const int torrentCount = gtk_tree_model_iter_n_children( tr_core_model( p->core ), NULL );
602        const int visibleCount = gtk_tree_model_iter_n_children( p->filter_model, NULL );
603
604        if( torrentCount != visibleCount )
605            g_snprintf( buf, sizeof( buf ), ngettext( _( "%d of %d Transfer" ),
606                                                      _( "%d of %d Transfers" ),
607                                                      torrentCount ),
608                                            visibleCount, torrentCount );
609        else
610            g_snprintf( buf, sizeof( buf ), ngettext( _( "%d Transfer" ),
611                                                      _( "%d Transfers" ),
612                                                      torrentCount ),
613                                            torrentCount );
614        gtk_label_set_text( GTK_LABEL( p->gutter_lb ), buf );
615    }
616}
617
618static void
619updateStats( PrivateData * p )
620{
621    char * pch;
622    char up[32], down[32], buf[128];
623    struct tr_session_stats stats;
624    tr_handle * handle = tr_core_handle( p->core );
625
626    /* update the stats */
627    pch = pref_string_get( PREF_KEY_STATUS_BAR_STATS );
628    if( !strcmp( pch, "session-ratio" ) ) {
629        tr_getSessionStats( handle, &stats );
630        g_snprintf( buf, sizeof(buf), _("Ratio: %.1f"), stats.ratio );
631    } else if( !strcmp( pch, "session-transfer" ) ) {
632        tr_getSessionStats( handle, &stats );
633        tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
634        tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
635        g_snprintf( buf, sizeof( buf ), _( "Down: %s  Up: %s" ), down, up );
636    } else if( !strcmp( pch, "total-transfer" ) ) { 
637        tr_getCumulativeSessionStats( handle, &stats );
638        tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
639        tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
640        g_snprintf( buf, sizeof( buf ), _( "Down: %s  Up: %s" ), down, up );
641    } else { /* default is total-ratio */
642        tr_getCumulativeSessionStats( handle, &stats );
643        g_snprintf( buf, sizeof(buf), _("Ratio: %.1f"), stats.ratio );
644    }
645    g_free( pch );
646    gtk_label_set_text( GTK_LABEL( p->stats_lb ), buf );
647}
648
649static void
650updateSpeeds( PrivateData * p )
651{
652    char buf[128];
653    float u, d;
654    tr_handle * handle = tr_core_handle( p->core );
655
656    tr_torrentRates( handle, &d, &u );
657    tr_strlspeed( buf, d, sizeof( buf ) );
658    gtk_label_set_text( GTK_LABEL( p->dl_lb ), buf );
659    tr_strlspeed( buf, u, sizeof( buf ) );
660    gtk_label_set_text( GTK_LABEL( p->ul_lb ), buf );
661}
662
663
664void
665tr_window_update( TrWindow * self )
666{
667    PrivateData * p = get_private_data( self );
668    if( p && p->core && tr_core_handle(p->core) )
669    {
670        updateSpeeds( p );
671        updateTorrentCount( p );
672        updateStats( p );
673        refilter( p );
674    }
675}
676
677GtkTreeSelection*
678tr_window_get_selection ( TrWindow * w )
679{
680    return get_private_data(w)->selection;
681}
Note: See TracBrowser for help on using the repository browser.