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

Last change on this file since 6859 was 6859, checked in by charles, 14 years ago

(gtk) better fix for the bug described in r6858

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