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

Last change on this file since 12356 was 12356, checked in by jordan, 11 years ago

(trunk gtk) more heap pruning: minor GtkTreeModel? changes

Use gtk_tree_model_iter_nth_child() instead of gtk_tree_model_get_iter_first() to avoid an unnecessary gtk_tree_path object being created and destroyed. This is a very minor change and I'm not sure how useful it really is, but it doesn't hurt.

  • Property svn:keywords set to Date Rev Author Id
File size: 31.3 KB
Line 
1/******************************************************************************
2 * $Id: tr-window.c 12356 2011-04-13 22:00:55Z jordan $
3 *
4 * Copyright (c) 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#include <libtransmission/utils.h> /* tr_formatter_speed_KBps() */
32
33#include "actions.h"
34#include "conf.h"
35#include "filter.h"
36#include "hig.h"
37#include "torrent-cell-renderer.h"
38#include "tr-prefs.h"
39#include "tr-window.h"
40#include "util.h"
41
42typedef struct
43{
44    GtkWidget *           speedlimit_on_item[2];
45    GtkWidget *           speedlimit_off_item[2];
46    GtkWidget *           ratio_on_item;
47    GtkWidget *           ratio_off_item;
48    GtkWidget *           scroll;
49    GtkWidget *           view;
50    GtkWidget *           toolbar;
51    GtkWidget *           filter;
52    GtkWidget *           status;
53    GtkWidget *           status_menu;
54    GtkWidget *           ul_lb;
55    GtkWidget *           dl_lb;
56    GtkWidget *           stats_lb;
57    GtkWidget *           gutter_lb;
58    GtkWidget *           alt_speed_image;
59    GtkWidget *           alt_speed_button;
60    GtkWidget *           options_menu;
61    GtkTreeSelection *    selection;
62    GtkCellRenderer *     renderer;
63    GtkTreeViewColumn *   column;
64    GtkTreeModel *        filter_model;
65    TrCore *              core;
66    gulong                pref_handler_id;
67}
68PrivateData;
69
70static GQuark
71get_private_data_key( void )
72{
73    static GQuark q = 0;
74    if( !q ) q = g_quark_from_static_string( "private-data" );
75    return q;
76}
77
78static PrivateData*
79get_private_data( TrWindow * w )
80{
81    return g_object_get_qdata ( G_OBJECT( w ), get_private_data_key( ) );
82}
83
84/***
85****
86***/
87
88static void
89on_popup_menu( GtkWidget * self UNUSED,
90               GdkEventButton * event )
91{
92    GtkWidget * menu = gtr_action_get_widget ( "/main-window-popup" );
93
94    gtk_menu_popup ( GTK_MENU( menu ), NULL, NULL, NULL, NULL,
95                    ( event ? event->button : 0 ),
96                    ( event ? event->time : 0 ) );
97}
98
99static void
100view_row_activated( GtkTreeView       * tree_view UNUSED,
101                    GtkTreePath       * path      UNUSED,
102                    GtkTreeViewColumn * column    UNUSED,
103                    gpointer            user_data UNUSED )
104{
105    gtr_action_activate( "show-torrent-properties" );
106}
107
108static GtkWidget*
109makeview( PrivateData * p )
110{
111    GtkWidget *         view;
112    GtkTreeViewColumn * col;
113    GtkTreeSelection *  sel;
114    GtkCellRenderer *   r;
115
116    view = gtk_tree_view_new( );
117    gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( view ), FALSE );
118    gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW( view ), TRUE );
119
120    p->selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
121
122    p->column = col = GTK_TREE_VIEW_COLUMN (g_object_new (GTK_TYPE_TREE_VIEW_COLUMN,
123        "title", _("Torrent"),
124        "resizable", TRUE,
125        "sizing", GTK_TREE_VIEW_COLUMN_FIXED,
126        NULL));
127
128    p->renderer = r = torrent_cell_renderer_new( );
129    gtk_tree_view_column_pack_start( col, r, FALSE );
130    gtk_tree_view_column_add_attribute( col, r, "torrent", MC_TORRENT );
131    gtk_tree_view_column_add_attribute( col, r, "piece-upload-speed", MC_SPEED_UP );
132    gtk_tree_view_column_add_attribute( col, r, "piece-download-speed", MC_SPEED_DOWN );
133
134    gtk_tree_view_append_column( GTK_TREE_VIEW( view ), col );
135    g_object_set( r, "xpad", GUI_PAD_SMALL, "ypad", GUI_PAD_SMALL, NULL );
136
137    gtk_tree_view_set_rules_hint( GTK_TREE_VIEW( view ), TRUE );
138    sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
139    gtk_tree_selection_set_mode( GTK_TREE_SELECTION( sel ),
140                                 GTK_SELECTION_MULTIPLE );
141
142    g_signal_connect( view, "popup-menu",
143                      G_CALLBACK( on_popup_menu ), NULL );
144    g_signal_connect( view, "button-press-event",
145                      G_CALLBACK( on_tree_view_button_pressed ),
146                      (void *) on_popup_menu );
147    g_signal_connect( view, "button-release-event",
148                      G_CALLBACK( on_tree_view_button_released ), NULL );
149    g_signal_connect( view, "row-activated",
150                      G_CALLBACK( view_row_activated ), NULL );
151
152
153    gtk_tree_view_set_model( GTK_TREE_VIEW( view ), p->filter_model );
154    g_object_unref( p->filter_model );
155
156    return view;
157}
158
159static void syncAltSpeedButton( PrivateData * p );
160
161static void
162prefsChanged( TrCore * core UNUSED,
163              const char *  key,
164              gpointer      wind )
165{
166    PrivateData * p = get_private_data( GTK_WINDOW( wind ) );
167
168    if( !strcmp( key, PREF_KEY_COMPACT_VIEW ) )
169    {
170        g_object_set( p->renderer, "compact", gtr_pref_flag_get( key ), NULL );
171        /* since the cell size has changed, we need gtktreeview to revalidate
172         * its fixed-height mode values. Unfortunately there's not an API call
173         * for that, but it *does* revalidate when it thinks the style's been tweaked */
174        g_signal_emit_by_name( p->view, "style-set", NULL, NULL );
175    }
176    else if( !strcmp( key, PREF_KEY_STATUSBAR ) )
177    {
178        const gboolean isEnabled = gtr_pref_flag_get( key );
179        g_object_set( p->status, "visible", isEnabled, NULL );
180    }
181    else if( !strcmp( key, PREF_KEY_FILTERBAR ) )
182    {
183        const gboolean isEnabled = gtr_pref_flag_get( key );
184        g_object_set( p->filter, "visible", isEnabled, NULL );
185    }
186    else if( !strcmp( key, PREF_KEY_TOOLBAR ) )
187    {
188        const gboolean isEnabled = gtr_pref_flag_get( key );
189        g_object_set( p->toolbar, "visible", isEnabled, NULL );
190    }
191    else if( !strcmp( key, PREF_KEY_STATUSBAR_STATS ) )
192    {
193        gtr_window_refresh( (TrWindow*)wind );
194    }
195    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_ENABLED ) ||
196             !strcmp( key, TR_PREFS_KEY_ALT_SPEED_UP_KBps ) ||
197             !strcmp( key, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps ) )
198    {
199        syncAltSpeedButton( p );
200    }
201}
202
203static void
204privateFree( gpointer vprivate )
205{
206    PrivateData * p = vprivate;
207    g_signal_handler_disconnect( p->core, p->pref_handler_id );
208    g_free( p );
209}
210
211static void
212onYinYangReleased( GtkWidget * w UNUSED, gpointer vprivate )
213{
214    PrivateData * p = vprivate;
215
216    gtk_menu_popup( GTK_MENU( p->status_menu ),
217                    NULL, NULL, NULL, NULL, 0,
218                    gtk_get_current_event_time( ) );
219}
220
221#define STATS_MODE "stats-mode"
222
223static struct
224{
225    const char *  val, *i18n;
226} stats_modes[] = {
227    { "total-ratio",      N_( "Total Ratio" )                },
228    { "session-ratio",    N_( "Session Ratio" )              },
229    { "total-transfer",   N_( "Total Transfer" )             },
230    { "session-transfer", N_( "Session Transfer" )           }
231};
232
233static void
234status_menu_toggled_cb( GtkCheckMenuItem * menu_item,
235                        gpointer           vprivate )
236{
237    if( gtk_check_menu_item_get_active( menu_item ) )
238    {
239        PrivateData * p = vprivate;
240        const char *  val = g_object_get_data( G_OBJECT(
241                                                   menu_item ), STATS_MODE );
242        gtr_core_set_pref( p->core, PREF_KEY_STATUSBAR_STATS, val );
243    }
244}
245
246static void
247syncAltSpeedButton( PrivateData * p )
248{
249    char u[32];
250    char d[32];
251    char * str;
252    const char * fmt;
253    const gboolean b = gtr_pref_flag_get( TR_PREFS_KEY_ALT_SPEED_ENABLED );
254    const char * stock = b ? "alt-speed-on" : "alt-speed-off";
255    GtkWidget * w = p->alt_speed_button;
256
257    tr_formatter_speed_KBps( u, gtr_pref_int_get( TR_PREFS_KEY_ALT_SPEED_UP_KBps ), sizeof( u ) );
258    tr_formatter_speed_KBps( d, gtr_pref_int_get( TR_PREFS_KEY_ALT_SPEED_DOWN_KBps ), sizeof( d ) );
259    fmt = b ? _( "Click to disable Alternative Speed Limits\n(%1$s down, %2$s up)" )
260            : _( "Click to enable Alternative Speed Limits\n(%1$s down, %2$s up)" );
261    str = g_strdup_printf( fmt, d, u );
262
263    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
264    gtk_image_set_from_stock( GTK_IMAGE( p->alt_speed_image ), stock, -1 );
265    gtk_button_set_alignment( GTK_BUTTON( w ), 0.5, 0.5 );
266    gtr_widget_set_tooltip_text( w, str );
267
268    g_free( str );
269}
270
271static void
272alt_speed_toggled_cb( GtkToggleButton * button, gpointer vprivate )
273{
274    PrivateData * p = vprivate;
275    const gboolean b = gtk_toggle_button_get_active( button );
276    gtr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED,  b );
277}
278
279/***
280****  FILTER
281***/
282
283#if GTK_CHECK_VERSION( 2, 12, 0 )
284
285static void
286findMaxAnnounceTime( GtkTreeModel *      model,
287                     GtkTreePath  * path UNUSED,
288                     GtkTreeIter *       iter,
289                     gpointer            gmaxTime )
290{
291    tr_torrent *    tor;
292    const tr_stat * torStat;
293    time_t *        maxTime = gmaxTime;
294
295    gtk_tree_model_get( model, iter, MC_TORRENT, &tor, -1 );
296    torStat = tr_torrentStatCached( tor );
297    *maxTime = MAX( *maxTime, torStat->manualAnnounceTime );
298}
299
300static gboolean
301onAskTrackerQueryTooltip( GtkWidget *            widget UNUSED,
302                          gint                   x UNUSED,
303                          gint                   y UNUSED,
304                          gboolean               keyboard_tip UNUSED,
305                          GtkTooltip *           tooltip,
306                          gpointer               gdata )
307{
308    const time_t now = time( NULL );
309    time_t       maxTime = 0;
310    PrivateData * p = gdata;
311
312    gtk_tree_selection_selected_foreach( p->selection,
313                                         findMaxAnnounceTime,
314                                         &maxTime );
315    if( maxTime <= now )
316    {
317        return FALSE;
318    }
319    else
320    {
321        char      buf[512];
322        char      timebuf[64];
323        const int seconds = maxTime - now;
324
325        tr_strltime( timebuf, seconds, sizeof( timebuf ) );
326        g_snprintf( buf, sizeof( buf ),
327                    _( "Tracker will allow requests in %s" ), timebuf );
328        gtk_tooltip_set_text( tooltip, buf );
329        return TRUE;
330    }
331}
332
333#endif
334
335static gboolean
336onAltSpeedToggledIdle( gpointer vp )
337{
338    PrivateData * p = vp;
339    gboolean b = tr_sessionUsesAltSpeed( gtr_core_session( p->core ) );
340    gtr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED, b );
341
342    return FALSE;
343}
344
345static void
346onAltSpeedToggled( tr_session * s UNUSED, bool isEnabled UNUSED, bool byUser UNUSED, void * p )
347{
348    gtr_idle_add( onAltSpeedToggledIdle, p );
349}
350
351/***
352****  Speed limit menu
353***/
354
355#define DIRECTION_KEY "direction-key"
356#define ENABLED_KEY "enabled-key"
357#define SPEED_KEY "speed-key"
358
359static void
360onSpeedToggled( GtkCheckMenuItem * check, gpointer vp )
361{
362    PrivateData * p = vp;
363    GObject * o = G_OBJECT( check );
364    gboolean isEnabled = g_object_get_data( o, ENABLED_KEY ) != 0;
365    tr_direction dir = GPOINTER_TO_INT( g_object_get_data( o, DIRECTION_KEY ) );
366    const char * key = dir == TR_UP ? TR_PREFS_KEY_USPEED_ENABLED
367                                    : TR_PREFS_KEY_DSPEED_ENABLED;
368
369    if( gtk_check_menu_item_get_active( check ) )
370        gtr_core_set_pref_bool( p->core, key, isEnabled );
371}
372
373static void
374onSpeedSet( GtkCheckMenuItem * check, gpointer vp )
375{
376    const char * key;
377    PrivateData * p = vp;
378    GObject * o = G_OBJECT( check );
379    const int KBps = GPOINTER_TO_INT( g_object_get_data( o, SPEED_KEY ) );
380    tr_direction dir = GPOINTER_TO_INT( g_object_get_data( o, DIRECTION_KEY ) );
381
382    key = dir==TR_UP ? TR_PREFS_KEY_USPEED_KBps : TR_PREFS_KEY_DSPEED_KBps;
383    gtr_core_set_pref_int( p->core, key, KBps );
384
385    key = dir==TR_UP ? TR_PREFS_KEY_USPEED_ENABLED : TR_PREFS_KEY_DSPEED_ENABLED;
386    gtr_core_set_pref_bool( p->core, key, TRUE );
387}
388
389static GtkWidget*
390createSpeedMenu( PrivateData * p, tr_direction dir )
391{
392    int i, n;
393    GtkWidget *w, *m;
394    const int speeds_KBps[] = { 5, 10, 20, 30, 40, 50, 75, 100, 150, 200, 250, 500, 750 };
395
396    m = gtk_menu_new( );
397
398    w = gtk_radio_menu_item_new_with_label( NULL, _( "Unlimited" ) );
399    p->speedlimit_off_item[dir] = w;
400    g_object_set_data( G_OBJECT( w ), DIRECTION_KEY, GINT_TO_POINTER( dir ) );
401    g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( FALSE ) );
402    g_signal_connect( w, "toggled", G_CALLBACK(onSpeedToggled), p );
403    gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
404
405    w = gtk_radio_menu_item_new_with_label_from_widget( GTK_RADIO_MENU_ITEM( w ), "" );
406    p->speedlimit_on_item[dir] = w;
407    g_object_set_data( G_OBJECT( w ), DIRECTION_KEY, GINT_TO_POINTER( dir ) );
408    g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( TRUE ) );
409    g_signal_connect( w, "toggled", G_CALLBACK(onSpeedToggled), p );
410    gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
411
412    w = gtk_separator_menu_item_new( );
413    gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
414
415    for( i=0, n=G_N_ELEMENTS(speeds_KBps); i<n; ++i )
416    {
417        char buf[128];
418        tr_formatter_speed_KBps( buf, speeds_KBps[i], sizeof( buf ) );
419        w = gtk_menu_item_new_with_label( buf );
420        g_object_set_data( G_OBJECT( w ), DIRECTION_KEY, GINT_TO_POINTER( dir ) );
421        g_object_set_data( G_OBJECT( w ), SPEED_KEY, GINT_TO_POINTER( speeds_KBps[i] ) );
422        g_signal_connect( w, "activate", G_CALLBACK(onSpeedSet), p );
423        gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
424    }
425
426    return m;
427}
428
429/***
430****  Speed limit menu
431***/
432
433#define RATIO_KEY "stock-ratio-index"
434
435static const double stockRatios[] = { 0.25, 0.5, 0.75, 1, 1.5, 2, 3 };
436
437static void
438onRatioToggled( GtkCheckMenuItem * check, gpointer vp )
439{
440    PrivateData * p = vp;
441    if( gtk_check_menu_item_get_active( check ) )
442    {
443        gboolean f = g_object_get_data( G_OBJECT( check ), ENABLED_KEY ) != 0;
444        gtr_core_set_pref_bool( p->core, TR_PREFS_KEY_RATIO_ENABLED, f );
445    }
446}
447static void
448onRatioSet( GtkCheckMenuItem * check, gpointer vp )
449{
450    PrivateData * p = vp;
451    int i = GPOINTER_TO_INT( g_object_get_data( G_OBJECT( check ), RATIO_KEY ) );
452    const double ratio = stockRatios[i];
453    gtr_core_set_pref_double( p->core, TR_PREFS_KEY_RATIO, ratio );
454    gtr_core_set_pref_bool  ( p->core, TR_PREFS_KEY_RATIO_ENABLED, TRUE );
455}
456
457static GtkWidget*
458createRatioMenu( PrivateData * p )
459{
460    int i, n;
461    GtkWidget *m, *w;
462
463    m = gtk_menu_new( );
464
465    w = gtk_radio_menu_item_new_with_label( NULL, _( "Seed Forever" ) );
466    p->ratio_off_item = w;
467    g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( FALSE ) );
468    g_signal_connect( w, "toggled", G_CALLBACK(onRatioToggled), p );
469    gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
470
471    w = gtk_radio_menu_item_new_with_label_from_widget( GTK_RADIO_MENU_ITEM( w ), "" );
472    p->ratio_on_item = w;
473    g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( TRUE ) );
474    g_signal_connect( w, "toggled", G_CALLBACK(onRatioToggled), p );
475    gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
476
477    w = gtk_separator_menu_item_new( );
478    gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
479
480    for( i=0, n=G_N_ELEMENTS(stockRatios); i<n; ++i )
481    {
482        char buf[128];
483        tr_strlratio( buf, stockRatios[i], sizeof( buf ) );
484        w = gtk_menu_item_new_with_label( buf );
485        g_object_set_data( G_OBJECT( w ), RATIO_KEY, GINT_TO_POINTER( i ) );
486        g_signal_connect( w, "activate", G_CALLBACK(onRatioSet), p );
487        gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
488    }
489
490    return m;
491}
492
493/***
494****  Option menu
495***/
496
497static GtkWidget*
498createOptionsMenu( PrivateData * p )
499{
500    GtkWidget * m;
501    GtkWidget * top = gtk_menu_new( );
502
503    m = gtk_menu_item_new_with_label( _( "Limit Download Speed" ) );
504    gtk_menu_item_set_submenu( GTK_MENU_ITEM( m ), createSpeedMenu( p, TR_DOWN ) );
505    gtk_menu_shell_append( GTK_MENU_SHELL( top ), m );
506
507    m = gtk_menu_item_new_with_label( _( "Limit Upload Speed" ) );
508    gtk_menu_item_set_submenu( GTK_MENU_ITEM( m ), createSpeedMenu( p, TR_UP ) );
509    gtk_menu_shell_append( GTK_MENU_SHELL( top ), m );
510
511    m = gtk_separator_menu_item_new( );
512    gtk_menu_shell_append( GTK_MENU_SHELL( top ), m );
513
514    m = gtk_menu_item_new_with_label( _( "Stop Seeding at Ratio" ) );
515    gtk_menu_item_set_submenu( GTK_MENU_ITEM( m ), createRatioMenu( p ) );
516    gtk_menu_shell_append( GTK_MENU_SHELL( top ), m );
517
518    gtk_widget_show_all( top );
519    return top;
520}
521
522static void
523onOptionsClicked( GtkButton * button UNUSED, gpointer vp )
524{
525    char buf1[512];
526    char buf2[512];
527    gboolean b;
528    GtkWidget * w;
529    PrivateData * p = vp;
530
531    w = p->speedlimit_on_item[TR_DOWN];
532    tr_formatter_speed_KBps( buf1, gtr_pref_int_get( TR_PREFS_KEY_DSPEED_KBps ), sizeof( buf1 ) );
533    gtr_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( w ) ) ), buf1 );
534
535    b = gtr_pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED );
536    w = b ? p->speedlimit_on_item[TR_DOWN] : p->speedlimit_off_item[TR_DOWN];
537    gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ), TRUE );
538
539    w = p->speedlimit_on_item[TR_UP];
540    tr_formatter_speed_KBps( buf1, gtr_pref_int_get( TR_PREFS_KEY_USPEED_KBps ), sizeof( buf1 ) );
541    gtr_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( w ) ) ), buf1 );
542
543    b = gtr_pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED );
544    w = b ? p->speedlimit_on_item[TR_UP] : p->speedlimit_off_item[TR_UP];
545    gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ), TRUE );
546
547    tr_strlratio( buf1, gtr_pref_double_get( TR_PREFS_KEY_RATIO ), sizeof( buf1 ) );
548    g_snprintf( buf2, sizeof( buf2 ), _( "Stop at Ratio (%s)" ), buf1 );
549    gtr_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( p->ratio_on_item ) ) ), buf2 );
550
551    b = gtr_pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED );
552    gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( b ? p->ratio_on_item : p->ratio_off_item ), TRUE );
553
554    gtk_menu_popup ( GTK_MENU( p->options_menu ), NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time( ) );
555}
556
557/***
558****  PUBLIC
559***/
560
561GtkWidget *
562gtr_window_new( GtkUIManager * ui_mgr, TrCore * core )
563{
564    int           i, n;
565    const char  * pch;
566    PrivateData * p;
567    GtkWidget   * mainmenu, *toolbar, *filter, *list, *status;
568    GtkWidget   * vbox, *w, *self, *h, *hbox, *menu;
569    GtkWindow   * win;
570    GSList      * l;
571
572    p = g_new0( PrivateData, 1 );
573
574    /* make the window */
575    self = gtk_window_new ( GTK_WINDOW_TOPLEVEL );
576    g_object_set_qdata_full( G_OBJECT(self), get_private_data_key( ), p, privateFree );
577    win = GTK_WINDOW( self );
578    gtk_window_set_title( win, g_get_application_name( ) );
579    gtk_window_set_role( win, "tr-main" );
580    gtk_window_set_default_size( win,
581                                 gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
582                                 gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
583    gtk_window_move( win, gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
584                          gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
585    if( gtr_pref_flag_get( PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED ) )
586        gtk_window_maximize( win );
587    gtk_window_add_accel_group( win, gtk_ui_manager_get_accel_group( ui_mgr ) );
588
589    /* window's main container */
590    vbox = gtk_vbox_new ( FALSE, 0 );
591    gtk_container_add ( GTK_CONTAINER( self ), vbox );
592
593    /* main menu */
594    mainmenu = gtr_action_get_widget( "/main-window-menu" );
595    w = gtr_action_get_widget( "/main-window-menu/torrent-menu/update-tracker" );
596#if GTK_CHECK_VERSION( 2, 12, 0 )
597    g_signal_connect( w, "query-tooltip",
598                      G_CALLBACK( onAskTrackerQueryTooltip ), p );
599#endif
600
601    /* toolbar */
602    toolbar = p->toolbar = gtr_action_get_widget( "/main-window-toolbar" );
603    gtr_action_set_important( "open-torrent-toolbar", TRUE );
604    gtr_action_set_important( "show-torrent-properties", TRUE );
605
606    /* filter */
607    h = filter = p->filter = gtr_filter_bar_new( gtr_core_session( core ),
608                                                 gtr_core_model( core ),
609                                                 &p->filter_model );
610    gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
611
612    /* status menu */
613    menu = p->status_menu = gtk_menu_new( );
614    l = NULL;
615    pch = gtr_pref_string_get( PREF_KEY_STATUSBAR_STATS );
616    for( i = 0, n = G_N_ELEMENTS( stats_modes ); i < n; ++i )
617    {
618        const char * val = stats_modes[i].val;
619        w = gtk_radio_menu_item_new_with_label( l, _( stats_modes[i].i18n ) );
620        l = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM( w ) );
621        gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ),
622                                       !strcmp( val, pch ) );
623        g_object_set_data( G_OBJECT(
624                               w ), STATS_MODE,
625                           (gpointer)stats_modes[i].val );
626        g_signal_connect( w, "toggled", G_CALLBACK(
627                              status_menu_toggled_cb ), p );
628        gtk_menu_shell_append( GTK_MENU_SHELL( menu ), w );
629        gtk_widget_show( w );
630    }
631
632    /* status */
633    h = status = p->status = gtk_hbox_new( FALSE, GUI_PAD_BIG );
634    gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
635
636        w = gtk_button_new( );
637        gtk_container_add( GTK_CONTAINER( w ), gtk_image_new_from_stock( "utilities", -1 ) );
638        gtr_widget_set_tooltip_text( w, _( "Options" ) );
639        gtk_box_pack_start( GTK_BOX( h ), w, 0, 0, 0 );
640        gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
641        p->options_menu = createOptionsMenu( p );
642        g_signal_connect( w, "clicked", G_CALLBACK(onOptionsClicked), p );
643
644        p->alt_speed_image = gtk_image_new( );
645        w = p->alt_speed_button = gtk_toggle_button_new( );
646        gtk_button_set_image( GTK_BUTTON( w ), p->alt_speed_image );
647        gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
648        g_signal_connect( w, "toggled", G_CALLBACK(alt_speed_toggled_cb ), p );
649        gtk_box_pack_start( GTK_BOX( h ), w, 0, 0, 0 );
650
651        w = p->gutter_lb = gtk_label_new( "N Torrents" );
652        gtk_label_set_single_line_mode( GTK_LABEL( w ), TRUE );
653        gtk_box_pack_start( GTK_BOX( h ), w, 1, 1, GUI_PAD );
654
655        hbox = gtk_hbox_new( FALSE, GUI_PAD );
656            w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
657            gtk_widget_set_size_request( w, GUI_PAD, 0u );
658            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
659            w = p->ul_lb = gtk_label_new( NULL );
660            gtk_label_set_single_line_mode( GTK_LABEL( w ), TRUE );
661            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
662            w = gtk_image_new_from_stock( GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU );
663            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
664        gtk_box_pack_end( GTK_BOX( h ), hbox, FALSE, FALSE, 0 );
665
666        hbox = gtk_hbox_new( FALSE, GUI_PAD );
667            w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
668            gtk_widget_set_size_request( w, GUI_PAD, 0u );
669            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
670            w = p->dl_lb = gtk_label_new( NULL );
671            gtk_label_set_single_line_mode( GTK_LABEL( w ), TRUE );
672            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
673            w = gtk_image_new_from_stock( GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU );
674            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
675        gtk_box_pack_end( GTK_BOX( h ), hbox, FALSE, FALSE, 0 );
676
677        hbox = gtk_hbox_new( FALSE, GUI_PAD );
678            w = gtk_button_new( );
679            gtr_widget_set_tooltip_text( w, _( "Statistics" ) );
680            gtk_container_add( GTK_CONTAINER( w ), gtk_image_new_from_stock( "ratio", -1 ) );
681            gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
682            g_signal_connect( w, "clicked", G_CALLBACK( onYinYangReleased ), p );
683            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
684            w = p->stats_lb = gtk_label_new( NULL );
685            gtk_label_set_single_line_mode( GTK_LABEL( w ), TRUE );
686            gtk_box_pack_end( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
687        gtk_box_pack_end( GTK_BOX( h ), hbox, FALSE, FALSE, 0 );
688
689
690    /* workarea */
691    p->view = makeview( p );
692    w = list = p->scroll = gtk_scrolled_window_new( NULL, NULL );
693    gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ),
694                                    GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
695    gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ),
696                                         GTK_SHADOW_IN );
697    gtk_container_add( GTK_CONTAINER( w ), p->view );
698
699    /* lay out the widgets */
700    gtk_box_pack_start( GTK_BOX( vbox ), mainmenu, FALSE, FALSE, 0 );
701    gtk_box_pack_start( GTK_BOX( vbox ), toolbar, FALSE, FALSE, 0 );
702    gtk_box_pack_start( GTK_BOX( vbox ), filter, FALSE, FALSE, 0 );
703    gtk_box_pack_start( GTK_BOX( vbox ), list, TRUE, TRUE, 0 );
704    gtk_box_pack_start( GTK_BOX( vbox ), status, FALSE, FALSE, 0 );
705
706    {
707        /* this is to determine the maximum width/height for the label */
708        int w=0, h=0;
709        PangoLayout * pango_layout;
710        pango_layout = gtk_widget_create_pango_layout( p->ul_lb, "999.99 KiB/s" );
711        pango_layout_get_pixel_size( pango_layout, &w, &h );
712        gtk_widget_set_size_request( p->ul_lb, w, h );
713        gtk_widget_set_size_request( p->dl_lb, w, h );
714        gtk_misc_set_alignment( GTK_MISC( p->ul_lb ), 1.0, 0.5 );
715        gtk_misc_set_alignment( GTK_MISC( p->dl_lb ), 1.0, 0.5 );
716        g_object_unref( G_OBJECT( pango_layout ) );
717    }
718
719    /* show all but the window */
720    gtk_widget_show_all( vbox );
721
722    /* listen for prefs changes that affect the window */
723    p->core = core;
724    prefsChanged( core, PREF_KEY_COMPACT_VIEW, self );
725    prefsChanged( core, PREF_KEY_FILTERBAR, self );
726    prefsChanged( core, PREF_KEY_STATUSBAR, self );
727    prefsChanged( core, PREF_KEY_STATUSBAR_STATS, self );
728    prefsChanged( core, PREF_KEY_TOOLBAR, self );
729    prefsChanged( core, TR_PREFS_KEY_ALT_SPEED_ENABLED, self );
730    p->pref_handler_id = g_signal_connect( core, "prefs-changed",
731                                           G_CALLBACK( prefsChanged ), self );
732
733    tr_sessionSetAltSpeedFunc( gtr_core_session( core ), onAltSpeedToggled, p );
734
735    return self;
736}
737
738static void
739updateTorrentCount( PrivateData * p )
740{
741    if( p && p->core )
742    {
743        char      buf[512];
744        const int torrentCount = gtk_tree_model_iter_n_children( gtr_core_model( p->core ), NULL );
745        const int visibleCount = gtk_tree_model_iter_n_children( p->filter_model, NULL );
746
747        if( !torrentCount )
748            *buf = '\0';
749        else if( torrentCount != visibleCount )
750            g_snprintf( buf, sizeof( buf ),
751                        gtr_ngettext( "%1$'d of %2$'d Torrent",
752                                      "%1$'d of %2$'d Torrents",
753                                      torrentCount ),
754                        visibleCount, torrentCount );
755        else
756            g_snprintf( buf, sizeof( buf ),
757                        gtr_ngettext( "%'d Torrent", "%'d Torrents", torrentCount ),
758                        torrentCount );
759        gtr_label_set_text( GTK_LABEL( p->gutter_lb ), buf );
760    }
761}
762
763static void
764updateStats( PrivateData * p )
765{
766    const char *            pch;
767    char                    up[32], down[32], ratio[32], buf[512];
768    struct tr_session_stats stats;
769    tr_session *            session = gtr_core_session( p->core );
770
771    /* update the stats */
772    pch = gtr_pref_string_get( PREF_KEY_STATUSBAR_STATS );
773    if( !strcmp( pch, "session-ratio" ) )
774    {
775        tr_sessionGetStats( session, &stats );
776        tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
777        g_snprintf( buf, sizeof( buf ), _( "Ratio: %s" ), ratio );
778    }
779    else if( !strcmp( pch, "session-transfer" ) )
780    {
781        tr_sessionGetStats( session, &stats );
782        tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
783        tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
784        /* Translators: "size|" is here for disambiguation. Please remove it from your translation.
785           %1$s is the size of the data we've downloaded
786           %2$s is the size of the data we've uploaded */
787        g_snprintf( buf, sizeof( buf ), Q_(
788                        "size|Down: %1$s, Up: %2$s" ), down, up );
789    }
790    else if( !strcmp( pch, "total-transfer" ) )
791    {
792        tr_sessionGetCumulativeStats( session, &stats );
793        tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
794        tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
795        /* Translators: "size|" is here for disambiguation. Please remove it from your translation.
796           %1$s is the size of the data we've downloaded
797           %2$s is the size of the data we've uploaded */
798        g_snprintf( buf, sizeof( buf ), Q_(
799                        "size|Down: %1$s, Up: %2$s" ), down, up );
800    }
801    else     /* default is total-ratio */
802    {
803        tr_sessionGetCumulativeStats( session, &stats );
804        tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
805        g_snprintf( buf, sizeof( buf ), _( "Ratio: %s" ), ratio );
806    }
807    gtr_label_set_text( GTK_LABEL( p->stats_lb ), buf );
808}
809
810static void
811updateSpeeds( PrivateData * p )
812{
813    tr_session * session = gtr_core_session( p->core );
814
815    if( session != NULL )
816    {
817        char buf[128];
818        double up=0, down=0;
819        GtkTreeIter iter;
820        GtkTreeModel * model = gtr_core_model( p->core );
821
822        if( gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 ) ) do
823        {
824            double u, d;
825            gtk_tree_model_get( model, &iter, MC_SPEED_UP, &u,
826                                              MC_SPEED_DOWN, &d,
827                                              -1 );
828            up += u;
829            down += d;
830        }
831        while( gtk_tree_model_iter_next( model, &iter ) );
832
833        tr_formatter_speed_KBps( buf, down, sizeof( buf ) );
834        gtr_label_set_text( GTK_LABEL( p->dl_lb ), buf );
835
836        tr_formatter_speed_KBps( buf, up, sizeof( buf ) );
837        gtr_label_set_text( GTK_LABEL( p->ul_lb ), buf );
838    }
839}
840
841void
842gtr_window_refresh( TrWindow * self )
843{
844    PrivateData * p = get_private_data( self );
845
846    if( p && p->core && gtr_core_session( p->core ) )
847    {
848        updateSpeeds( p );
849        updateTorrentCount( p );
850        updateStats( p );
851    }
852}
853
854GtkTreeSelection*
855gtr_window_get_selection( TrWindow * w )
856{
857    return get_private_data( w )->selection;
858}
859
860void
861gtr_window_set_busy( TrWindow * w, gboolean isBusy )
862{
863    if( w && gtr_widget_get_realized( GTK_WIDGET( w ) ) )
864    {
865        GdkDisplay * display = gtk_widget_get_display( GTK_WIDGET( w ) );
866        GdkCursor * cursor = isBusy ? gdk_cursor_new_for_display( display, GDK_WATCH ) : NULL;
867
868        gdk_window_set_cursor( gtr_widget_get_window( GTK_WIDGET( w ) ), cursor );
869        gdk_display_flush( display );
870
871        if( cursor ) {
872#if GTK_CHECK_VERSION(3,0,0)
873            g_object_unref( cursor );
874#else
875            gdk_cursor_unref( cursor );
876#endif
877        }
878    }
879}
Note: See TracBrowser for help on using the repository browser.