Context Navigation

source: trunk/gtk/details.c @ 10937

Visit:

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: 84.4 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: details.c 10937 2010-07-04 06:07:21Z charles $
11	*/
12
13	#include <assert.h>
14	#include <math.h> /* ceil() */
15	#include <stddef.h>
16	#include <stdio.h> /* sscanf */
17	#include <stdlib.h>
18	#include <glib/gi18n.h>
19	#include <gtk/gtk.h>
20
21	#include <libtransmission/transmission.h>
22	#include <libtransmission/utils.h> /* tr_free */
23
24	#include "actions.h"
25	#include "details.h"
26	#include "favicon.h" /* gtr_get_favicon() */
27	#include "file-list.h"
28	#include "hig.h"
29	#include "tr-prefs.h"
30	#include "util.h"
31
32	#define DETAILS_KEY "details-data"
33
34	struct DetailsImpl
35	{
36	GtkWidget * dialog;
37
38	GtkWidget * peersPage;
39	GtkWidget * trackerPage;
40	GtkWidget * activityPage;
41
42	GtkWidget * honorLimitsCheck;
43	GtkWidget * upLimitedCheck;
44	GtkWidget * upLimitSpin;
45	GtkWidget * downLimitedCheck;
46	GtkWidget * downLimitSpin;
47	GtkWidget * bandwidthCombo;
48	GtkWidget * seedGlobalRadio;
49	GtkWidget * seedForeverRadio;
50	GtkWidget * seedCustomRadio;
51	GtkWidget * seedCustomSpin;
52	GtkWidget * maxPeersSpin;
53
54	guint honorLimitsCheckTag;
55	guint upLimitedCheckTag;
56	guint downLimitedCheckTag;
57	guint downLimitSpinTag;
58	guint upLimitSpinTag;
59	guint bandwidthComboTag;
60	guint seedForeverRadioTag;
61	guint seedGlobalRadioTag;
62	guint seedCustomRadioTag;
63	guint seedCustomSpinTag;
64	guint maxPeersSpinTag;
65
66	GtkWidget * size_lb;
67	GtkWidget * state_lb;
68	GtkWidget * have_lb;
69	GtkWidget * availability_lb;
70	GtkWidget * dl_lb;
71	GtkWidget * ul_lb;
72	GtkWidget * ratio_lb;
73	GtkWidget * error_lb;
74	GtkWidget * date_started_lb;
75	GtkWidget * eta_lb;
76	GtkWidget * last_activity_lb;
77
78	GtkWidget * hash_lb;
79	GtkWidget * privacy_lb;
80	GtkWidget * origin_lb;
81	GtkWidget * destination_lb;
82	GtkTextBuffer * comment_buffer;
83
84	GHashTable * peer_hash;
85	GHashTable * webseed_hash;
86	GtkListStore * peer_store;
87	GtkListStore * webseed_store;
88	GtkWidget * webseed_view;
89	GtkWidget * peer_view;
90	GtkWidget * more_peer_details_check;
91
92	GtkListStore * trackers;
93	GtkTreeModel * trackers_filtered;
94	GtkWidget * edit_trackers_button;
95	GtkWidget * tracker_view;
96	GtkWidget * scrape_check;
97	GtkWidget * all_check;
98	GtkTextBuffer * tracker_buffer;
99
100	GtkWidget * file_list;
101	GtkWidget * file_label;
102
103	GSList * ids;
104	TrCore * core;
105	guint periodic_refresh_tag;
106	};
107
108	static tr_torrent**
109	getTorrents( struct DetailsImpl * d, int * setmeCount )
110	{
111	int n = g_slist_length( d->ids );
112	int torrentCount = 0;
113	tr_session * session = tr_core_session( d->core );
114	tr_torrent ** torrents = NULL;
115
116	if( session != NULL )
117	{
118	GSList * l;
119
120	torrents = g_new( tr_torrent*, n );
121
122	for( l=d->ids; l!=NULL; l=l->next ) {
123	const int id = GPOINTER_TO_INT( l->data );
124	tr_torrent * tor = tr_torrentFindFromId( session, id );
125	if( tor )
126	torrents[torrentCount++] = tor;
127	}
128	}
129
130	*setmeCount = torrentCount;
131	return torrents;
132	}
133
134	/****
135	*****
136	***** OPTIONS TAB
137	*****
138	****/
139
140	static void
141	set_togglebutton_if_different( GtkWidget * w, guint tag, gboolean value )
142	{
143	GtkToggleButton * toggle = GTK_TOGGLE_BUTTON( w );
144	const gboolean currentValue = gtk_toggle_button_get_active( toggle );
145	if( currentValue != value )
146	{
147	g_signal_handler_block( toggle, tag );
148	gtk_toggle_button_set_active( toggle, value );
149	g_signal_handler_unblock( toggle, tag );
150	}
151	}
152
153	static void
154	set_int_spin_if_different( GtkWidget * w, guint tag, int value )
155	{
156	GtkSpinButton * spin = GTK_SPIN_BUTTON( w );
157	const int currentValue = gtk_spin_button_get_value_as_int( spin );
158	if( currentValue != value )
159	{
160	g_signal_handler_block( spin, tag );
161	gtk_spin_button_set_value( spin, value );
162	g_signal_handler_unblock( spin, tag );
163	}
164	}
165
166	static void
167	set_double_spin_if_different( GtkWidget * w, guint tag, double value )
168	{
169	GtkSpinButton * spin = GTK_SPIN_BUTTON( w );
170	const double currentValue = gtk_spin_button_get_value( spin );
171	if( ( (int)(currentValue100) != (int)(value100) ) )
172	{
173	g_signal_handler_block( spin, tag );
174	gtk_spin_button_set_value( spin, value );
175	g_signal_handler_unblock( spin, tag );
176	}
177	}
178
179	static void
180	unset_combo( GtkWidget * w, guint tag )
181	{
182	GtkComboBox * combobox = GTK_COMBO_BOX( w );
183
184	g_signal_handler_block( combobox, tag );
185	gtk_combo_box_set_active( combobox, -1 );
186	g_signal_handler_unblock( combobox, tag );
187	}
188
189	static void
190	refreshOptions( struct DetailsImpl * di, tr_torrent ** torrents, int n )
191	{
192	/***
193	**** Options Page
194	***/
195
196	/* honorLimitsCheck */
197	if( n ) {
198	const tr_bool baseline = tr_torrentUsesSessionLimits( torrents[0] );
199	int i;
200	for( i=1; i<n; ++i )
201	if( baseline != tr_torrentUsesSessionLimits( torrents[i] ) )
202	break;
203	if( i == n )
204	set_togglebutton_if_different( di->honorLimitsCheck,
205	di->honorLimitsCheckTag, baseline );
206	}
207
208	/* downLimitedCheck */
209	if( n ) {
210	const tr_bool baseline = tr_torrentUsesSpeedLimit( torrents[0], TR_DOWN );
211	int i;
212	for( i=1; i<n; ++i )
213	if( baseline != tr_torrentUsesSpeedLimit( torrents[i], TR_DOWN ) )
214	break;
215	if( i == n )
216	set_togglebutton_if_different( di->downLimitedCheck,
217	di->downLimitedCheckTag, baseline );
218	}
219
220	/* downLimitSpin */
221	if( n ) {
222	const int baseline = tr_torrentGetSpeedLimit_KBps( torrents[0], TR_DOWN );
223	int i;
224	for( i=1; i<n; ++i )
225	if( baseline != ( tr_torrentGetSpeedLimit_KBps( torrents[i], TR_DOWN ) ) )
226	break;
227	if( i == n )
228	set_int_spin_if_different( di->downLimitSpin,
229	di->downLimitSpinTag, baseline );
230	}
231
232	/* upLimitedCheck */
233	if( n ) {
234	const tr_bool baseline = tr_torrentUsesSpeedLimit( torrents[0], TR_UP );
235	int i;
236	for( i=1; i<n; ++i )
237	if( baseline != tr_torrentUsesSpeedLimit( torrents[i], TR_UP ) )
238	break;
239	if( i == n )
240	set_togglebutton_if_different( di->upLimitedCheck,
241	di->upLimitedCheckTag, baseline );
242	}
243
244	/* upLimitSpin */
245	if( n ) {
246	const int baseline = tr_torrentGetSpeedLimit_KBps( torrents[0], TR_UP );
247	int i;
248	for( i=1; i<n; ++i )
249	if( baseline != ( tr_torrentGetSpeedLimit_KBps( torrents[i], TR_UP ) ) )
250	break;
251	if( i == n )
252	set_int_spin_if_different( di->upLimitSpin,
253	di->upLimitSpinTag, baseline );
254	}
255
256	/* bandwidthCombo */
257	if( n ) {
258	const int baseline = tr_torrentGetPriority( torrents[0] );
259	int i;
260	for( i=1; i<n; ++i )
261	if( baseline != tr_torrentGetPriority( torrents[i] ) )
262	break;
263	if( i == n ) {
264	g_signal_handler_block( di->bandwidthCombo, di->bandwidthComboTag );
265	gtr_priority_combo_set_value( di->bandwidthCombo, baseline );
266	g_signal_handler_unblock( di->bandwidthCombo, di->bandwidthComboTag );
267	}
268	else
269	unset_combo( di->bandwidthCombo, di->bandwidthComboTag );
270	}
271
272	/* seedGlobalRadio */
273	/* seedForeverRadio */
274	/* seedCustomRadio */
275	if( n ) {
276	guint t;
277	const int baseline = tr_torrentGetRatioMode( torrents[0] );
278	int i;
279	for( i=1; i<n; ++i )
280	if( baseline != (int)tr_torrentGetRatioMode( torrents[i] ) )
281	break;
282	if( i == n ) {
283	GtkWidget * w;
284	switch( baseline ) {
285	case TR_RATIOLIMIT_SINGLE: w = di->seedCustomRadio;
286	t = di->seedCustomRadioTag; break;
287	case TR_RATIOLIMIT_UNLIMITED: w = di->seedForeverRadio;
288	t = di->seedForeverRadioTag; break;
289	default /TR_RATIOLIMIT_GLOBAL/: w = di->seedGlobalRadio;
290	t = di->seedGlobalRadioTag; break;
291	}
292	set_togglebutton_if_different( w, t, TRUE );
293	}
294	}
295
296	/* seedCustomSpin */
297	if( n ) {
298	const double baseline = tr_torrentGetRatioLimit( torrents[0] );
299	set_double_spin_if_different( di->seedCustomSpin,
300	di->seedCustomSpinTag, baseline );
301	}
302
303	/* maxPeersSpin */
304	if( n ) {
305	const int baseline = tr_torrentGetPeerLimit( torrents[0] );
306	set_int_spin_if_different( di->maxPeersSpin,
307	di->maxPeersSpinTag, baseline );
308	}
309	}
310
311	static void
312	torrent_set_bool( struct DetailsImpl * di, const char * key, gboolean value )
313	{
314	GSList *l;
315	tr_benc top, args, ids;
316
317	tr_bencInitDict( &top, 2 );
318	tr_bencDictAddStr( &top, "method", "torrent-set" );
319	args = tr_bencDictAddDict( &top, "arguments", 2 );
320	tr_bencDictAddBool( args, key, value );
321	ids = tr_bencDictAddList( args, "ids", g_slist_length(di->ids) );
322	for( l=di->ids; l; l=l->next )
323	tr_bencListAddInt( ids, GPOINTER_TO_INT( l->data ) );
324
325	tr_core_exec( di->core, &top );
326	tr_bencFree( &top );
327	}
328
329	static void
330	torrent_set_int( struct DetailsImpl * di, const char * key, int value )
331	{
332	GSList *l;
333	tr_benc top, args, ids;
334
335	tr_bencInitDict( &top, 2 );
336	tr_bencDictAddStr( &top, "method", "torrent-set" );
337	args = tr_bencDictAddDict( &top, "arguments", 2 );
338	tr_bencDictAddInt( args, key, value );
339	ids = tr_bencDictAddList( args, "ids", g_slist_length(di->ids) );
340	for( l=di->ids; l; l=l->next )
341	tr_bencListAddInt( ids, GPOINTER_TO_INT( l->data ) );
342
343	tr_core_exec( di->core, &top );
344	tr_bencFree( &top );
345	}
346
347	static void
348	torrent_set_real( struct DetailsImpl * di, const char * key, double value )
349	{
350	GSList *l;
351	tr_benc top, args, ids;
352
353	tr_bencInitDict( &top, 2 );
354	tr_bencDictAddStr( &top, "method", "torrent-set" );
355	args = tr_bencDictAddDict( &top, "arguments", 2 );
356	tr_bencDictAddReal( args, key, value );
357	ids = tr_bencDictAddList( args, "ids", g_slist_length(di->ids) );
358	for( l=di->ids; l; l=l->next )
359	tr_bencListAddInt( ids, GPOINTER_TO_INT( l->data ) );
360
361	tr_core_exec( di->core, &top );
362	tr_bencFree( &top );
363	}
364
365	static void
366	up_speed_toggled_cb( GtkToggleButton * tb, gpointer d )
367	{
368	torrent_set_bool( d, "uploadLimited", gtk_toggle_button_get_active( tb ) );
369	}
370
371	static void
372	down_speed_toggled_cb( GtkToggleButton *tb, gpointer d )
373	{
374	torrent_set_bool( d, "downloadLimited", gtk_toggle_button_get_active( tb ) );
375	}
376
377	static void
378	global_speed_toggled_cb( GtkToggleButton * tb, gpointer d )
379	{
380	torrent_set_bool( d, "honorsSessionLimits", gtk_toggle_button_get_active( tb ) );
381	}
382
383	#define RATIO_KEY "ratio-mode"
384
385	static void
386	ratio_mode_changed_cb( GtkToggleButton * tb, struct DetailsImpl * d )
387	{
388	if( gtk_toggle_button_get_active( tb ) )
389	{
390	GObject * o = G_OBJECT( tb );
391	const int mode = GPOINTER_TO_INT( g_object_get_data( o, RATIO_KEY ) );
392	torrent_set_int( d, "seedRatioMode", mode );
393	}
394	}
395
396	static void
397	up_speed_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
398	{
399	torrent_set_int( di, "uploadLimit", gtk_spin_button_get_value_as_int( s ) );
400	}
401
402	static void
403	down_speed_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
404	{
405	torrent_set_int( di, "downloadLimit", gtk_spin_button_get_value_as_int( s ) );
406	}
407
408	static void
409	ratio_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
410	{
411	torrent_set_real( di, "seedRatioLimit", gtk_spin_button_get_value( s ) );
412	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( di->seedCustomRadio ), TRUE );
413	}
414
415	static void
416	max_peers_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
417	{
418	torrent_set_int( di, "peer-limit", gtk_spin_button_get_value( s ) );
419	}
420
421	static void
422	onPriorityChanged( GtkComboBox * w, struct DetailsImpl * di )
423	{
424	const tr_priority_t priority = gtr_priority_combo_get_value( GTK_WIDGET( w ) );
425	torrent_set_int( di, "bandwidthPriority", priority );
426	}
427
428	static GtkWidget*
429	new_priority_combo( struct DetailsImpl * di )
430	{
431	GtkWidget * w = gtr_priority_combo_new( );
432	di->bandwidthComboTag = g_signal_connect( w, "changed", G_CALLBACK( onPriorityChanged ), di );
433	return w;
434	}
435
436
437	static GtkWidget*
438	options_page_new( struct DetailsImpl * d )
439	{
440	guint tag;
441	int row;
442	char buf[128];
443	const char *s;
444	GtkWidget t, w, tb, h;
445
446	row = 0;
447	t = hig_workarea_create( );
448	hig_workarea_add_section_title( t, &row, _( "Speed" ) );
449
450	tb = hig_workarea_add_wide_checkbutton( t, &row, _( "Honor global _limits" ), 0 );
451	d->honorLimitsCheck = tb;
452	tag = g_signal_connect( tb, "toggled", G_CALLBACK( global_speed_toggled_cb ), d );
453	d->honorLimitsCheckTag = tag;
454
455	g_snprintf( buf, sizeof( buf ), _( "Limit _download speed (%s):" ), _(speed_K_str) );
456	tb = gtk_check_button_new_with_mnemonic( buf );
457	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( tb ), FALSE );
458	d->downLimitedCheck = tb;
459	tag = g_signal_connect( tb, "toggled", G_CALLBACK( down_speed_toggled_cb ), d );
460	d->downLimitedCheckTag = tag;
461
462	w = gtk_spin_button_new_with_range( 1, INT_MAX, 5 );
463	tag = g_signal_connect( w, "value-changed", G_CALLBACK( down_speed_spun_cb ), d );
464	d->downLimitSpinTag = tag;
465	hig_workarea_add_row_w( t, &row, tb, w, NULL );
466	d->downLimitSpin = w;
467
468	g_snprintf( buf, sizeof( buf ), _( "Limit _upload speed (%s):" ), _(speed_K_str) );
469	tb = gtk_check_button_new_with_mnemonic( buf );
470	d->upLimitedCheck = tb;
471	tag = g_signal_connect( tb, "toggled", G_CALLBACK( up_speed_toggled_cb ), d );
472	d->upLimitedCheckTag = tag;
473
474	w = gtk_spin_button_new_with_range( 1, INT_MAX, 5 );
475	tag = g_signal_connect( w, "value-changed", G_CALLBACK( up_speed_spun_cb ), d );
476	d->upLimitSpinTag = tag;
477	hig_workarea_add_row_w( t, &row, tb, w, NULL );
478	d->upLimitSpin = w;
479
480	w = new_priority_combo( d );
481	hig_workarea_add_row( t, &row, _( "Torrent _priority:" ), w, NULL );
482	d->bandwidthCombo = w;
483
484	hig_workarea_add_section_divider( t, &row );
485	hig_workarea_add_section_title( t, &row, _( "Seed-Until Ratio" ) );
486
487	s = _( "Use _global settings" );
488	w = gtk_radio_button_new_with_mnemonic( NULL, s );
489	hig_workarea_add_wide_control( t, &row, w );
490	g_object_set_data( G_OBJECT( w ), RATIO_KEY, GINT_TO_POINTER( TR_RATIOLIMIT_GLOBAL ) );
491	tag = g_signal_connect( w, "toggled", G_CALLBACK( ratio_mode_changed_cb ), d );
492	d->seedGlobalRadio = w;
493	d->seedGlobalRadioTag = tag;
494
495	s = _( "Seed _regardless of ratio" );
496	w = gtk_radio_button_new_with_mnemonic_from_widget( GTK_RADIO_BUTTON( w ), s );
497	hig_workarea_add_wide_control( t, &row, w );
498	g_object_set_data( G_OBJECT( w ), RATIO_KEY, GINT_TO_POINTER( TR_RATIOLIMIT_UNLIMITED ) );
499	tag = g_signal_connect( w, "toggled", G_CALLBACK( ratio_mode_changed_cb ), d );
500	d->seedForeverRadio = w;
501	d->seedForeverRadioTag = tag;
502
503	h = gtk_hbox_new( FALSE, GUI_PAD );
504	s = _( "_Seed torrent until its ratio reaches:" );
505	w = gtk_radio_button_new_with_mnemonic_from_widget( GTK_RADIO_BUTTON( w ), s );
506	d->seedCustomRadio = w;
507	g_object_set_data( G_OBJECT( w ), RATIO_KEY, GINT_TO_POINTER( TR_RATIOLIMIT_SINGLE ) );
508	tag = g_signal_connect( w, "toggled", G_CALLBACK( ratio_mode_changed_cb ), d );
509	d->seedCustomRadioTag = tag;
510	gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
511	w = gtk_spin_button_new_with_range( 0, INT_MAX, .05 );
512	gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 2 );
513	tag = g_signal_connect( w, "value-changed", G_CALLBACK( ratio_spun_cb ), d );
514	gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
515	hig_workarea_add_wide_control( t, &row, h );
516	d->seedCustomSpin = w;
517	d->seedCustomSpinTag = tag;
518
519	hig_workarea_add_section_divider( t, &row );
520	hig_workarea_add_section_title( t, &row, _( "Peer Connections" ) );
521
522	w = gtk_spin_button_new_with_range( 1, 3000, 5 );
523	hig_workarea_add_row( t, &row, _( "_Maximum peers:" ), w, w );
524	tag = g_signal_connect( w, "value-changed", G_CALLBACK( max_peers_spun_cb ), d );
525	d->maxPeersSpin = w;
526	d->maxPeersSpinTag = tag;
527
528	hig_workarea_finish( t, &row );
529	return t;
530	}
531
532	/****
533	*****
534	***** INFO TAB
535	*****
536	****/
537
538	static const char *
539	activityString( int activity, tr_bool finished )
540	{
541	switch( activity )
542	{
543	case TR_STATUS_CHECK_WAIT: return _( "Waiting to verify local data" );
544	case TR_STATUS_CHECK: return _( "Verifying local data" );
545	case TR_STATUS_DOWNLOAD: return _( "Downloading" );
546	case TR_STATUS_SEED: return _( "Seeding" );
547	case TR_STATUS_STOPPED: return finished ? _( "Finished" ) : _( "Paused" );
548	}
549
550	return "";
551	}
552
553	/* Only call gtk_label_set_text() if the new text differs from the old.
554	* This way if the user has text selected, refreshing won't deselect it */
555	static void
556	gtr_label_set_text( GtkLabel * lb, const char * newstr )
557	{
558	const char * oldstr = gtk_label_get_text( lb );
559
560	if( ( oldstr == NULL ) \|\| strcmp( oldstr, newstr ) )
561	gtk_label_set_text( lb, newstr );
562	}
563
564	/* Only call gtk_text_buffer_set_text() if the new text differs from the old.
565	* This way if the user has text selected, refreshing won't deselect it */
566	static void
567	gtr_text_buffer_set_text( GtkTextBuffer * b, const char * str )
568	{
569	char * old_str;
570	GtkTextIter start, end;
571
572	if( str == NULL )
573	str = "";
574
575	gtk_text_buffer_get_bounds( b, &start, &end );
576	old_str = gtk_text_buffer_get_text( b, &start, &end, FALSE );
577
578	if( ( old_str == NULL ) \|\| strcmp( old_str, str ) )
579	gtk_text_buffer_set_text( b, str, -1 );
580
581	g_free( old_str );
582	}
583
584	static char*
585	get_short_date_string( time_t t )
586	{
587	char buf[64];
588	struct tm tm;
589	tr_localtime_r( &t, &tm );
590	strftime( buf, sizeof( buf ), "%d %b %Y", &tm );
591	return g_locale_to_utf8( buf, -1, NULL, NULL, NULL );
592	};
593
594	static void
595	refreshInfo( struct DetailsImpl * di, tr_torrent ** torrents, int n )
596	{
597	int i;
598	const char * str;
599	const char * none = _( "None" );
600	const char * mixed = _( "Mixed" );
601	const char * stateString;
602	char buf[512];
603	uint64_t available = 0;
604	uint64_t sizeWhenDone = 0;
605	const tr_stat ** stats = g_new( const tr_stat*, n );
606	const tr_info ** infos = g_new( const tr_info*, n );
607	for( i=0; i<n; ++i ) {
608	stats[i] = tr_torrentStatCached( torrents[i] );
609	infos[i] = tr_torrentInfo( torrents[i] );
610	}
611
612	/* privacy_lb */
613	if( n<=0 )
614	str = none;
615	else {
616	const tr_bool baseline = infos[0]->isPrivate;
617	for( i=1; i<n; ++i )
618	if( baseline != infos[i]->isPrivate )
619	break;
620	if( i!=n )
621	str = mixed;
622	else if( baseline )
623	str = _( "Private to this tracker -- DHT and PEX disabled" );
624	else
625	str = _( "Public torrent" );
626	}
627	gtr_label_set_text( GTK_LABEL( di->privacy_lb ), str );
628
629
630	/* origin_lb */
631	if( n<=0 )
632	str = none;
633	else {
634	const char * creator = infos[0]->creator ? infos[0]->creator : "";
635	const time_t date = infos[0]->dateCreated;
636	char * datestr = get_short_date_string( date );
637	gboolean mixed_creator = FALSE;
638	gboolean mixed_date = FALSE;
639
640	for( i=1; i<n; ++i ) {
641	mixed_creator \|= strcmp( creator, infos[i]->creator ? infos[i]->creator : "" );
642	mixed_date \|= ( date != infos[i]->dateCreated );
643	}
644	if( mixed_date && mixed_creator )
645	str = mixed;
646	else {
647	if( mixed_date )
648	g_snprintf( buf, sizeof( buf ), _( "Created by %1$s" ), creator );
649	else if( mixed_creator \|\| !*creator )
650	g_snprintf( buf, sizeof( buf ), _( "Created on %1$s" ), datestr );
651	else
652	g_snprintf( buf, sizeof( buf ), _( "Created by %1$s on %2$s" ), creator, datestr );
653	str = buf;
654	}
655
656	g_free( datestr );
657	}
658	gtr_label_set_text( GTK_LABEL( di->origin_lb ), str );
659
660
661	/* comment_buffer */
662	if( n<=0 )
663	str = "";
664	else {
665	const char * baseline = infos[0]->comment ? infos[0]->comment : "";
666	for( i=1; i<n; ++i )
667	if( strcmp( baseline, infos[i]->comment ? infos[i]->comment : "" ) )
668	break;
669	if( i==n )
670	str = baseline;
671	else
672	str = mixed;
673	}
674	gtr_text_buffer_set_text( di->comment_buffer, str );
675
676	/* destination_lb */
677	if( n<=0 )
678	str = none;
679	else {
680	const char * baseline = tr_torrentGetDownloadDir( torrents[0] );
681	for( i=1; i<n; ++i )
682	if( strcmp( baseline, tr_torrentGetDownloadDir( torrents[i] ) ) )
683	break;
684	if( i==n )
685	str = baseline;
686	else
687	str = mixed;
688	}
689	gtr_label_set_text( GTK_LABEL( di->destination_lb ), str );
690
691	/* state_lb */
692	if( n < 1 )
693	str = none;
694	else {
695	const tr_torrent_activity activity = stats[0]->activity;
696	tr_bool allFinished = stats[0]->finished;
697	for( i=1; i<n; ++i ) {
698	if( activity != stats[i]->activity )
699	break;
700	if( !stats[i]->finished )
701	allFinished = FALSE;
702	}
703	str = i<n ? mixed : activityString( activity, allFinished );
704	}
705	stateString = str;
706	gtr_label_set_text( GTK_LABEL( di->state_lb ), str );
707
708
709	/* date started */
710	if( n < 1 )
711	str = none;
712	else {
713	const time_t baseline = stats[0]->startDate;
714	for( i=1; i<n; ++i )
715	if( baseline != stats[i]->startDate )
716	break;
717	if( i != n )
718	str = mixed;
719	else if( ( baseline<=0 ) \|\| ( stats[0]->activity == TR_STATUS_STOPPED ) )
720	str = stateString;
721	else
722	str = tr_strltime( buf, time(NULL)-baseline, sizeof( buf ) );
723	}
724	gtr_label_set_text( GTK_LABEL( di->date_started_lb ), str );
725
726
727	/* eta */
728	if( n <= 0 )
729	str = none;
730	else {
731	const int baseline = stats[0]->eta;
732	for( i=1; i<n; ++i )
733	if( baseline != stats[i]->eta )
734	break;
735	if( i!=n )
736	str = mixed;
737	else if( baseline < 0 )
738	str = _( "Unknown" );
739	else
740	str = tr_strltime( buf, baseline, sizeof( buf ) );
741	}
742	gtr_label_set_text( GTK_LABEL( di->eta_lb ), str );
743
744
745	/* size_lb */
746	{
747	char sizebuf[128];
748	uint64_t size = 0;
749	int pieces = 0;
750	int32_t pieceSize = 0;
751	for( i=0; i<n; ++i ) {
752	size += infos[i]->totalSize;
753	pieces += infos[i]->pieceCount;
754	if( !pieceSize )
755	pieceSize = infos[i]->pieceSize;
756	else if( pieceSize != (int)infos[i]->pieceSize )
757	pieceSize = -1;
758	}
759	tr_strlsize( sizebuf, size, sizeof( sizebuf ) );
760	if( !size )
761	str = none;
762	else if( pieceSize >= 0 ) {
763	char piecebuf[128];
764	tr_formatter_mem_B( piecebuf, pieceSize, sizeof( piecebuf ) );
765	g_snprintf( buf, sizeof( buf ),
766	ngettext( "%1$s (%2$'d piece @ %3$s)",
767	"%1$s (%2$'d pieces @ %3$s)", pieces ),
768	sizebuf, pieces, piecebuf );
769	str = buf;
770	} else {
771	g_snprintf( buf, sizeof( buf ),
772	ngettext( "%1$s (%2$'d piece)",
773	"%1$s (%2$'d pieces)", pieces ),
774	sizebuf, pieces );
775	str = buf;
776	}
777	gtr_label_set_text( GTK_LABEL( di->size_lb ), str );
778	}
779
780
781	/* have_lb */
782	if( n <= 0 )
783	str = none;
784	else {
785	uint64_t leftUntilDone = 0;
786	uint64_t haveUnchecked = 0;
787	uint64_t haveValid = 0;
788	uint32_t verifiedPieces = 0;
789	for( i=0; i<n; ++i ) {
790	const tr_stat * st = stats[i];
791	haveUnchecked += st->haveUnchecked;
792	haveValid += st->haveValid;
793	verifiedPieces += st->haveValid / tr_torrentInfo(torrents[i])->pieceSize;
794	sizeWhenDone += st->sizeWhenDone;
795	leftUntilDone += st->leftUntilDone;
796	available += st->sizeWhenDone - st->leftUntilDone + st->desiredAvailable;
797	}
798	if( !haveValid && !haveUnchecked )
799	str = none;
800	else {
801	char buf2[32], unver[64], total[64];
802	const double ratio = 100.0 * ( leftUntilDone ? ( haveValid + haveUnchecked ) / sizeWhenDone : 1 );
803	tr_strlpercent( buf2, ratio, sizeof( buf2 ) );
804	tr_strlsize( total, haveUnchecked + haveValid, sizeof( total ) );
805	tr_strlsize( unver, haveUnchecked, sizeof( unver ) );
806	if( haveUnchecked )
807	g_snprintf( buf, sizeof( buf ), _( "%1$s (%2$s%%); %3$s Unverified" ), total, buf2, unver );
808	else
809	g_snprintf( buf, sizeof( buf ), _( "%1$s (%2$s%%)" ), total, buf2 );
810	str = buf;
811	}
812	}
813	gtr_label_set_text( GTK_LABEL( di->have_lb ), str );
814
815	/* availability_lb */
816	if( !sizeWhenDone )
817	str = none;
818	else {
819	char buf2[32];
820	const double d = ( 100.0 * available ) / sizeWhenDone;
821	tr_strlpercent( buf2, d, sizeof( buf2 ) );
822	g_snprintf( buf, sizeof( buf ), _( "%1$s%%" ), buf2 );
823	str = buf;
824	}
825	gtr_label_set_text( GTK_LABEL( di->availability_lb ), str );
826
827	/* dl_lb */
828	if( n <= 0 )
829	str = none;
830	else {
831	char dbuf[64], fbuf[64];
832	uint64_t d=0, f=0;
833	for( i=0; i<n; ++i ) {
834	d += stats[i]->downloadedEver;
835	f += stats[i]->corruptEver;
836	}
837	tr_strlsize( dbuf, d, sizeof( dbuf ) );
838	tr_strlsize( fbuf, f, sizeof( fbuf ) );
839	if( f )
840	g_snprintf( buf, sizeof( buf ), _( "%1$s (+%2$s corrupt)" ), dbuf, fbuf );
841	else
842	tr_strlcpy( buf, dbuf, sizeof( buf ) );
843	str = buf;
844	}
845	gtr_label_set_text( GTK_LABEL( di->dl_lb ), str );
846
847
848	/* ul_lb */
849	if( n <= 0 )
850	str = none;
851	else {
852	uint64_t sum = 0;
853	for( i=0; i<n; ++i ) sum += stats[i]->uploadedEver;
854	str = tr_strlsize( buf, sum, sizeof( buf ) );
855	}
856	gtr_label_set_text( GTK_LABEL( di->ul_lb ), str );
857
858
859	/* ratio */
860	if( n <= 0 )
861	str = none;
862	else {
863	uint64_t up = 0;
864	uint64_t down = 0;
865	for( i=0; i<n; ++i ) {
866	up += stats[i]->uploadedEver;
867	down += stats[i]->downloadedEver;
868	}
869	str = tr_strlratio( buf, tr_getRatio( up, down ), sizeof( buf ) );
870	}
871	gtr_label_set_text( GTK_LABEL( di->ratio_lb ), str );
872
873	/* hash_lb */
874	if( n<=0 )
875	str = none;
876	else if ( n==1 )
877	str = infos[0]->hashString;
878	else
879	str = mixed;
880	gtr_label_set_text( GTK_LABEL( di->hash_lb ), str );
881
882	/* error */
883	if( n <= 0 )
884	str = none;
885	else {
886	const char * baseline = stats[0]->errorString;
887	for( i=1; i<n; ++i )
888	if( strcmp( baseline, stats[i]->errorString ) )
889	break;
890	if( i==n )
891	str = baseline;
892	else
893	str = mixed;
894	}
895	if( !str \|\| !*str )
896	str = none;
897	gtr_label_set_text( GTK_LABEL( di->error_lb ), str );
898
899
900	/* activity date */
901	if( n <= 0 )
902	str = none;
903	else {
904	time_t latest = 0;
905	for( i=0; i<n; ++i )
906	if( latest < stats[i]->activityDate )
907	latest = stats[i]->activityDate;
908	if( latest <= 0 )
909	str = none;
910	else {
911	const int period = time( NULL ) - latest;
912	if( period < 5 )
913	tr_strlcpy( buf, _( "Active now" ), sizeof( buf ) );
914	else {
915	char tbuf[128];
916	tr_strltime( tbuf, period, sizeof( tbuf ) );
917	g_snprintf( buf, sizeof( buf ), _( "%1$s ago" ), tbuf );
918	}
919	str = buf;
920	}
921	}
922	gtr_label_set_text( GTK_LABEL( di->last_activity_lb ), str );
923
924	g_free( stats );
925	g_free( infos );
926	}
927
928	static GtkWidget*
929	info_page_new( struct DetailsImpl * di )
930	{
931	int row = 0;
932	GtkTextBuffer * b;
933	GtkWidget l, w, fr, sw;
934	GtkWidget *t = hig_workarea_create( );
935
936	hig_workarea_add_section_title( t, &row, _( "Activity" ) );
937
938	/* size */
939	l = di->size_lb = gtk_label_new( NULL );
940	hig_workarea_add_row( t, &row, _( "Torrent size:" ), l, NULL );
941
942	/* have */
943	l = di->have_lb = gtk_label_new( NULL );
944	hig_workarea_add_row( t, &row, _( "Have:" ), l, NULL );
945
946	/* availability */
947	l = di->availability_lb = gtk_label_new( NULL );
948	hig_workarea_add_row( t, &row, _( "Availability:" ), l, NULL );
949
950	/* downloaded */
951	l = di->dl_lb = gtk_label_new( NULL );
952	hig_workarea_add_row( t, &row, _( "Downloaded:" ), l, NULL );
953
954	/* uploaded */
955	l = di->ul_lb = gtk_label_new( NULL );
956	hig_workarea_add_row( t, &row, _( "Uploaded:" ), l, NULL );
957
958	/* ratio */
959	l = di->ratio_lb = gtk_label_new( NULL );
960	hig_workarea_add_row( t, &row, _( "Ratio:" ), l, NULL );
961
962	/* state */
963	l = di->state_lb = gtk_label_new( NULL );
964	hig_workarea_add_row( t, &row, _( "State:" ), l, NULL );
965
966	/* running for */
967	l = di->date_started_lb = gtk_label_new( NULL );
968	hig_workarea_add_row( t, &row, _( "Running time:" ), l, NULL );
969
970	/* eta */
971	l = di->eta_lb = gtk_label_new( NULL );
972	hig_workarea_add_row( t, &row, _( "Remaining time:" ), l, NULL );
973
974	/* last activity */
975	l = di->last_activity_lb = gtk_label_new( NULL );
976	hig_workarea_add_row( t, &row, _( "Last activity:" ), l, NULL );
977
978	/* error */
979	l = di->error_lb = gtk_label_new( NULL );
980	hig_workarea_add_row( t, &row, _( "Error:" ), l, NULL );
981
982
983	hig_workarea_add_section_divider( t, &row );
984	hig_workarea_add_section_title( t, &row, _( "Details" ) );
985
986	/* destination */
987	l = g_object_new( GTK_TYPE_LABEL, "selectable", TRUE,
988	"ellipsize", PANGO_ELLIPSIZE_END,
989	NULL );
990	hig_workarea_add_row( t, &row, _( "Location:" ), l, NULL );
991	di->destination_lb = l;
992
993	/* hash */
994	l = g_object_new( GTK_TYPE_LABEL, "selectable", TRUE,
995	"ellipsize", PANGO_ELLIPSIZE_END,
996	NULL );
997	hig_workarea_add_row( t, &row, _( "Hash:" ), l, NULL );
998	di->hash_lb = l;
999
1000	/* privacy */
1001	l = gtk_label_new( NULL );
1002	hig_workarea_add_row( t, &row, _( "Privacy:" ), l, NULL );
1003	di->privacy_lb = l;
1004
1005	/* origins */
1006	l = gtk_label_new( NULL );
1007	hig_workarea_add_row( t, &row, _( "Origin:" ), l, NULL );
1008	di->origin_lb = l;
1009
1010	/* comment */
1011	b = di->comment_buffer = gtk_text_buffer_new( NULL );
1012	w = gtk_text_view_new_with_buffer( b );
1013	gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( w ), GTK_WRAP_WORD );
1014	gtk_text_view_set_editable( GTK_TEXT_VIEW( w ), FALSE );
1015	sw = gtk_scrolled_window_new( NULL, NULL );
1016	gtk_widget_set_size_request( sw, 350, 36 );
1017	gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( sw ),
1018	GTK_POLICY_AUTOMATIC,
1019	GTK_POLICY_AUTOMATIC );
1020	gtk_container_add( GTK_CONTAINER( sw ), w );
1021	fr = gtk_frame_new( NULL );
1022	gtk_frame_set_shadow_type( GTK_FRAME( fr ), GTK_SHADOW_IN );
1023	gtk_container_add( GTK_CONTAINER( fr ), sw );
1024	w = hig_workarea_add_row( t, &row, _( "Comment:" ), fr, NULL );
1025	gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.0f );
1026
1027	hig_workarea_add_section_divider( t, &row );
1028	hig_workarea_finish( t, &row );
1029	return t;
1030
1031	hig_workarea_finish( t, &row );
1032	return t;
1033	}
1034
1035	/****
1036	*****
1037	***** PEERS TAB
1038	*****
1039	****/
1040
1041	enum
1042	{
1043	WEBSEED_COL_KEY,
1044	WEBSEED_COL_WAS_UPDATED,
1045	WEBSEED_COL_URL,
1046	WEBSEED_COL_DOWNLOAD_RATE_DOUBLE,
1047	WEBSEED_COL_DOWNLOAD_RATE_STRING,
1048	N_WEBSEED_COLS
1049	};
1050
1051	static const char*
1052	getWebseedColumnNames( int column )
1053	{
1054	switch( column )
1055	{
1056	case WEBSEED_COL_URL: return _( "Webseeds" );
1057	case WEBSEED_COL_DOWNLOAD_RATE_DOUBLE:
1058	case WEBSEED_COL_DOWNLOAD_RATE_STRING: return _( "Down" );
1059	default: return "";
1060	}
1061	}
1062
1063	static GtkListStore*
1064	webseed_model_new( void )
1065	{
1066	return gtk_list_store_new( N_WEBSEED_COLS,
1067	G_TYPE_STRING, /* key */
1068	G_TYPE_BOOLEAN, /* was-updated */
1069	G_TYPE_STRING, /* url */
1070	G_TYPE_INT, /* download rate int */
1071	G_TYPE_STRING ); /* download rate string */
1072	}
1073
1074	enum
1075	{
1076	PEER_COL_KEY,
1077	PEER_COL_WAS_UPDATED,
1078	PEER_COL_ADDRESS,
1079	PEER_COL_ADDRESS_COLLATED,
1080	PEER_COL_DOWNLOAD_RATE_DOUBLE,
1081	PEER_COL_DOWNLOAD_RATE_STRING,
1082	PEER_COL_UPLOAD_RATE_DOUBLE,
1083	PEER_COL_UPLOAD_RATE_STRING,
1084	PEER_COL_CLIENT,
1085	PEER_COL_PROGRESS,
1086	PEER_COL_UPLOAD_REQUEST_COUNT_INT,
1087	PEER_COL_UPLOAD_REQUEST_COUNT_STRING,
1088	PEER_COL_DOWNLOAD_REQUEST_COUNT_INT,
1089	PEER_COL_DOWNLOAD_REQUEST_COUNT_STRING,
1090	PEER_COL_BLOCKS_DOWNLOADED_COUNT_INT,
1091	PEER_COL_BLOCKS_DOWNLOADED_COUNT_STRING,
1092	PEER_COL_BLOCKS_UPLOADED_COUNT_INT,
1093	PEER_COL_BLOCKS_UPLOADED_COUNT_STRING,
1094	PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_INT,
1095	PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_STRING,
1096	PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_INT,
1097	PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_STRING,
1098	PEER_COL_ENCRYPTION_STOCK_ID,
1099	PEER_COL_STATUS,
1100	N_PEER_COLS
1101	};
1102
1103	static const char*
1104	getPeerColumnName( int column )
1105	{
1106	switch( column )
1107	{
1108	case PEER_COL_ADDRESS: return _( "Address" );
1109	case PEER_COL_DOWNLOAD_RATE_STRING:
1110	case PEER_COL_DOWNLOAD_RATE_DOUBLE: return _( "Down" );
1111	case PEER_COL_UPLOAD_RATE_STRING:
1112	case PEER_COL_UPLOAD_RATE_DOUBLE: return _( "Up" );
1113	case PEER_COL_CLIENT: return _( "Client" );
1114	case PEER_COL_PROGRESS: return _( "%" );
1115	case PEER_COL_UPLOAD_REQUEST_COUNT_INT:
1116	case PEER_COL_UPLOAD_REQUEST_COUNT_STRING: return _( "Up Reqs" );
1117	case PEER_COL_DOWNLOAD_REQUEST_COUNT_INT:
1118	case PEER_COL_DOWNLOAD_REQUEST_COUNT_STRING: return _( "Dn Reqs" );
1119	case PEER_COL_BLOCKS_DOWNLOADED_COUNT_INT:
1120	case PEER_COL_BLOCKS_DOWNLOADED_COUNT_STRING: return _( "Dn Blocks" );
1121	case PEER_COL_BLOCKS_UPLOADED_COUNT_INT:
1122	case PEER_COL_BLOCKS_UPLOADED_COUNT_STRING: return _( "Up Blocks" );
1123	case PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_INT:
1124	case PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_STRING: return _( "We Cancelled" );
1125	case PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_INT:
1126	case PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_STRING: return _( "They Cancelled" );
1127	case PEER_COL_STATUS: return _( "Status" );
1128	default: return "";
1129	}
1130	}
1131
1132	static GtkListStore*
1133	peer_store_new( void )
1134	{
1135	return gtk_list_store_new( N_PEER_COLS,
1136	G_TYPE_STRING, /* key */
1137	G_TYPE_BOOLEAN, /* was-updated */
1138	G_TYPE_STRING, /* address */
1139	G_TYPE_STRING, /* collated address */
1140	G_TYPE_DOUBLE, /* download speed int */
1141	G_TYPE_STRING, /* download speed string */
1142	G_TYPE_DOUBLE, /* upload speed int */
1143	G_TYPE_STRING, /* upload speed string */
1144	G_TYPE_STRING, /* client */
1145	G_TYPE_INT, /* progress [0..100] */
1146	G_TYPE_INT, /* upload request count int */
1147	G_TYPE_STRING, /* upload request count string */
1148	G_TYPE_INT, /* download request count int */
1149	G_TYPE_STRING, /* download request count string */
1150	G_TYPE_INT, /* # blocks downloaded int */
1151	G_TYPE_STRING, /* # blocks downloaded string */
1152	G_TYPE_INT, /* # blocks uploaded int */
1153	G_TYPE_STRING, /* # blocks uploaded string */
1154	G_TYPE_INT, /* # blocks cancelled by client int */
1155	G_TYPE_STRING, /* # blocks cancelled by client string */
1156	G_TYPE_INT, /* # blocks cancelled by peer int */
1157	G_TYPE_STRING, /* # blocks cancelled by peer string */
1158	G_TYPE_STRING, /* encryption stock id */
1159	G_TYPE_STRING); /* flagString */
1160	}
1161
1162	static void
1163	initPeerRow( GtkListStore * store,
1164	GtkTreeIter * iter,
1165	const char * key,
1166	const tr_peer_stat * peer )
1167	{
1168	int q[4];
1169	char collated_name[128];
1170	const char * client = peer->client;
1171
1172	if( !client \|\| !strcmp( client, "Unknown Client" ) )
1173	client = "";
1174
1175	if( sscanf( peer->addr, "%d.%d.%d.%d", q, q+1, q+2, q+3 ) != 4 )
1176	g_strlcpy( collated_name, peer->addr, sizeof( collated_name ) );
1177	else
1178	g_snprintf( collated_name, sizeof( collated_name ),
1179	"%03d.%03d.%03d.%03d", q[0], q[1], q[2], q[3] );
1180
1181	gtk_list_store_set( store, iter,
1182	PEER_COL_ADDRESS, peer->addr,
1183	PEER_COL_ADDRESS_COLLATED, collated_name,
1184	PEER_COL_CLIENT, client,
1185	PEER_COL_ENCRYPTION_STOCK_ID, peer->isEncrypted ? "transmission-lock" : NULL,
1186	PEER_COL_KEY, key,
1187	-1 );
1188	}
1189
1190	static void
1191	refreshPeerRow( GtkListStore * store,
1192	GtkTreeIter * iter,
1193	const tr_peer_stat * peer )
1194	{
1195	char up_speed[64];
1196	char down_speed[64];
1197	char up_count[64];
1198	char down_count[64];
1199	char blocks_to_peer[64];
1200	char blocks_to_client[64];
1201	char cancelled_by_peer[64];
1202	char cancelled_by_client[64];
1203
1204	if( peer->rateToPeer_KBps > 0.01 )
1205	tr_formatter_speed_KBps( up_speed, peer->rateToPeer_KBps, sizeof( up_speed ) );
1206	else
1207	*up_speed = '\0';
1208
1209	if( peer->rateToClient_KBps > 0 )
1210	tr_formatter_speed_KBps( down_speed, peer->rateToClient_KBps, sizeof( down_speed ) );
1211	else
1212	*down_speed = '\0';
1213
1214	if( peer->pendingReqsToPeer > 0 )
1215	g_snprintf( down_count, sizeof( down_count ), "%d", peer->pendingReqsToPeer );
1216	else
1217	*down_count = '\0';
1218
1219	if( peer->pendingReqsToClient > 0 )
1220	g_snprintf( up_count, sizeof( down_count ), "%d", peer->pendingReqsToClient );
1221	else
1222	*up_count = '\0';
1223
1224	if( peer->blocksToPeer > 0 )
1225	g_snprintf( blocks_to_peer, sizeof( blocks_to_peer ), "%"PRIu32, peer->blocksToPeer );
1226	else
1227	*blocks_to_peer = '\0';
1228
1229	if( peer->blocksToClient > 0 )
1230	g_snprintf( blocks_to_client, sizeof( blocks_to_client ), "%"PRIu32, peer->blocksToClient );
1231	else
1232	*blocks_to_client = '\0';
1233
1234	if( peer->cancelsToPeer > 0 )
1235	g_snprintf( cancelled_by_client, sizeof( cancelled_by_client ), "%"PRIu32, peer->cancelsToPeer );
1236	else
1237	*cancelled_by_client = '\0';
1238
1239	if( peer->cancelsToClient > 0 )
1240	g_snprintf( cancelled_by_peer, sizeof( cancelled_by_peer ), "%"PRIu32, peer->cancelsToClient );
1241	else
1242	*cancelled_by_peer = '\0';
1243
1244	gtk_list_store_set( store, iter,
1245	PEER_COL_PROGRESS, (int)( 100.0 * peer->progress ),
1246	PEER_COL_UPLOAD_REQUEST_COUNT_INT, peer->pendingReqsToClient,
1247	PEER_COL_UPLOAD_REQUEST_COUNT_STRING, up_count,
1248	PEER_COL_DOWNLOAD_REQUEST_COUNT_INT, peer->pendingReqsToPeer,
1249	PEER_COL_DOWNLOAD_REQUEST_COUNT_STRING, down_count,
1250	PEER_COL_DOWNLOAD_RATE_DOUBLE, peer->rateToClient_KBps,
1251	PEER_COL_DOWNLOAD_RATE_STRING, down_speed,
1252	PEER_COL_UPLOAD_RATE_DOUBLE, peer->rateToPeer_KBps,
1253	PEER_COL_UPLOAD_RATE_STRING, up_speed,
1254	PEER_COL_STATUS, peer->flagStr,
1255	PEER_COL_WAS_UPDATED, TRUE,
1256	PEER_COL_BLOCKS_DOWNLOADED_COUNT_INT, (int)peer->blocksToClient,
1257	PEER_COL_BLOCKS_DOWNLOADED_COUNT_STRING, blocks_to_client,
1258	PEER_COL_BLOCKS_UPLOADED_COUNT_INT, (int)peer->blocksToPeer,
1259	PEER_COL_BLOCKS_UPLOADED_COUNT_STRING, blocks_to_peer,
1260	PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_INT, (int)peer->cancelsToPeer,
1261	PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_STRING, cancelled_by_client,
1262	PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_INT, (int)peer->cancelsToClient,
1263	PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_STRING, cancelled_by_peer,
1264	-1 );
1265	}
1266
1267	static void
1268	refreshPeerList( struct DetailsImpl * di, tr_torrent ** torrents, int n )
1269	{
1270	int i;
1271	int * peerCount;
1272	GtkTreeIter iter;
1273	GtkTreeModel * model;
1274	GHashTable * hash = di->peer_hash;
1275	GtkListStore * store = di->peer_store;
1276	struct tr_peer_stat ** peers;
1277
1278	/* step 1: get all the peers */
1279	peers = g_new( struct tr_peer_stat*, n );
1280	peerCount = g_new( int, n );
1281	for( i=0; i<n; ++i )
1282	peers[i] = tr_torrentPeers( torrents[i], &peerCount[i] );
1283
1284	/* step 2: mark all the peers in the list as not-updated */
1285	model = GTK_TREE_MODEL( store );
1286	if( gtk_tree_model_get_iter_first( model, &iter ) ) do
1287	gtk_list_store_set( store, &iter, PEER_COL_WAS_UPDATED, FALSE, -1 );
1288	while( gtk_tree_model_iter_next( model, &iter ) );
1289
1290	/* step 3: add any new peers */
1291	for( i=0; i<n; ++i ) {
1292	int j;
1293	const tr_torrent * tor = torrents[i];
1294	for( j=0; j<peerCount[i]; ++j ) {
1295	const tr_peer_stat * s = &peers[i][j];
1296	char key[128];
1297	g_snprintf( key, sizeof(key), "%d.%s", tr_torrentId(tor), s->addr );
1298	if( g_hash_table_lookup( hash, key ) == NULL ) {
1299	GtkTreePath * p;
1300	gtk_list_store_append( store, &iter );
1301	initPeerRow( store, &iter, key, s );
1302	p = gtk_tree_model_get_path( model, &iter );
1303	g_hash_table_insert( hash, g_strdup( key ),
1304	gtk_tree_row_reference_new( model, p ) );
1305	gtk_tree_path_free( p );
1306	}
1307	}
1308	}
1309
1310	/* step 4: update the peers */
1311	for( i=0; i<n; ++i ) {
1312	int j;
1313	const tr_torrent * tor = torrents[i];
1314	for( j=0; j<peerCount[i]; ++j ) {
1315	const tr_peer_stat * s = &peers[i][j];
1316	char key[128];
1317	GtkTreeRowReference * ref;
1318	GtkTreePath * p;
1319	g_snprintf( key, sizeof(key), "%d.%s", tr_torrentId(tor), s->addr );
1320	ref = g_hash_table_lookup( hash, key );
1321	p = gtk_tree_row_reference_get_path( ref );
1322	gtk_tree_model_get_iter( model, &iter, p );
1323	refreshPeerRow( store, &iter, s );
1324	gtk_tree_path_free( p );
1325	}
1326	}
1327
1328	/* step 5: remove peers that have disappeared */
1329	model = GTK_TREE_MODEL( store );
1330	if( gtk_tree_model_get_iter_first( model, &iter ) ) {
1331	gboolean more = TRUE;
1332	while( more ) {
1333	gboolean b;
1334	gtk_tree_model_get( model, &iter, PEER_COL_WAS_UPDATED, &b, -1 );
1335	if( b )
1336	more = gtk_tree_model_iter_next( model, &iter );
1337	else {
1338	char * key;
1339	gtk_tree_model_get( model, &iter, PEER_COL_KEY, &key, -1 );
1340	g_hash_table_remove( hash, key );
1341	more = gtk_list_store_remove( store, &iter );
1342	g_free( key );
1343	}
1344	}
1345	}
1346
1347	/* step 6: cleanup */
1348	for( i=0; i<n; ++i )
1349	tr_torrentPeersFree( peers[i], peerCount[i] );
1350	tr_free( peers );
1351	tr_free( peerCount );
1352	}
1353
1354	static void
1355	refreshWebseedList( struct DetailsImpl * di, tr_torrent ** torrents, int n )
1356	{
1357	int i;
1358	int total = 0;
1359	GtkTreeIter iter;
1360	GHashTable * hash = di->webseed_hash;
1361	GtkListStore * store = di->webseed_store;
1362	GtkTreeModel * model = GTK_TREE_MODEL( store );
1363
1364	/* step 1: mark all webseeds as not-updated */
1365	if( gtk_tree_model_get_iter_first( model, &iter ) ) do
1366	gtk_list_store_set( store, &iter, WEBSEED_COL_WAS_UPDATED, FALSE, -1 );
1367	while( gtk_tree_model_iter_next( model, &iter ) );
1368
1369	/* step 2: add any new webseeds */
1370	for( i=0; i<n; ++i ) {
1371	int j;
1372	const tr_torrent * tor = torrents[i];
1373	const tr_info * inf = tr_torrentInfo( tor );
1374	total += inf->webseedCount;
1375	for( j=0; j<inf->webseedCount; ++j ) {
1376	char key[256];
1377	const char * url = inf->webseeds[j];
1378	g_snprintf( key, sizeof(key), "%d.%s", tr_torrentId( tor ), url );
1379	if( g_hash_table_lookup( hash, key ) == NULL ) {
1380	GtkTreePath * p;
1381	gtk_list_store_append( store, &iter );
1382	gtk_list_store_set( store, &iter, WEBSEED_COL_URL, url,
1383	WEBSEED_COL_KEY, key,
1384	-1 );
1385	p = gtk_tree_model_get_path( model, &iter );
1386	g_hash_table_insert( hash, g_strdup( key ),
1387	gtk_tree_row_reference_new( model, p ) );
1388	gtk_tree_path_free( p );
1389	}
1390	}
1391	}
1392
1393	/* step 3: update the webseeds */
1394	for( i=0; i<n; ++i ) {
1395	int j;
1396	const tr_torrent * tor = torrents[i];
1397	const tr_info * inf = tr_torrentInfo( tor );
1398	double * speeds_KBps = tr_torrentWebSpeeds_KBps( tor );
1399	for( j=0; j<inf->webseedCount; ++j ) {
1400	char buf[128];
1401	char key[256];
1402	const char * url = inf->webseeds[j];
1403	GtkTreePath * p;
1404	GtkTreeRowReference * ref;
1405	g_snprintf( key, sizeof(key), "%d.%s", tr_torrentId( tor ), url );
1406	ref = g_hash_table_lookup( hash, key );
1407	p = gtk_tree_row_reference_get_path( ref );
1408	gtk_tree_model_get_iter( model, &iter, p );
1409	if( speeds_KBps[j] > 0 )
1410	tr_formatter_speed_Bps( buf, speeds_KBps[j], sizeof( buf ) );
1411	else
1412	*buf = '\0';
1413	gtk_list_store_set( store, &iter, WEBSEED_COL_DOWNLOAD_RATE_DOUBLE, speeds_KBps[j],
1414	WEBSEED_COL_DOWNLOAD_RATE_STRING, buf,
1415	WEBSEED_COL_WAS_UPDATED, TRUE,
1416	-1 );
1417	gtk_tree_path_free( p );
1418	}
1419	tr_free( speeds_KBps );
1420	}
1421
1422	/* step 4: remove webseeds that have disappeared */
1423	if( gtk_tree_model_get_iter_first( model, &iter ) ) {
1424	gboolean more = TRUE;
1425	while( more ) {
1426	gboolean b;
1427	gtk_tree_model_get( model, &iter, WEBSEED_COL_WAS_UPDATED, &b, -1 );
1428	if( b )
1429	more = gtk_tree_model_iter_next( model, &iter );
1430	else {
1431	char * key;
1432	gtk_tree_model_get( model, &iter, WEBSEED_COL_KEY, &key, -1 );
1433	if( key != NULL )
1434	g_hash_table_remove( hash, key );
1435	more = gtk_list_store_remove( store, &iter );
1436	g_free( key );
1437	}
1438	}
1439	}
1440
1441	/* most of the time there are no webseeds...
1442	if that's the case, don't waste space showing an empty list */
1443	if( total > 0 )
1444	gtk_widget_show( di->webseed_view );
1445	else
1446	gtk_widget_hide( di->webseed_view );
1447	}
1448
1449	static void
1450	refreshPeers( struct DetailsImpl * di, tr_torrent ** torrents, int n )
1451	{
1452	refreshPeerList( di, torrents, n );
1453	refreshWebseedList( di, torrents, n );
1454	}
1455
1456	#if GTK_CHECK_VERSION( 2,12,0 )
1457	static gboolean
1458	onPeerViewQueryTooltip( GtkWidget * widget,
1459	gint x,
1460	gint y,
1461	gboolean keyboard_tip,
1462	GtkTooltip * tooltip,
1463	gpointer user_data UNUSED )
1464	{
1465	gboolean show_tip = FALSE;
1466	GtkTreeModel * model;
1467	GtkTreeIter iter;
1468
1469	if( gtk_tree_view_get_tooltip_context( GTK_TREE_VIEW( widget ),
1470	&x, &y, keyboard_tip,
1471	&model, NULL, &iter ) )
1472	{
1473	const char * pch;
1474	char * str = NULL;
1475	GString * gstr = g_string_new( NULL );
1476	gtk_tree_model_get( model, &iter, PEER_COL_STATUS, &str, -1 );
1477	for( pch = str; pch && *pch; ++pch )
1478	{
1479	const char * s = NULL;
1480	switch( *pch )
1481	{
1482	case 'O': s = _( "Optimistic unchoke" ); break;
1483	case 'D': s = _( "Downloading from this peer" ); break;
1484	case 'd': s = _( "We would download from this peer if they would let us" ); break;
1485	case 'U': s = _( "Uploading to peer" ); break;
1486	case 'u': s = _( "We would upload to this peer if they asked" ); break;
1487	case 'K': s = _( "Peer has unchoked us, but we're not interested" ); break;
1488	case '?': s = _( "We unchoked this peer, but they're not interested" ); break;
1489	case 'E': s = _( "Encrypted connection" ); break;
1490	case 'X': s = _( "Peer was discovered through Peer Exchange (PEX)" ); break;
1491	case 'H': s = _( "Peer was discovered through DHT" ); break;
1492	case 'I': s = _( "Peer is an incoming connection" ); break;
1493	}
1494	if( s )
1495	g_string_append_printf( gstr, "%c: %s\n", *pch, s );
1496	}
1497	if( gstr->len ) /* remove the last linefeed */
1498	g_string_set_size( gstr, gstr->len - 1 );
1499	gtk_tooltip_set_text( tooltip, gstr->str );
1500	g_string_free( gstr, TRUE );
1501	g_free( str );
1502	show_tip = TRUE;
1503	}
1504
1505	return show_tip;
1506	}
1507	#endif
1508
1509	static void
1510	setPeerViewColumns( GtkTreeView * peer_view )
1511	{
1512	int i;
1513	int n = 0;
1514	const tr_bool more = pref_flag_get( PREF_KEY_SHOW_MORE_PEER_INFO );
1515	int view_columns[32];
1516	GtkTreeViewColumn * c;
1517	GtkCellRenderer * r;
1518
1519	view_columns[n++] = PEER_COL_ENCRYPTION_STOCK_ID;
1520	view_columns[n++] = PEER_COL_UPLOAD_RATE_STRING;
1521	if( more ) view_columns[n++] = PEER_COL_UPLOAD_REQUEST_COUNT_STRING;
1522	view_columns[n++] = PEER_COL_DOWNLOAD_RATE_STRING;
1523	if( more ) view_columns[n++] = PEER_COL_DOWNLOAD_REQUEST_COUNT_STRING;
1524	if( more ) view_columns[n++] = PEER_COL_BLOCKS_DOWNLOADED_COUNT_STRING;
1525	if( more ) view_columns[n++] = PEER_COL_BLOCKS_UPLOADED_COUNT_STRING;
1526	if( more ) view_columns[n++] = PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_STRING;
1527	if( more ) view_columns[n++] = PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_STRING;
1528	view_columns[n++] = PEER_COL_PROGRESS;
1529	view_columns[n++] = PEER_COL_STATUS;
1530	view_columns[n++] = PEER_COL_ADDRESS;
1531	view_columns[n++] = PEER_COL_CLIENT;
1532
1533	/* remove any existing columns */
1534	{
1535	GList * l;
1536	GList * columns = gtk_tree_view_get_columns( peer_view );
1537	for( l=columns; l!=NULL; l=l->next )
1538	gtk_tree_view_remove_column( peer_view, l->data );
1539	g_list_free( columns );
1540	}
1541
1542	for( i=0; i<n; ++i )
1543	{
1544	const int col = view_columns[i];
1545	const char * t = getPeerColumnName( col );
1546	int sort_col = col;
1547
1548	switch( col )
1549	{
1550	case PEER_COL_ADDRESS:
1551	r = gtk_cell_renderer_text_new( );
1552	c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
1553	sort_col = PEER_COL_ADDRESS_COLLATED;
1554	break;
1555
1556	case PEER_COL_CLIENT:
1557	r = gtk_cell_renderer_text_new( );
1558	c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
1559	break;
1560
1561	case PEER_COL_PROGRESS:
1562	r = gtk_cell_renderer_progress_new( );
1563	c = gtk_tree_view_column_new_with_attributes( t, r, "value", PEER_COL_PROGRESS, NULL );
1564	break;
1565
1566	case PEER_COL_ENCRYPTION_STOCK_ID:
1567	r = gtk_cell_renderer_pixbuf_new( );
1568	g_object_set( r, "xalign", (gfloat)0.0,
1569	"yalign", (gfloat)0.5,
1570	NULL );
1571	c = gtk_tree_view_column_new_with_attributes( t, r, "stock-id", PEER_COL_ENCRYPTION_STOCK_ID, NULL );
1572	gtk_tree_view_column_set_sizing( c, GTK_TREE_VIEW_COLUMN_FIXED );
1573	gtk_tree_view_column_set_fixed_width( c, 20 );
1574	break;
1575
1576	case PEER_COL_DOWNLOAD_REQUEST_COUNT_STRING:
1577	r = gtk_cell_renderer_text_new( );
1578	c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
1579	sort_col = PEER_COL_DOWNLOAD_REQUEST_COUNT_INT;
1580	break;
1581	case PEER_COL_UPLOAD_REQUEST_COUNT_STRING:
1582	r = gtk_cell_renderer_text_new( );
1583	c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
1584	sort_col = PEER_COL_UPLOAD_REQUEST_COUNT_INT;
1585	break;
1586
1587	case PEER_COL_BLOCKS_DOWNLOADED_COUNT_STRING:
1588	r = gtk_cell_renderer_text_new( );
1589	c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
1590	sort_col = PEER_COL_BLOCKS_DOWNLOADED_COUNT_INT;
1591	break;
1592	case PEER_COL_BLOCKS_UPLOADED_COUNT_STRING:
1593	r = gtk_cell_renderer_text_new( );
1594	c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
1595	sort_col = PEER_COL_BLOCKS_UPLOADED_COUNT_INT;
1596	break;
1597
1598	case PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_STRING:
1599	r = gtk_cell_renderer_text_new( );
1600	c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
1601	sort_col = PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_INT;
1602	break;
1603	case PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_STRING:
1604	r = gtk_cell_renderer_text_new( );
1605	c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
1606	sort_col = PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_INT;
1607	break;
1608
1609	case PEER_COL_DOWNLOAD_RATE_STRING:
1610	r = gtk_cell_renderer_text_new( );
1611	g_object_set( G_OBJECT( r ), "xalign", 1.0f, NULL );
1612	c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
1613	sort_col = PEER_COL_DOWNLOAD_RATE_DOUBLE;
1614	break;
1615	case PEER_COL_UPLOAD_RATE_STRING:
1616	r = gtk_cell_renderer_text_new( );
1617	g_object_set( G_OBJECT( r ), "xalign", 1.0f, NULL );
1618	c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
1619	sort_col = PEER_COL_UPLOAD_RATE_DOUBLE;
1620	break;
1621
1622	case PEER_COL_STATUS:
1623	r = gtk_cell_renderer_text_new( );
1624	c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
1625	break;
1626
1627	default:
1628	abort( );
1629	}
1630
1631	gtk_tree_view_column_set_resizable( c, FALSE );
1632	gtk_tree_view_column_set_sort_column_id( c, sort_col );
1633	gtk_tree_view_append_column( GTK_TREE_VIEW( peer_view ), c );
1634	}
1635
1636	/* the 'expander' column has a 10-pixel margin on the left
1637	that doesn't look quite correct in any of these columns...
1638	so create a non-visible column and assign it as the
1639	'expander column. */
1640	{
1641	GtkTreeViewColumn *c = gtk_tree_view_column_new( );
1642	gtk_tree_view_column_set_visible( c, FALSE );
1643	gtk_tree_view_append_column( GTK_TREE_VIEW( peer_view ), c );
1644	gtk_tree_view_set_expander_column( GTK_TREE_VIEW( peer_view ), c );
1645	}
1646	}
1647
1648	static void
1649	onMorePeerInfoToggled( GtkToggleButton * button, struct DetailsImpl * di )
1650	{
1651	const char * key = PREF_KEY_SHOW_MORE_PEER_INFO;
1652	const gboolean value = gtk_toggle_button_get_active( button );
1653	tr_core_set_pref_bool( di->core, key, value );
1654	setPeerViewColumns( GTK_TREE_VIEW( di->peer_view ) );
1655	}
1656
1657	static GtkWidget*
1658	peer_page_new( struct DetailsImpl * di )
1659	{
1660	gboolean b;
1661	const char * str;
1662	GtkListStore *store;
1663	GtkWidget v, w, ret, sw, *vbox;
1664	GtkWidget *webtree = NULL;
1665	GtkTreeModel * m;
1666	GtkTreeViewColumn * c;
1667	GtkCellRenderer * r;
1668
1669	/* webseeds */
1670
1671	store = di->webseed_store = webseed_model_new( );
1672	v = gtk_tree_view_new_with_model( GTK_TREE_MODEL( store ) );
1673	g_signal_connect( v, "button-release-event", G_CALLBACK( on_tree_view_button_released ), NULL );
1674	gtk_tree_view_set_rules_hint( GTK_TREE_VIEW( v ), TRUE );
1675	g_object_unref( store );
1676
1677	str = getWebseedColumnNames( WEBSEED_COL_URL );
1678	r = gtk_cell_renderer_text_new( );
1679	g_object_set( G_OBJECT( r ), "ellipsize", PANGO_ELLIPSIZE_END, NULL );
1680	c = gtk_tree_view_column_new_with_attributes( str, r, "text", WEBSEED_COL_URL, NULL );
1681	g_object_set( G_OBJECT( c ), "expand", TRUE, NULL );
1682	gtk_tree_view_column_set_sort_column_id( c, WEBSEED_COL_URL );
1683	gtk_tree_view_append_column( GTK_TREE_VIEW( v ), c );
1684
1685	str = getWebseedColumnNames( WEBSEED_COL_DOWNLOAD_RATE_STRING );
1686	r = gtk_cell_renderer_text_new( );
1687	c = gtk_tree_view_column_new_with_attributes( str, r, "text", WEBSEED_COL_DOWNLOAD_RATE_STRING, NULL );
1688	gtk_tree_view_column_set_sort_column_id( c, WEBSEED_COL_DOWNLOAD_RATE_DOUBLE );
1689	gtk_tree_view_append_column( GTK_TREE_VIEW( v ), c );
1690
1691	w = gtk_scrolled_window_new( NULL, NULL );
1692	gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ),
1693	GTK_POLICY_AUTOMATIC,
1694	GTK_POLICY_AUTOMATIC );
1695	gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ),
1696	GTK_SHADOW_IN );
1697	gtk_container_add( GTK_CONTAINER( w ), v );
1698
1699	webtree = w;
1700	di->webseed_view = w;
1701
1702	/* peers */
1703
1704	store = di->peer_store = peer_store_new( );
1705	m = gtk_tree_model_sort_new_with_model( GTK_TREE_MODEL( store ) );
1706	gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE( m ),
1707	PEER_COL_PROGRESS,
1708	GTK_SORT_DESCENDING );
1709	#if GTK_CHECK_VERSION( 2,12,0 )
1710	v = GTK_WIDGET( g_object_new( GTK_TYPE_TREE_VIEW,
1711	"model", m,
1712	"rules-hint", TRUE,
1713	"has-tooltip", TRUE,
1714	NULL ) );
1715	#else
1716	v = GTK_WIDGET( g_object_new( GTK_TYPE_TREE_VIEW,
1717	"model", m,
1718	"rules-hint", TRUE,
1719	NULL ) );
1720	#endif
1721	di->peer_view = v;
1722
1723	#if GTK_CHECK_VERSION( 2,12,0 )
1724	g_signal_connect( v, "query-tooltip",
1725	G_CALLBACK( onPeerViewQueryTooltip ), NULL );
1726	#endif
1727	g_object_unref( store );
1728	g_signal_connect( v, "button-release-event",
1729	G_CALLBACK( on_tree_view_button_released ), NULL );
1730
1731	setPeerViewColumns( GTK_TREE_VIEW( v ) );
1732
1733	w = sw = gtk_scrolled_window_new( NULL, NULL );
1734	gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ),
1735	GTK_POLICY_AUTOMATIC,
1736	GTK_POLICY_AUTOMATIC );
1737	gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ),
1738	GTK_SHADOW_IN );
1739	gtk_container_add( GTK_CONTAINER( w ), v );
1740
1741	vbox = gtk_vbox_new( FALSE, GUI_PAD );
1742	gtk_container_set_border_width( GTK_CONTAINER( vbox ), GUI_PAD_BIG );
1743
1744	v = gtk_vpaned_new( );
1745	gtk_paned_pack1( GTK_PANED( v ), webtree, FALSE, TRUE );
1746	gtk_paned_pack2( GTK_PANED( v ), sw, TRUE, TRUE );
1747	gtk_box_pack_start( GTK_BOX( vbox ), v, TRUE, TRUE, 0 );
1748
1749	w = gtk_check_button_new_with_mnemonic( _( "Show _more details" ) );
1750	di->more_peer_details_check = w;
1751	b = pref_flag_get( PREF_KEY_SHOW_MORE_PEER_INFO );
1752	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
1753	g_signal_connect( w, "toggled", G_CALLBACK( onMorePeerInfoToggled ), di );
1754	gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
1755
1756
1757	/* ip-to-GtkTreeRowReference */
1758	di->peer_hash = g_hash_table_new_full( g_str_hash,
1759	g_str_equal,
1760	(GDestroyNotify)g_free,
1761	(GDestroyNotify)gtk_tree_row_reference_free );
1762
1763	/* url-to-GtkTreeRowReference */
1764	di->webseed_hash = g_hash_table_new_full( g_str_hash,
1765	g_str_equal,
1766	(GDestroyNotify)g_free,
1767	(GDestroyNotify)gtk_tree_row_reference_free );
1768	ret = vbox;
1769	return ret;
1770	}
1771
1772
1773
1774	/****
1775	***** TRACKER
1776	****/
1777
1778	/* if it's been longer than a minute, don't bother showing the seconds */
1779	static void
1780	tr_strltime_rounded( char * buf, time_t t, size_t buflen )
1781	{
1782	if( t > 60 ) t -= ( t % 60 );
1783	tr_strltime( buf, t, buflen );
1784	}
1785
1786	static char *
1787	buildTrackerSummary( const char * key, const tr_tracker_stat * st, gboolean showScrape )
1788	{
1789	char * str;
1790	char timebuf[256];
1791	const time_t now = time( NULL );
1792	GString * gstr = g_string_new( NULL );
1793	const char * err_markup_begin = "<span color=\"red\">";
1794	const char * err_markup_end = "</span>";
1795	const char * timeout_markup_begin = "<span color=\"#224466\">";
1796	const char * timeout_markup_end = "</span>";
1797	const char * success_markup_begin = "<span color=\"#008B00\">";
1798	const char * success_markup_end = "</span>";
1799
1800	/* hostname */
1801	{
1802	const char * host = st->host;
1803	const char * pch = strstr( host, "://" );
1804	if( pch )
1805	host = pch + 3;
1806	g_string_append( gstr, st->isBackup ? "<i>" : "<b>" );
1807	if( key )
1808	str = g_markup_printf_escaped( "%s - %s", host, key );
1809	else
1810	str = g_markup_printf_escaped( "%s", host );
1811	g_string_append( gstr, str );
1812	g_free( str );
1813	g_string_append( gstr, st->isBackup ? "</i>" : "</b>" );
1814	}
1815
1816	if( !st->isBackup )
1817	{
1818	if( st->hasAnnounced )
1819	{
1820	g_string_append_c( gstr, '\n' );
1821	tr_strltime_rounded( timebuf, now - st->lastAnnounceTime, sizeof( timebuf ) );
1822	if( st->lastAnnounceSucceeded )
1823	g_string_append_printf( gstr, _( "Got a list of %1$s%2$'d peers%3$s %4$s ago" ),
1824	success_markup_begin, st->lastAnnouncePeerCount, success_markup_end,
1825	timebuf );
1826	else if( st->lastAnnounceTimedOut )
1827	g_string_append_printf( gstr, _( "Peer list request %1$stimed out%2$s %3$s ago; will retry" ),
1828	timeout_markup_begin, timeout_markup_end, timebuf );
1829	else
1830	g_string_append_printf( gstr, _( "Got an error %1$s\"%2$s\"%3$s %4$s ago" ),
1831	err_markup_begin, st->lastAnnounceResult, err_markup_end, timebuf );
1832	}
1833
1834	switch( st->announceState )
1835	{
1836	case TR_TRACKER_INACTIVE:
1837	if( !st->hasAnnounced ) {
1838	g_string_append_c( gstr, '\n' );
1839	g_string_append( gstr, _( "No updates scheduled" ) );
1840	}
1841	break;
1842	case TR_TRACKER_WAITING:
1843	tr_strltime_rounded( timebuf, st->nextAnnounceTime - now, sizeof( timebuf ) );
1844	g_string_append_c( gstr, '\n' );
1845	g_string_append_printf( gstr, _( "Asking for more peers in %s" ), timebuf );
1846	break;
1847	case TR_TRACKER_QUEUED:
1848	g_string_append_c( gstr, '\n' );
1849	g_string_append( gstr, _( "Queued to ask for more peers" ) );
1850	break;
1851	case TR_TRACKER_ACTIVE:
1852	tr_strltime_rounded( timebuf, now - st->lastAnnounceStartTime, sizeof( timebuf ) );
1853	g_string_append_c( gstr, '\n' );
1854	g_string_append_printf( gstr, _( "Asking for more peers now... <small>%s</small>" ), timebuf );
1855	break;
1856	}
1857
1858	if( showScrape )
1859	{
1860	if( st->hasScraped ) {
1861	g_string_append_c( gstr, '\n' );
1862	tr_strltime_rounded( timebuf, now - st->lastScrapeTime, sizeof( timebuf ) );
1863	if( st->lastScrapeSucceeded )
1864	g_string_append_printf( gstr, _( "Tracker had %s%'d seeders and %'d leechers%s %s ago" ),
1865	success_markup_begin, st->seederCount, st->leecherCount, success_markup_end,
1866	timebuf );
1867	else
1868	g_string_append_printf( gstr, _( "Got a scrape error \"%s%s%s\" %s ago" ), err_markup_begin, st->lastScrapeResult, err_markup_end, timebuf );
1869	}
1870
1871	switch( st->scrapeState )
1872	{
1873	case TR_TRACKER_INACTIVE:
1874	break;
1875	case TR_TRACKER_WAITING:
1876	g_string_append_c( gstr, '\n' );
1877	tr_strltime_rounded( timebuf, st->nextScrapeTime - now, sizeof( timebuf ) );
1878	g_string_append_printf( gstr, _( "Asking for peer counts in %s" ), timebuf );
1879	break;
1880	case TR_TRACKER_QUEUED:
1881	g_string_append_c( gstr, '\n' );
1882	g_string_append( gstr, _( "Queued to ask for peer counts" ) );
1883	break;
1884	case TR_TRACKER_ACTIVE:
1885	g_string_append_c( gstr, '\n' );
1886	tr_strltime_rounded( timebuf, now - st->lastScrapeStartTime, sizeof( timebuf ) );
1887	g_string_append_printf( gstr, _( "Asking for peer counts now... <small>%s</small>" ), timebuf );
1888	break;
1889	}
1890	}
1891	}
1892
1893	return g_string_free( gstr, FALSE );
1894	}
1895
1896	enum
1897	{
1898	TRACKER_COL_TORRENT_ID,
1899	TRACKER_COL_TRACKER_INDEX,
1900	TRACKER_COL_TEXT,
1901	TRACKER_COL_BACKUP,
1902	TRACKER_COL_TORRENT_NAME,
1903	TRACKER_COL_TRACKER_NAME,
1904	TRACKER_COL_FAVICON,
1905	TRACKER_N_COLS
1906	};
1907
1908	static gboolean
1909	trackerVisibleFunc( GtkTreeModel * model, GtkTreeIter * iter, gpointer data )
1910	{
1911	gboolean isBackup;
1912	struct DetailsImpl * di = data;
1913
1914	/* show all */
1915	if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( di->all_check ) ) )
1916	return TRUE;
1917
1918	/* don't show the backups... */
1919	gtk_tree_model_get( model, iter, TRACKER_COL_BACKUP, &isBackup, -1 );
1920	return !isBackup;
1921	}
1922
1923	static void
1924	populate_tracker_buffer( GtkTextBuffer * buffer, const tr_torrent * tor )
1925	{
1926	int i;
1927	int tier = 0;
1928	GString * gstr = g_string_new( NULL );
1929	const tr_info * inf = tr_torrentInfo( tor );
1930	for( i=0; i<inf->trackerCount; ++i ) {
1931	const tr_tracker_info * t = &inf->trackers[i];
1932	if( tier != t->tier ) {
1933	tier = t->tier;
1934	g_string_append_c( gstr, '\n' );
1935	}
1936	g_string_append_printf( gstr, "%s\n", t->announce );
1937	}
1938	if( gstr->len > 0 )
1939	g_string_truncate( gstr, gstr->len-1 );
1940	gtk_text_buffer_set_text( buffer, gstr->str, -1 );
1941	g_string_free( gstr, TRUE );
1942	}
1943
1944	#define TORRENT_PTR_KEY "torrent-pointer"
1945
1946	static void
1947	favicon_ready_cb( gpointer pixbuf, gpointer vreference )
1948	{
1949	GtkTreeIter iter;
1950	GtkTreeRowReference * reference = vreference;
1951
1952	if( pixbuf != NULL )
1953	{
1954	GtkTreePath * path = gtk_tree_row_reference_get_path( reference );
1955	GtkTreeModel * model = gtk_tree_row_reference_get_model( reference );
1956
1957	if( gtk_tree_model_get_iter( model, &iter, path ) )
1958	gtk_list_store_set( GTK_LIST_STORE( model ), &iter,
1959	TRACKER_COL_FAVICON, pixbuf,
1960	-1 );
1961
1962	gtk_tree_path_free( path );
1963
1964	g_object_unref( pixbuf );
1965	}
1966
1967	gtk_tree_row_reference_free( reference );
1968	}
1969
1970	static void
1971	refreshTracker( struct DetailsImpl * di, tr_torrent ** torrents, int n )
1972	{
1973	int i;
1974	int * statCount;
1975	tr_tracker_stat ** stats;
1976	GtkTreeIter iter;
1977	GtkListStore * store = di->trackers;
1978	GtkTreeModel * model;
1979	const gboolean showScrape = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( di->scrape_check ) );
1980
1981	statCount = g_new0( int, n );
1982	stats = g_new0( tr_tracker_stat *, n );
1983	for( i=0; i<n; ++i )
1984	stats[i] = tr_torrentTrackers( torrents[i], &statCount[i] );
1985
1986	/* "edit trackers" button */
1987	gtk_widget_set_sensitive( di->edit_trackers_button, n==1 );
1988	if( n==1 )
1989	g_object_set_data( G_OBJECT( di->edit_trackers_button ), TORRENT_PTR_KEY, torrents[0] );
1990
1991	/* build the store if we don't already have it */
1992	if( store == NULL )
1993	{
1994	GtkTreeModel * filter;
1995
1996	store = gtk_list_store_new( TRACKER_N_COLS, G_TYPE_INT,
1997	G_TYPE_INT,
1998	G_TYPE_STRING,
1999	G_TYPE_BOOLEAN,
2000	G_TYPE_STRING,
2001	G_TYPE_STRING,
2002	GDK_TYPE_PIXBUF );
2003
2004	filter = gtk_tree_model_filter_new( GTK_TREE_MODEL( store ), NULL );
2005	gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( filter ),
2006	trackerVisibleFunc, di, NULL );
2007
2008	di->trackers = store;
2009	di->trackers_filtered = filter;
2010
2011	gtk_tree_view_set_model( GTK_TREE_VIEW( di->tracker_view ), filter );
2012	}
2013
2014	if( ( di->tracker_buffer == NULL ) && ( n == 1 ) )
2015	{
2016	di->tracker_buffer = gtk_text_buffer_new( NULL );
2017	populate_tracker_buffer( di->tracker_buffer, torrents[0] );
2018	}
2019
2020	/* add any missing rows (FIXME: doesn't handle edited trackers) */
2021	model = GTK_TREE_MODEL( store );
2022	if( n && !gtk_tree_model_get_iter_first( model, &iter ) )
2023	{
2024	tr_session * session = tr_core_session( di->core );
2025
2026	for( i=0; i<n; ++i )
2027	{
2028	int j;
2029	const tr_torrent * tor = torrents[i];
2030	const int torrentId = tr_torrentId( tor );
2031	const tr_info * inf = tr_torrentInfo( tor );
2032
2033	for( j=0; j<statCount[i]; ++j )
2034	{
2035	GtkTreePath * path;
2036	GtkTreeRowReference * reference;
2037	const tr_tracker_stat * st = &stats[i][j];
2038
2039	gtk_list_store_insert_with_values( store, &iter, -1,
2040	TRACKER_COL_TORRENT_ID, torrentId,
2041	TRACKER_COL_TRACKER_INDEX, j,
2042	TRACKER_COL_TORRENT_NAME, inf->name,
2043	TRACKER_COL_TRACKER_NAME, st->host,
2044	-1 );
2045
2046	path = gtk_tree_model_get_path( model, &iter );
2047	reference = gtk_tree_row_reference_new( model, path );
2048	gtr_get_favicon_from_url( session, st->announce, favicon_ready_cb, reference );
2049	gtk_tree_path_free( path );
2050	}
2051	}
2052	}
2053
2054	/* update the store */
2055	if( gtk_tree_model_get_iter_first( model, &iter ) ) do
2056	{
2057	int torrentId;
2058	int trackerIndex;
2059
2060	gtk_tree_model_get( model, &iter, TRACKER_COL_TORRENT_ID, &torrentId,
2061	TRACKER_COL_TRACKER_INDEX, &trackerIndex,
2062	-1 );
2063
2064	for( i=0; i<n; ++i )
2065	if( tr_torrentId( torrents[i] ) == torrentId )
2066	break;
2067
2068	if( i<n && trackerIndex<statCount[i] )
2069	{
2070	const tr_tracker_stat * st = &stats[i][trackerIndex];
2071	const char * key = n>1 ? tr_torrentInfo( torrents[i] )->name : NULL;
2072	char * text = buildTrackerSummary( key, st, showScrape );
2073	gtk_list_store_set( store, &iter, TRACKER_COL_TEXT, text,
2074	TRACKER_COL_BACKUP, st->isBackup,
2075	-1 );
2076	g_free( text );
2077	}
2078	}
2079	while( gtk_tree_model_iter_next( model, &iter ) );
2080
2081	/* cleanup */
2082	for( i=0; i<n; ++i )
2083	tr_torrentTrackersFree( stats[i], statCount[i] );
2084	g_free( stats );
2085	g_free( statCount );
2086	}
2087
2088	static void refresh( struct DetailsImpl * di );
2089
2090	static void
2091	onScrapeToggled( GtkToggleButton * button, struct DetailsImpl * di )
2092	{
2093	const char * key = PREF_KEY_SHOW_MORE_TRACKER_INFO;
2094	const gboolean value = gtk_toggle_button_get_active( button );
2095	tr_core_set_pref_bool( di->core, key, value );
2096	refresh( di );
2097	}
2098
2099	static void
2100	onBackupToggled( GtkToggleButton * button, struct DetailsImpl * di )
2101	{
2102	const char * key = PREF_KEY_SHOW_BACKUP_TRACKERS;
2103	const gboolean value = gtk_toggle_button_get_active( button );
2104	tr_core_set_pref_bool( di->core, key, value );
2105	refresh( di );
2106	}
2107
2108	static void
2109	onEditTrackersResponse( GtkDialog * dialog, int response, gpointer data )
2110	{
2111	gboolean do_destroy = TRUE;
2112	struct DetailsImpl * di = data;
2113
2114	if( response == GTK_RESPONSE_ACCEPT )
2115	{
2116	int i, n;
2117	int tier;
2118	GtkTextIter start, end;
2119	char * tracker_text;
2120	char ** tracker_strings;
2121	tr_tracker_info * trackers;
2122	tr_torrent * tor = g_object_get_data( G_OBJECT( dialog ), TORRENT_PTR_KEY );
2123
2124	/* build the array of trackers */
2125	gtk_text_buffer_get_bounds( di->tracker_buffer, &start, &end );
2126	tracker_text = gtk_text_buffer_get_text( di->tracker_buffer, &start, &end, FALSE );
2127	tracker_strings = g_strsplit( tracker_text, "\n", 0 );
2128	for( i=0; tracker_strings[i]; )
2129	++i;
2130	trackers = g_new0( tr_tracker_info, i );
2131	for( i=n=tier=0; tracker_strings[i]; ++i ) {
2132	const char * str = tracker_strings[i];
2133	if( !*str )
2134	++tier;
2135	else {
2136	trackers[n].tier = tier;
2137	trackers[n].announce = tracker_strings[i];
2138	++n;
2139	}
2140	}
2141
2142	/* update the torrent */
2143	if( !tr_torrentSetAnnounceList( tor, trackers, n ) )
2144	{
2145	GtkWidget * w;
2146	const char * text = _( "List contains invalid URLs" );
2147	w = gtk_message_dialog_new( GTK_WINDOW( dialog ),
2148	GTK_DIALOG_MODAL,
2149	GTK_MESSAGE_ERROR,
2150	GTK_BUTTONS_CLOSE, "%s", text );
2151	gtk_dialog_run( GTK_DIALOG( w ) );
2152	gtk_widget_destroy( w );
2153	do_destroy = FALSE;
2154	}
2155	else
2156	{
2157	di->trackers = NULL;
2158	di->tracker_buffer = NULL;
2159	tr_core_torrent_changed( di->core, tr_torrentId( tor ) );
2160	}
2161
2162	/* cleanup */
2163	g_free( trackers );
2164	g_strfreev( tracker_strings );
2165	g_free( tracker_text );
2166	}
2167
2168	if( response == GTK_RESPONSE_CANCEL )
2169	{
2170	tr_torrent * tor = g_object_get_data( G_OBJECT( dialog ), TORRENT_PTR_KEY );
2171	populate_tracker_buffer( di->tracker_buffer, tor );
2172	}
2173
2174	if( do_destroy )
2175	gtk_widget_destroy( GTK_WIDGET( dialog ) );
2176	}
2177
2178	static void
2179	onEditTrackers( GtkButton * button, gpointer data )
2180	{
2181	int row;
2182	GtkWidget w, d, fr, t, l, sw;
2183	GtkWindow * win = GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( button ) ) );
2184	struct DetailsImpl * di = data;
2185
2186	d = gtk_dialog_new_with_buttons( _( "Edit Trackers" ), win,
2187	GTK_DIALOG_MODAL\|GTK_DIALOG_DESTROY_WITH_PARENT,
2188	GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
2189	GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
2190	NULL );
2191	g_object_set_data( G_OBJECT( d ), TORRENT_PTR_KEY,
2192	g_object_get_data( G_OBJECT( button ), TORRENT_PTR_KEY ) );
2193	g_signal_connect( d, "response",
2194	G_CALLBACK( onEditTrackersResponse ), data );
2195
2196	row = 0;
2197	t = hig_workarea_create( );
2198	hig_workarea_add_section_title( t, &row, _( "Tracker Announce URLs" ) );
2199
2200	l = gtk_label_new( NULL );
2201	gtk_label_set_markup( GTK_LABEL( l ), _( "To add a backup URL, add it on the line after the primary URL.\n"
2202	"To add another primary URL, add it after a blank line." ) );
2203	gtk_label_set_justify( GTK_LABEL( l ), GTK_JUSTIFY_LEFT );
2204	gtk_misc_set_alignment( GTK_MISC( l ), 0.0, 0.5 );
2205	hig_workarea_add_wide_control( t, &row, l );
2206
2207	w = gtk_text_view_new_with_buffer( di->tracker_buffer );
2208	gtk_widget_set_size_request( w, 500u, 166u );
2209	fr = gtk_frame_new( NULL );
2210	gtk_frame_set_shadow_type( GTK_FRAME( fr ), GTK_SHADOW_IN );
2211	sw = gtk_scrolled_window_new( NULL, NULL );
2212	gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( sw ),
2213	GTK_POLICY_AUTOMATIC,
2214	GTK_POLICY_AUTOMATIC );
2215	gtk_container_add( GTK_CONTAINER( sw ), w );
2216	gtk_container_add( GTK_CONTAINER( fr ), sw );
2217	hig_workarea_add_wide_tall_control( t, &row, fr );
2218
2219	hig_workarea_finish( t, &row );
2220	gtk_box_pack_start( GTK_BOX( GTK_DIALOG( d )->vbox ), t, TRUE, TRUE, GUI_PAD_SMALL );
2221	gtk_widget_show_all( d );
2222	}
2223
2224	static GtkWidget*
2225	tracker_page_new( struct DetailsImpl * di )
2226	{
2227	gboolean b;
2228	GtkCellRenderer *r;
2229	GtkTreeViewColumn *c;
2230	GtkWidget vbox, sw, w, v, *hbox;
2231	const int pad = ( GUI_PAD + GUI_PAD_BIG ) / 2;
2232
2233	vbox = gtk_vbox_new( FALSE, GUI_PAD );
2234	gtk_container_set_border_width( GTK_CONTAINER( vbox ), GUI_PAD_BIG );
2235
2236	v = di->tracker_view = gtk_tree_view_new( );
2237	g_signal_connect( v, "button-press-event",
2238	G_CALLBACK( on_tree_view_button_pressed ), NULL );
2239	g_signal_connect( v, "button-release-event",
2240	G_CALLBACK( on_tree_view_button_released ), NULL );
2241	gtk_tree_view_set_rules_hint( GTK_TREE_VIEW( v ), TRUE );
2242
2243	c = gtk_tree_view_column_new( );
2244	gtk_tree_view_column_set_title( c, _( "Trackers" ) );
2245	gtk_tree_view_append_column( GTK_TREE_VIEW( v ), c );
2246
2247	r = gtk_cell_renderer_pixbuf_new( );
2248	g_object_set( r, "width", 20 + (GUI_PAD_SMALL*2), "xpad", GUI_PAD_SMALL, "ypad", pad, "yalign", 0.0f, NULL );
2249	gtk_tree_view_column_pack_start( c, r, FALSE );
2250	gtk_tree_view_column_add_attribute( c, r, "pixbuf", TRACKER_COL_FAVICON );
2251
2252	r = gtk_cell_renderer_text_new( );
2253	g_object_set( G_OBJECT( r ), "ellipsize", PANGO_ELLIPSIZE_END, "xpad", GUI_PAD_SMALL, "ypad", pad, NULL );
2254	gtk_tree_view_column_pack_start( c, r, TRUE );
2255	gtk_tree_view_column_add_attribute( c, r, "markup", TRACKER_COL_TEXT );
2256
2257	sw = gtk_scrolled_window_new( NULL, NULL );
2258	gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( sw ),
2259	GTK_POLICY_AUTOMATIC,
2260	GTK_POLICY_AUTOMATIC );
2261	gtk_container_add( GTK_CONTAINER( sw ), v );
2262	w = gtk_frame_new( NULL );
2263	gtk_frame_set_shadow_type( GTK_FRAME( w ), GTK_SHADOW_IN );
2264	gtk_container_add( GTK_CONTAINER( w ), sw );
2265	gtk_box_pack_start( GTK_BOX( vbox ), w, TRUE, TRUE, 0 );
2266
2267	hbox = gtk_hbox_new( FALSE, 0 );
2268
2269	w = gtk_check_button_new_with_mnemonic( _( "Show _more details" ) );
2270	di->scrape_check = w;
2271	b = pref_flag_get( PREF_KEY_SHOW_MORE_TRACKER_INFO );
2272	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
2273	g_signal_connect( w, "toggled", G_CALLBACK( onScrapeToggled ), di );
2274	gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
2275
2276	w = gtk_button_new_with_mnemonic( _( "_Edit Trackers" ) );
2277	gtk_button_set_image( GTK_BUTTON( w ), gtk_image_new_from_stock( GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON ) );
2278	g_signal_connect( w, "clicked", G_CALLBACK( onEditTrackers ), di );
2279	gtk_box_pack_end( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
2280	di->edit_trackers_button = w;
2281
2282	gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
2283
2284	w = gtk_check_button_new_with_mnemonic( _( "Show _backup trackers" ) );
2285	di->all_check = w;
2286	b = pref_flag_get( PREF_KEY_SHOW_BACKUP_TRACKERS );
2287	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
2288	g_signal_connect( w, "toggled", G_CALLBACK( onBackupToggled ), di );
2289	gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
2290
2291	return vbox;
2292	}
2293
2294
2295	/****
2296	***** DIALOG
2297	****/
2298
2299	static void
2300	refresh( struct DetailsImpl * di )
2301	{
2302	int n;
2303	tr_torrent ** torrents = getTorrents( di, &n );
2304
2305	refreshInfo( di, torrents, n );
2306	refreshPeers( di, torrents, n );
2307	refreshTracker( di, torrents, n );
2308	refreshOptions( di, torrents, n );
2309
2310	if( n == 0 )
2311	gtk_dialog_response( GTK_DIALOG( di->dialog ), GTK_RESPONSE_CLOSE );
2312
2313	g_free( torrents );
2314	}
2315
2316	static gboolean
2317	periodic_refresh( gpointer data )
2318	{
2319	refresh( data );
2320	return TRUE;
2321	}
2322
2323	static void
2324	details_free( gpointer gdata )
2325	{
2326	struct DetailsImpl * data = gdata;
2327	g_source_remove( data->periodic_refresh_tag );
2328	g_hash_table_destroy( data->webseed_hash );
2329	g_hash_table_destroy( data->peer_hash );
2330	g_slist_free( data->ids );
2331	g_free( data );
2332	}
2333
2334	GtkWidget*
2335	torrent_inspector_new( GtkWindow * parent, TrCore * core )
2336	{
2337	GtkWidget * d, * n, * w, * l;
2338	struct DetailsImpl * di = g_new0( struct DetailsImpl, 1 );
2339
2340	/* create the dialog */
2341	di->core = core;
2342	d = gtk_dialog_new_with_buttons( NULL, parent, 0,
2343	GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
2344	NULL );
2345	di->dialog = d;
2346	gtk_window_set_role( GTK_WINDOW( d ), "tr-info" );
2347	g_signal_connect_swapped( d, "response",
2348	G_CALLBACK( gtk_widget_destroy ), d );
2349	gtk_dialog_set_has_separator( GTK_DIALOG( d ), FALSE );
2350	gtk_container_set_border_width( GTK_CONTAINER( d ), GUI_PAD );
2351	g_object_set_data_full( G_OBJECT( d ), DETAILS_KEY, di, details_free );
2352
2353	n = gtk_notebook_new( );
2354	gtk_container_set_border_width( GTK_CONTAINER( n ), GUI_PAD );
2355
2356	w = info_page_new( di );
2357	l = gtk_label_new( _( "Information" ) );
2358	gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, l );
2359
2360	w = peer_page_new( di );
2361	l = gtk_label_new( _( "Peers" ) );
2362	gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, l );
2363
2364	w = tracker_page_new( di );
2365	l = gtk_label_new( _( "Trackers" ) );
2366	gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, l );
2367
2368	{
2369	GtkWidget * v = gtk_vbox_new( FALSE, 0 );
2370	di->file_list = file_list_new( core, 0 );
2371	di->file_label = gtk_label_new( _( "File listing not available for combined torrent properties" ) );
2372	gtk_box_pack_start( GTK_BOX( v ), di->file_list, TRUE, TRUE, 0 );
2373	gtk_box_pack_start( GTK_BOX( v ), di->file_label, TRUE, TRUE, 0 );
2374	gtk_container_set_border_width( GTK_CONTAINER( v ), GUI_PAD_BIG );
2375	l = gtk_label_new( _( "Files" ) );
2376	gtk_notebook_append_page( GTK_NOTEBOOK( n ), v, l );
2377	}
2378
2379	w = options_page_new( di );
2380	l = gtk_label_new( _( "Options" ) );
2381	gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, l );
2382
2383	gtk_box_pack_start( GTK_BOX( GTK_DIALOG( d )->vbox ), n, TRUE, TRUE, 0 );
2384
2385	di->periodic_refresh_tag = gtr_timeout_add_seconds( SECONDARY_WINDOW_REFRESH_INTERVAL_SECONDS,
2386	periodic_refresh, di );
2387	gtk_widget_show_all( GTK_DIALOG( d )->vbox );
2388	return d;
2389	}
2390
2391	void
2392	torrent_inspector_set_torrents( GtkWidget * w, GSList * ids )
2393	{
2394	struct DetailsImpl * di = g_object_get_data( G_OBJECT( w ), DETAILS_KEY );
2395	const int len = g_slist_length( ids );
2396	char title[256];
2397
2398	g_slist_free( di->ids );
2399	di->ids = g_slist_copy( ids );
2400
2401	if( len == 1 )
2402	{
2403	const int id = GPOINTER_TO_INT( ids->data );
2404	tr_session * session = tr_core_session( di->core );
2405	tr_torrent * tor = tr_torrentFindFromId( session, id );
2406	const tr_info * inf = tr_torrentInfo( tor );
2407	g_snprintf( title, sizeof( title ), _( "%s Properties" ), inf->name );
2408
2409	file_list_set_torrent( di->file_list, id );
2410	gtk_widget_show( di->file_list );
2411	gtk_widget_hide( di->file_label );
2412	}
2413	else
2414	{
2415	file_list_clear( di->file_list );
2416	gtk_widget_hide( di->file_list );
2417	gtk_widget_show( di->file_label );
2418	g_snprintf( title, sizeof( title ), _( "%'d Torrent Properties" ), len );
2419	}
2420
2421	gtk_window_set_title( GTK_WINDOW( w ), title );
2422
2423	refresh( di );
2424	}

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

Download in other formats: