Context Navigation

source: trunk/gtk/tr-window.c @ 10536

Visit:

Last change on this file since 10536 was 10536, checked in by charles, 13 years ago
(trunk) #3174 "Use IEC standard units (KiB, MiB, GiB) instead of (KB, MB, GB)" -- implemented for gtk, qt, daemon, cli, and web client
Property svn:keywords set to `Date Rev Author Id`
File size: 31.6 KB

Line
1	/******************************************************************************
2	* $Id: tr-window.c 10536 2010-04-28 01:26:46Z charles $
3	*
4	* Copyright (c) 2005-2008 Transmission authors and contributors
5	*
6	* Permission is hereby granted, free of charge, to any person obtaining a
7	* copy of this software and associated documentation files (the "Software"),
8	* to deal in the Software without restriction, including without limitation
9	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
10	* and/or sell copies of the Software, and to permit persons to whom the
11	* Software is furnished to do so, subject to the following conditions:
12	*
13	* The above copyright notice and this permission notice shall be included in
14	* all copies or substantial portions of the Software.
15	*
16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22	* DEALINGS IN THE SOFTWARE.
23	*****************************************************************************/
24
25	#include <string.h>
26
27	#include <gtk/gtk.h>
28	#include <glib/gi18n.h>
29
30	#if !GTK_CHECK_VERSION( 2,16,0 )
31	/* FIXME: when 2.16 has been out long enough, it would be really nice to
32	* get rid of this libsexy usage because of its makefile strangeness */
33	#define USE_SEXY
34	#include "sexy-icon-entry.h"
35	#endif
36
37	#include <libtransmission/transmission.h>
38
39	#include "actions.h"
40	#include "conf.h"
41	#include "filter.h"
42	#include "hig.h"
43	#include "torrent-cell-renderer.h"
44	#include "tr-prefs.h"
45	#include "tr-torrent.h"
46	#include "tr-window.h"
47	#include "util.h"
48
49	#if !GTK_CHECK_VERSION( 2, 8, 0 )
50	static void
51	gtk_tree_view_column_queue_resize( GtkTreeViewColumn * column ) /* yuck */
52	{
53	const int spacing = gtk_tree_view_column_get_spacing( column );
54
55	gtk_tree_view_column_set_spacing( column, spacing + 1 );
56	gtk_tree_view_column_set_spacing( column, spacing );
57	}
58
59	#endif
60
61	typedef struct
62	{
63	GtkWidget * speedlimit_on_item[2];
64	GtkWidget * speedlimit_off_item[2];
65	GtkWidget * ratio_on_item;
66	GtkWidget * ratio_off_item;
67	GtkWidget * scroll;
68	GtkWidget * view;
69	GtkWidget * toolbar;
70	GtkWidget * filter;
71	GtkWidget * status;
72	GtkWidget * status_menu;
73	GtkWidget * ul_lb;
74	GtkWidget * dl_lb;
75	GtkWidget * stats_lb;
76	GtkWidget * gutter_lb;
77	GtkWidget * alt_speed_image;
78	GtkWidget * alt_speed_button;
79	GtkWidget * options_menu;
80	GtkTreeSelection * selection;
81	GtkCellRenderer * renderer;
82	GtkTreeViewColumn * column;
83	GtkTreeModel * filter_model;
84	TrCore * core;
85	gulong pref_handler_id;
86	}
87	PrivateData;
88
89	#define PRIVATE_DATA_KEY "private-data"
90
91	static PrivateData*
92	get_private_data( TrWindow * w )
93	{
94	return g_object_get_data ( G_OBJECT( w ), PRIVATE_DATA_KEY );
95	}
96
97	/***
98	****
99	***/
100
101	static void
102	on_popup_menu( GtkWidget * self UNUSED,
103	GdkEventButton * event )
104	{
105	GtkWidget * menu = action_get_widget ( "/main-window-popup" );
106
107	gtk_menu_popup ( GTK_MENU( menu ), NULL, NULL, NULL, NULL,
108	( event ? event->button : 0 ),
109	( event ? event->time : 0 ) );
110	}
111
112	static void
113	view_row_activated( GtkTreeView * tree_view UNUSED,
114	GtkTreePath * path UNUSED,
115	GtkTreeViewColumn * column UNUSED,
116	gpointer user_data UNUSED )
117	{
118	action_activate( "show-torrent-properties" );
119	}
120
121	static GtkWidget*
122	makeview( PrivateData * p )
123	{
124	GtkWidget * view;
125	GtkTreeViewColumn * col;
126	GtkTreeSelection * sel;
127	GtkCellRenderer * r;
128
129	view = gtk_tree_view_new( );
130	gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( view ), FALSE );
131	gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW( view ), TRUE );
132
133	p->selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
134
135	p->column = col = GTK_TREE_VIEW_COLUMN (g_object_new (GTK_TYPE_TREE_VIEW_COLUMN,
136	"title", _("Torrent"),
137	"resizable", TRUE,
138	"sizing", GTK_TREE_VIEW_COLUMN_FIXED,
139	NULL));
140
141	p->renderer = r = torrent_cell_renderer_new( );
142	gtk_tree_view_column_pack_start( col, r, FALSE );
143	gtk_tree_view_column_add_attribute( col, r, "torrent", MC_TORRENT_RAW );
144	gtk_tree_view_column_add_attribute( col, r, "piece-upload-speed", MC_SPEED_UP );
145	gtk_tree_view_column_add_attribute( col, r, "piece-download-speed", MC_SPEED_DOWN );
146
147	gtk_tree_view_append_column( GTK_TREE_VIEW( view ), col );
148	g_object_set( r, "xpad", GUI_PAD_SMALL, "ypad", GUI_PAD_SMALL, NULL );
149
150	gtk_tree_view_set_rules_hint( GTK_TREE_VIEW( view ), TRUE );
151	sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
152	gtk_tree_selection_set_mode( GTK_TREE_SELECTION( sel ),
153	GTK_SELECTION_MULTIPLE );
154
155	g_signal_connect( view, "popup-menu",
156	G_CALLBACK( on_popup_menu ), NULL );
157	g_signal_connect( view, "button-press-event",
158	G_CALLBACK( on_tree_view_button_pressed ),
159	(void *) on_popup_menu );
160	g_signal_connect( view, "button-release-event",
161	G_CALLBACK( on_tree_view_button_released ), NULL );
162	g_signal_connect( view, "row-activated",
163	G_CALLBACK( view_row_activated ), NULL );
164
165
166	gtk_tree_view_set_model( GTK_TREE_VIEW( view ), p->filter_model );
167
168	return view;
169	}
170
171	static void syncAltSpeedButton( PrivateData * p );
172
173	static void
174	prefsChanged( TrCore * core UNUSED,
175	const char * key,
176	gpointer wind )
177	{
178	PrivateData * p = get_private_data( GTK_WINDOW( wind ) );
179
180	if( !strcmp( key, PREF_KEY_COMPACT_VIEW ) )
181	{
182	g_object_set( p->renderer, "compact", pref_flag_get( key ), NULL );
183	/* since the cell size has changed, we need gtktreeview to revalidate
184	* its fixed-height mode values. Unfortunately there's not an API call
185	* for that, but it does revalidate when it thinks the style's been tweaked */
186	g_signal_emit_by_name( p->view, "style-set", NULL, NULL );
187	}
188	else if( !strcmp( key, PREF_KEY_STATUSBAR ) )
189	{
190	const gboolean isEnabled = pref_flag_get( key );
191	g_object_set( p->status, "visible", isEnabled, NULL );
192	}
193	else if( !strcmp( key, PREF_KEY_FILTERBAR ) )
194	{
195	const gboolean isEnabled = pref_flag_get( key );
196	g_object_set( p->filter, "visible", isEnabled, NULL );
197	}
198	else if( !strcmp( key, PREF_KEY_TOOLBAR ) )
199	{
200	const gboolean isEnabled = pref_flag_get( key );
201	g_object_set( p->toolbar, "visible", isEnabled, NULL );
202	}
203	else if( !strcmp( key, PREF_KEY_STATUSBAR_STATS ) )
204	{
205	tr_window_update( (TrWindow*)wind );
206	}
207	else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_ENABLED ) \|\|
208	!strcmp( key, TR_PREFS_KEY_ALT_SPEED_UP ) \|\|
209	!strcmp( key, TR_PREFS_KEY_ALT_SPEED_DOWN ) )
210	{
211	syncAltSpeedButton( p );
212	}
213	}
214
215	static void
216	privateFree( gpointer vprivate )
217	{
218	PrivateData * p = vprivate;
219	g_signal_handler_disconnect( p->core, p->pref_handler_id );
220	g_free( p );
221	}
222
223	static void
224	onYinYangReleased( GtkWidget * w UNUSED, gpointer vprivate )
225	{
226	PrivateData * p = vprivate;
227
228	gtk_menu_popup( GTK_MENU( p->status_menu ),
229	NULL, NULL, NULL, NULL, 0,
230	gtk_get_current_event_time( ) );
231	}
232
233	#define STATS_MODE "stats-mode"
234
235	static struct
236	{
237	const char * val, *i18n;
238	} stats_modes[] = {
239	{ "total-ratio", N_( "Total Ratio" ) },
240	{ "session-ratio", N_( "Session Ratio" ) },
241	{ "total-transfer", N_( "Total Transfer" ) },
242	{ "session-transfer", N_( "Session Transfer" ) }
243	};
244
245	static void
246	status_menu_toggled_cb( GtkCheckMenuItem * menu_item,
247	gpointer vprivate )
248	{
249	if( gtk_check_menu_item_get_active( menu_item ) )
250	{
251	PrivateData * p = vprivate;
252	const char * val = g_object_get_data( G_OBJECT(
253	menu_item ), STATS_MODE );
254	tr_core_set_pref( p->core, PREF_KEY_STATUSBAR_STATS, val );
255	}
256	}
257
258	static void
259	syncAltSpeedButton( PrivateData * p )
260	{
261	char u[32];
262	char d[32];
263	char * str;
264	const char * fmt;
265	const gboolean b = pref_flag_get( TR_PREFS_KEY_ALT_SPEED_ENABLED );
266	const char * stock = b ? "alt-speed-on" : "alt-speed-off";
267	GtkWidget * w = p->alt_speed_button;
268
269	tr_strlspeed( u, pref_int_get( TR_PREFS_KEY_ALT_SPEED_UP ), sizeof( u ) );
270	tr_strlspeed( d, pref_int_get( TR_PREFS_KEY_ALT_SPEED_DOWN ), sizeof( d ) );
271	fmt = b ? _( "Click to disable Temporary Speed Limits\n(%1$s down, %2$s up)" )
272	: _( "Click to enable Temporary Speed Limits\n(%1$s down, %2$s up)" );
273	str = g_strdup_printf( fmt, d, u );
274
275	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
276	gtk_image_set_from_stock( GTK_IMAGE( p->alt_speed_image ), stock, -1 );
277	gtk_button_set_alignment( GTK_BUTTON( w ), 0.5, 0.5 );
278	gtr_widget_set_tooltip_text( w, str );
279
280	g_free( str );
281	}
282
283	static void
284	alt_speed_toggled_cb( GtkToggleButton * button, gpointer vprivate )
285	{
286	PrivateData * p = vprivate;
287	const gboolean b = gtk_toggle_button_get_active( button );
288	tr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED, b );
289	}
290
291	/***
292	**** FILTER
293	***/
294
295	#if GTK_CHECK_VERSION( 2, 12, 0 )
296
297	static void
298	findMaxAnnounceTime( GtkTreeModel * model,
299	GtkTreePath * path UNUSED,
300	GtkTreeIter * iter,
301	gpointer gmaxTime )
302	{
303	tr_torrent * tor;
304	const tr_stat * torStat;
305	time_t * maxTime = gmaxTime;
306
307	gtk_tree_model_get( model, iter, MC_TORRENT_RAW, &tor, -1 );
308	torStat = tr_torrentStatCached( tor );
309	maxTime = MAX( maxTime, torStat->manualAnnounceTime );
310	}
311
312	static gboolean
313	onAskTrackerQueryTooltip( GtkWidget * widget UNUSED,
314	gint x UNUSED,
315	gint y UNUSED,
316	gboolean keyboard_tip UNUSED,
317	GtkTooltip * tooltip,
318	gpointer gdata )
319	{
320	const time_t now = time( NULL );
321	time_t maxTime = 0;
322	PrivateData * p = gdata;
323
324	gtk_tree_selection_selected_foreach( p->selection,
325	findMaxAnnounceTime,
326	&maxTime );
327	if( maxTime <= now )
328	{
329	return FALSE;
330	}
331	else
332	{
333	char buf[512];
334	char timebuf[64];
335	const int seconds = maxTime - now;
336
337	tr_strltime( timebuf, seconds, sizeof( timebuf ) );
338	g_snprintf( buf, sizeof( buf ),
339	_( "Tracker will allow requests in %s" ), timebuf );
340	gtk_tooltip_set_text( tooltip, buf );
341	return TRUE;
342	}
343	}
344
345	#endif
346
347	static gboolean
348	onAltSpeedToggledIdle( gpointer vp )
349	{
350	PrivateData * p = vp;
351	gboolean b = tr_sessionUsesAltSpeed( tr_core_session( p->core ) );
352	tr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED, b );
353
354	return FALSE;
355	}
356
357	static void
358	onAltSpeedToggled( tr_session * s UNUSED, tr_bool isEnabled UNUSED, tr_bool byUser UNUSED, void * p )
359	{
360	gtr_idle_add( onAltSpeedToggledIdle, p );
361	}
362
363	/***
364	**** Speed limit menu
365	***/
366
367	#define DIRECTION_KEY "direction-key"
368	#define ENABLED_KEY "enabled-key"
369	#define SPEED_KEY "speed-key"
370
371	static void
372	onSpeedToggled( GtkCheckMenuItem * check, gpointer vp )
373	{
374	PrivateData * p = vp;
375	GObject * o = G_OBJECT( check );
376	gboolean isEnabled = g_object_get_data( o, ENABLED_KEY ) != 0;
377	tr_direction dir = GPOINTER_TO_INT( g_object_get_data( o, DIRECTION_KEY ) );
378	const char * key = dir == TR_UP ? TR_PREFS_KEY_USPEED_ENABLED
379	: TR_PREFS_KEY_DSPEED_ENABLED;
380
381	if( gtk_check_menu_item_get_active( check ) )
382	tr_core_set_pref_bool( p->core, key, isEnabled );
383	}
384
385	static void
386	onSpeedSet( GtkCheckMenuItem * check, gpointer vp )
387	{
388	const char * key;
389	PrivateData * p = vp;
390	GObject * o = G_OBJECT( check );
391	const int speed = GPOINTER_TO_INT( g_object_get_data( o, SPEED_KEY ) );
392	tr_direction dir = GPOINTER_TO_INT( g_object_get_data( o, DIRECTION_KEY ) );
393
394	key = dir==TR_UP ? TR_PREFS_KEY_USPEED : TR_PREFS_KEY_DSPEED;
395	tr_core_set_pref_int( p->core, key, speed );
396
397	key = dir==TR_UP ? TR_PREFS_KEY_USPEED_ENABLED : TR_PREFS_KEY_DSPEED_ENABLED;
398	tr_core_set_pref_bool( p->core, key, TRUE );
399	}
400
401	static GtkWidget*
402	createSpeedMenu( PrivateData * p, tr_direction dir )
403	{
404	int i, n;
405	GtkWidget w, m;
406	const int speeds[] = { 5, 10, 20, 30, 40, 50, 75, 100, 150, 200, 250, 500, 750 };
407
408	m = gtk_menu_new( );
409
410	w = gtk_radio_menu_item_new_with_label( NULL, _( "Unlimited" ) );
411	p->speedlimit_off_item[dir] = w;
412	g_object_set_data( G_OBJECT( w ), DIRECTION_KEY, GINT_TO_POINTER( dir ) );
413	g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( FALSE ) );
414	g_signal_connect( w, "toggled", G_CALLBACK(onSpeedToggled), p );
415	gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
416
417	w = gtk_radio_menu_item_new_with_label_from_widget( GTK_RADIO_MENU_ITEM( w ), "" );
418	p->speedlimit_on_item[dir] = w;
419	g_object_set_data( G_OBJECT( w ), DIRECTION_KEY, GINT_TO_POINTER( dir ) );
420	g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( TRUE ) );
421	g_signal_connect( w, "toggled", G_CALLBACK(onSpeedToggled), p );
422	gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
423
424	w = gtk_separator_menu_item_new( );
425	gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
426
427	for( i=0, n=G_N_ELEMENTS(speeds); i<n; ++i )
428	{
429	char buf[128];
430	tr_strlspeed( buf, speeds[i], sizeof( buf ) );
431	w = gtk_menu_item_new_with_label( buf );
432	g_object_set_data( G_OBJECT( w ), DIRECTION_KEY, GINT_TO_POINTER( dir ) );
433	g_object_set_data( G_OBJECT( w ), SPEED_KEY, GINT_TO_POINTER( speeds[i] ) );
434	g_signal_connect( w, "activate", G_CALLBACK(onSpeedSet), p );
435	gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
436	}
437
438	return m;
439	}
440
441	/***
442	**** Speed limit menu
443	***/
444
445	#define RATIO_KEY "stock-ratio-index"
446
447	static const double stockRatios[] = { 0.25, 0.5, 0.75, 1, 1.5, 2, 3 };
448
449	static void
450	onRatioToggled( GtkCheckMenuItem * check, gpointer vp )
451	{
452	PrivateData * p = vp;
453	if( gtk_check_menu_item_get_active( check ) )
454	{
455	gboolean f = g_object_get_data( G_OBJECT( check ), ENABLED_KEY ) != 0;
456	tr_core_set_pref_bool( p->core, TR_PREFS_KEY_RATIO_ENABLED, f );
457	}
458	}
459	static void
460	onRatioSet( GtkCheckMenuItem * check, gpointer vp )
461	{
462	PrivateData * p = vp;
463	int i = GPOINTER_TO_INT( g_object_get_data( G_OBJECT( check ), RATIO_KEY ) );
464	const double ratio = stockRatios[i];
465	tr_core_set_pref_double( p->core, TR_PREFS_KEY_RATIO, ratio );
466	tr_core_set_pref_bool ( p->core, TR_PREFS_KEY_RATIO_ENABLED, TRUE );
467	}
468
469	static GtkWidget*
470	createRatioMenu( PrivateData * p )
471	{
472	int i, n;
473	GtkWidget m, w;
474
475	m = gtk_menu_new( );
476
477	w = gtk_radio_menu_item_new_with_label( NULL, _( "Seed Forever" ) );
478	p->ratio_off_item = w;
479	g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( FALSE ) );
480	g_signal_connect( w, "toggled", G_CALLBACK(onRatioToggled), p );
481	gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
482
483	w = gtk_radio_menu_item_new_with_label_from_widget( GTK_RADIO_MENU_ITEM( w ), "" );
484	p->ratio_on_item = w;
485	g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( TRUE ) );
486	g_signal_connect( w, "toggled", G_CALLBACK(onRatioToggled), p );
487	gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
488
489	w = gtk_separator_menu_item_new( );
490	gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
491
492	for( i=0, n=G_N_ELEMENTS(stockRatios); i<n; ++i )
493	{
494	char buf[128];
495	tr_strlratio( buf, stockRatios[i], sizeof( buf ) );
496	w = gtk_menu_item_new_with_label( buf );
497	g_object_set_data( G_OBJECT( w ), RATIO_KEY, GINT_TO_POINTER( i ) );
498	g_signal_connect( w, "activate", G_CALLBACK(onRatioSet), p );
499	gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
500	}
501
502	return m;
503	}
504
505	/***
506	**** Option menu
507	***/
508
509	static GtkWidget*
510	createOptionsMenu( PrivateData * p )
511	{
512	GtkWidget * m;
513	GtkWidget * top = gtk_menu_new( );
514
515	m = gtk_menu_item_new_with_label( _( "Limit Download Speed" ) );
516	gtk_menu_item_set_submenu( GTK_MENU_ITEM( m ), createSpeedMenu( p, TR_DOWN ) );
517	gtk_menu_shell_append( GTK_MENU_SHELL( top ), m );
518
519	m = gtk_menu_item_new_with_label( _( "Limit Upload Speed" ) );
520	gtk_menu_item_set_submenu( GTK_MENU_ITEM( m ), createSpeedMenu( p, TR_UP ) );
521	gtk_menu_shell_append( GTK_MENU_SHELL( top ), m );
522
523	m = gtk_separator_menu_item_new( );
524	gtk_menu_shell_append( GTK_MENU_SHELL( top ), m );
525
526	m = gtk_menu_item_new_with_label( _( "Stop Seeding at Ratio" ) );
527	gtk_menu_item_set_submenu( GTK_MENU_ITEM( m ), createRatioMenu( p ) );
528	gtk_menu_shell_append( GTK_MENU_SHELL( top ), m );
529
530	gtk_widget_show_all( top );
531	return top;
532	}
533
534	static void
535	onOptionsClicked( GtkButton * button UNUSED, gpointer vp )
536	{
537	char buf1[512];
538	char buf2[512];
539	gboolean b;
540	GtkWidget * w;
541	PrivateData * p = vp;
542
543	w = p->speedlimit_on_item[TR_DOWN];
544	tr_strlspeed( buf1, pref_int_get( TR_PREFS_KEY_DSPEED ), sizeof( buf1 ) );
545	gtk_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( w ) ) ), buf1 );
546
547	b = pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED );
548	w = b ? p->speedlimit_on_item[TR_DOWN] : p->speedlimit_off_item[TR_DOWN];
549	gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ), TRUE );
550
551	w = p->speedlimit_on_item[TR_UP];
552	tr_strlspeed( buf1, pref_int_get( TR_PREFS_KEY_USPEED ), sizeof( buf1 ) );
553	gtk_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( w ) ) ), buf1 );
554
555	b = pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED );
556	w = b ? p->speedlimit_on_item[TR_UP] : p->speedlimit_off_item[TR_UP];
557	gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ), TRUE );
558
559	tr_strlratio( buf1, pref_double_get( TR_PREFS_KEY_RATIO ), sizeof( buf1 ) );
560	g_snprintf( buf2, sizeof( buf2 ), _( "Stop at Ratio (%s)" ), buf1 );
561	gtk_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( p->ratio_on_item ) ) ), buf2 );
562
563	b = pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED );
564	gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( b ? p->ratio_on_item : p->ratio_off_item ), TRUE );
565
566	gtk_menu_popup ( GTK_MENU( p->options_menu ), NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time( ) );
567	}
568
569	/***
570	**** PUBLIC
571	***/
572
573	GtkWidget *
574	tr_window_new( GtkUIManager * ui_mgr, TrCore * core )
575	{
576	int i, n;
577	const char * pch;
578	PrivateData * p;
579	GtkWidget * mainmenu, toolbar, filter, list, status;
580	GtkWidget * vbox, w, self, h, hbox, *menu;
581	GtkWindow * win;
582	GSList * l;
583
584	p = g_new0( PrivateData, 1 );
585
586	/* make the window */
587	self = gtk_window_new ( GTK_WINDOW_TOPLEVEL );
588	g_object_set_data_full( G_OBJECT(
589	self ), PRIVATE_DATA_KEY, p, privateFree );
590	win = GTK_WINDOW( self );
591	gtk_window_set_title( win, g_get_application_name( ) );
592	gtk_window_set_role( win, "tr-main" );
593	gtk_window_set_default_size( win,
594	pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
595	pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
596	gtk_window_move( win, pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
597	pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
598	if( pref_flag_get( PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED ) )
599	gtk_window_maximize( win );
600	gtk_window_add_accel_group( win, gtk_ui_manager_get_accel_group( ui_mgr ) );
601
602	/* window's main container */
603	vbox = gtk_vbox_new ( FALSE, 0 );
604	gtk_container_add ( GTK_CONTAINER( self ), vbox );
605
606	/* main menu */
607	mainmenu = action_get_widget( "/main-window-menu" );
608	w = action_get_widget( "/main-window-menu/torrent-menu/update-tracker" );
609	#if GTK_CHECK_VERSION( 2, 12, 0 )
610	g_signal_connect( w, "query-tooltip",
611	G_CALLBACK( onAskTrackerQueryTooltip ), p );
612	#endif
613
614	/* toolbar */
615	toolbar = p->toolbar = action_get_widget( "/main-window-toolbar" );
616	action_set_important( "add-torrent-toolbar", TRUE );
617	action_set_important( "show-torrent-properties", TRUE );
618
619	/* filter */
620	h = filter = p->filter = gtr_filter_bar_new( tr_core_session( core ),
621	tr_core_model( core ),
622	&p->filter_model );
623	gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
624
625	/* status menu */
626	menu = p->status_menu = gtk_menu_new( );
627	l = NULL;
628	pch = pref_string_get( PREF_KEY_STATUSBAR_STATS );
629	for( i = 0, n = G_N_ELEMENTS( stats_modes ); i < n; ++i )
630	{
631	const char * val = stats_modes[i].val;
632	w = gtk_radio_menu_item_new_with_label( l, _( stats_modes[i].i18n ) );
633	l = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM( w ) );
634	gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ),
635	!strcmp( val, pch ) );
636	g_object_set_data( G_OBJECT(
637	w ), STATS_MODE,
638	(gpointer)stats_modes[i].val );
639	g_signal_connect( w, "toggled", G_CALLBACK(
640	status_menu_toggled_cb ), p );
641	gtk_menu_shell_append( GTK_MENU_SHELL( menu ), w );
642	gtk_widget_show( w );
643	}
644
645	/* status */
646	h = status = p->status = gtk_hbox_new( FALSE, GUI_PAD );
647	gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
648
649	w = gtk_button_new( );
650	gtk_container_add( GTK_CONTAINER( w ), gtk_image_new_from_stock( "options", GTK_ICON_SIZE_SMALL_TOOLBAR ) );
651	gtr_widget_set_tooltip_text( w, _( "Options" ) );
652	gtk_box_pack_start( GTK_BOX( h ), w, 0, 0, 0 );
653	gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
654	p->options_menu = createOptionsMenu( p );
655	g_signal_connect( w, "clicked", G_CALLBACK(onOptionsClicked), p );
656
657	p->alt_speed_image = gtk_image_new( );
658	w = p->alt_speed_button = gtk_toggle_button_new( );
659	gtk_button_set_image( GTK_BUTTON( w ), p->alt_speed_image );
660	gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
661	g_signal_connect( w, "toggled", G_CALLBACK(alt_speed_toggled_cb ), p );
662	gtk_box_pack_start( GTK_BOX( h ), w, 0, 0, 0 );
663
664	w = p->gutter_lb = gtk_label_new( "N Torrents" );
665	gtk_box_pack_start( GTK_BOX( h ), w, 1, 1, GUI_PAD_BIG );
666
667	hbox = gtk_hbox_new( FALSE, GUI_PAD_SMALL );
668	w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
669	gtk_widget_set_size_request( w, GUI_PAD, 0u );
670	gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
671	w = gtk_image_new_from_stock( GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU );
672	gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
673	w = p->ul_lb = gtk_label_new( NULL );
674	gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
675	gtk_box_pack_end( GTK_BOX( h ), hbox, FALSE, FALSE, 0 );
676
677	hbox = gtk_hbox_new( FALSE, GUI_PAD_SMALL );
678	w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
679	gtk_widget_set_size_request( w, GUI_PAD, 0u );
680	gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
681	w = gtk_image_new_from_stock( GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU );
682	gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
683	w = p->dl_lb = gtk_label_new( NULL );
684	gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
685	gtk_box_pack_end( GTK_BOX( h ), hbox, FALSE, FALSE, 0 );
686
687	hbox = gtk_hbox_new( FALSE, GUI_PAD_SMALL );
688	w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
689	gtk_widget_set_size_request( w, GUI_PAD, 0u );
690	gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
691	w = gtk_button_new( );
692	gtr_widget_set_tooltip_text( w, _( "Statistics" ) );
693	gtk_container_add( GTK_CONTAINER( w ), gtk_image_new_from_stock( "ratio", GTK_ICON_SIZE_SMALL_TOOLBAR ) );
694	gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
695	g_signal_connect( w, "clicked", G_CALLBACK( onYinYangReleased ), p );
696	gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
697	w = p->stats_lb = gtk_label_new( NULL );
698	gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
699	gtk_box_pack_end( GTK_BOX( h ), hbox, FALSE, FALSE, 0 );
700
701
702	/* workarea */
703	p->view = makeview( p );
704	w = list = p->scroll = gtk_scrolled_window_new( NULL, NULL );
705	gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ),
706	GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
707	gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ),
708	GTK_SHADOW_IN );
709	gtk_container_add( GTK_CONTAINER( w ), p->view );
710
711	/* layout the widgets */
712	{
713	const char * str = pref_string_get( PREF_KEY_MAIN_WINDOW_LAYOUT_ORDER );
714	char ** tokens = g_strsplit( str, ",", -1 );
715	for( i=0; tokens && tokens[i]; ++i )
716	{
717	const char * key = tokens[i];
718
719	if( !strcmp( key, "menu" ) )
720	gtk_box_pack_start( GTK_BOX( vbox ), mainmenu, FALSE, FALSE, 0 );
721	else if( !strcmp( key, "toolbar" ) )
722	gtk_box_pack_start( GTK_BOX( vbox ), toolbar, FALSE, FALSE, 0 );
723	else if( !strcmp( key, "filter" ) )
724	gtk_box_pack_start( GTK_BOX( vbox ), filter, FALSE, FALSE, 0 );
725	else if( !strcmp( key, "list" ) )
726	gtk_box_pack_start( GTK_BOX( vbox ), list, TRUE, TRUE, 0 );
727	else if( !strcmp( key, "statusbar" ) )
728	gtk_box_pack_start( GTK_BOX( vbox ), status, FALSE, FALSE, 0 );
729	}
730	g_strfreev( tokens );
731	}
732
733	{
734	int w=0, h=0;
735	/* this is to determine the maximum width/height for the label */
736	PangoLayout * pango_layout =
737	gtk_widget_create_pango_layout( p->ul_lb, _( "999.9 KiB/s" ) );
738	pango_layout_get_pixel_size( pango_layout, &w, &h );
739	gtk_widget_set_size_request( p->ul_lb, w, h );
740	gtk_widget_set_size_request( p->dl_lb, w, h );
741	gtk_misc_set_alignment( GTK_MISC( p->ul_lb ), 1.0, 0.5 );
742	gtk_misc_set_alignment( GTK_MISC( p->dl_lb ), 1.0, 0.5 );
743	g_object_unref( G_OBJECT( pango_layout ) );
744	}
745
746	/* show all but the window */
747	gtk_widget_show_all( vbox );
748
749	/* listen for prefs changes that affect the window */
750	p->core = core;
751	prefsChanged( core, PREF_KEY_COMPACT_VIEW, self );
752	prefsChanged( core, PREF_KEY_FILTERBAR, self );
753	prefsChanged( core, PREF_KEY_STATUSBAR, self );
754	prefsChanged( core, PREF_KEY_STATUSBAR_STATS, self );
755	prefsChanged( core, PREF_KEY_TOOLBAR, self );
756	prefsChanged( core, PREF_KEY_FILTER_MODE, self );
757	prefsChanged( core, TR_PREFS_KEY_ALT_SPEED_ENABLED, self );
758	p->pref_handler_id = g_signal_connect( core, "prefs-changed",
759	G_CALLBACK( prefsChanged ), self );
760
761	tr_sessionSetAltSpeedFunc( tr_core_session( core ), onAltSpeedToggled, p );
762
763	return self;
764	}
765
766	static void
767	updateTorrentCount( PrivateData * p )
768	{
769	if( p && p->core )
770	{
771	char buf[512];
772	const int torrentCount = gtk_tree_model_iter_n_children(
773	tr_core_model( p->core ), NULL );
774	const int visibleCount = gtk_tree_model_iter_n_children(
775	p->filter_model, NULL );
776
777	if( !torrentCount )
778	*buf = '\0';
779	else if( torrentCount != visibleCount )
780	g_snprintf( buf, sizeof( buf ),
781	ngettext( "%1$'d of %2$'d Torrent",
782	"%1$'d of %2$'d Torrents",
783	torrentCount ),
784	visibleCount, torrentCount );
785	else
786	g_snprintf( buf, sizeof( buf ),
787	ngettext( "%'d Torrent", "%'d Torrents", torrentCount ),
788	torrentCount );
789	gtk_label_set_text( GTK_LABEL( p->gutter_lb ), buf );
790	}
791	}
792
793	static void
794	updateStats( PrivateData * p )
795	{
796	const char * pch;
797	char up[32], down[32], ratio[32], buf[512];
798	struct tr_session_stats stats;
799	tr_session * session = tr_core_session( p->core );
800
801	/* update the stats */
802	pch = pref_string_get( PREF_KEY_STATUSBAR_STATS );
803	if( !strcmp( pch, "session-ratio" ) )
804	{
805	tr_sessionGetStats( session, &stats );
806	tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
807	g_snprintf( buf, sizeof( buf ), _( "Ratio: %s" ), ratio );
808	}
809	else if( !strcmp( pch, "session-transfer" ) )
810	{
811	tr_sessionGetStats( session, &stats );
812	tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
813	tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
814	/* Translators: "size\|" is here for disambiguation. Please remove it from your translation.
815	%1$s is the size of the data we've downloaded
816	%2$s is the size of the data we've uploaded */
817	g_snprintf( buf, sizeof( buf ), Q_(
818	"size\|Down: %1$s, Up: %2$s" ), down, up );
819	}
820	else if( !strcmp( pch, "total-transfer" ) )
821	{
822	tr_sessionGetCumulativeStats( session, &stats );
823	tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
824	tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
825	/* Translators: "size\|" is here for disambiguation. Please remove it from your translation.
826	%1$s is the size of the data we've downloaded
827	%2$s is the size of the data we've uploaded */
828	g_snprintf( buf, sizeof( buf ), Q_(
829	"size\|Down: %1$s, Up: %2$s" ), down, up );
830	}
831	else /* default is total-ratio */
832	{
833	tr_sessionGetCumulativeStats( session, &stats );
834	tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
835	g_snprintf( buf, sizeof( buf ), _( "Ratio: %s" ), ratio );
836	}
837	gtk_label_set_text( GTK_LABEL( p->stats_lb ), buf );
838	}
839
840	static void
841	updateSpeeds( PrivateData * p )
842	{
843	tr_session * session = tr_core_session( p->core );
844
845	if( session != NULL )
846	{
847	char buf[128];
848	double up=0, down=0;
849	GtkTreeIter iter;
850	GtkTreeModel * model = tr_core_model( p->core );
851
852	if( gtk_tree_model_get_iter_first( model, &iter ) ) do
853	{
854	double u, d;
855	gtk_tree_model_get( model, &iter, MC_SPEED_UP, &u,
856	MC_SPEED_DOWN, &d,
857	-1 );
858	up += u;
859	down += d;
860	}
861	while( gtk_tree_model_iter_next( model, &iter ) );
862
863	tr_strlspeed( buf, down, sizeof( buf ) );
864	gtk_label_set_text( GTK_LABEL( p->dl_lb ), buf );
865
866	tr_strlspeed( buf, up, sizeof( buf ) );
867	gtk_label_set_text( GTK_LABEL( p->ul_lb ), buf );
868	}
869	}
870
871	void
872	tr_window_update( TrWindow * self )
873	{
874	PrivateData * p = get_private_data( self );
875
876	if( p && p->core && tr_core_session( p->core ) )
877	{
878	updateSpeeds( p );
879	updateTorrentCount( p );
880	updateStats( p );
881	gtk_tree_model_filter_refilter( GTK_TREE_MODEL_FILTER( p->filter_model ) );
882	}
883	}
884
885	GtkTreeSelection*
886	tr_window_get_selection( TrWindow * w )
887	{
888	return get_private_data( w )->selection;
889	}
890

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

Download in other formats: