source: branches/1.5x/gtk/tr-window.c @ 8205

Last change on this file since 8205 was 8205, checked in by charles, 12 years ago

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

  • Property svn:keywords set to Date Rev Author Id
File size: 26.6 KB
Line 
1/******************************************************************************
2 * $Id: tr-window.c 8205 2009-04-10 17:44:17Z charles $
3 *
4 * Copyright (c) 2005-2008 Transmission authors and contributors
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *****************************************************************************/
24
25#include <string.h>
26
27#include <gtk/gtk.h>
28#include <glib/gi18n.h>
29
30#include <libtransmission/transmission.h>
31
32#include "actions.h"
33#include "conf.h"
34#include "hig.h"
35#include "sexy-icon-entry.h"
36#include "torrent-cell-renderer.h"
37#include "tr-prefs.h"
38#include "tr-torrent.h"
39#include "tr-window.h"
40#include "util.h"
41
42#if !GTK_CHECK_VERSION( 2, 8, 0 )
43static void
44gtk_tree_view_column_queue_resize( GtkTreeViewColumn * column ) /* yuck */
45{
46    const int spacing = gtk_tree_view_column_get_spacing( column );
47
48    gtk_tree_view_column_set_spacing( column, spacing + 1 );
49    gtk_tree_view_column_set_spacing( column, spacing );
50}
51
52#endif
53
54typedef enum
55{
56    FILTER_TEXT_MODE_NAME,
57    FILTER_TEXT_MODE_FILES,
58    FILTER_TEXT_MODE_TRACKER,
59    FILTER_TEXT_MODE_QTY
60}
61filter_text_mode_t;
62
63typedef enum
64{
65    FILTER_MODE_ALL,
66    FILTER_MODE_ACTIVE,
67    FILTER_MODE_DOWNLOADING,
68    FILTER_MODE_SEEDING,
69    FILTER_MODE_PAUSED,
70    FILTER_MODE_QTY
71}
72filter_mode_t;
73
74typedef struct
75{
76    GtkWidget *           scroll;
77    GtkWidget *           view;
78    GtkWidget *           toolbar;
79    GtkWidget *           filter;
80    GtkWidget *           status;
81    GtkWidget *           status_menu;
82    GtkWidget *           ul_lb;
83    GtkWidget *           dl_lb;
84    GtkWidget *           stats_lb;
85    GtkWidget *           gutter_lb;
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    GtkToggleButton     * filter_toggles[FILTER_MODE_QTY];
96}
97PrivateData;
98
99#define PRIVATE_DATA_KEY "private-data"
100
101#define FILTER_TEXT_MODE_KEY "tr-filter-text-mode"
102
103static PrivateData*
104get_private_data( TrWindow * w )
105{
106    return g_object_get_data ( G_OBJECT( w ), PRIVATE_DATA_KEY );
107}
108
109/***
110****
111***/
112
113static void
114on_popup_menu( GtkWidget * self UNUSED,
115               GdkEventButton * event )
116{
117    GtkWidget * menu = action_get_widget ( "/main-window-popup" );
118
119    gtk_menu_popup ( GTK_MENU( menu ), NULL, NULL, NULL, NULL,
120                    ( event ? event->button : 0 ),
121                    ( event ? event->time : 0 ) );
122}
123
124static void
125view_row_activated( GtkTreeView       * tree_view UNUSED,
126                    GtkTreePath       * path      UNUSED,
127                    GtkTreeViewColumn * column    UNUSED,
128                    gpointer            user_data UNUSED )
129{
130    action_activate( "show-torrent-properties" );
131}
132
133static gboolean is_row_visible( GtkTreeModel *,
134                                GtkTreeIter  *,
135                                gpointer );
136
137static GtkWidget*
138makeview( PrivateData * p,
139          TrCore *      core )
140{
141    GtkWidget *         view;
142    GtkTreeViewColumn * col;
143    GtkTreeSelection *  sel;
144    GtkCellRenderer *   r;
145    GtkTreeModel *      filter_model;
146
147    view = gtk_tree_view_new( );
148    gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( view ), FALSE );
149    gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW( view ), TRUE );
150
151    p->selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
152
153    p->column = col = GTK_TREE_VIEW_COLUMN (g_object_new (GTK_TYPE_TREE_VIEW_COLUMN,                 
154        "title", _("Torrent"),
155        "resizable", TRUE,
156        "sizing", GTK_TREE_VIEW_COLUMN_FIXED,
157        NULL));
158
159    p->renderer = r = torrent_cell_renderer_new( );
160    gtk_tree_view_column_pack_start( col, r, FALSE );
161    gtk_tree_view_column_add_attribute( col, r, "torrent", MC_TORRENT_RAW );
162   
163    gtk_tree_view_append_column( GTK_TREE_VIEW( view ), col );
164    g_object_set( r, "xpad", GUI_PAD_SMALL, "ypad", GUI_PAD_SMALL, NULL );
165
166    gtk_tree_view_set_rules_hint( GTK_TREE_VIEW( view ), TRUE );
167    sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
168    gtk_tree_selection_set_mode( GTK_TREE_SELECTION( sel ),
169                                 GTK_SELECTION_MULTIPLE );
170
171    g_signal_connect( view, "popup-menu",
172                      G_CALLBACK( on_popup_menu ), NULL );
173    g_signal_connect( view, "button-press-event",
174                      G_CALLBACK( on_tree_view_button_pressed ),
175                      (void *) on_popup_menu );
176    g_signal_connect( view, "button-release-event",
177                      G_CALLBACK( on_tree_view_button_released ), NULL );
178    g_signal_connect( view, "row-activated",
179                      G_CALLBACK( view_row_activated ), NULL );
180
181
182    filter_model = p->filter_model = gtk_tree_model_filter_new(
183                       tr_core_model( core ), NULL );
184
185    gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER(
186                                                filter_model ),
187                                            is_row_visible,
188                                            p, NULL );
189
190    gtk_tree_view_set_model( GTK_TREE_VIEW( view ), filter_model );
191
192    return view;
193}
194
195static void
196prefsChanged( TrCore * core UNUSED,
197              const char *  key,
198              gpointer      wind )
199{
200    PrivateData * p = get_private_data( GTK_WINDOW( wind ) );
201
202    if( !strcmp( key, PREF_KEY_MINIMAL_VIEW ) )
203    {
204        g_object_set( p->renderer, "minimal", pref_flag_get( key ), NULL );
205        /* since the cell size has changed, we need gtktreeview to revalidate
206         * its fixed-height mode values.  Unfortunately there's not an API call
207         * for that, but it *does* revalidate when it thinks the style's been tweaked */
208        g_signal_emit_by_name( p->view, "style-set", NULL, NULL );
209    }
210    else if( !strcmp( key, PREF_KEY_STATUSBAR ) )
211    {
212        const gboolean isEnabled = pref_flag_get( key );
213        g_object_set( p->status, "visible", isEnabled, NULL );
214    }
215    else if( !strcmp( key, PREF_KEY_FILTERBAR ) )
216    {
217        const gboolean isEnabled = pref_flag_get( key );
218        g_object_set( p->filter, "visible", isEnabled, NULL );
219    }
220    else if( !strcmp( key, PREF_KEY_TOOLBAR ) )
221    {
222        const gboolean isEnabled = pref_flag_get( key );
223        g_object_set( p->toolbar, "visible", isEnabled, NULL );
224    }
225    else if( !strcmp( key, PREF_KEY_STATUSBAR_STATS ) )
226    {
227        tr_window_update( (TrWindow*)wind );
228    }
229}
230
231static void
232privateFree( gpointer vprivate )
233{
234    PrivateData * p = vprivate;
235
236    g_signal_handler_disconnect( p->core, p->pref_handler_id );
237    g_free( p->filter_text );
238    g_free( p );
239}
240
241static void
242onYinYangReleased( GtkWidget * w           UNUSED,
243                   GdkEventButton * button UNUSED,
244                   gpointer                vprivate )
245{
246    PrivateData * p = vprivate;
247
248    gtk_menu_popup( GTK_MENU(
249                       p->status_menu ), NULL, NULL, NULL, NULL, 0,
250                   gtk_get_current_event_time( ) );
251}
252
253#define STATS_MODE "stats-mode"
254
255static struct
256{
257    const char *  val, *i18n;
258} stats_modes[] = {
259    { "total-ratio",      N_( "Total Ratio" )                },
260    { "session-ratio",    N_( "Session Ratio" )              },
261    { "total-transfer",   N_( "Total Transfer" )             },
262    { "session-transfer", N_( "Session Transfer" )           }
263};
264
265static void
266status_menu_toggled_cb( GtkCheckMenuItem * menu_item,
267                        gpointer           vprivate )
268{
269    if( gtk_check_menu_item_get_active( menu_item ) )
270    {
271        PrivateData * p = vprivate;
272        const char *  val = g_object_get_data( G_OBJECT(
273                                                   menu_item ), STATS_MODE );
274        tr_core_set_pref( p->core, PREF_KEY_STATUSBAR_STATS, val );
275    }
276}
277
278/***
279****  FILTER
280***/
281
282static int
283checkFilterText( filter_text_mode_t    filter_text_mode,
284                 const tr_info       * torInfo,
285                 const char          * text )
286{
287    tr_file_index_t i;
288    int             ret = 0;
289    char *          pch;
290
291    switch( filter_text_mode )
292    {
293        case FILTER_TEXT_MODE_FILES:
294            for( i = 0; i < torInfo->fileCount && !ret; ++i )
295            {
296                pch = g_utf8_casefold( torInfo->files[i].name, -1 );
297                ret = !text || strstr( pch, text ) != NULL;
298                g_free( pch );
299            }
300            break;
301
302        case FILTER_TEXT_MODE_TRACKER:
303            pch = g_utf8_casefold( torInfo->trackers[0].announce, -1 );
304            ret = !text || ( strstr( pch, text ) != NULL );
305            g_free( pch );
306            break;
307
308        default: /* NAME */
309            pch = g_utf8_casefold( torInfo->name, -1 );
310            ret = !text || ( strstr( pch, text ) != NULL );
311            g_free( pch );
312            break;
313    }
314
315    return ret;
316}
317
318static int
319checkFilterMode( filter_mode_t filter_mode,
320                 tr_torrent *  tor )
321{
322    int ret = 0;
323
324    switch( filter_mode )
325    {
326        case FILTER_MODE_DOWNLOADING:
327            ret = tr_torrentGetActivity( tor ) == TR_STATUS_DOWNLOAD;
328            break;
329
330        case FILTER_MODE_SEEDING:
331            ret = tr_torrentGetActivity( tor ) == TR_STATUS_SEED;
332            break;
333
334        case FILTER_MODE_PAUSED:
335            ret = tr_torrentGetActivity( tor ) == TR_STATUS_STOPPED;
336            break;
337
338        case FILTER_MODE_ACTIVE:
339        {
340            const tr_stat * s = tr_torrentStatCached( tor );
341            ret = s->peersSendingToUs > 0
342               || s->peersGettingFromUs > 0
343               || tr_torrentGetActivity( tor ) == TR_STATUS_CHECK;
344            break;
345        }
346
347        default: /* all */
348            ret = 1;
349    }
350
351    return ret;
352}
353
354static gboolean
355is_row_visible( GtkTreeModel * model,
356                GtkTreeIter *  iter,
357                gpointer       vprivate )
358{
359    PrivateData * p = vprivate;
360    tr_torrent *  tor;
361
362    gtk_tree_model_get( model, iter, MC_TORRENT_RAW, &tor, -1 );
363
364    return checkFilterMode( p->filter_mode, tor )
365           && checkFilterText( p->filter_text_mode, tr_torrentInfo( tor ), p->filter_text );
366}
367
368static void updateTorrentCount( PrivateData * p );
369
370static void
371refilter( PrivateData * p )
372{
373    gtk_tree_model_filter_refilter( GTK_TREE_MODEL_FILTER( p->filter_model ) );
374
375    updateTorrentCount( p );
376}
377
378static void
379filter_text_toggled_cb( GtkCheckMenuItem * menu_item,
380                        gpointer           vprivate )
381{
382    if( gtk_check_menu_item_get_active( menu_item ) )
383    {
384        PrivateData * p = vprivate;
385        p->filter_text_mode =
386            GPOINTER_TO_UINT( g_object_get_data( G_OBJECT( menu_item ),
387                                                 FILTER_TEXT_MODE_KEY ) );
388        refilter( p );
389    }
390}
391
392static void
393filter_toggled_cb( GtkToggleButton * toggle,
394                   gpointer          vprivate )
395{
396    int mode = -1;
397    PrivateData * p = vprivate;
398
399    if( gtk_toggle_button_get_active( toggle ) )
400    {
401        int i;
402        for( i=0; i<FILTER_MODE_QTY; ++i )
403            if( p->filter_toggles[i] == toggle )
404                mode = i;
405            else
406                gtk_toggle_button_set_active( p->filter_toggles[i], FALSE );
407    }
408
409    if( mode >= 0 ) {
410        p->filter_mode = mode;
411        refilter( p );
412    }
413}
414
415static void
416filter_entry_changed( GtkEditable * e,
417                      gpointer      vprivate )
418{
419    char *        pch;
420    PrivateData * p = vprivate;
421
422    pch = gtk_editable_get_chars( e, 0, -1 );
423    g_free( p->filter_text );
424    p->filter_text = g_utf8_casefold( pch, -1 );
425    refilter( p );
426    g_free( pch );
427}
428
429static void
430entry_icon_released( SexyIconEntry         * entry  UNUSED,
431                     SexyIconEntryPosition          icon_pos,
432                     int                     button UNUSED,
433                     gpointer                       menu )
434{
435    if( icon_pos == SEXY_ICON_ENTRY_PRIMARY )
436        gtk_menu_popup ( GTK_MENU(
437                            menu ), NULL, NULL, NULL, NULL, 0,
438                        gtk_get_current_event_time( ) );
439}
440
441#if GTK_CHECK_VERSION( 2, 12, 0 )
442
443static void
444findMaxAnnounceTime( GtkTreeModel *      model,
445                     GtkTreePath  * path UNUSED,
446                     GtkTreeIter *       iter,
447                     gpointer            gmaxTime )
448{
449    tr_torrent *    tor;
450    const tr_stat * torStat;
451    time_t *        maxTime = gmaxTime;
452
453    gtk_tree_model_get( model, iter, MC_TORRENT_RAW, &tor, -1 );
454    torStat = tr_torrentStatCached( tor );
455    *maxTime = MAX( *maxTime, torStat->manualAnnounceTime );
456}
457
458static gboolean
459onAskTrackerQueryTooltip( GtkWidget *            widget UNUSED,
460                          gint                   x UNUSED,
461                          gint                   y UNUSED,
462                          gboolean               keyboard_tip UNUSED,
463                          GtkTooltip *           tooltip,
464                          gpointer               gdata )
465{
466    const time_t now = time( NULL );
467    time_t       maxTime = 0;
468    PrivateData * p = gdata;
469
470    gtk_tree_selection_selected_foreach( p->selection,
471                                         findMaxAnnounceTime,
472                                         &maxTime );
473    if( maxTime <= now )
474    {
475        return FALSE;
476    }
477    else
478    {
479        char      buf[128];
480        char      timebuf[64];
481        const int seconds = maxTime - now;
482
483        tr_strltime( timebuf, seconds, sizeof( timebuf ) );
484        g_snprintf( buf, sizeof( buf ),
485                    _( "Tracker will allow requests in %s" ), timebuf );
486        gtk_tooltip_set_text( tooltip, buf );
487        return TRUE;
488    }
489}
490
491#endif
492
493/***
494****  PUBLIC
495***/
496
497GtkWidget *
498tr_window_new( GtkUIManager * ui_mgr, TrCore * core )
499{
500    int           i, n;
501    const char *  pch;
502    PrivateData * p;
503    GtkWidget   *mainmenu, *toolbar, *filter, *list, *status;
504    GtkWidget *   vbox, *w, *self, *h, *c, *s, *image, *menu;
505    GtkWindow *   win;
506    GSList *      l;
507
508    const char *  filter_names[FILTER_MODE_QTY] = {
509        /* show all torrents */
510        N_( "A_ll" ),
511        /* show only torrents that have connected peers */
512        N_( "_Active" ),
513        /* show only torrents that are trying to download */
514        N_( "_Downloading" ),
515        /* show only torrents that are trying to upload */
516        N_( "_Seeding" ),
517        /* show only torrents that are paused */
518        N_( "_Paused" )
519    };
520    const char *  filter_text_names[FILTER_TEXT_MODE_QTY] = {
521        N_( "Name" ), N_( "Files" ), N_( "Tracker" )
522    };
523
524    p = g_new0( PrivateData, 1 );
525    p->filter_mode = FILTER_MODE_ALL;
526    p->filter_text_mode = FILTER_TEXT_MODE_NAME;
527    p->filter_text = NULL;
528
529    /* make the window */
530    self = gtk_window_new ( GTK_WINDOW_TOPLEVEL );
531    g_object_set_data_full( G_OBJECT(
532                                self ), PRIVATE_DATA_KEY, p, privateFree );
533    win = GTK_WINDOW( self );
534    gtk_window_set_title( win, g_get_application_name( ) );
535    gtk_window_set_role( win, "tr-main" );
536    gtk_window_set_default_size( win,
537                                 pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
538                                 pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
539    gtk_window_move( win, pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
540                     pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
541    gtk_window_add_accel_group( win, gtk_ui_manager_get_accel_group( ui_mgr ) );
542
543    /* window's main container */
544    vbox = gtk_vbox_new ( FALSE, 0 );
545    gtk_container_add ( GTK_CONTAINER( self ), vbox );
546
547    /* main menu */
548    w = mainmenu = action_get_widget( "/main-window-menu" );
549    w = action_get_widget( "/main-window-menu/torrent-menu/update-tracker" );
550#if GTK_CHECK_VERSION( 2, 12, 0 )
551    g_signal_connect( w, "query-tooltip",
552                      G_CALLBACK( onAskTrackerQueryTooltip ), p );
553#endif
554
555    /* toolbar */
556    w = toolbar = p->toolbar = action_get_widget( "/main-window-toolbar" );
557
558    /* filter */
559    h = filter = p->filter = gtk_hbox_new( FALSE, 0 );
560    gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
561    for( i = 0; i < FILTER_MODE_QTY; ++i )
562    {
563        const char * mnemonic = _( filter_names[i] );
564        w = gtk_toggle_button_new_with_mnemonic( mnemonic );
565        gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
566        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), i == FILTER_MODE_ALL );
567        p->filter_toggles[i] = GTK_TOGGLE_BUTTON( w );
568        g_signal_connect( w, "toggled", G_CALLBACK( filter_toggled_cb ), p );
569        gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
570    }
571    s = sexy_icon_entry_new( );
572    sexy_icon_entry_add_clear_button( SEXY_ICON_ENTRY( s ) );
573    image = gtk_image_new_from_stock( GTK_STOCK_FIND, GTK_ICON_SIZE_MENU );
574    sexy_icon_entry_set_icon( SEXY_ICON_ENTRY( s ), SEXY_ICON_ENTRY_PRIMARY, GTK_IMAGE( image ) );
575    sexy_icon_entry_set_icon_highlight( SEXY_ICON_ENTRY( s ), SEXY_ICON_ENTRY_PRIMARY, TRUE );
576    gtk_box_pack_end( GTK_BOX( h ), s, FALSE, FALSE, 0 );
577    g_signal_connect( s, "changed", G_CALLBACK( filter_entry_changed ), p );
578
579    /* status menu */
580    menu = p->status_menu = gtk_menu_new( );
581    l = NULL;
582    pch = pref_string_get( PREF_KEY_STATUSBAR_STATS );
583    for( i = 0, n = G_N_ELEMENTS( stats_modes ); i < n; ++i )
584    {
585        const char * val = stats_modes[i].val;
586        w = gtk_radio_menu_item_new_with_label( l, _( stats_modes[i].i18n ) );
587        l = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM( w ) );
588        gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ),
589                                       !strcmp( val, pch ) );
590        g_object_set_data( G_OBJECT(
591                               w ), STATS_MODE,
592                           (gpointer)stats_modes[i].val );
593        g_signal_connect( w, "toggled", G_CALLBACK(
594                              status_menu_toggled_cb ), p );
595        gtk_menu_shell_append( GTK_MENU_SHELL( menu ), w );
596        gtk_widget_show( w );
597    }
598
599    /* status */
600    h = status = p->status = gtk_hbox_new( FALSE, GUI_PAD );
601    gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD );
602    w = p->gutter_lb = gtk_label_new( "N Torrents" );
603    gtk_box_pack_start( GTK_BOX( h ), w, 0, 0, 0 );
604    w = p->ul_lb = gtk_label_new( NULL );
605    gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
606    w = gtk_image_new_from_stock( GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU );
607    gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
608    w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
609    gtk_widget_set_size_request( w, GUI_PAD, 0u );
610    gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
611    w = p->dl_lb = gtk_label_new( NULL );
612    gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
613    w = gtk_image_new_from_stock( GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU );
614    gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
615    w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
616    gtk_widget_set_size_request( w, GUI_PAD, 0u );
617    gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
618    w = p->stats_lb = gtk_label_new( NULL );
619    gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
620    w = gtk_image_new_from_stock( GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU );
621    c = gtk_event_box_new( );
622    gtk_container_add( GTK_CONTAINER( c ), w );
623    w = c;
624    gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
625    g_signal_connect( w, "button-release-event",
626                      G_CALLBACK( onYinYangReleased ), p );
627
628    menu = gtk_menu_new( );
629    l = NULL;
630    for( i = 0; i < FILTER_TEXT_MODE_QTY; ++i )
631    {
632        const char * name = _( filter_text_names[i] );
633        GtkWidget *  w = gtk_radio_menu_item_new_with_label ( l, name );
634        l = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM( w ) );
635        g_object_set_data( G_OBJECT( w ), FILTER_TEXT_MODE_KEY,
636                           GINT_TO_POINTER( i ) );
637        g_signal_connect( w, "toggled",
638                          G_CALLBACK( filter_text_toggled_cb ), p );
639        gtk_menu_shell_append( GTK_MENU_SHELL( menu ), w );
640        gtk_widget_show( w );
641    }
642    g_signal_connect( s, "icon-released",
643                      G_CALLBACK( entry_icon_released ), menu );
644
645    /* workarea */
646    p->view = makeview( p, core );
647    w = list = p->scroll = gtk_scrolled_window_new( NULL, NULL );
648    gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ),
649                                    GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
650    gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ),
651                                         GTK_SHADOW_IN );
652    gtk_container_add( GTK_CONTAINER( w ), p->view );
653
654    /* layout the widgets */
655    {
656        const char * str = pref_string_get( PREF_KEY_MAIN_WINDOW_LAYOUT_ORDER );
657        char ** tokens = g_strsplit( str, ",", -1 );
658        for( i=0; tokens && tokens[i]; ++i )
659        {
660            const char * key = tokens[i];
661
662            if( !strcmp( key, "menu" ) )
663                gtk_box_pack_start( GTK_BOX( vbox ), mainmenu, FALSE, FALSE, 0 );
664            else if( !strcmp( key, "toolbar" ) )
665                gtk_box_pack_start( GTK_BOX( vbox ), toolbar, FALSE, FALSE, 0 );
666            else if( !strcmp( key, "filter" ) )
667                gtk_box_pack_start( GTK_BOX( vbox ), filter, FALSE, FALSE, 0 );
668            else if( !strcmp( key, "list" ) )
669                gtk_box_pack_start( GTK_BOX( vbox ), list, TRUE, TRUE, 0 );
670            else if( !strcmp( key, "statusbar" ) )
671                gtk_box_pack_start( GTK_BOX( vbox ), status, FALSE, FALSE, 0 );
672        }
673        g_strfreev( tokens );
674    }
675
676    /* show all but the window */
677    gtk_widget_show_all( vbox );
678
679    /* listen for prefs changes that affect the window */
680    p->core = core;
681    prefsChanged( core, PREF_KEY_MINIMAL_VIEW, self );
682    prefsChanged( core, PREF_KEY_FILTERBAR, self );
683    prefsChanged( core, PREF_KEY_STATUSBAR, self );
684    prefsChanged( core, PREF_KEY_STATUSBAR_STATS, self );
685    prefsChanged( core, PREF_KEY_TOOLBAR, self );
686    p->pref_handler_id = g_signal_connect( core, "prefs-changed",
687                                           G_CALLBACK( prefsChanged ), self );
688
689    filter_entry_changed( GTK_EDITABLE( s ), p );
690    return self;
691}
692
693static void
694updateTorrentCount( PrivateData * p )
695{
696    if( p && p->core )
697    {
698        char      buf[128];
699        const int torrentCount = gtk_tree_model_iter_n_children(
700            tr_core_model( p->core ), NULL );
701        const int visibleCount = gtk_tree_model_iter_n_children(
702            p->filter_model, NULL );
703
704        if( torrentCount != visibleCount )
705            g_snprintf( buf, sizeof( buf ),
706                        ngettext( "%1$'d of %2$'d Torrent",
707                                  "%1$'d of %2$'d Torrents",
708                                  torrentCount ),
709                        visibleCount, torrentCount );
710        else
711            g_snprintf( buf, sizeof( buf ), ngettext( "%'d Torrent",
712                                                      "%'d Torrents",
713                                                      torrentCount ),
714                        torrentCount );
715        gtk_label_set_text( GTK_LABEL( p->gutter_lb ), buf );
716    }
717}
718
719static void
720updateStats( PrivateData * p )
721{
722    const char *            pch;
723    char                    up[32], down[32], ratio[32], buf[128];
724    struct tr_session_stats stats;
725    tr_session *            session = tr_core_session( p->core );
726
727    /* update the stats */
728    pch = pref_string_get( PREF_KEY_STATUSBAR_STATS );
729    if( !strcmp( pch, "session-ratio" ) )
730    {
731        tr_sessionGetStats( session, &stats );
732        tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
733        g_snprintf( buf, sizeof( buf ), _( "Ratio: %s" ), ratio );
734    }
735    else if( !strcmp( pch, "session-transfer" ) )
736    {
737        tr_sessionGetStats( session, &stats );
738        tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
739        tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
740        /* Translators: "size|" is here for disambiguation.  Please remove it from your translation.
741           %1$s is the size of the data we've downloaded
742           %2$s is the size of the data we've uploaded */
743        g_snprintf( buf, sizeof( buf ), Q_(
744                        "size|Down: %1$s, Up: %2$s" ), down, up );
745    }
746    else if( !strcmp( pch, "total-transfer" ) )
747    {
748        tr_sessionGetCumulativeStats( session, &stats );
749        tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
750        tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
751        /* Translators: "size|" is here for disambiguation.  Please remove it from your translation.
752           %1$s is the size of the data we've downloaded
753           %2$s is the size of the data we've uploaded */
754        g_snprintf( buf, sizeof( buf ), Q_(
755                        "size|Down: %1$s, Up: %2$s" ), down, up );
756    }
757    else     /* default is total-ratio */
758    {
759        tr_sessionGetCumulativeStats( session, &stats );
760        tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
761        g_snprintf( buf, sizeof( buf ), _( "Ratio: %s" ), ratio );
762    }
763    gtk_label_set_text( GTK_LABEL( p->stats_lb ), buf );
764}
765
766static void
767updateSpeeds( PrivateData * p )
768{
769    tr_session * session = tr_core_session( p->core );
770
771    if( session != NULL )
772    {
773        char buf[128];
774        double d;
775
776        d = tr_sessionGetPieceSpeed( session, TR_DOWN );
777        tr_strlspeed( buf, d, sizeof( buf ) );
778        gtk_label_set_text( GTK_LABEL( p->dl_lb ), buf );
779
780        d = tr_sessionGetPieceSpeed( session, TR_UP );
781        tr_strlspeed( buf, d, sizeof( buf ) );
782        gtk_label_set_text( GTK_LABEL( p->ul_lb ), buf );
783    }
784}
785
786void
787tr_window_update( TrWindow * self )
788{
789    PrivateData * p = get_private_data( self );
790
791    if( p && p->core && tr_core_session( p->core ) )
792    {
793        updateSpeeds( p );
794        updateTorrentCount( p );
795        updateStats( p );
796        refilter( p );
797    }
798}
799
800GtkTreeSelection*
801tr_window_get_selection( TrWindow * w )
802{
803    return get_private_data( w )->selection;
804}
805
Note: See TracBrowser for help on using the repository browser.