source: branches/1.5x/gtk/tr-prefs.c @ 8048

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

(1.5x gtk) launchpad bug #338046: XDG_DOWNLOAD_DIR isn't honored in gtk client

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