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

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

(trunkg gtk) fix confusing phrasing in the gtk preferences dialog

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