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

Last change on this file since 5908 was 5908, checked in by charles, 14 years ago

(libt) more janitorial work on cleaning up tr_session*() and tr_torrent*() functions: session stats, torrent count, and manual update.

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