Context Navigation

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

Visit:

Last change on this file since 8173 was 8173, checked in by charles, 14 years ago
(gtk) don't stretch the turtle icon in the prefs dialog.
Property svn:keywords set to `Date Rev Author Id`
File size: 29.7 KB

Line
1	/******************************************************************************
2	* $Id: tr-window.c 8173 2009-04-07 04:42:50Z 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	#include <libtransmission/transmission.h>
31
32	#include "actions.h"
33	#include "conf.h"
34	#include "hig.h"
35	#include "sexy-icon-entry.h"
36	#include "torrent-cell-renderer.h"
37	#include "tr-prefs.h"
38	#include "tr-torrent.h"
39	#include "tr-window.h"
40	#include "util.h"
41
42	#if !GTK_CHECK_VERSION( 2, 8, 0 )
43	static void
44	gtk_tree_view_column_queue_resize( GtkTreeViewColumn * column ) /* yuck */
45	{
46	const int spacing = gtk_tree_view_column_get_spacing( column );
47
48	gtk_tree_view_column_set_spacing( column, spacing + 1 );
49	gtk_tree_view_column_set_spacing( column, spacing );
50	}
51
52	#endif
53
54	typedef enum
55	{
56	FILTER_TEXT_MODE_NAME,
57	FILTER_TEXT_MODE_FILES,
58	FILTER_TEXT_MODE_TRACKER,
59	FILTER_TEXT_MODE_QTY
60	}
61	filter_text_mode_t;
62
63	typedef enum
64	{
65	FILTER_MODE_ALL,
66	FILTER_MODE_ACTIVE,
67	FILTER_MODE_DOWNLOADING,
68	FILTER_MODE_SEEDING,
69	FILTER_MODE_PAUSED,
70	FILTER_MODE_QTY
71	}
72	filter_mode_t;
73
74	typedef struct
75	{
76	GtkWidget * scroll;
77	GtkWidget * view;
78	GtkWidget * toolbar;
79	GtkWidget * filter;
80	GtkWidget * status;
81	GtkWidget * status_menu;
82	GtkWidget * ul_lb;
83	GtkWidget * dl_lb;
84	GtkWidget * stats_lb;
85	GtkWidget * gutter_lb;
86	GtkWidget * alt_speed_image[2]; /* 0==off, 1==on */
87	GtkWidget * alt_speed_button;
88	GtkTreeSelection * selection;
89	GtkCellRenderer * renderer;
90	GtkTreeViewColumn * column;
91	GtkTreeModel * filter_model;
92	TrCore * core;
93	gulong pref_handler_id;
94	filter_mode_t filter_mode;
95	filter_text_mode_t filter_text_mode;
96	char * filter_text;
97	}
98	PrivateData;
99
100	#define PRIVATE_DATA_KEY "private-data"
101
102	#define FILTER_MODE_KEY "tr-filter-mode"
103	#define FILTER_TEXT_MODE_KEY "tr-filter-text-mode"
104	#define FILTER_TOGGLES_KEY "tr-filter-toggles"
105
106	static PrivateData*
107	get_private_data( TrWindow * w )
108	{
109	return g_object_get_data ( G_OBJECT( w ), PRIVATE_DATA_KEY );
110	}
111
112	/***
113	****
114	***/
115
116	static void
117	on_popup_menu( GtkWidget * self UNUSED,
118	GdkEventButton * event )
119	{
120	GtkWidget * menu = action_get_widget ( "/main-window-popup" );
121
122	gtk_menu_popup ( GTK_MENU( menu ), NULL, NULL, NULL, NULL,
123	( event ? event->button : 0 ),
124	( event ? event->time : 0 ) );
125	}
126
127	static void
128	view_row_activated( GtkTreeView * tree_view UNUSED,
129	GtkTreePath * path UNUSED,
130	GtkTreeViewColumn * column UNUSED,
131	gpointer user_data UNUSED )
132	{
133	action_activate( "show-torrent-properties" );
134	}
135
136	static gboolean is_row_visible( GtkTreeModel *,
137	GtkTreeIter *,
138	gpointer );
139
140	static GtkWidget*
141	makeview( PrivateData * p,
142	TrCore * core )
143	{
144	GtkWidget * view;
145	GtkTreeViewColumn * col;
146	GtkTreeSelection * sel;
147	GtkCellRenderer * r;
148	GtkTreeModel * filter_model;
149
150	view = gtk_tree_view_new( );
151	gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( view ), FALSE );
152	gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW( view ), TRUE );
153
154	p->selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
155
156	p->column = col = GTK_TREE_VIEW_COLUMN (g_object_new (GTK_TYPE_TREE_VIEW_COLUMN,
157	"title", _("Torrent"),
158	"resizable", TRUE,
159	"sizing", GTK_TREE_VIEW_COLUMN_FIXED,
160	NULL));
161
162	p->renderer = r = torrent_cell_renderer_new( );
163	gtk_tree_view_column_pack_start( col, r, FALSE );
164	gtk_tree_view_column_add_attribute( col, r, "torrent", MC_TORRENT_RAW );
165
166	gtk_tree_view_append_column( GTK_TREE_VIEW( view ), col );
167	g_object_set( r, "xpad", GUI_PAD_SMALL, "ypad", GUI_PAD_SMALL, NULL );
168
169	gtk_tree_view_set_rules_hint( GTK_TREE_VIEW( view ), TRUE );
170	sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
171	gtk_tree_selection_set_mode( GTK_TREE_SELECTION( sel ),
172	GTK_SELECTION_MULTIPLE );
173
174	g_signal_connect( view, "popup-menu",
175	G_CALLBACK( on_popup_menu ), NULL );
176	g_signal_connect( view, "button-press-event",
177	G_CALLBACK( on_tree_view_button_pressed ),
178	(void *) on_popup_menu );
179	g_signal_connect( view, "button-release-event",
180	G_CALLBACK( on_tree_view_button_released ), NULL );
181	g_signal_connect( view, "row-activated",
182	G_CALLBACK( view_row_activated ), NULL );
183
184
185	filter_model = p->filter_model = gtk_tree_model_filter_new(
186	tr_core_model( core ), NULL );
187
188	gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER(
189	filter_model ),
190	is_row_visible,
191	p, NULL );
192
193	gtk_tree_view_set_model( GTK_TREE_VIEW( view ), filter_model );
194
195	return view;
196	}
197
198	static void syncAltSpeedButton( PrivateData * p );
199
200	static void
201	prefsChanged( TrCore * core UNUSED,
202	const char * key,
203	gpointer wind )
204	{
205	PrivateData * p = get_private_data( GTK_WINDOW( wind ) );
206
207	if( !strcmp( key, PREF_KEY_MINIMAL_VIEW ) )
208	{
209	g_object_set( p->renderer, "minimal", pref_flag_get( key ), NULL );
210	/* since the cell size has changed, we need gtktreeview to revalidate
211	* its fixed-height mode values. Unfortunately there's not an API call
212	* for that, but it does revalidate when it thinks the style's been tweaked */
213	g_signal_emit_by_name( p->view, "style-set", NULL, NULL );
214	}
215	else if( !strcmp( key, PREF_KEY_STATUSBAR ) )
216	{
217	const gboolean isEnabled = pref_flag_get( key );
218	g_object_set( p->status, "visible", isEnabled, NULL );
219	}
220	else if( !strcmp( key, PREF_KEY_FILTERBAR ) )
221	{
222	const gboolean isEnabled = pref_flag_get( key );
223	g_object_set( p->filter, "visible", isEnabled, NULL );
224	}
225	else if( !strcmp( key, PREF_KEY_TOOLBAR ) )
226	{
227	const gboolean isEnabled = pref_flag_get( key );
228	g_object_set( p->toolbar, "visible", isEnabled, NULL );
229	}
230	else if( !strcmp( key, PREF_KEY_STATUSBAR_STATS ) )
231	{
232	tr_window_update( (TrWindow*)wind );
233	}
234	else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_ENABLED ) )
235	{
236	syncAltSpeedButton( p );
237	}
238	}
239
240	static void
241	privateFree( gpointer vprivate )
242	{
243	PrivateData * p = vprivate;
244
245	g_signal_handler_disconnect( p->core, p->pref_handler_id );
246	g_free( p->filter_text );
247	g_free( p );
248	}
249
250	static void
251	onYinYangReleased( GtkWidget * w UNUSED,
252	GdkEventButton * button UNUSED,
253	gpointer vprivate )
254	{
255	PrivateData * p = vprivate;
256
257	gtk_menu_popup( GTK_MENU(
258	p->status_menu ), NULL, NULL, NULL, NULL, 0,
259	gtk_get_current_event_time( ) );
260	}
261
262	#define STATS_MODE "stats-mode"
263
264	static struct
265	{
266	const char * val, *i18n;
267	} stats_modes[] = {
268	{ "total-ratio", N_( "Total Ratio" ) },
269	{ "session-ratio", N_( "Session Ratio" ) },
270	{ "total-transfer", N_( "Total Transfer" ) },
271	{ "session-transfer", N_( "Session Transfer" ) }
272	};
273
274	static void
275	status_menu_toggled_cb( GtkCheckMenuItem * menu_item,
276	gpointer vprivate )
277	{
278	if( gtk_check_menu_item_get_active( menu_item ) )
279	{
280	PrivateData * p = vprivate;
281	const char * val = g_object_get_data( G_OBJECT(
282	menu_item ), STATS_MODE );
283	tr_core_set_pref( p->core, PREF_KEY_STATUSBAR_STATS, val );
284	}
285	}
286
287	static void
288	syncAltSpeedButton( PrivateData * p )
289	{
290	const char * tip;
291	const gboolean b = pref_flag_get( TR_PREFS_KEY_ALT_SPEED_ENABLED );
292	GtkWidget * w = p->alt_speed_button;
293
294	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
295
296	gtk_button_set_image( GTK_BUTTON( w ), p->alt_speed_image[b?1:0] );
297	gtk_button_set_alignment( GTK_BUTTON( w ), 0.5, 0.5 );
298
299	tip = b ? _( "Click to disable Speed Limit Mode" )
300	: _( "Click to enable Speed Limit Mode" );
301	gtr_widget_set_tooltip_text( w, tip );
302	}
303
304	static void
305	alt_speed_toggled_cb( GtkToggleButton * button, gpointer vprivate )
306	{
307	PrivateData * p = vprivate;
308	const gboolean b = gtk_toggle_button_get_active( button );
309	tr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED, b );
310	}
311
312	/***
313	**** FILTER
314	***/
315
316	static int
317	checkFilterText( filter_text_mode_t filter_text_mode,
318	const tr_info * torInfo,
319	const char * text )
320	{
321	tr_file_index_t i;
322	int ret = 0;
323	char * pch;
324
325	switch( filter_text_mode )
326	{
327	case FILTER_TEXT_MODE_FILES:
328	for( i = 0; i < torInfo->fileCount && !ret; ++i )
329	{
330	pch = g_utf8_casefold( torInfo->files[i].name, -1 );
331	ret = !text \|\| strstr( pch, text ) != NULL;
332	g_free( pch );
333	}
334	break;
335
336	case FILTER_TEXT_MODE_TRACKER:
337	pch = g_utf8_casefold( torInfo->trackers[0].announce, -1 );
338	ret = !text \|\| ( strstr( pch, text ) != NULL );
339	g_free( pch );
340	break;
341
342	default: /* NAME */
343	pch = g_utf8_casefold( torInfo->name, -1 );
344	ret = !text \|\| ( strstr( pch, text ) != NULL );
345	g_free( pch );
346	break;
347	}
348
349	return ret;
350	}
351
352	static int
353	checkFilterMode( filter_mode_t filter_mode,
354	tr_torrent * tor )
355	{
356	int ret = 0;
357
358	switch( filter_mode )
359	{
360	case FILTER_MODE_DOWNLOADING:
361	ret = tr_torrentGetActivity( tor ) == TR_STATUS_DOWNLOAD;
362	break;
363
364	case FILTER_MODE_SEEDING:
365	ret = tr_torrentGetActivity( tor ) == TR_STATUS_SEED;
366	break;
367
368	case FILTER_MODE_PAUSED:
369	ret = tr_torrentGetActivity( tor ) == TR_STATUS_STOPPED;
370	break;
371
372	case FILTER_MODE_ACTIVE:
373	{
374	const tr_stat * s = tr_torrentStatCached( tor );
375	ret = s->peersSendingToUs > 0 \|\| s->peersGettingFromUs > 0;
376	break;
377	}
378
379	default: /* all */
380	ret = 1;
381	}
382
383	return ret;
384	}
385
386	static gboolean
387	is_row_visible( GtkTreeModel * model,
388	GtkTreeIter * iter,
389	gpointer vprivate )
390	{
391	PrivateData * p = vprivate;
392	tr_torrent * tor;
393
394	gtk_tree_model_get( model, iter, MC_TORRENT_RAW, &tor, -1 );
395
396	return checkFilterMode( p->filter_mode, tor )
397	&& checkFilterText( p->filter_text_mode, tr_torrentInfo( tor ), p->filter_text );
398	}
399
400	static void updateTorrentCount( PrivateData * p );
401
402	static void
403	refilter( PrivateData * p )
404	{
405	gtk_tree_model_filter_refilter( GTK_TREE_MODEL_FILTER( p->filter_model ) );
406
407	updateTorrentCount( p );
408	}
409
410	static void
411	filter_text_toggled_cb( GtkCheckMenuItem * menu_item,
412	gpointer vprivate )
413	{
414	if( gtk_check_menu_item_get_active( menu_item ) )
415	{
416	PrivateData * p = vprivate;
417	p->filter_text_mode =
418	GPOINTER_TO_UINT( g_object_get_data( G_OBJECT( menu_item ),
419	FILTER_TEXT_MODE_KEY ) );
420	refilter( p );
421	}
422	}
423
424	static void
425	filter_toggled_cb( GtkToggleButton * toggle,
426	gpointer vprivate )
427	{
428	PrivateData * p = vprivate;
429	GSList * l;
430	GSList * toggles = g_object_get_data( G_OBJECT(
431	toggle ),
432	FILTER_TOGGLES_KEY );
433	const gboolean isActive = gtk_toggle_button_get_active( toggle );
434	const filter_mode_t mode =
435	GPOINTER_TO_UINT( g_object_get_data( G_OBJECT( toggle ),
436	FILTER_MODE_KEY ) );
437
438	/* update the filter */
439	if( isActive )
440	{
441	p->filter_mode = mode;
442	refilter( p );
443	}
444
445	/* deactivate the other toggles */
446	for( l = toggles; l != NULL; l = l->next )
447	{
448	GtkToggleButton * walk = GTK_TOGGLE_BUTTON( l->data );
449	if( isActive && ( toggle != walk ) )
450	gtk_toggle_button_set_active( walk, FALSE );
451	}
452
453	/* at least one button must always be set */
454	if( !isActive && ( p->filter_mode == mode ) )
455	gtk_toggle_button_set_active( toggle, TRUE );
456	}
457
458	static void
459	filter_entry_changed( GtkEditable * e,
460	gpointer vprivate )
461	{
462	char * pch;
463	PrivateData * p = vprivate;
464
465	pch = gtk_editable_get_chars( e, 0, -1 );
466	g_free( p->filter_text );
467	p->filter_text = g_utf8_casefold( pch, -1 );
468	refilter( p );
469	g_free( pch );
470	}
471
472	static void
473	entry_icon_released( SexyIconEntry * entry UNUSED,
474	SexyIconEntryPosition icon_pos,
475	int button UNUSED,
476	gpointer menu )
477	{
478	if( icon_pos == SEXY_ICON_ENTRY_PRIMARY )
479	gtk_menu_popup ( GTK_MENU(
480	menu ), NULL, NULL, NULL, NULL, 0,
481	gtk_get_current_event_time( ) );
482	}
483
484	#if GTK_CHECK_VERSION( 2, 12, 0 )
485
486	static void
487	findMaxAnnounceTime( GtkTreeModel * model,
488	GtkTreePath * path UNUSED,
489	GtkTreeIter * iter,
490	gpointer gmaxTime )
491	{
492	tr_torrent * tor;
493	const tr_stat * torStat;
494	time_t * maxTime = gmaxTime;
495
496	gtk_tree_model_get( model, iter, MC_TORRENT_RAW, &tor, -1 );
497	torStat = tr_torrentStatCached( tor );
498	maxTime = MAX( maxTime, torStat->manualAnnounceTime );
499	}
500
501	static gboolean
502	onAskTrackerQueryTooltip( GtkWidget * widget UNUSED,
503	gint x UNUSED,
504	gint y UNUSED,
505	gboolean keyboard_tip UNUSED,
506	GtkTooltip * tooltip,
507	gpointer gdata )
508	{
509	const time_t now = time( NULL );
510	time_t maxTime = 0;
511	PrivateData * p = gdata;
512
513	gtk_tree_selection_selected_foreach( p->selection,
514	findMaxAnnounceTime,
515	&maxTime );
516	if( maxTime <= now )
517	{
518	return FALSE;
519	}
520	else
521	{
522	char buf[128];
523	char timebuf[64];
524	const int seconds = maxTime - now;
525
526	tr_strltime( timebuf, seconds, sizeof( timebuf ) );
527	g_snprintf( buf, sizeof( buf ),
528	_( "Tracker will allow requests in %s" ), timebuf );
529	gtk_tooltip_set_text( tooltip, buf );
530	return TRUE;
531	}
532	}
533
534	#endif
535
536	static gboolean
537	onAltSpeedToggledIdle( gpointer vp )
538	{
539	PrivateData * p = vp;
540	gboolean b = tr_sessionUsesAltSpeed( tr_core_session( p->core ) );
541	tr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED, b );
542
543	return FALSE;
544	}
545
546	static void
547	onAltSpeedToggled( tr_session * s UNUSED, tr_bool isEnabled UNUSED, tr_bool byUser UNUSED, void * p )
548	{
549	g_idle_add( onAltSpeedToggledIdle, p );
550	}
551
552	/***
553	**** PUBLIC
554	***/
555
556	GtkWidget *
557	tr_window_new( GtkUIManager * ui_mgr, TrCore * core )
558	{
559	int i, n;
560	const char * pch;
561	PrivateData * p;
562	GtkWidget mainmenu, toolbar, filter, list, *status;
563	GtkWidget * vbox, w, self, h, c, s, image, *menu;
564	GtkWindow * win;
565	GSList * l;
566	GSList * toggles;
567
568	const char * filter_names[FILTER_MODE_QTY] = {
569	/* show all torrents */
570	N_( "A_ll" ),
571	/* show only torrents that have connected peers */
572	N_( "_Active" ),
573	/* show only torrents that are trying to download */
574	N_( "_Downloading" ),
575	/* show only torrents that are trying to upload */
576	N_( "_Seeding" ),
577	/* show only torrents that are paused */
578	N_( "_Paused" )
579	};
580	const char * filter_text_names[FILTER_TEXT_MODE_QTY] = {
581	N_( "Name" ), N_( "Files" ), N_( "Tracker" )
582	};
583
584	p = g_new0( PrivateData, 1 );
585	p->filter_mode = FILTER_MODE_ALL;
586	p->filter_text_mode = FILTER_TEXT_MODE_NAME;
587	p->filter_text = NULL;
588
589	/* make the window */
590	self = gtk_window_new ( GTK_WINDOW_TOPLEVEL );
591	g_object_set_data_full( G_OBJECT(
592	self ), PRIVATE_DATA_KEY, p, privateFree );
593	win = GTK_WINDOW( self );
594	gtk_window_set_title( win, g_get_application_name( ) );
595	gtk_window_set_role( win, "tr-main" );
596	gtk_window_set_default_size( win,
597	pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
598	pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
599	gtk_window_move( win, pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
600	pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
601	gtk_window_add_accel_group( win, gtk_ui_manager_get_accel_group( ui_mgr ) );
602
603	/* window's main container */
604	vbox = gtk_vbox_new ( FALSE, 0 );
605	gtk_container_add ( GTK_CONTAINER( self ), vbox );
606
607	/* main menu */
608	w = mainmenu = action_get_widget( "/main-window-menu" );
609	w = action_get_widget( "/main-window-menu/torrent-menu/update-tracker" );
610	#if GTK_CHECK_VERSION( 2, 12, 0 )
611	g_signal_connect( w, "query-tooltip",
612	G_CALLBACK( onAskTrackerQueryTooltip ), p );
613	#endif
614
615	/* toolbar */
616	w = toolbar = p->toolbar = action_get_widget( "/main-window-toolbar" );
617
618	/* filter */
619	toggles = NULL;
620	h = filter = p->filter = gtk_hbox_new( FALSE, 0 );
621	gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
622	for( i = 0; i < FILTER_MODE_QTY; ++i )
623	{
624	const char * mnemonic = _( filter_names[i] );
625	w = gtk_toggle_button_new_with_mnemonic( mnemonic );
626	g_object_set_data( G_OBJECT( w ), FILTER_MODE_KEY,
627	GINT_TO_POINTER( i ) );
628	gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
629	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(
630	w ), i == FILTER_MODE_ALL );
631	toggles = g_slist_prepend( toggles, w );
632	g_signal_connect( w, "toggled", G_CALLBACK( filter_toggled_cb ), p );
633	gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
634	}
635	for( l = toggles; l != NULL; l = l->next )
636	g_object_set_data( G_OBJECT( l->data ), FILTER_TOGGLES_KEY, toggles );
637	s = sexy_icon_entry_new( );
638	sexy_icon_entry_add_clear_button( SEXY_ICON_ENTRY( s ) );
639	image = gtk_image_new_from_stock( GTK_STOCK_FIND, GTK_ICON_SIZE_MENU );
640	sexy_icon_entry_set_icon( SEXY_ICON_ENTRY(
641	s ), SEXY_ICON_ENTRY_PRIMARY,
642	GTK_IMAGE( image ) );
643	sexy_icon_entry_set_icon_highlight( SEXY_ICON_ENTRY(
644	s ), SEXY_ICON_ENTRY_PRIMARY,
645	TRUE );
646	gtk_box_pack_end( GTK_BOX( h ), s, FALSE, FALSE, 0 );
647	g_signal_connect( s, "changed", G_CALLBACK( filter_entry_changed ), p );
648
649	/* status menu */
650	menu = p->status_menu = gtk_menu_new( );
651	l = NULL;
652	pch = pref_string_get( PREF_KEY_STATUSBAR_STATS );
653	for( i = 0, n = G_N_ELEMENTS( stats_modes ); i < n; ++i )
654	{
655	const char * val = stats_modes[i].val;
656	w = gtk_radio_menu_item_new_with_label( l, _( stats_modes[i].i18n ) );
657	l = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM( w ) );
658	gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ),
659	!strcmp( val, pch ) );
660	g_object_set_data( G_OBJECT(
661	w ), STATS_MODE,
662	(gpointer)stats_modes[i].val );
663	g_signal_connect( w, "toggled", G_CALLBACK(
664	status_menu_toggled_cb ), p );
665	gtk_menu_shell_append( GTK_MENU_SHELL( menu ), w );
666	gtk_widget_show( w );
667	}
668
669	/* status */
670	h = status = p->status = gtk_hbox_new( FALSE, GUI_PAD );
671	gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
672	p->alt_speed_image[0] = gtk_image_new_from_stock( "alt-speed-off", -1 );
673	p->alt_speed_image[1] = gtk_image_new_from_stock( "alt-speed-on", -1 );
674	w = p->alt_speed_button = gtk_toggle_button_new( );
675	/gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );/
676	g_object_ref( G_OBJECT( p->alt_speed_image[0] ) );
677	g_object_ref( G_OBJECT( p->alt_speed_image[1] ) );
678	g_signal_connect( w, "toggled", G_CALLBACK(alt_speed_toggled_cb ), p );
679	gtk_box_pack_start( GTK_BOX( h ), w, 0, 0, 0 );
680	w = p->gutter_lb = gtk_label_new( "N Torrents" );
681	gtk_box_pack_start( GTK_BOX( h ), w, 1, 1, GUI_PAD_BIG );
682	w = p->ul_lb = gtk_label_new( NULL );
683	gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
684	w = gtk_image_new_from_stock( GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU );
685	gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
686	w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
687	gtk_widget_set_size_request( w, GUI_PAD, 0u );
688	gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
689	w = p->dl_lb = gtk_label_new( NULL );
690	gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
691	w = gtk_image_new_from_stock( GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU );
692	gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
693	w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
694	gtk_widget_set_size_request( w, GUI_PAD, 0u );
695	gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
696	w = p->stats_lb = gtk_label_new( NULL );
697	gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
698	w = gtk_image_new_from_stock( GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU );
699	c = gtk_event_box_new( );
700	gtk_container_add( GTK_CONTAINER( c ), w );
701	w = c;
702	gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
703	g_signal_connect( w, "button-release-event",
704	G_CALLBACK( onYinYangReleased ), p );
705
706	menu = gtk_menu_new( );
707	l = NULL;
708	for( i = 0; i < FILTER_TEXT_MODE_QTY; ++i )
709	{
710	const char * name = _( filter_text_names[i] );
711	GtkWidget * w = gtk_radio_menu_item_new_with_label ( l, name );
712	l = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM( w ) );
713	g_object_set_data( G_OBJECT( w ), FILTER_TEXT_MODE_KEY,
714	GINT_TO_POINTER( i ) );
715	g_signal_connect( w, "toggled",
716	G_CALLBACK( filter_text_toggled_cb ), p );
717	gtk_menu_shell_append( GTK_MENU_SHELL( menu ), w );
718	gtk_widget_show( w );
719	}
720	g_signal_connect( s, "icon-released",
721	G_CALLBACK( entry_icon_released ), menu );
722
723	/* workarea */
724	p->view = makeview( p, core );
725	w = list = p->scroll = gtk_scrolled_window_new( NULL, NULL );
726	gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ),
727	GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
728	gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ),
729	GTK_SHADOW_IN );
730	gtk_container_add( GTK_CONTAINER( w ), p->view );
731
732	/* layout the widgets */
733	{
734	const char * str = pref_string_get( PREF_KEY_MAIN_WINDOW_LAYOUT_ORDER );
735	char ** tokens = g_strsplit( str, ",", -1 );
736	for( i=0; tokens && tokens[i]; ++i )
737	{
738	const char * key = tokens[i];
739
740	if( !strcmp( key, "menu" ) )
741	gtk_box_pack_start( GTK_BOX( vbox ), mainmenu, FALSE, FALSE, 0 );
742	else if( !strcmp( key, "toolbar" ) )
743	gtk_box_pack_start( GTK_BOX( vbox ), toolbar, FALSE, FALSE, 0 );
744	else if( !strcmp( key, "filter" ) )
745	gtk_box_pack_start( GTK_BOX( vbox ), filter, FALSE, FALSE, 0 );
746	else if( !strcmp( key, "list" ) )
747	gtk_box_pack_start( GTK_BOX( vbox ), list, TRUE, TRUE, 0 );
748	else if( !strcmp( key, "statusbar" ) )
749	gtk_box_pack_start( GTK_BOX( vbox ), status, FALSE, FALSE, 0 );
750	}
751	g_strfreev( tokens );
752	}
753
754	/* show all but the window */
755	gtk_widget_show_all( vbox );
756
757	/* listen for prefs changes that affect the window */
758	p->core = core;
759	prefsChanged( core, PREF_KEY_MINIMAL_VIEW, self );
760	prefsChanged( core, PREF_KEY_FILTERBAR, self );
761	prefsChanged( core, PREF_KEY_STATUSBAR, self );
762	prefsChanged( core, PREF_KEY_STATUSBAR_STATS, self );
763	prefsChanged( core, PREF_KEY_TOOLBAR, self );
764	prefsChanged( core, TR_PREFS_KEY_ALT_SPEED_ENABLED, self );
765	p->pref_handler_id = g_signal_connect( core, "prefs-changed",
766	G_CALLBACK( prefsChanged ), self );
767
768	tr_sessionSetAltSpeedFunc( tr_core_session( core ), onAltSpeedToggled, p );
769
770	filter_entry_changed( GTK_EDITABLE( s ), p );
771	return self;
772	}
773
774	static void
775	updateTorrentCount( PrivateData * p )
776	{
777	if( p && p->core )
778	{
779	char buf[128];
780	const int torrentCount = gtk_tree_model_iter_n_children(
781	tr_core_model( p->core ), NULL );
782	const int visibleCount = gtk_tree_model_iter_n_children(
783	p->filter_model, NULL );
784
785	if( torrentCount != visibleCount )
786	g_snprintf( buf, sizeof( buf ),
787	ngettext( "%1$'d of %2$'d Torrent",
788	"%1$'d of %2$'d Torrents",
789	torrentCount ),
790	visibleCount, torrentCount );
791	else
792	g_snprintf( buf, sizeof( buf ), ngettext( "%'d Torrent",
793	"%'d Torrents",
794	torrentCount ),
795	torrentCount );
796	gtk_label_set_text( GTK_LABEL( p->gutter_lb ), buf );
797	}
798	}
799
800	static void
801	updateStats( PrivateData * p )
802	{
803	const char * pch;
804	char up[32], down[32], ratio[32], buf[128];
805	struct tr_session_stats stats;
806	tr_session * session = tr_core_session( p->core );
807
808	/* update the stats */
809	pch = pref_string_get( PREF_KEY_STATUSBAR_STATS );
810	if( !strcmp( pch, "session-ratio" ) )
811	{
812	tr_sessionGetStats( session, &stats );
813	tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
814	g_snprintf( buf, sizeof( buf ), _( "Ratio: %s" ), ratio );
815	}
816	else if( !strcmp( pch, "session-transfer" ) )
817	{
818	tr_sessionGetStats( session, &stats );
819	tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
820	tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
821	/* Translators: "size\|" is here for disambiguation. Please remove it from your translation.
822	%1$s is the size of the data we've downloaded
823	%2$s is the size of the data we've uploaded */
824	g_snprintf( buf, sizeof( buf ), Q_(
825	"size\|Down: %1$s, Up: %2$s" ), down, up );
826	}
827	else if( !strcmp( pch, "total-transfer" ) )
828	{
829	tr_sessionGetCumulativeStats( session, &stats );
830	tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
831	tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
832	/* Translators: "size\|" is here for disambiguation. Please remove it from your translation.
833	%1$s is the size of the data we've downloaded
834	%2$s is the size of the data we've uploaded */
835	g_snprintf( buf, sizeof( buf ), Q_(
836	"size\|Down: %1$s, Up: %2$s" ), down, up );
837	}
838	else /* default is total-ratio */
839	{
840	tr_sessionGetCumulativeStats( session, &stats );
841	tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
842	g_snprintf( buf, sizeof( buf ), _( "Ratio: %s" ), ratio );
843	}
844	gtk_label_set_text( GTK_LABEL( p->stats_lb ), buf );
845	}
846
847	static void
848	updateSpeeds( PrivateData * p )
849	{
850	tr_session * session = tr_core_session( p->core );
851
852	if( session != NULL )
853	{
854	char buf[128];
855	double d;
856
857	d = tr_sessionGetPieceSpeed( session, TR_DOWN );
858	tr_strlspeed( buf, d, sizeof( buf ) );
859	gtk_label_set_text( GTK_LABEL( p->dl_lb ), buf );
860
861	d = tr_sessionGetPieceSpeed( session, TR_UP );
862	tr_strlspeed( buf, d, sizeof( buf ) );
863	gtk_label_set_text( GTK_LABEL( p->ul_lb ), buf );
864	}
865	}
866
867	void
868	tr_window_update( TrWindow * self )
869	{
870	PrivateData * p = get_private_data( self );
871
872	if( p && p->core && tr_core_session( p->core ) )
873	{
874	updateSpeeds( p );
875	updateTorrentCount( p );
876	updateStats( p );
877	refilter( p );
878	}
879	}
880
881	GtkTreeSelection*
882	tr_window_get_selection( TrWindow * w )
883	{
884	return get_private_data( w )->selection;
885	}
886

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

Download in other formats: