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

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

add a separate flag for enabling/disabling the rpc address whitelist

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