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

Last change on this file since 7404 was 7404, checked in by charles, 12 years ago

updated email address

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