Context Navigation

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

Visit:

Last change on this file since 5146 was 5146, checked in by charles, 14 years ago
fix r5145 oops
Property svn:keywords set to `Date Rev Author Id`
File size: 23.8 KB

Line
1	/******************************************************************************
2	* $Id: tr-window.c 5146 2008-02-27 18:39:12Z 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	gtk_tree_view_column_set_spacing( column, spacing+1 );
48	gtk_tree_view_column_set_spacing( column, spacing );
49	}
50	#endif
51
52	typedef enum
53	{
54	FILTER_TEXT_MODE_NAME,
55	FILTER_TEXT_MODE_FILES,
56	FILTER_TEXT_MODE_TRACKER,
57	FILTER_TEXT_MODE_QTY
58	}
59	filter_text_mode_t;
60
61	typedef enum
62	{
63	FILTER_MODE_ALL,
64	FILTER_MODE_ACTIVE,
65	FILTER_MODE_DOWNLOADING,
66	FILTER_MODE_SEEDING,
67	FILTER_MODE_PAUSED,
68	FILTER_MODE_QTY
69	}
70	filter_mode_t;
71
72	typedef struct
73	{
74	GtkTooltips * tooltips;
75	GtkWidget * scroll;
76	GtkWidget * view;
77	GtkWidget * toolbar;
78	GtkWidget * filter;
79	GtkWidget * status;
80	GtkWidget * status_menu;
81	GtkWidget * ul_lb;
82	GtkWidget * dl_lb;
83	GtkWidget * stats_lb;
84	GtkWidget * gutter_lb;
85	GtkWidget * update_tracker_button;
86	GtkTreeSelection * selection;
87	GtkCellRenderer * renderer;
88	GtkTreeViewColumn * column;
89	GtkTreeModel * filter_model;
90	TrCore * core;
91	gulong pref_handler_id;
92	filter_mode_t filter_mode;
93	filter_text_mode_t filter_text_mode;
94	char * filter_text;
95	}
96	PrivateData;
97
98	#define PRIVATE_DATA_KEY "private-data"
99
100	#define FILTER_MODE_KEY "tr-filter-mode"
101	#define FILTER_TEXT_MODE_KEY "tr-filter-text-mode"
102	#define FILTER_TOGGLES_KEY "tr-filter-toggles"
103
104	PrivateData*
105	get_private_data( TrWindow * w )
106	{
107	return g_object_get_data (G_OBJECT(w), PRIVATE_DATA_KEY);
108	}
109
110	/***
111	****
112	***/
113
114	static void
115	on_popup_menu ( GtkWidget * self UNUSED, GdkEventButton * event )
116	{
117	GtkWidget * menu = action_get_widget ( "/main-window-popup" );
118	gtk_menu_popup (GTK_MENU(menu), NULL, NULL, NULL, NULL,
119	(event ? event->button : 0),
120	(event ? event->time : 0));
121	}
122
123	static void
124	view_row_activated ( GtkTreeView * tree_view UNUSED,
125	GtkTreePath * path UNUSED,
126	GtkTreeViewColumn * column UNUSED,
127	gpointer user_data UNUSED )
128	{
129	action_activate( "show-torrent-details" );
130	}
131
132	static gboolean is_row_visible( GtkTreeModel , GtkTreeIter , gpointer );
133
134	static GtkWidget*
135	makeview( PrivateData * p, TrCore * core )
136	{
137	GtkWidget * view;
138	GtkTreeViewColumn * col;
139	GtkTreeSelection * sel;
140	GtkCellRenderer * r;
141	GtkTreeModel * filter_model;
142
143	view = gtk_tree_view_new();
144	gtk_tree_view_set_headers_visible( GTK_TREE_VIEW(view), FALSE );
145
146	p->selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(view) );
147
148	p->renderer = r = torrent_cell_renderer_new( );
149	p->column = col = gtk_tree_view_column_new_with_attributes(
150	_("Torrent"), r, "torrent", MC_TORRENT_RAW, NULL );
151	g_object_set( G_OBJECT(col), "resizable", TRUE,
152	"sizing", GTK_TREE_VIEW_COLUMN_FIXED,
153	NULL );
154	gtk_tree_view_append_column( GTK_TREE_VIEW( view ), col );
155	g_object_set( r, "xpad", GUI_PAD_SMALL, "ypad", GUI_PAD_SMALL, NULL );
156
157	gtk_tree_view_set_rules_hint( GTK_TREE_VIEW( view ), TRUE );
158	sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
159	gtk_tree_selection_set_mode( GTK_TREE_SELECTION( sel ),
160	GTK_SELECTION_MULTIPLE );
161
162	g_signal_connect( view, "popup-menu",
163	G_CALLBACK(on_popup_menu), NULL );
164	g_signal_connect( view, "button-press-event",
165	G_CALLBACK(on_tree_view_button_pressed),
166	(void *) on_popup_menu);
167	g_signal_connect( view, "row-activated",
168	G_CALLBACK(view_row_activated), NULL);
169
170
171	filter_model = p->filter_model = gtk_tree_model_filter_new( tr_core_model( core ), NULL );
172
173	gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( filter_model ),
174	is_row_visible,
175	p, NULL );
176
177	gtk_tree_view_set_model( GTK_TREE_VIEW( view ), filter_model );
178
179	return view;
180	}
181
182	static void
183	realized_cb ( GtkWidget * wind, gpointer unused UNUSED )
184	{
185	PrivateData * p = get_private_data( GTK_WINDOW( wind ) );
186	sizingmagic( GTK_WINDOW(wind),
187	GTK_SCROLLED_WINDOW( p->scroll ),
188	GTK_POLICY_NEVER,
189	GTK_POLICY_AUTOMATIC );
190	}
191
192	static void
193	prefsChanged( TrCore * core UNUSED, const char * key, gpointer wind )
194	{
195	PrivateData * p = get_private_data( GTK_WINDOW( wind ) );
196
197	if( !strcmp( key, PREF_KEY_MINIMAL_VIEW ) )
198	{
199	g_object_set( p->renderer, "minimal", pref_flag_get( key ), NULL );
200	gtk_tree_view_column_queue_resize( p->column );
201	gtk_widget_queue_draw( p->view );
202	}
203	else if( !strcmp( key, PREF_KEY_STATUS_BAR ) )
204	{
205	const gboolean isEnabled = pref_flag_get( key );
206	g_object_set( p->status, "visible", isEnabled, NULL );
207	}
208	else if( !strcmp( key, PREF_KEY_FILTER_BAR ) )
209	{
210	const gboolean isEnabled = pref_flag_get( key );
211	g_object_set( p->filter, "visible", isEnabled, NULL );
212	}
213	else if( !strcmp( key, PREF_KEY_TOOLBAR ) )
214	{
215	const gboolean isEnabled = pref_flag_get( key );
216	g_object_set( p->toolbar, "visible", isEnabled, NULL );
217	}
218	else if( !strcmp( key, PREF_KEY_STATUS_BAR_STATS ) )
219	{
220	tr_window_update( (TrWindow*)wind );
221	}
222	}
223
224	static void
225	privateFree( gpointer vprivate )
226	{
227	PrivateData * p = vprivate;
228	g_signal_handler_disconnect( p->core, p->pref_handler_id );
229	g_free( p->filter_text );
230	g_free( p );
231	}
232
233	static void
234	onYinYangReleased( GtkWidget * w UNUSED, GdkEventButton * button UNUSED, gpointer vprivate )
235	{
236	PrivateData * p = vprivate;
237	gtk_menu_popup( GTK_MENU( p->status_menu ), 0, 0, 0, 0, 0, gtk_get_current_event_time( ) );
238	}
239
240	#define STATS_MODE "stats-mode"
241
242	static struct {
243	const char val, i18n;
244	} stats_modes[] = {
245	{ "total-ratio", N_("Total Ratio") },
246	{ "session-ratio", N_("Session Ratio") },
247	{ "total-transfer", N_("Total Transfer") },
248	{ "session-transfer", N_("Session Transfer") }
249	};
250
251	static void
252	status_menu_toggled_cb( GtkCheckMenuItem * menu_item,
253	gpointer vprivate )
254	{
255	if( gtk_check_menu_item_get_active( menu_item ) )
256	{
257	PrivateData * p = vprivate;
258	const char * val = g_object_get_data( G_OBJECT( menu_item ), STATS_MODE );
259	tr_core_set_pref( p->core, PREF_KEY_STATUS_BAR_STATS, val );
260	}
261	}
262
263	/***
264	**** FILTER
265	***/
266
267	static int
268	checkFilterText( filter_text_mode_t filter_text_mode,
269	const tr_info * torInfo,
270	const char * text )
271	{
272	int i;
273	int ret = 0;
274	char * pch;
275
276	switch( filter_text_mode )
277	{
278	case FILTER_TEXT_MODE_FILES:
279	for( i=0; i<torInfo->fileCount && !ret; ++i ) {
280	pch = g_ascii_strdown( torInfo->files[i].name, -1 );
281	ret = !text \|\| strstr( pch, text ) != NULL;
282	g_free( pch );
283	}
284	break;
285
286	case FILTER_TEXT_MODE_TRACKER:
287	pch = g_ascii_strdown( torInfo->primaryAddress, -1 );
288	ret = !text \|\| ( strstr( pch, text ) != NULL );
289	g_free( pch );
290	break;
291
292	default: /* NAME */
293	pch = g_ascii_strdown( torInfo->name, -1 );
294	ret = !text \|\| ( strstr( pch, text ) != NULL );
295	g_free( pch );
296	break;
297	}
298
299	return ret;
300	}
301
302	static int
303	checkFilterMode( filter_mode_t filter_mode,
304	const tr_stat * torStat )
305	{
306	int ret = 0;
307	const int haveDown = torStat->peersSendingToUs > 0;
308	const int haveUp = torStat->peersGettingFromUs > 0;
309
310	switch( filter_mode )
311	{
312	case FILTER_MODE_ACTIVE:
313	ret = haveUp \|\| haveDown;
314	break;
315	case FILTER_MODE_DOWNLOADING:
316	ret = torStat->status == TR_STATUS_DOWNLOAD;
317	break;
318	case FILTER_MODE_SEEDING:
319	ret = ( torStat->status == TR_STATUS_DONE )
320	\|\| ( torStat->status == TR_STATUS_SEED );
321	break;
322	case FILTER_MODE_PAUSED:
323	ret = torStat->status == TR_STATUS_STOPPED;
324	break;
325	default: /* all */
326	ret = 1;
327	}
328
329	return ret;
330	}
331
332	static gboolean
333	is_row_visible( GtkTreeModel * model,
334	GtkTreeIter * iter,
335	gpointer vprivate )
336	{
337	PrivateData * p = vprivate;
338	tr_torrent * tor;
339	gtk_tree_model_get( model, iter, MC_TORRENT_RAW, &tor, -1 );
340
341	return checkFilterMode( p->filter_mode, tr_torrentStatCached( tor ) )
342	&& checkFilterText( p->filter_text_mode, tr_torrentInfo( tor ), p->filter_text );
343	}
344
345	static void updateTorrentCount( PrivateData * p );
346
347	static void
348	refilter( PrivateData * p )
349	{
350	gtk_tree_model_filter_refilter( GTK_TREE_MODEL_FILTER( p->filter_model ) );
351
352	updateTorrentCount( p );
353	}
354
355	static void
356	filter_text_toggled_cb( GtkCheckMenuItem * menu_item,
357	gpointer vprivate )
358	{
359	if( gtk_check_menu_item_get_active( menu_item ) )
360	{
361	PrivateData * p = vprivate;
362	p->filter_text_mode = GPOINTER_TO_UINT( g_object_get_data( G_OBJECT( menu_item ),
363	FILTER_TEXT_MODE_KEY ) );
364	refilter( p );
365	}
366	}
367
368	static void
369	filter_toggled_cb( GtkToggleButton * toggle, gpointer vprivate )
370	{
371	PrivateData * p = vprivate;
372	GSList * l;
373	GSList * toggles = g_object_get_data( G_OBJECT( toggle ), FILTER_TOGGLES_KEY );
374	const gboolean isActive = gtk_toggle_button_get_active( toggle );
375	const filter_mode_t mode = GPOINTER_TO_UINT( g_object_get_data( G_OBJECT( toggle ), FILTER_MODE_KEY ) );
376
377	/* update the filter */
378	if( isActive ) {
379	p->filter_mode = mode;
380	refilter( p );
381	}
382
383	/* deactivate the other toggles */
384	for( l=toggles; l!=NULL; l=l->next ) {
385	GtkToggleButton * walk = GTK_TOGGLE_BUTTON( l->data );
386	if( isActive && ( toggle != walk ) )
387	gtk_toggle_button_set_active( walk, FALSE );
388	}
389
390	/* at least one button must always be set */
391	if( !isActive && ( p->filter_mode == mode ) )
392	gtk_toggle_button_set_active( toggle, TRUE );
393	}
394
395	static void
396	filter_entry_changed( GtkEditable * e, gpointer vprivate )
397	{
398	char * pch;
399	PrivateData * p = vprivate;
400
401	pch = gtk_editable_get_chars( e, 0, -1 );
402	g_free( p->filter_text );
403	p->filter_text = g_ascii_strdown( pch, -1 );
404	refilter( p );
405	g_free( pch );
406	}
407
408	static void
409	entry_icon_released( SexyIconEntry * entry UNUSED,
410	SexyIconEntryPosition icon_pos,
411	int button UNUSED,
412	gpointer menu )
413	{
414	if ( icon_pos == SEXY_ICON_ENTRY_PRIMARY )
415	gtk_menu_popup ( GTK_MENU( menu ), 0, 0, 0, 0, 0, gtk_get_current_event_time( ) );
416	}
417
418	/***
419	**** PUBLIC
420	***/
421
422	GtkWidget *
423	tr_window_new( GtkUIManager * ui_manager, TrCore * core )
424	{
425	int i, n;
426	int status_stats_mode;
427	char * pch;
428	PrivateData * p;
429	GtkWidget vbox, w, self, h, c, s, image, menu;
430	GSList * l;
431	GSList * toggles;
432	const char * filter_names[FILTER_MODE_QTY] = {
433	N_( "A_ll"), N_("_Active"),
434	N_("_Downloading"), N_("_Seeding"), N_("_Paused")
435	};
436	const char * filter_text_names[FILTER_TEXT_MODE_QTY] = {
437	N_("Name"), N_("Files"), N_("Tracker")
438	};
439
440	p = g_new0( PrivateData, 1 );
441	p->filter_mode = FILTER_MODE_ALL;
442	p->filter_text_mode = FILTER_TEXT_MODE_NAME;
443	p->filter_text = NULL;
444
445	/* make the window */
446	self = gtk_window_new (GTK_WINDOW_TOPLEVEL);
447	g_object_set_data_full(G_OBJECT(self), PRIVATE_DATA_KEY, p, privateFree );
448	gtk_window_set_title( GTK_WINDOW( self ), g_get_application_name());
449	gtk_window_set_role( GTK_WINDOW( self ), "tr-main" );
450	gtk_window_add_accel_group (GTK_WINDOW(self),
451	gtk_ui_manager_get_accel_group (ui_manager));
452	g_signal_connect( self, "realize", G_CALLBACK(realized_cb), NULL);
453
454	#if GTK_CHECK_VERSION(2,10,0)
455	{
456	GdkScreen * screen = gtk_widget_get_screen( self );
457	GdkColormap * colormap = gdk_screen_get_rgba_colormap( screen );
458	if( colormap && gdk_screen_is_composited( screen ) )
459	gtk_widget_set_default_colormap( colormap );
460	}
461	#endif
462
463	/* window's main container */
464	vbox = gtk_vbox_new (FALSE, 0);
465	gtk_container_add (GTK_CONTAINER(self), vbox);
466
467	/* main menu */
468	w = action_get_widget( "/main-window-menu" );
469	gtk_box_pack_start( GTK_BOX(vbox), w, FALSE, FALSE, 0 );
470	w = action_get_widget( "/main-window-menu/torrent-menu/update-tracker" );
471	p->update_tracker_button = w;
472
473	/* toolbar */
474	w = p->toolbar = action_get_widget( "/main-window-toolbar" );
475	gtk_box_pack_start( GTK_BOX(vbox), w, FALSE, FALSE, 0 );
476
477	/* filter */
478	toggles = NULL;
479	h = p->filter = gtk_hbox_new( FALSE, 0 );
480	gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
481	for( i=0; i<FILTER_MODE_QTY; ++i ) {
482	const char * mnemonic = _( filter_names[i] );
483	w = gtk_toggle_button_new_with_mnemonic( mnemonic );
484	g_object_set_data( G_OBJECT( w ), FILTER_MODE_KEY, GINT_TO_POINTER( i ) );
485	gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
486	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), i==FILTER_MODE_ALL );
487	toggles = g_slist_prepend( toggles, w );
488	g_signal_connect( w, "toggled", G_CALLBACK(filter_toggled_cb), p );
489	gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
490	}
491	for( l=toggles; l!=NULL; l=l->next )
492	g_object_set_data( G_OBJECT( l->data ), FILTER_TOGGLES_KEY, toggles );
493	s = sexy_icon_entry_new( );
494	sexy_icon_entry_add_clear_button( SEXY_ICON_ENTRY(s) );
495	image = gtk_image_new_from_stock( GTK_STOCK_FIND, GTK_ICON_SIZE_MENU );
496	sexy_icon_entry_set_icon( SEXY_ICON_ENTRY(s), SEXY_ICON_ENTRY_PRIMARY, GTK_IMAGE(image) );
497	sexy_icon_entry_set_icon_highlight( SEXY_ICON_ENTRY(s), SEXY_ICON_ENTRY_PRIMARY, TRUE );
498	gtk_box_pack_end( GTK_BOX( h ), s, FALSE, FALSE, 0 );
499	gtk_box_pack_start( GTK_BOX(vbox), h, FALSE, FALSE, 0 );
500	g_signal_connect( s, "changed", G_CALLBACK( filter_entry_changed ), p );
501
502	w = gtk_hseparator_new( );
503	gtk_box_pack_start( GTK_BOX(vbox), w, FALSE, FALSE, 0 );
504
505	/* status menu */
506	menu = p->status_menu = gtk_menu_new( );
507	status_stats_mode = 0;
508	l = NULL;
509	pch = pref_string_get( PREF_KEY_STATUS_BAR_STATS );
510	for( i=0, n=G_N_ELEMENTS(stats_modes); i<n; ++i )
511	{
512	const char * val = stats_modes[i].val;
513	w = gtk_radio_menu_item_new_with_label( l, _( stats_modes[i].i18n ) );
514	l = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(w) );
515	gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(w), !strcmp( val, pch ) );
516	g_object_set_data( G_OBJECT(w), STATS_MODE, (gpointer)stats_modes[i].val );
517	g_signal_connect( w, "toggled", G_CALLBACK(status_menu_toggled_cb), p );
518	gtk_menu_shell_append( GTK_MENU_SHELL(menu), w );
519	gtk_widget_show( w );
520	}
521	g_free( pch );
522
523	/* status */
524	h = p->status = gtk_hbox_new( FALSE, GUI_PAD );
525	gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD );
526	w = p->gutter_lb = gtk_label_new( "N transfers" );
527	gtk_box_pack_start( GTK_BOX(h), w, 0, 0, 0 );
528	w = p->ul_lb = gtk_label_new( NULL );
529	gtk_box_pack_end( GTK_BOX(h), w, FALSE, FALSE, 0 );
530	w = gtk_image_new_from_stock( GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU );
531	gtk_box_pack_end( GTK_BOX(h), w, FALSE, FALSE, 0 );
532	w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
533	gtk_widget_set_size_request( w, GUI_PAD, 0u );
534	gtk_box_pack_end( GTK_BOX(h), w, FALSE, FALSE, 0 );
535	w = p->dl_lb = gtk_label_new( NULL );
536	gtk_box_pack_end( GTK_BOX(h), w, FALSE, FALSE, 0 );
537	w = gtk_image_new_from_stock( GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU );
538	gtk_box_pack_end( GTK_BOX(h), w, FALSE, FALSE, 0 );
539	w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
540	gtk_widget_set_size_request( w, GUI_PAD, 0u );
541	gtk_box_pack_end( GTK_BOX(h), w, FALSE, FALSE, 0 );
542	w = p->stats_lb = gtk_label_new( NULL );
543	gtk_box_pack_end( GTK_BOX(h), w, FALSE, FALSE, 0 );
544	w = gtk_image_new_from_stock( GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU );
545	c = gtk_event_box_new( );
546	gtk_container_add( GTK_CONTAINER(c), w );
547	w = c;
548	gtk_box_pack_end( GTK_BOX(h), w, FALSE, FALSE, 0 );
549	g_signal_connect( w, "button-release-event", G_CALLBACK(onYinYangReleased), p );
550	gtk_box_pack_start( GTK_BOX(vbox), h, FALSE, FALSE, 0 );
551
552	menu = gtk_menu_new( );
553	l = NULL;
554	for( i=0; i<FILTER_TEXT_MODE_QTY; ++i )
555	{
556	const char * name = _( filter_text_names[i] );
557	GtkWidget * w = gtk_radio_menu_item_new_with_label ( l, name );
558	l = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM( w ) );
559	g_object_set_data( G_OBJECT( w ), FILTER_TEXT_MODE_KEY, GINT_TO_POINTER( i ) );
560	g_signal_connect( w, "toggled", G_CALLBACK( filter_text_toggled_cb ), p );
561	gtk_menu_shell_append( GTK_MENU_SHELL( menu ), w );
562	gtk_widget_show( w );
563	}
564	g_signal_connect( s, "icon-released", G_CALLBACK(entry_icon_released), menu );
565
566	/* workarea */
567	p->view = makeview( p, core );
568	w = p->scroll = gtk_scrolled_window_new( NULL, NULL );
569	gtk_container_add( GTK_CONTAINER(w), p->view );
570	gtk_box_pack_start_defaults( GTK_BOX(vbox), w );
571	gtk_container_set_focus_child( GTK_CONTAINER( vbox ), w );
572
573	/* show all but the window */
574	gtk_widget_show_all( vbox );
575
576	/* listen for prefs changes that affect the window */
577	p->core = core;
578	prefsChanged( core, PREF_KEY_MINIMAL_VIEW, self );
579	prefsChanged( core, PREF_KEY_FILTER_BAR, self );
580	prefsChanged( core, PREF_KEY_STATUS_BAR, self );
581	prefsChanged( core, PREF_KEY_STATUS_BAR_STATS, self );
582	prefsChanged( core, PREF_KEY_TOOLBAR, self );
583	p->pref_handler_id = g_signal_connect( core, "prefs-changed",
584	G_CALLBACK(prefsChanged), self );
585
586	filter_entry_changed( GTK_EDITABLE( s ), p );
587	return self;
588	}
589
590	static void
591	updateTorrentCount( PrivateData * p )
592	{
593	if( p && p->core )
594	{
595	char buf[128];
596	const int torrentCount = gtk_tree_model_iter_n_children( tr_core_model( p->core ), NULL );
597	const int visibleCount = gtk_tree_model_iter_n_children( p->filter_model, NULL );
598
599	if( torrentCount != visibleCount )
600	g_snprintf( buf, sizeof( buf ), ngettext( "%d of %d Transfer",
601	"%d of %d Transfers",
602	torrentCount ),
603	visibleCount, torrentCount );
604	else
605	g_snprintf( buf, sizeof( buf ), ngettext( "%d Transfer",
606	"%d Transfers",
607	torrentCount ),
608	torrentCount );
609	gtk_label_set_text( GTK_LABEL( p->gutter_lb ), buf );
610	}
611	}
612
613	static void
614	updateStats( PrivateData * p )
615	{
616	char * pch;
617	char up[32], down[32], ratio[32], buf[128];
618	struct tr_session_stats stats;
619	tr_handle * handle = tr_core_handle( p->core );
620
621	/* update the stats */
622	pch = pref_string_get( PREF_KEY_STATUS_BAR_STATS );
623	if( !strcmp( pch, "session-ratio" ) ) {
624	tr_getSessionStats( handle, &stats );
625	tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
626	g_snprintf( buf, sizeof(buf), _("Ratio: %s"), ratio );
627	} else if( !strcmp( pch, "session-transfer" ) ) {
628	tr_getSessionStats( handle, &stats );
629	tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
630	tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
631	g_snprintf( buf, sizeof( buf ), _( "Down: %s Up: %s" ), down, up );
632	} else if( !strcmp( pch, "total-transfer" ) ) {
633	tr_getCumulativeSessionStats( handle, &stats );
634	tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
635	tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
636	g_snprintf( buf, sizeof( buf ), _( "Down: %s Up: %s" ), down, up );
637	} else { /* default is total-ratio */
638	tr_getCumulativeSessionStats( handle, &stats );
639	tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
640	g_snprintf( buf, sizeof(buf), _("Ratio: %s"), ratio );
641	}
642	g_free( pch );
643	gtk_label_set_text( GTK_LABEL( p->stats_lb ), buf );
644	}
645
646	static void
647	updateSpeeds( PrivateData * p )
648	{
649	char buf[128];
650	float u, d;
651	tr_handle * handle = tr_core_handle( p->core );
652
653	tr_torrentRates( handle, &d, &u );
654	tr_strlspeed( buf, d, sizeof( buf ) );
655	gtk_label_set_text( GTK_LABEL( p->dl_lb ), buf );
656	tr_strlspeed( buf, u, sizeof( buf ) );
657	gtk_label_set_text( GTK_LABEL( p->ul_lb ), buf );
658	}
659
660	static void
661	findMaxAnnounceTime( GtkTreeModel * model,
662	GtkTreePath * path UNUSED,
663	GtkTreeIter * iter,
664	gpointer gmaxTime )
665	{
666	tr_torrent * tor;
667	const tr_stat * torStat;
668	time_t * maxTime = gmaxTime;
669
670	gtk_tree_model_get( model, iter, MC_TORRENT_RAW, &tor, -1 );
671	torStat = tr_torrentStatCached( tor );
672	maxTime = MAX( maxTime, torStat->manualAnnounceTime );
673	}
674
675	static void
676	updateAskForPeers( PrivateData * p )
677	{
678	char buf[128];
679	time_t maxTime = 0;
680	const time_t now = time( NULL );
681
682	gtk_tree_selection_selected_foreach( p->selection,
683	findMaxAnnounceTime,
684	&maxTime );
685
686	if( maxTime <= now )
687	*buf = '\0';
688	else {
689	char secbuf[32];
690	const int seconds = maxTime - time( NULL );
691	tr_strltime( secbuf, seconds, sizeof( secbuf ) );
692	g_snprintf( buf, sizeof( buf ), _( "Tracker will allow requests in %s" ), secbuf );
693	}
694
695	if( !p->tooltips )
696	p->tooltips = gtk_tooltips_new( );
697	gtk_tooltips_set_tip( p->tooltips, p->update_tracker_button, buf, NULL );
698	}
699
700	void
701	tr_window_update( TrWindow * self )
702	{
703	PrivateData * p = get_private_data( self );
704	if( p && p->core && tr_core_handle(p->core) )
705	{
706	updateSpeeds( p );
707	updateTorrentCount( p );
708	updateStats( p );
709	updateAskForPeers( p );
710	refilter( p );
711	}
712	}
713
714	GtkTreeSelection*
715	tr_window_get_selection ( TrWindow * w )
716	{
717	return get_private_data(w)->selection;
718	}

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

Download in other formats: