Context Navigation

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

Visit:

Last change on this file since 7404 was 7404, checked in by charles, 12 years ago
updated email address
Property svn:keywords set to `Date Rev Author Id`
File size: 44.7 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: