source: trunk/gtk/tr-prefs.c @ 7888

Last change on this file since 7888 was 7888, checked in by charles, 13 years ago

(trunk) #1787: add support for seeding ratio limiting in libtransmission

  • Property svn:keywords set to Date Rev Author Id
File size: 46.7 KB
Line 
1/*
2 * This file Copyright (C) 2007-2009 Charles Kerr <charles@transmissionbt.com>
3 *
4 * This file is licensed by the GPL version 2.  Works owned by the
5 * Transmission project are granted a special exemption to clause 2(b)
6 * so that the bulk of its code can remain under the MIT license.
7 * This exemption does not extend to derived works not owned by
8 * the Transmission project.
9 *
10 * $Id: tr-prefs.c 7888 2009-02-13 18:23:56Z charles $
11 */
12
13#include <ctype.h> /* isspace */
14#include <errno.h>
15#include <stdarg.h>
16#include <stdlib.h> /* free() */
17#include <unistd.h>
18#include <glib/gi18n.h>
19#include <gtk/gtk.h>
20#include <libtransmission/transmission.h>
21#include <libtransmission/utils.h>
22#include <libtransmission/version.h>
23#include <libtransmission/web.h>
24#include "blocklist.h"
25#include "conf.h"
26#include "hig.h"
27#include "tr-core.h"
28#include "tr-prefs.h"
29#include "util.h"
30
31/**
32 * This is where we initialize the preferences file with the default values.
33 * If you add a new preferences key, you /must/ add a default value here.
34 */
35void
36tr_prefs_init_global( void )
37{
38    const char * str;
39
40    cf_check_older_configs( );
41
42#ifdef HAVE_GIO
43    str = NULL;
44    if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DESKTOP );
45    if( !str ) str = tr_getDefaultDownloadDir( );
46    pref_string_set_default ( PREF_KEY_DIR_WATCH, str );
47    pref_flag_set_default   ( PREF_KEY_DIR_WATCH_ENABLED, FALSE );
48#endif
49
50    pref_flag_set_default   ( PREF_KEY_INHIBIT_HIBERNATION, FALSE );
51    pref_flag_set_default   ( PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE );
52
53    pref_string_set_default ( PREF_KEY_OPEN_DIALOG_FOLDER, g_get_home_dir( ) );
54
55    pref_flag_set_default   ( PREF_KEY_TOOLBAR, TRUE );
56    pref_flag_set_default   ( PREF_KEY_FILTERBAR, TRUE );
57    pref_flag_set_default   ( PREF_KEY_STATUSBAR, TRUE );
58    pref_flag_set_default   ( PREF_KEY_SHOW_TRAY_ICON, FALSE );
59    pref_flag_set_default   ( PREF_KEY_SHOW_DESKTOP_NOTIFICATION, TRUE );
60    pref_string_set_default ( PREF_KEY_STATUSBAR_STATS, "total-ratio" );
61
62    pref_flag_set_default   ( PREF_KEY_SCHED_LIMIT_ENABLED, FALSE );
63    pref_int_set_default    ( PREF_KEY_SCHED_BEGIN,    60 * 23 ); /* 11pm */
64    pref_int_set_default    ( PREF_KEY_SCHED_END,      60 * 7 );  /* 7am */
65    pref_int_set_default    ( PREF_KEY_SCHED_DL_LIMIT, 200 );   /* 2x the other limit */
66    pref_int_set_default    ( PREF_KEY_SCHED_UL_LIMIT, 100 );   /* 2x the other limit */
67
68    pref_flag_set_default   ( PREF_KEY_OPTIONS_PROMPT, TRUE );
69
70    pref_int_set_default    ( PREF_KEY_MAIN_WINDOW_HEIGHT, 500 );
71    pref_int_set_default    ( PREF_KEY_MAIN_WINDOW_WIDTH, 300 );
72    pref_int_set_default    ( PREF_KEY_MAIN_WINDOW_X, 50 );
73    pref_int_set_default    ( PREF_KEY_MAIN_WINDOW_Y, 50 );
74    pref_string_set_default ( PREF_KEY_MAIN_WINDOW_LAYOUT_ORDER, "menu,toolbar,filter,list,statusbar" );
75
76    str = NULL;
77#if GLIB_CHECK_VERSION( 2, 14, 0 )
78    if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DOWNLOAD );
79#endif
80    if( !str ) str = g_get_home_dir( );
81    pref_string_set_default ( TR_PREFS_KEY_DOWNLOAD_DIR, str );
82
83    pref_flag_set_default   ( PREF_KEY_ASKQUIT, TRUE );
84
85    pref_string_set_default ( PREF_KEY_SORT_MODE, "sort-by-name" );
86    pref_flag_set_default   ( PREF_KEY_SORT_REVERSED, FALSE );
87    pref_flag_set_default   ( PREF_KEY_MINIMAL_VIEW, FALSE );
88
89    pref_flag_set_default   ( PREF_KEY_START, TRUE );
90    pref_flag_set_default   ( PREF_KEY_TRASH_ORIGINAL, FALSE );
91}
92
93/**
94***
95**/
96
97#define PREF_KEY "pref-key"
98
99static void
100response_cb( GtkDialog *     dialog,
101             int             response,
102             gpointer unused UNUSED )
103{
104    if( response == GTK_RESPONSE_HELP )
105    {
106        char * base = gtr_get_help_url( );
107        char * url = g_strdup_printf( "%s/html/preferences.html", base );
108        gtr_open_file( url );
109        g_free( url );
110        g_free( base );
111    }
112
113    if( response == GTK_RESPONSE_CLOSE )
114        gtk_widget_destroy( GTK_WIDGET( dialog ) );
115}
116
117static void
118toggled_cb( GtkToggleButton * w,
119            gpointer          core )
120{
121    const char *   key = g_object_get_data( G_OBJECT( w ), PREF_KEY );
122    const gboolean flag = gtk_toggle_button_get_active( w );
123
124    tr_core_set_pref_bool( TR_CORE( core ), key, flag );
125}
126
127static GtkWidget*
128new_check_button( const char * mnemonic,
129                  const char * key,
130                  gpointer     core )
131{
132    GtkWidget * w = gtk_check_button_new_with_mnemonic( mnemonic );
133
134    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup(
135                                key ), g_free );
136    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ),
137                                 pref_flag_get( key ) );
138    g_signal_connect( w, "toggled", G_CALLBACK( toggled_cb ), core );
139    return w;
140}
141
142#define IDLE_DATA "idle-data"
143
144struct spin_idle_data
145{
146    gpointer    core;
147    GTimer *    last_change;
148    gboolean    isDouble;
149};
150
151static void
152spin_idle_data_free( gpointer gdata )
153{
154    struct spin_idle_data * data = gdata;
155
156    g_timer_destroy( data->last_change );
157    g_free( data );
158}
159
160static gboolean
161spun_cb_idle( gpointer spin )
162{
163    gboolean                keep_waiting = TRUE;
164    GObject *               o = G_OBJECT( spin );
165    struct spin_idle_data * data = g_object_get_data( o, IDLE_DATA );
166
167    /* has the user stopped making changes? */
168    if( g_timer_elapsed( data->last_change, NULL ) > 0.33f )
169    {
170        /* update the core */
171        const char * key = g_object_get_data( o, PREF_KEY );
172        if (data->isDouble)
173        {
174            const double value = gtk_spin_button_get_value( GTK_SPIN_BUTTON( spin ) );
175            tr_core_set_pref_double( TR_CORE( data->core ), key, value );
176        }
177        else
178        {
179            const int    value = gtk_spin_button_get_value_as_int(
180                                 GTK_SPIN_BUTTON( spin ) );
181            tr_core_set_pref_int( TR_CORE( data->core ), key, value );
182        }
183
184        /* cleanup */
185        g_object_set_data( o, IDLE_DATA, NULL );
186        keep_waiting = FALSE;
187        g_object_unref( G_OBJECT( o ) );
188    }
189
190    return keep_waiting;
191}
192
193static void
194spun_cb( GtkSpinButton * w,
195         gpointer        core,
196         gboolean        isDouble )
197{
198    /* user may be spinning through many values, so let's hold off
199       for a moment to keep from flooding the core with changes */
200    GObject *               o = G_OBJECT( w );
201    struct spin_idle_data * data = g_object_get_data( o, IDLE_DATA );
202
203    if( data == NULL )
204    {
205        data = g_new( struct spin_idle_data, 1 );
206        data->core = core;
207        data->last_change = g_timer_new( );
208        data->isDouble = isDouble;
209        g_object_set_data_full( o, IDLE_DATA, data, spin_idle_data_free );
210        g_object_ref( G_OBJECT( o ) );
211        g_timeout_add( 100, spun_cb_idle, w );
212    }
213    g_timer_start( data->last_change );
214}
215
216static void
217spun_cb_int( GtkSpinButton * w,
218             gpointer        core )
219{
220    spun_cb( w, core, FALSE );
221}
222
223static void
224spun_cb_double( GtkSpinButton * w,
225                gpointer        core )
226{
227    spun_cb( w, core, TRUE );
228}
229
230static GtkWidget*
231new_spin_button( const char * key,
232                 gpointer     core,
233                 int          low,
234                 int          high,
235                 int          step )
236{
237    GtkWidget * w = gtk_spin_button_new_with_range( low, high, step );
238
239    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup(
240                                key ), g_free );
241    gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 0 );
242    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), pref_int_get( key ) );
243    g_signal_connect( w, "value-changed", G_CALLBACK( spun_cb_int ), core );
244    return w;
245}
246
247static GtkWidget*
248new_spin_button_double( const char * key,
249                       gpointer      core,
250                       double        low,
251                       double        high,
252                       double        step )
253{
254    GtkWidget * w = gtk_spin_button_new_with_range( low, high, step );
255
256    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup(
257                                key ), g_free );
258    gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 2 );
259    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), pref_double_get( key ) );
260    g_signal_connect( w, "value-changed", G_CALLBACK( spun_cb_double ), core );
261    return w;
262}
263
264static void
265entry_changed_cb( GtkEntry * w,
266                  gpointer   core )
267{
268    const char * key = g_object_get_data( G_OBJECT( w ), PREF_KEY );
269    const char * value = gtk_entry_get_text( w );
270
271    tr_core_set_pref( TR_CORE( core ), key, value );
272}
273
274static GtkWidget*
275new_entry( const char * key,
276           gpointer     core )
277{
278    GtkWidget *  w = gtk_entry_new( );
279    const char * value = pref_string_get( key );
280
281    if( value )
282        gtk_entry_set_text( GTK_ENTRY( w ), value );
283    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup(
284                                key ), g_free );
285    g_signal_connect( w, "changed", G_CALLBACK( entry_changed_cb ), core );
286    return w;
287}
288
289static void
290chosen_cb( GtkFileChooser * w,
291           gpointer         core )
292{
293    const char * key = g_object_get_data( G_OBJECT( w ), PREF_KEY );
294    char *       value = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( w ) );
295
296    tr_core_set_pref( TR_CORE( core ), key, value );
297    g_free( value );
298}
299
300static GtkWidget*
301new_path_chooser_button( const char * key,
302                         gpointer     core )
303{
304    GtkWidget *  w = gtk_file_chooser_button_new(
305        NULL,
306        GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
307    const char * path = pref_string_get( key );
308
309    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup(
310                                key ), g_free );
311    g_signal_connect( w, "selection-changed", G_CALLBACK( chosen_cb ), core );
312    gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), path );
313    return w;
314}
315
316static void
317target_cb( GtkWidget * tb,
318           gpointer    target )
319{
320    const gboolean b = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( tb ) );
321
322    gtk_widget_set_sensitive( GTK_WIDGET( target ), b );
323}
324
325/****
326*****  Torrent Tab
327****/
328
329static GtkWidget*
330torrentPage( GObject * core )
331{
332    int          row = 0;
333    const char * s;
334    GtkWidget *  t;
335    GtkWidget *  w;
336
337#ifdef HAVE_GIO
338    GtkWidget *  l;
339#endif
340
341    t = hig_workarea_create( );
342    hig_workarea_add_section_title( t, &row, _( "Adding Torrents" ) );
343
344#ifdef HAVE_GIO
345    s = _( "Automatically _add torrents from:" );
346    l = new_check_button( s, PREF_KEY_DIR_WATCH_ENABLED, core );
347    w = new_path_chooser_button( PREF_KEY_DIR_WATCH, core );
348    gtk_widget_set_sensitive( GTK_WIDGET( w ),
349                             pref_flag_get( PREF_KEY_DIR_WATCH_ENABLED ) );
350    g_signal_connect( l, "toggled", G_CALLBACK( target_cb ), w );
351    hig_workarea_add_row_w( t, &row, l, w, NULL );
352#endif
353
354    s = _( "Display _options dialog" );
355    w = new_check_button( s, PREF_KEY_OPTIONS_PROMPT, core );
356    hig_workarea_add_wide_control( t, &row, w );
357
358    s = _( "_Start when added" );
359    w = new_check_button( s, PREF_KEY_START, core );
360    hig_workarea_add_wide_control( t, &row, w );
361
362    s = _( "Mo_ve source files to Trash" );
363    w = new_check_button( s, PREF_KEY_TRASH_ORIGINAL, core );
364    hig_workarea_add_wide_control( t, &row, w );
365
366    w = new_path_chooser_button( TR_PREFS_KEY_DOWNLOAD_DIR, core );
367    hig_workarea_add_row( t, &row, _( "_Destination folder:" ), w, NULL );
368
369    hig_workarea_finish( t, &row );
370    return t;
371}
372
373/****
374*****  Desktop Tab
375****/
376
377static GtkWidget*
378desktopPage( GObject * core )
379{
380    int          row = 0;
381    const char * s;
382    GtkWidget *  t;
383    GtkWidget *  w;
384
385    t = hig_workarea_create( );
386    hig_workarea_add_section_title( t, &row, _( "Options" ) );
387
388    s = _( "Inhibit desktop _hibernation when torrents are active" );
389    w = new_check_button( s, PREF_KEY_INHIBIT_HIBERNATION, core );
390    hig_workarea_add_wide_control( t, &row, w );
391
392    s = _( "Show _icon in the desktop Notification Area" );
393    w = new_check_button( s, PREF_KEY_SHOW_TRAY_ICON, core );
394    hig_workarea_add_wide_control( t, &row, w );
395
396    s = _( "Show desktop _notifications" );
397    w = new_check_button( s, PREF_KEY_SHOW_DESKTOP_NOTIFICATION, core );
398    hig_workarea_add_wide_control( t, &row, w );
399
400    hig_workarea_finish( t, &row );
401    return t;
402}
403
404/****
405*****  Peer Tab
406****/
407
408struct blocklist_data
409{
410    GtkWidget *  check;
411    GtkWidget *  dialog;
412    TrCore *     core;
413    gulong       id;
414    int          abortFlag;
415    char         secondary[256];
416};
417
418static void
419updateBlocklistText( GtkWidget * w,
420                     TrCore *    core )
421{
422    const int n = tr_blocklistGetRuleCount( tr_core_session( core ) );
423    char      buf[512];
424
425    g_snprintf( buf, sizeof( buf ),
426                ngettext( "Enable _blocklist (contains %'d rule)",
427                          "Enable _blocklist (contains %'d rules)", n ), n );
428    gtk_button_set_label( GTK_BUTTON( w ), buf );
429}
430
431static void
432onBlocklistDialogResponse( GtkDialog *  d,
433                           int response UNUSED,
434                           gpointer     gdata )
435{
436    struct blocklist_data * data = gdata;
437
438    g_signal_handler_disconnect( data->core, data->id );
439    gtk_widget_destroy( GTK_WIDGET( d ) );
440}
441
442static void
443onBlocklistStatus( TrCore * core UNUSED,
444                   gboolean      isDone,
445                   const char *  status,
446                   gpointer      gdata )
447{
448    struct blocklist_data * data = gdata;
449
450    gdk_threads_enter( );
451    gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( data-> dialog ),
452                                              "%s", status );
453    gtk_dialog_set_response_sensitive( GTK_DIALOG( data->dialog ),
454                                       GTK_RESPONSE_CANCEL, !isDone );
455    gtk_dialog_set_response_sensitive( GTK_DIALOG( data->dialog ),
456                                       GTK_RESPONSE_CLOSE, isDone );
457    if( isDone )
458        updateBlocklistText( data->check, core );
459    gdk_threads_leave( );
460}
461
462static void
463onUpdateBlocklistCB( GtkButton * w,
464                     gpointer    gdata )
465{
466    GtkWidget *             d;
467    struct blocklist_data * data = gdata;
468
469    d =
470        gtk_message_dialog_new( GTK_WINDOW( gtk_widget_get_toplevel( 
471                                                                    GTK_WIDGET(
472                                                                        w ) ) ),
473                               GTK_DIALOG_DESTROY_WITH_PARENT,
474                               GTK_MESSAGE_INFO,
475                               GTK_BUTTONS_NONE,
476                               _( "Updating Blocklist" ) );
477
478    data->dialog = d;
479    data->id =
480        g_signal_connect( data->core, "blocklist-status", G_CALLBACK(
481                              onBlocklistStatus ), data );
482
483    gtk_dialog_add_buttons( GTK_DIALOG( d ),
484                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
485                            GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
486                            NULL );
487    gtk_dialog_set_response_sensitive( GTK_DIALOG(
488                                           d ), GTK_RESPONSE_CLOSE, FALSE );
489
490    g_signal_connect( d, "response", G_CALLBACK(
491                          onBlocklistDialogResponse ), data );
492    gtk_widget_show( d );
493
494    gtr_blocklist_update( data->core );
495}
496
497static void
498onEncryptionToggled( GtkToggleButton * w,
499                     gpointer          core )
500{
501    const int val = gtk_toggle_button_get_active( w )
502                    ? TR_ENCRYPTION_REQUIRED
503                    : TR_ENCRYPTION_PREFERRED;
504
505    tr_core_set_pref_int( TR_CORE( core ), TR_PREFS_KEY_ENCRYPTION, val );
506}
507
508static GtkWidget*
509peerPage( GObject * core )
510{
511    int                     row = 0;
512    const char *            s;
513    GtkWidget *             t;
514    GtkWidget *             w;
515    GtkWidget *             b;
516    GtkWidget *             h;
517    struct blocklist_data * data;
518
519    data = g_new0( struct blocklist_data, 1 );
520    data->core = TR_CORE( core );
521
522    t = hig_workarea_create( );
523    hig_workarea_add_section_title( t, &row, _( "Blocklist" ) );
524
525    w = new_check_button( "", TR_PREFS_KEY_BLOCKLIST_ENABLED, core );
526    updateBlocklistText( w, TR_CORE( core ) );
527    h = gtk_hbox_new( FALSE, GUI_PAD_BIG );
528    gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
529    b = gtr_button_new_from_stock( GTK_STOCK_REFRESH, _( "_Update" ) );
530    data->check = w;
531    g_object_set_data( G_OBJECT( b ), "session",
532                      tr_core_session( TR_CORE( core ) ) );
533    g_signal_connect( b, "clicked", G_CALLBACK( onUpdateBlocklistCB ), data );
534    gtk_box_pack_start( GTK_BOX( h ), b, FALSE, FALSE, 0 );
535    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), b );
536    target_cb( w, b );
537    hig_workarea_add_wide_control( t, &row, h );
538
539    s = _( "Enable _automatic updates" );
540    w = new_check_button( s, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, core );
541    hig_workarea_add_wide_control( t, &row, w );
542    g_signal_connect( data->check, "toggled", G_CALLBACK( target_cb ), w );
543    target_cb( data->check, w );
544
545    hig_workarea_add_section_divider( t, &row );
546    hig_workarea_add_section_title( t, &row, _( "Limits" ) );
547
548    w = new_spin_button( TR_PREFS_KEY_PEER_LIMIT_GLOBAL, core, 1, 3000, 5 );
549    hig_workarea_add_row( t, &row, _( "Maximum peers _overall:" ), w, NULL );
550    w = new_spin_button( TR_PREFS_KEY_PEER_LIMIT_TORRENT, core, 1, 300, 5 );
551    hig_workarea_add_row( t, &row, _( "Maximum peers per _torrent:" ), w, NULL );
552
553    hig_workarea_add_section_divider( t, &row );
554    hig_workarea_add_section_title ( t, &row, _( "Options" ) );
555
556    s = _( "_Ignore unencrypted peers" );
557    w = gtk_check_button_new_with_mnemonic( s );
558    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ),
559                                  pref_int_get( TR_PREFS_KEY_ENCRYPTION ) ==
560                                  TR_ENCRYPTION_REQUIRED );
561    g_signal_connect( w, "toggled", G_CALLBACK( onEncryptionToggled ), core );
562    hig_workarea_add_wide_control( t, &row, w );
563
564    s = _( "Use peer e_xchange" );
565    w = new_check_button( s, TR_PREFS_KEY_PEX_ENABLED, core );
566    hig_workarea_add_wide_control( t, &row, w );
567
568    hig_workarea_finish( t, &row );
569    return t;
570}
571
572/****
573*****  Web Tab
574****/
575
576enum
577{
578    COL_ADDRESS,
579    N_COLS
580};
581
582static GtkTreeModel*
583whitelist_tree_model_new( const char * whitelist )
584{
585    int            i;
586    char **        rules;
587    GtkListStore * store = gtk_list_store_new( N_COLS,
588                                               G_TYPE_STRING,
589                                               G_TYPE_STRING );
590
591    rules = g_strsplit( whitelist, ",", 0 );
592
593    for( i = 0; rules && rules[i]; ++i )
594    {
595        GtkTreeIter iter;
596        const char * s = rules[i];
597        while( isspace( *s ) ) ++s;
598        gtk_list_store_append( store, &iter );
599        gtk_list_store_set( store, &iter, COL_ADDRESS, s, -1 );
600    }
601
602    g_strfreev( rules );
603    return GTK_TREE_MODEL( store );
604}
605
606struct remote_page
607{
608    TrCore *           core;
609    GtkTreeView *      view;
610    GtkListStore *     store;
611    GtkWidget *        remove_button;
612    GSList *           widgets;
613    GSList *           auth_widgets;
614    GSList *           whitelist_widgets;
615    GtkToggleButton *  rpc_tb;
616    GtkToggleButton *  auth_tb;
617    GtkToggleButton *  whitelist_tb;
618};
619
620static void
621refreshWhitelist( struct remote_page * page )
622{
623    GtkTreeIter    iter;
624    GtkTreeModel * model = GTK_TREE_MODEL( page->store );
625    GString *      gstr = g_string_new( NULL );
626
627    if( gtk_tree_model_get_iter_first( model, &iter ) ) do
628        {
629            char * address;
630            gtk_tree_model_get( model, &iter,
631                                COL_ADDRESS, &address,
632                                -1 );
633            g_string_append( gstr, address );
634            g_string_append( gstr, "," );
635            g_free( address );
636        }
637        while( gtk_tree_model_iter_next( model, &iter ) );
638
639    g_string_truncate( gstr, gstr->len - 1 ); /* remove the trailing comma */
640
641    tr_core_set_pref( page->core, TR_PREFS_KEY_RPC_WHITELIST, gstr->str );
642
643    g_string_free( gstr, TRUE );
644}
645
646static void
647onAddressEdited( GtkCellRendererText  * r UNUSED,
648                 gchar *                  path_string,
649                 gchar *                  address,
650                 gpointer                 gpage )
651{
652    GtkTreeIter          iter;
653    struct remote_page * page = gpage;
654    GtkTreeModel *       model = GTK_TREE_MODEL( page->store );
655    GtkTreePath *        path = gtk_tree_path_new_from_string( path_string );
656
657    if( gtk_tree_model_get_iter( model, &iter, path ) )
658        gtk_list_store_set( page->store, &iter, COL_ADDRESS, address, -1 );
659
660    gtk_tree_path_free( path );
661    refreshWhitelist( page );
662}
663
664static void
665onAddWhitelistClicked( GtkButton * b UNUSED,
666                 gpointer      gpage )
667{
668    GtkTreeIter          iter;
669    GtkTreePath *        path;
670    struct remote_page * page = gpage;
671
672    gtk_list_store_append( page->store, &iter );
673    gtk_list_store_set( page->store, &iter,
674                        COL_ADDRESS,  "0.0.0.0",
675                        -1 );
676
677    path = gtk_tree_model_get_path( GTK_TREE_MODEL( page->store ), &iter );
678    gtk_tree_view_set_cursor(
679        page->view, path,
680        gtk_tree_view_get_column( page->view, COL_ADDRESS ),
681        TRUE );
682    gtk_tree_path_free( path );
683}
684
685static void
686onRemoveWhitelistClicked( GtkButton * b UNUSED,
687                    gpointer      gpage )
688{
689    struct remote_page * page = gpage;
690    GtkTreeSelection *   sel = gtk_tree_view_get_selection( page->view );
691    GtkTreeIter          iter;
692
693    if( gtk_tree_selection_get_selected( sel, NULL, &iter ) )
694    {
695        gtk_list_store_remove( page->store, &iter );
696        refreshWhitelist( page );
697    }
698}
699
700static void
701refreshRPCSensitivity( struct remote_page * page )
702{
703    GSList *           l;
704    const int          rpc_active = gtk_toggle_button_get_active(
705        page->rpc_tb );
706    const int          auth_active = gtk_toggle_button_get_active(
707        page->auth_tb );
708    const int          whitelist_active = gtk_toggle_button_get_active(
709        page->whitelist_tb );
710    GtkTreeSelection * sel = gtk_tree_view_get_selection( page->view );
711    const int          have_addr =
712        gtk_tree_selection_get_selected( sel, NULL,
713                                         NULL );
714    const int          n_rules = gtk_tree_model_iter_n_children(
715        GTK_TREE_MODEL( page->store ), NULL );
716
717    for( l = page->widgets; l != NULL; l = l->next )
718        gtk_widget_set_sensitive( GTK_WIDGET( l->data ), rpc_active );
719
720    for( l = page->auth_widgets; l != NULL; l = l->next )
721        gtk_widget_set_sensitive( GTK_WIDGET(
722                                      l->data ), rpc_active && auth_active );
723
724    for( l = page->whitelist_widgets; l != NULL; l = l->next )
725        gtk_widget_set_sensitive( GTK_WIDGET( l->data ),
726                                  rpc_active && whitelist_active );
727
728    gtk_widget_set_sensitive( page->remove_button,
729                              rpc_active && have_addr && n_rules > 1 );
730}
731
732static void
733onRPCToggled( GtkToggleButton * tb UNUSED,
734              gpointer             page )
735{
736    refreshRPCSensitivity( page );
737}
738
739static void
740onWhitelistSelectionChanged( GtkTreeSelection * sel UNUSED,
741                       gpointer               page )
742{
743    refreshRPCSensitivity( page );
744}
745
746static void
747onLaunchClutchCB( GtkButton * w UNUSED,
748                  gpointer data UNUSED )
749{
750    int    port = pref_int_get( TR_PREFS_KEY_RPC_PORT );
751    char * url = g_strdup_printf( "http://localhost:%d/transmission/web",
752                                  port );
753
754    gtr_open_file( url );
755    g_free( url );
756}
757
758static GtkWidget*
759webPage( GObject * core )
760{
761    const char *         s;
762    int                  row = 0;
763    GtkWidget *          t;
764    GtkWidget *          w;
765    GtkWidget *          h;
766    struct remote_page * page = g_new0( struct remote_page, 1 );
767
768    page->core = TR_CORE( core );
769
770    t = hig_workarea_create( );
771    g_object_set_data_full( G_OBJECT( t ), "page", page, g_free );
772
773    hig_workarea_add_section_title( t, &row, _( "Web Interface" ) );
774
775    /* "enabled" checkbutton */
776    s = _( "_Enable web interface" );
777    w = new_check_button( s, TR_PREFS_KEY_RPC_ENABLED, core );
778    page->rpc_tb = GTK_TOGGLE_BUTTON( w );
779    g_signal_connect( w, "clicked", G_CALLBACK( onRPCToggled ), page );
780    h = gtk_hbox_new( FALSE, GUI_PAD_BIG );
781    gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
782    w = gtr_button_new_from_stock( GTK_STOCK_OPEN, _( "_Open web interface" ) );
783    page->widgets = g_slist_append( page->widgets, w );
784    g_signal_connect( w, "clicked", G_CALLBACK( onLaunchClutchCB ), NULL );
785    gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
786    hig_workarea_add_wide_control( t, &row, h );
787
788    /* port */
789    w = new_spin_button( TR_PREFS_KEY_RPC_PORT, core, 0, 65535, 1 );
790    page->widgets = g_slist_append( page->widgets, w );
791    w = hig_workarea_add_row( t, &row, _( "Listening _port:" ), w, NULL );
792    page->widgets = g_slist_append( page->widgets, w );
793
794    /* require authentication */
795    s = _( "_Require username" );
796    w = new_check_button( s, TR_PREFS_KEY_RPC_AUTH_REQUIRED, core );
797    hig_workarea_add_wide_control( t, &row, w );
798    page->auth_tb = GTK_TOGGLE_BUTTON( w );
799    page->widgets = g_slist_append( page->widgets, w );
800    g_signal_connect( w, "clicked", G_CALLBACK( onRPCToggled ), page );
801
802    /* username */
803    s = _( "_Username:" );
804    w = new_entry( TR_PREFS_KEY_RPC_USERNAME, core );
805    page->auth_widgets = g_slist_append( page->auth_widgets, w );
806    w = hig_workarea_add_row( t, &row, s, w, NULL );
807    page->auth_widgets = g_slist_append( page->auth_widgets, w );
808
809    /* password */
810    s = _( "Pass_word:" );
811    w = new_entry( TR_PREFS_KEY_RPC_PASSWORD, core );
812    gtk_entry_set_visibility( GTK_ENTRY( w ), FALSE );
813    page->auth_widgets = g_slist_append( page->auth_widgets, w );
814    w = hig_workarea_add_row( t, &row, s, w, NULL );
815    page->auth_widgets = g_slist_append( page->auth_widgets, w );
816
817    /* require authentication */
818    s = _( "Only allow the following IP _addresses to connect:" );
819    w = new_check_button( s, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, core );
820    hig_workarea_add_wide_control( t, &row, w );
821    page->whitelist_tb = GTK_TOGGLE_BUTTON( w );
822    page->widgets = g_slist_append( page->widgets, w );
823    g_signal_connect( w, "clicked", G_CALLBACK( onRPCToggled ), page );
824
825    /* access control list */
826    {
827        const char *        val = pref_string_get( TR_PREFS_KEY_RPC_WHITELIST );
828        GtkTreeModel *      m = whitelist_tree_model_new( val );
829        GtkTreeViewColumn * c;
830        GtkCellRenderer *   r;
831        GtkTreeSelection *  sel;
832        GtkTreeView *       v;
833        GtkWidget *         w;
834        GtkWidget *         h;
835
836        page->store = GTK_LIST_STORE( m );
837        w = gtk_tree_view_new_with_model( m );
838        g_signal_connect( w, "button-release-event",
839                          G_CALLBACK( on_tree_view_button_released ), NULL );
840
841        page->whitelist_widgets = g_slist_append( page->whitelist_widgets, w );
842        v = page->view = GTK_TREE_VIEW( w );
843#if GTK_CHECK_VERSION( 2,12,0 )
844        gtk_widget_set_tooltip_text( w,
845                  _( "IP addresses may use wildcards, such as 192.168.*.*" ) );
846#endif
847        sel = gtk_tree_view_get_selection( v );
848        g_signal_connect( sel, "changed",
849                          G_CALLBACK( onWhitelistSelectionChanged ), page );
850        g_object_unref( G_OBJECT( m ) );
851        gtk_tree_view_set_headers_visible( v, TRUE );
852        w = gtk_frame_new( NULL );
853        gtk_frame_set_shadow_type( GTK_FRAME( w ), GTK_SHADOW_IN );
854        gtk_container_add( GTK_CONTAINER( w ), GTK_WIDGET( v ) );
855
856        /* ip address column */
857        r = gtk_cell_renderer_text_new( );
858        g_signal_connect( r, "edited",
859                          G_CALLBACK( onAddressEdited ), page );
860        g_object_set( G_OBJECT( r ), "editable", TRUE, NULL );
861        c = gtk_tree_view_column_new_with_attributes( NULL, r,
862                                                      "text", COL_ADDRESS,
863                                                      NULL );
864        gtk_tree_view_column_set_expand( c, TRUE );
865        gtk_tree_view_append_column( v, c );
866        gtk_tree_view_set_headers_visible( v, FALSE );
867
868        s = _( "Addresses:" );
869        w = hig_workarea_add_row( t, &row, s, w, NULL );
870        gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.0f );
871        gtk_misc_set_padding( GTK_MISC( w ), 0, GUI_PAD );
872        page->whitelist_widgets = g_slist_append( page->whitelist_widgets, w );
873
874        h = gtk_hbox_new( TRUE, GUI_PAD );
875        w = gtk_button_new_from_stock( GTK_STOCK_REMOVE );
876        g_signal_connect( w, "clicked", G_CALLBACK(
877                              onRemoveWhitelistClicked ), page );
878        page->remove_button = w;
879        onWhitelistSelectionChanged( sel, page );
880        gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
881        w = gtk_button_new_from_stock( GTK_STOCK_ADD );
882        page->whitelist_widgets = g_slist_append( page->whitelist_widgets, w );
883        g_signal_connect( w, "clicked", G_CALLBACK( onAddWhitelistClicked ), page );
884        gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
885        w = gtk_hbox_new( FALSE, 0 );
886        gtk_box_pack_start( GTK_BOX( w ), gtk_alignment_new( 0, 0, 0, 0 ),
887                            TRUE, TRUE, 0 );
888        gtk_box_pack_start( GTK_BOX( w ), h, FALSE, FALSE, 0 );
889        hig_workarea_add_wide_control( t, &row, w );
890    }
891
892    refreshRPCSensitivity( page );
893    hig_workarea_finish( t, &row );
894    return t;
895}
896
897/****
898*****  Proxy Tab
899****/
900
901struct ProxyPage
902{
903    TrCore *  core;
904    GSList *  proxy_widgets;
905    GSList *  proxy_auth_widgets;
906};
907
908static void
909refreshProxySensitivity( struct ProxyPage * p )
910{
911    GSList *       l;
912    const gboolean proxy_enabled = pref_flag_get( TR_PREFS_KEY_PROXY_ENABLED );
913    const gboolean proxy_auth_enabled = pref_flag_get( TR_PREFS_KEY_PROXY_AUTH_ENABLED );
914
915    for( l = p->proxy_widgets; l != NULL; l = l->next )
916        gtk_widget_set_sensitive( GTK_WIDGET( l->data ), proxy_enabled );
917
918    for( l = p->proxy_auth_widgets; l != NULL; l = l->next )
919        gtk_widget_set_sensitive( GTK_WIDGET( l->data ),
920                                  proxy_enabled && proxy_auth_enabled );
921}
922
923static void
924onProxyToggled( GtkToggleButton * tb UNUSED,
925                gpointer             user_data )
926{
927    refreshProxySensitivity( user_data );
928}
929
930static void
931proxyPageFree( gpointer gpage )
932{
933    struct ProxyPage * page = gpage;
934
935    g_slist_free( page->proxy_widgets );
936    g_slist_free( page->proxy_auth_widgets );
937    g_free( page );
938}
939
940static GtkTreeModel*
941proxyTypeModelNew( void )
942{
943    GtkTreeIter    iter;
944    GtkListStore * store = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT );
945
946    gtk_list_store_append( store, &iter );
947    gtk_list_store_set( store, &iter, 0, "HTTP", 1, TR_PROXY_HTTP, -1 );
948    gtk_list_store_append( store, &iter );
949    gtk_list_store_set( store, &iter, 0, "SOCKS4", 1, TR_PROXY_SOCKS4, -1 );
950    gtk_list_store_append( store, &iter );
951    gtk_list_store_set( store, &iter, 0, "SOCKS5", 1, TR_PROXY_SOCKS5, -1 );
952    return GTK_TREE_MODEL( store );
953}
954
955static void
956onProxyTypeChanged( GtkComboBox * w,
957                    gpointer      gpage )
958{
959    GtkTreeIter iter;
960
961    if( gtk_combo_box_get_active_iter( w, &iter ) )
962    {
963        struct ProxyPage * page = gpage;
964        int type = TR_PROXY_HTTP;
965        gtk_tree_model_get( gtk_combo_box_get_model( w ), &iter, 1, &type, -1 );
966        tr_core_set_pref_int( TR_CORE( page->core ), TR_PREFS_KEY_PROXY_TYPE, type );
967    }
968}
969
970static GtkWidget*
971trackerPage( GObject * core )
972{
973    int                row = 0;
974    const char *       s;
975    GtkWidget *        t;
976    GtkWidget *        w;
977    GtkTreeModel *     m;
978    GtkCellRenderer *  r;
979    struct ProxyPage * page = tr_new0( struct ProxyPage, 1 );
980
981    page->core = TR_CORE( core );
982
983    t = hig_workarea_create( );
984    hig_workarea_add_section_title ( t, &row, _( "Tracker Proxy" ) );
985
986    s = _( "Connect to tracker via a pro_xy" );
987    w = new_check_button( s, TR_PREFS_KEY_PROXY_ENABLED, core );
988    g_signal_connect( w, "toggled", G_CALLBACK( onProxyToggled ), page );
989    hig_workarea_add_wide_control( t, &row, w );
990
991    s = _( "Proxy _server:" );
992    w = new_entry( TR_PREFS_KEY_PROXY, core );
993    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
994    w = hig_workarea_add_row( t, &row, s, w, NULL );
995    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
996
997    w = new_spin_button( TR_PREFS_KEY_PROXY_PORT, core, 0, 65535, 1 );
998    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
999    w = hig_workarea_add_row( t, &row, _( "Proxy _port:" ), w, NULL );
1000    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
1001
1002    s = _( "Proxy _type:" );
1003    m = proxyTypeModelNew( );
1004    w = gtk_combo_box_new_with_model( m );
1005    r = gtk_cell_renderer_text_new( );
1006    gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( w ), r, TRUE );
1007    gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( w ), r, "text", 0, NULL );
1008    gtk_combo_box_set_active( GTK_COMBO_BOX( w ), pref_int_get( TR_PREFS_KEY_PROXY_TYPE ) );
1009    g_signal_connect( w, "changed", G_CALLBACK( onProxyTypeChanged ), page );
1010    g_object_unref( G_OBJECT( m ) );
1011    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
1012    w = hig_workarea_add_row( t, &row, s, w, NULL );
1013    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
1014
1015    s = _( "_Authentication is required" );
1016    w = new_check_button( s, TR_PREFS_KEY_PROXY_AUTH_ENABLED, core );
1017    g_signal_connect( w, "toggled", G_CALLBACK( onProxyToggled ), page );
1018    hig_workarea_add_wide_control( t, &row, w );
1019    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
1020
1021    s = _( "_Username:" );
1022    w = new_entry( TR_PREFS_KEY_PROXY_USERNAME, core );
1023    page->proxy_auth_widgets = g_slist_append( page->proxy_auth_widgets, w );
1024    w = hig_workarea_add_row( t, &row, s, w, NULL );
1025    page->proxy_auth_widgets = g_slist_append( page->proxy_auth_widgets, w );
1026
1027    s = _( "Pass_word:" );
1028    w = new_entry( TR_PREFS_KEY_RPC_PASSWORD, core );
1029    gtk_entry_set_visibility( GTK_ENTRY( w ), FALSE );
1030    page->proxy_auth_widgets = g_slist_append( page->proxy_auth_widgets, w );
1031    w = hig_workarea_add_row( t, &row, s, w, NULL );
1032    page->proxy_auth_widgets = g_slist_append( page->proxy_auth_widgets, w );
1033
1034    hig_workarea_finish( t, &row );
1035    g_object_set_data_full( G_OBJECT( t ), "page", page, proxyPageFree );
1036
1037    refreshProxySensitivity( page );
1038    return t;
1039}
1040
1041/****
1042*****  Bandwidth Tab
1043****/
1044
1045struct BandwidthPage
1046{
1047    TrCore *  core;
1048    GSList *  sched_widgets;
1049};
1050
1051static void
1052refreshSchedSensitivity( struct BandwidthPage * p )
1053{
1054    GSList *       l;
1055    const gboolean sched_enabled = pref_flag_get(
1056        PREF_KEY_SCHED_LIMIT_ENABLED );
1057
1058    for( l = p->sched_widgets; l != NULL; l = l->next )
1059        gtk_widget_set_sensitive( GTK_WIDGET( l->data ), sched_enabled );
1060}
1061
1062static void
1063onSchedToggled( GtkToggleButton * tb UNUSED,
1064                gpointer             user_data )
1065{
1066    refreshSchedSensitivity( user_data );
1067}
1068
1069static void
1070onTimeComboChanged( GtkComboBox * w,
1071                    gpointer      core )
1072{
1073    GtkTreeIter iter;
1074
1075    if( gtk_combo_box_get_active_iter( w, &iter ) )
1076    {
1077        const char * key = g_object_get_data( G_OBJECT( w ), PREF_KEY );
1078        int          val = 0;
1079        gtk_tree_model_get( gtk_combo_box_get_model(
1080                                w ), &iter, 0, &val, -1 );
1081        tr_core_set_pref_int( TR_CORE( core ), key, val );
1082    }
1083}
1084
1085static GtkWidget*
1086new_time_combo( GObject *    core,
1087                const char * key )
1088{
1089    int               val;
1090    int               i;
1091    GtkWidget *       w;
1092    GtkCellRenderer * r;
1093    GtkListStore *    store;
1094
1095    /* build a store at 15 minute intervals */
1096    store = gtk_list_store_new( 2, G_TYPE_INT, G_TYPE_STRING );
1097    for( i = 0; i < 60 * 24; i += 15 )
1098    {
1099        char        buf[128];
1100        GtkTreeIter iter;
1101        struct tm   tm;
1102        tm.tm_hour = i / 60;
1103        tm.tm_min = i % 60;
1104        tm.tm_sec = 0;
1105        strftime( buf, sizeof( buf ), "%H:%M", &tm );
1106        gtk_list_store_append( store, &iter );
1107        gtk_list_store_set( store, &iter, 0, i, 1, buf, -1 );
1108    }
1109
1110    /* build the widget */
1111    w = gtk_combo_box_new_with_model( GTK_TREE_MODEL( store ) );
1112    gtk_combo_box_set_wrap_width( GTK_COMBO_BOX( w ), 4 );
1113    r = gtk_cell_renderer_text_new( );
1114    gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( w ), r, TRUE );
1115    gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(
1116                                        w ), r, "text", 1, NULL );
1117    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, tr_strdup(
1118                                key ), g_free );
1119    val = pref_int_get( key );
1120    gtk_combo_box_set_active( GTK_COMBO_BOX( w ), val / ( 15 ) );
1121    g_signal_connect( w, "changed", G_CALLBACK( onTimeComboChanged ), core );
1122
1123    /* cleanup */
1124    g_object_unref( G_OBJECT( store ) );
1125    return w;
1126}
1127
1128static void
1129bandwidthPageFree( gpointer gpage )
1130{
1131    struct BandwidthPage * page = gpage;
1132
1133    g_slist_free( page->sched_widgets );
1134    g_free( page );
1135}
1136
1137static GtkWidget*
1138bandwidthPage( GObject * core )
1139{
1140    int                    row = 0;
1141    const char *           s;
1142    GtkWidget *            t;
1143    GtkWidget *            w, * w2, * h, * l;
1144    struct BandwidthPage * page = tr_new0( struct BandwidthPage, 1 );
1145
1146    page->core = TR_CORE( core );
1147
1148    t = hig_workarea_create( );
1149    hig_workarea_add_section_title( t, &row, _( "Limits" ) );
1150
1151    s = _( "Limit _download speed (KB/s):" );
1152    w = new_check_button( s, TR_PREFS_KEY_DSPEED_ENABLED, core );
1153    w2 = new_spin_button( TR_PREFS_KEY_DSPEED, core, 0, INT_MAX, 5 );
1154    gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED ) );
1155    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
1156    hig_workarea_add_row_w( t, &row, w, w2, NULL );
1157
1158    s = _( "Limit _upload speed (KB/s):" );
1159    w = new_check_button( s, TR_PREFS_KEY_USPEED_ENABLED, core );
1160    w2 = new_spin_button( TR_PREFS_KEY_USPEED, core, 0, INT_MAX, 5 );
1161    gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED ) );
1162    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
1163    hig_workarea_add_row_w( t, &row, w, w2, NULL );
1164
1165    s = _( "_Stop seeding when a torrent's ratio reaches:" );
1166    w = new_check_button( s, TR_PREFS_KEY_RATIO_ENABLED, core );
1167    w2 = new_spin_button_double( TR_PREFS_KEY_RATIO, core, .5, INT_MAX, .05 );
1168    gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED ) );
1169    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
1170    hig_workarea_add_row_w( t, &row, w, w2, NULL );
1171
1172    hig_workarea_add_section_divider( t, &row );
1173    hig_workarea_add_section_title( t, &row, _( "Scheduled Limits" ) );
1174
1175    h = gtk_hbox_new( FALSE, 0 );
1176    w2 = new_time_combo( core, PREF_KEY_SCHED_BEGIN );
1177    page->sched_widgets = g_slist_append( page->sched_widgets, w2 );
1178    gtk_box_pack_start( GTK_BOX( h ), w2, FALSE, FALSE, 0 );
1179    w2 = gtk_label_new ( _( " and " ) );
1180    page->sched_widgets = g_slist_append( page->sched_widgets, w2 );
1181    gtk_box_pack_start( GTK_BOX( h ), w2, FALSE, FALSE, 0 );
1182    w2 = new_time_combo( core, PREF_KEY_SCHED_END );
1183    page->sched_widgets = g_slist_append( page->sched_widgets, w2 );
1184    gtk_box_pack_start( GTK_BOX( h ), w2, FALSE, FALSE, 0 );
1185
1186    s = _( "_Limit bandwidth between" );
1187    w = new_check_button( s, PREF_KEY_SCHED_LIMIT_ENABLED, core );
1188    g_signal_connect( w, "toggled", G_CALLBACK( onSchedToggled ), page );
1189    hig_workarea_add_row_w( t, &row, w, h, NULL );
1190
1191    w = new_spin_button( PREF_KEY_SCHED_DL_LIMIT, core, 0, INT_MAX, 5 );
1192    page->sched_widgets = g_slist_append( page->sched_widgets, w );
1193    l = hig_workarea_add_row( t, &row, _( "Limit d_ownload speed (KB/s):" ), w, NULL );
1194    page->sched_widgets = g_slist_append( page->sched_widgets, l );
1195
1196    w = new_spin_button( PREF_KEY_SCHED_UL_LIMIT, core, 0, INT_MAX, 5 );
1197    page->sched_widgets = g_slist_append( page->sched_widgets, w );
1198    l = hig_workarea_add_row( t, &row, _( "Limit u_pload speed (KB/s):" ), w, NULL );
1199    page->sched_widgets = g_slist_append( page->sched_widgets, l );
1200
1201    hig_workarea_finish( t, &row );
1202    g_object_set_data_full( G_OBJECT( t ), "page", page, bandwidthPageFree );
1203
1204    refreshSchedSensitivity( page );
1205    return t;
1206}
1207
1208/****
1209*****  Network Tab
1210****/
1211
1212struct test_port_data
1213{
1214    GtkWidget *  label;
1215    gboolean *   alive;
1216    char text[128];
1217};
1218
1219/* this is invoked in the gtk main loop's thread */
1220static gboolean
1221testing_port_done_idle( gpointer gdata )
1222{
1223    struct test_port_data * data = gdata;
1224
1225    if( *data->alive )
1226    {
1227        gdk_threads_enter( );
1228        gtk_label_set_markup( GTK_LABEL( data->label ), data->text );
1229        gdk_threads_leave( );
1230    }
1231
1232    return FALSE;
1233}
1234
1235/* this is invoked in the libtransmission thread */
1236static void
1237testing_port_done( tr_session * session        UNUSED,
1238                   long          response_code UNUSED,
1239                   const void *                response,
1240                   size_t                      response_len,
1241                   void *                      gdata )
1242{
1243    struct test_port_data * data = gdata;
1244
1245    if( *data->alive )
1246    {
1247        const int isOpen = response_len && *(char*)response == '1';
1248        g_snprintf( data->text, sizeof( data->text ), isOpen
1249                    ? _( "Port is <b>open</b>" )
1250                    : _( "Port is <b>closed</b>" ) );
1251        g_idle_add( testing_port_done_idle, data );
1252    }
1253}
1254
1255static gboolean
1256testing_port_begin( gpointer gdata )
1257{
1258    struct test_port_data * data = gdata;
1259
1260    if( *data->alive )
1261    {
1262        char            url[256];
1263        GObject       * o       = G_OBJECT( data->label );
1264        GtkSpinButton * spin    = g_object_get_data( o, "tr-port-spin" );
1265        tr_session    * session = g_object_get_data( o, "session" );
1266        const int       port    = gtk_spin_button_get_value_as_int( spin );
1267        g_snprintf( url, sizeof( url ),
1268                    "http://portcheck.transmissionbt.com/%d",
1269                    port );
1270        tr_webRun( session, url, NULL, testing_port_done, data );
1271    }
1272    return FALSE;
1273}
1274
1275struct network_page_data
1276{
1277    gboolean *   alive;
1278    GtkWidget *  label;
1279    guint        id;
1280    TrCore *     core;
1281};
1282
1283static void
1284onCorePrefsChanged( TrCore * core UNUSED,
1285                    const char *  key,
1286                    gpointer      gdata )
1287{
1288    if( !strcmp( key, TR_PREFS_KEY_PEER_PORT ) )
1289    {
1290        struct network_page_data * ndata = gdata;
1291        struct test_port_data *    data;
1292
1293        gtk_label_set_markup( GTK_LABEL( ndata->label ),
1294                             _( "<i>Testing port...</i>" ) );
1295
1296        /* wait three seconds to give the port forwarding time to kick in */
1297        data = g_new0( struct test_port_data, 1 );
1298        data->label = ndata->label;
1299        data->alive = ndata->alive;
1300        gtr_timeout_add_seconds( 3, testing_port_begin, data );
1301    }
1302}
1303
1304static void
1305networkPageDestroyed( gpointer       gdata,
1306                      GObject * dead UNUSED )
1307{
1308    struct network_page_data * data = gdata;
1309
1310    *data->alive = FALSE;
1311    g_signal_handler_disconnect( data->core, data->id );
1312    g_free( data );
1313}
1314
1315static GtkWidget*
1316networkPage( GObject * core )
1317{
1318    int                        row = 0;
1319    const char *               s;
1320    GtkWidget *                t;
1321    GtkWidget *                w;
1322    GtkWidget *                w2;
1323    GtkWidget *                h;
1324    GtkWidget *                l;
1325    struct network_page_data * data;
1326
1327    /* register to stop listening to core prefs changes when the page is
1328      destroyed */
1329    data = g_new0( struct network_page_data, 1 );
1330    data->core = TR_CORE( core );
1331
1332    /* we leak this gboolean* s.t. we know it will still be alive when the port
1333       check is done, whether the dialog was destroyed or not.  kind of
1334       clumsy... */
1335    data->alive = g_new( gboolean, 1 );
1336    *data->alive = TRUE;
1337
1338    /* build the page */
1339    t = hig_workarea_create( );
1340    hig_workarea_add_section_title( t, &row, _( "Incoming Peers" ) );
1341
1342    h = gtk_hbox_new( FALSE, GUI_PAD_BIG );
1343    w2 = new_spin_button( TR_PREFS_KEY_PEER_PORT, core, 1, 65535, 1 );
1344    gtk_box_pack_start( GTK_BOX( h ), w2, FALSE, FALSE, 0 );
1345    data->label = l = gtk_label_new( NULL );
1346    gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
1347    gtk_box_pack_start( GTK_BOX( h ), l, FALSE, FALSE, 0 );
1348    hig_workarea_add_row( t, &row, _( "Listening _port:" ), h, w2 );
1349
1350    g_object_set_data( G_OBJECT( l ), "tr-port-spin", w2 );
1351    g_object_set_data( G_OBJECT( l ), "session",
1352                      tr_core_session( TR_CORE( core ) ) );
1353    data->id = g_signal_connect( TR_CORE( core ), "prefs-changed",
1354                                 G_CALLBACK( onCorePrefsChanged ), data );
1355    onCorePrefsChanged( NULL, TR_PREFS_KEY_PEER_PORT, data );
1356
1357    s = _( "Use UPnP or NAT-PMP port _forwarding from my router" );
1358    w = new_check_button( s, TR_PREFS_KEY_PORT_FORWARDING, core );
1359    hig_workarea_add_wide_control( t, &row, w );
1360
1361    hig_workarea_finish( t, &row );
1362    g_object_weak_ref( G_OBJECT( t ), networkPageDestroyed, data );
1363
1364    return t;
1365}
1366
1367/****
1368*****
1369****/
1370
1371GtkWidget *
1372tr_prefs_dialog_new( GObject *   core,
1373                     GtkWindow * parent )
1374{
1375    GtkWidget * d;
1376    GtkWidget * n;
1377
1378    d = gtk_dialog_new_with_buttons( _(
1379                                         "Transmission Preferences" ),
1380                                     parent,
1381                                     GTK_DIALOG_DESTROY_WITH_PARENT,
1382                                     GTK_STOCK_HELP, GTK_RESPONSE_HELP,
1383                                     GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
1384                                     NULL );
1385    gtk_window_set_role( GTK_WINDOW( d ), "transmission-preferences-dialog" );
1386    gtk_dialog_set_has_separator( GTK_DIALOG( d ), FALSE );
1387    gtk_container_set_border_width( GTK_CONTAINER( d ), GUI_PAD );
1388
1389    n = gtk_notebook_new( );
1390    gtk_container_set_border_width ( GTK_CONTAINER ( n ), GUI_PAD );
1391
1392    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
1393                              torrentPage( core ),
1394                              gtk_label_new ( _( "Torrents" ) ) );
1395    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
1396                              peerPage( core ),
1397                              gtk_label_new ( _( "Peers" ) ) );
1398    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
1399                              networkPage( core ),
1400                              gtk_label_new ( _( "Network" ) ) );
1401    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
1402                              desktopPage( core ),
1403                              gtk_label_new ( _( "Desktop" ) ) );
1404    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
1405                              bandwidthPage( core ),
1406                              gtk_label_new ( _( "Bandwidth" ) ) );
1407    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
1408                              webPage( core ),
1409                              gtk_label_new ( _( "Web" ) ) );
1410    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
1411                              trackerPage( core ),
1412                              gtk_label_new ( _( "Trackers" ) ) );
1413
1414    g_signal_connect( d, "response", G_CALLBACK( response_cb ), core );
1415    gtk_box_pack_start( GTK_BOX( GTK_DIALOG( d )->vbox ), n, TRUE, TRUE, 0 );
1416    gtk_widget_show_all( GTK_DIALOG( d )->vbox );
1417    return d;
1418}
1419
Note: See TracBrowser for help on using the repository browser.