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

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

(trunk) #3045 "speed units" -- change the public API of libtransmission based on feedback from livings

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