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

Last change on this file since 11599 was 11599, checked in by charles, 11 years ago

(trunk) Join the 21st century and use only 1 space at the end sentences. This commit is nearly as important as the semi-annual ones that remove trailing spaces from the ends of lines of code... :)

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