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

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

(gtk) fix prefs dialog crash when closing the dialog immediately after changing a spinbox value, reported by wereHamster

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