[lttv.git] / lttv / modules / gui / lttvwindow / lttvwindow / timebar.c

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2010 Yannick Brosseau
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 */
#include "timebar.h"

#include "timeentry.h"

#include <gtk/gtkeventbox.h>
#include <gtk/gtkvseparator.h>
#include <lttv/time.h>

enum {
	SIGNAL_START_TIME_CHANGED,
	SIGNAL_END_TIME_CHANGED,
	SIGNAL_CURRENT_TIME_CHANGED,
	LAST_SIGNAL
};

static void timebar_class_init(TimebarClass *klass);
static void timebar_init(Timebar      *ttt);

static guint timebar_signals[LAST_SIGNAL] = { 0 };

static void on_start_time_value_changed(Timeentry *spinbutton,
					gpointer user_data);
static void on_end_time_value_changed(Timeentry *spinbutton,
				gpointer user_data);
static void on_interval_time_value_changed(Timeentry *spinbutton,
					gpointer user_data);
static void on_current_time_value_changed(Timeentry *spinbutton,
					gpointer user_data);

static void update_interval(Timebar *timebar);

static inline LttTime timeentry_get_ltt_time(Timeentry *timeentry)
{
	LttTime time;

	timeentry_get_time(timeentry,
			&time.tv_sec,
			&time.tv_nsec);
	return time;
}

GType timebar_get_type(void)
{
	static GType tb_type = 0;

	if (!tb_type) {
		const GTypeInfo tb_info =
			{
				sizeof (TimebarClass),
				NULL, /* base_init */
				NULL, /* base_finalize */
				(GClassInitFunc) timebar_class_init,
				NULL, /* class_finalize */
				NULL, /* class_data */
				sizeof (Timebar),
				0,    /* n_preallocs */
				(GInstanceInitFunc) timebar_init,
			};

		tb_type = g_type_register_static(GTK_TYPE_HBOX,
						"Timebar",
						&tb_info,
						0);
	}

	return tb_type;
}


static void timebar_class_init(TimebarClass *klass)
{
	timebar_signals[SIGNAL_START_TIME_CHANGED] = g_signal_new("start-time-changed",
					G_TYPE_FROM_CLASS(klass),
					G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
					G_STRUCT_OFFSET(TimebarClass, timebar),
					NULL,
					NULL,               
					g_cclosure_marshal_VOID__VOID,
					G_TYPE_NONE, 0);

	timebar_signals[SIGNAL_END_TIME_CHANGED] = g_signal_new("end-time-changed",
					G_TYPE_FROM_CLASS(klass),
					G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
					G_STRUCT_OFFSET(TimebarClass, timebar),
					NULL,
					NULL,               
					g_cclosure_marshal_VOID__VOID,
					G_TYPE_NONE, 0);
	timebar_signals[SIGNAL_CURRENT_TIME_CHANGED] = g_signal_new("current-time-changed",
					G_TYPE_FROM_CLASS(klass),
					G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
					G_STRUCT_OFFSET(TimebarClass, timebar),
					NULL,
					NULL,               
					g_cclosure_marshal_VOID__VOID,
					G_TYPE_NONE, 0);
}


static void timebar_init(Timebar *timebar)
{
	/* Title label */
	timebar->title_eventbox = gtk_event_box_new();
	gtk_widget_show(timebar->title_eventbox);

	timebar->title_label = gtk_label_new("Time Frame ");
	gtk_widget_show(timebar->title_label);
	gtk_container_add(GTK_CONTAINER(timebar->title_eventbox), timebar->title_label);

	/* Start time entry */
	timebar->start_timeentry = timeentry_new("Start: ");
	gtk_widget_show(timebar->start_timeentry);

	/* End time entry */
	timebar->end_timeentry = timeentry_new("End: ");
	gtk_widget_show(timebar->end_timeentry);

	/* Interval time entry */
	timebar->interval_timeentry = timeentry_new("Time Interval: ");
	gtk_widget_show(timebar->interval_timeentry);

	/* Current time entry */
	timebar->current_timeentry = timeentry_new("Current Time: ");
	gtk_widget_show(timebar->current_timeentry);

	/* Pack all the widget in the timebar box */
	GtkWidget *temp_widget;
  
	gtk_box_pack_start (GTK_BOX(timebar), timebar->title_eventbox, FALSE, FALSE, 2);

	gtk_box_pack_start (GTK_BOX(timebar), timebar->start_timeentry, FALSE, FALSE, 0);

	temp_widget = gtk_vseparator_new();
	gtk_widget_show(temp_widget);
	gtk_box_pack_start (GTK_BOX(timebar), temp_widget, FALSE, FALSE, 2);

	gtk_box_pack_start (GTK_BOX(timebar), timebar->end_timeentry, FALSE, FALSE, 0);

	temp_widget = gtk_vseparator_new();
	gtk_widget_show(temp_widget);
	gtk_box_pack_start (GTK_BOX(timebar), temp_widget, FALSE, FALSE, 2);

	gtk_box_pack_start (GTK_BOX(timebar), timebar->interval_timeentry, FALSE, FALSE, 0);

	gtk_box_pack_end (GTK_BOX(timebar), timebar->current_timeentry, FALSE, FALSE, 0);
	temp_widget = gtk_vseparator_new();
	gtk_widget_show(temp_widget);
	gtk_box_pack_end (GTK_BOX(timebar), temp_widget, FALSE, FALSE, 2);

	/* Set an initial time */
	timebar_set_minmax_time(timebar, &ltt_time_zero, &ltt_time_one);

	/* Connect signals */
	g_signal_connect ((gpointer) timebar->start_timeentry, "time-changed",
			G_CALLBACK(on_start_time_value_changed),
			timebar);
	g_signal_connect ((gpointer) timebar->end_timeentry, "time-changed",
			G_CALLBACK(on_end_time_value_changed),
			timebar);
	timebar->interval_handler_id =
		g_signal_connect ((gpointer) timebar->interval_timeentry, "time-changed",
				G_CALLBACK (on_interval_time_value_changed),
				timebar);
	g_signal_connect ((gpointer) timebar->current_timeentry, "time-changed",
			G_CALLBACK(on_current_time_value_changed),
			timebar);
}

GtkWidget *timebar_new(void)
{
	return GTK_WIDGET(g_object_new (TIMEBAR_TYPE, NULL));
}

void timebar_set_current_time(Timebar *timebar, const LttTime* time)
{
	if (time == NULL) {
		return;
	}

	timeentry_set_time(TIMEENTRY(timebar->current_timeentry),
					time->tv_sec,
					time->tv_nsec);
}

void timebar_set_start_time(Timebar *timebar, const LttTime* time)
{
	if (time == NULL) {
		return;
	}

	timeentry_set_time(TIMEENTRY(timebar->start_timeentry),
					time->tv_sec,
					time->tv_nsec);

	update_interval(timebar);
}

void timebar_set_end_time(Timebar *timebar, const LttTime* time)
{
	if (time == NULL) {
		return;
	}

	timeentry_set_time(TIMEENTRY(timebar->end_timeentry),
					time->tv_sec,
					time->tv_nsec);
	update_interval(timebar);
}

void timebar_set_minmax_time(Timebar *timebar,
			const LttTime *min_time,
			const LttTime *max_time)
{
	LttTime new_interval_length;
	LttTime start_max_time;
	LttTime end_min_time;

	/* Need to set both min_time and max_time */
	if (min_time == NULL || max_time == NULL) {
		return;
	}
	/* Do nothing if there is no change */
	if (ltt_time_compare(timebar->min_time, *min_time) == 0 &&
		ltt_time_compare(timebar->max_time, *max_time) == 0
		) {
		return;
	}
	/* null-checked already */
	timebar->min_time = *min_time;
	timebar->max_time = *max_time;

	if (ltt_time_compare(timebar->min_time, timebar->max_time) == 0) {

		/* If the min and max are equal set the same values, which will
		   disable all the widgets of the timebar */
		new_interval_length.tv_sec = 0;
		new_interval_length.tv_nsec = 1;

		start_max_time.tv_sec = timebar->max_time.tv_sec;
		start_max_time.tv_nsec = timebar->max_time.tv_nsec;

		end_min_time.tv_sec = timebar->min_time.tv_sec;
		end_min_time.tv_nsec = timebar->min_time.tv_nsec;

	} else {
		/* Special minmax (to keep a minimum interval of 1 nsec */
		/* start max time is max minus 1 nsec */
		if (timebar->max_time.tv_nsec == 0) {
			start_max_time.tv_sec = timebar->max_time.tv_sec - 1;
			start_max_time.tv_nsec = NANOSECONDS_PER_SECOND - 1;
		} else {
			start_max_time.tv_sec = timebar->max_time.tv_sec;
			start_max_time.tv_nsec = timebar->max_time.tv_nsec - 1;
		}

		/* end min time is min plus 1 nsec */
		if (timebar->min_time.tv_nsec + 1 == NANOSECONDS_PER_SECOND) {
			end_min_time.tv_sec = timebar->min_time.tv_sec + 1;
			end_min_time.tv_nsec = 0;
		} else {
			end_min_time.tv_sec = timebar->min_time.tv_sec;
			end_min_time.tv_nsec = timebar->min_time.tv_nsec + 1;
		}

		/* Compute max interval */
		new_interval_length = ltt_time_sub(timebar->max_time,
						timebar->min_time);
	}


	/* Update widgets */
	timeentry_set_minmax_time(TIMEENTRY(timebar->start_timeentry),
				timebar->min_time.tv_sec,
				timebar->min_time.tv_nsec,
				start_max_time.tv_sec,
				start_max_time.tv_nsec);
	timeentry_set_minmax_time(TIMEENTRY(timebar->end_timeentry),
				end_min_time.tv_sec,
				end_min_time.tv_nsec,
				timebar->max_time.tv_sec,
				timebar->max_time.tv_nsec);
	timeentry_set_minmax_time(TIMEENTRY(timebar->current_timeentry),
				timebar->min_time.tv_sec,
				timebar->min_time.tv_nsec,
				timebar->max_time.tv_sec,
				timebar->max_time.tv_nsec);


	timeentry_set_minmax_time(TIMEENTRY(timebar->interval_timeentry),
				0,
				1,
				new_interval_length.tv_sec,
				new_interval_length.tv_nsec);	
}

LttTime timebar_get_start_time(Timebar *timebar)
{
	return timeentry_get_ltt_time(TIMEENTRY(timebar->start_timeentry));
}

LttTime timebar_get_end_time(Timebar *timebar)
{
	return timeentry_get_ltt_time(TIMEENTRY(timebar->end_timeentry));
}

LttTime timebar_get_current_time(Timebar *timebar)
{
	return timeentry_get_ltt_time(TIMEENTRY(timebar->current_timeentry));
}

static void update_interval(Timebar *timebar)
{
	LttTime start_time = timeentry_get_ltt_time(TIMEENTRY(timebar->start_timeentry));
	LttTime end_time = timeentry_get_ltt_time(TIMEENTRY(timebar->end_timeentry));
	LttTime new_interval;

	/* Compute max interval */
	new_interval = ltt_time_sub(end_time,
				start_time);
	
	/* Don't trigger the signal when we update the interval */
	g_signal_handler_block(timebar->interval_timeentry,
			timebar->interval_handler_id);

	timeentry_set_time(TIMEENTRY(timebar->interval_timeentry),
				new_interval.tv_sec,
				new_interval.tv_nsec);

	g_signal_handler_unblock(timebar->interval_timeentry,
			timebar->interval_handler_id);
}

static void on_start_time_value_changed(Timeentry *timeentry,
					gpointer user_data)
{
	Timebar *timebar = (Timebar *)user_data;

	update_interval(timebar);

	g_signal_emit(timebar,
		timebar_signals[SIGNAL_START_TIME_CHANGED], 0);
}

static void on_end_time_value_changed(Timeentry *timeentry,
				gpointer user_data)
{
	Timebar *timebar = (Timebar *)user_data;

	update_interval(timebar);

	g_signal_emit(timebar,
		timebar_signals[SIGNAL_END_TIME_CHANGED], 0);
}

static void on_interval_time_value_changed (Timeentry *timeentry,
				gpointer user_data)
{
	Timebar *timebar = (Timebar *)user_data;

	LttTime new_interval = timeentry_get_ltt_time(TIMEENTRY(timebar->interval_timeentry));

	LttTime start_time = timebar_get_start_time(timebar);

	LttTime new_end_time;

	gboolean need_interval_update = FALSE;

	/* Lock the start and change the end */
	new_end_time = ltt_time_add(start_time, new_interval);

	/* We cannot push further the max end */
	if (ltt_time_compare(new_end_time, timebar->max_time) > 0) {
		/* Set the end to the max and pull on the start */
		new_end_time = timebar->max_time;
		LttTime new_start_time = ltt_time_sub(new_end_time, new_interval);

		/* We cannot pull before the min start */
		if (ltt_time_compare(new_start_time, timebar->min_time) < 0) {
			/* Set the interval to the max */
			new_start_time = timebar->min_time;
			need_interval_update = TRUE;
		}
		timebar_set_start_time(timebar, &new_start_time);
	}
	timebar_set_end_time(timebar, &new_end_time);

	if (need_interval_update) {
		update_interval(timebar);
	}
}

static void on_current_time_value_changed(Timeentry *timeentry,
					gpointer user_data)
{
	Timebar *timebar = (Timebar *)user_data;

	g_signal_emit(timebar, 
		timebar_signals[SIGNAL_CURRENT_TIME_CHANGED], 0);
}
Commit	Line	Data
4172f013 YB	1	/* This file is part of the Linux Trace Toolkit viewer
	2	* Copyright (C) 2010 Yannick Brosseau
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License Version 2 as
	6	* published by the Free Software Foundation;
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU General Public License
	14	* along with this program; if not, write to the Free Software
b9ce0bad YB	15	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
b9ce0bad YB	16	* MA 02110-1301, USA.
4172f013 YB	17	*/
	18	#include "timebar.h"
	19
	20	#include "timeentry.h"
	21
	22	#include <gtk/gtkeventbox.h>
	23	#include <gtk/gtkvseparator.h>
190724cd	24	#include <lttv/time.h>
4172f013 YB	25
	26	enum {
	27	SIGNAL_START_TIME_CHANGED,
	28	SIGNAL_END_TIME_CHANGED,
	29	SIGNAL_CURRENT_TIME_CHANGED,
	30	LAST_SIGNAL
	31	};
	32
	33	static void timebar_class_init(TimebarClass *klass);
	34	static void timebar_init(Timebar *ttt);
	35
	36	static guint timebar_signals[LAST_SIGNAL] = { 0 };
	37
	38	static void on_start_time_value_changed(Timeentry *spinbutton,
	39	gpointer user_data);
	40	static void on_end_time_value_changed(Timeentry *spinbutton,
	41	gpointer user_data);
	42	static void on_interval_time_value_changed(Timeentry *spinbutton,
	43	gpointer user_data);
	44	static void on_current_time_value_changed(Timeentry *spinbutton,
	45	gpointer user_data);
	46
	47	static void update_interval(Timebar *timebar);
	48
	49	static inline LttTime timeentry_get_ltt_time(Timeentry *timeentry)
	50	{
	51	LttTime time;
	52
	53	timeentry_get_time(timeentry,
	54	&time.tv_sec,
	55	&time.tv_nsec);
	56	return time;
	57	}
	58
	59	GType timebar_get_type(void)
	60	{
	61	static GType tb_type = 0;
	62
	63	if (!tb_type) {
	64	const GTypeInfo tb_info =
	65	{
	66	sizeof (TimebarClass),
	67	NULL, /* base_init */
	68	NULL, /* base_finalize */
	69	(GClassInitFunc) timebar_class_init,
	70	NULL, /* class_finalize */
	71	NULL, /* class_data */
	72	sizeof (Timebar),
	73	0, /* n_preallocs */
	74	(GInstanceInitFunc) timebar_init,
	75	};
	76
	77	tb_type = g_type_register_static(GTK_TYPE_HBOX,
	78	"Timebar",
	79	&tb_info,
	80	0);
	81	}
	82
	83	return tb_type;
	84	}
	85
	86
	87	static void timebar_class_init(TimebarClass *klass)
	88	{
89	timebar_signals[SIGNAL_START_TIME_CHANGED] = g_signal_new("start-time-changed",
90	G_TYPE_FROM_CLASS(klass),
91	G_SIGNAL_RUN_FIRST \| G_SIGNAL_ACTION,
92	G_STRUCT_OFFSET(TimebarClass, timebar),
93	NULL,
94	NULL,
95	g_cclosure_marshal_VOID__VOID,
96	G_TYPE_NONE, 0);
97
98	timebar_signals[SIGNAL_END_TIME_CHANGED] = g_signal_new("end-time-changed",
99	G_TYPE_FROM_CLASS(klass),
100	G_SIGNAL_RUN_FIRST \| G_SIGNAL_ACTION,
101	G_STRUCT_OFFSET(TimebarClass, timebar),
102	NULL,
103	NULL,
104	g_cclosure_marshal_VOID__VOID,
105	G_TYPE_NONE, 0);
106	timebar_signals[SIGNAL_CURRENT_TIME_CHANGED] = g_signal_new("current-time-changed",
107	G_TYPE_FROM_CLASS(klass),
108	G_SIGNAL_RUN_FIRST \| G_SIGNAL_ACTION,
109	G_STRUCT_OFFSET(TimebarClass, timebar),
110	NULL,
111	NULL,
112	g_cclosure_marshal_VOID__VOID,
113	G_TYPE_NONE, 0);
114	}
115
116
117	static void timebar_init(Timebar *timebar)
118	{
119	/* Title label */
120	timebar->title_eventbox = gtk_event_box_new();
121	gtk_widget_show(timebar->title_eventbox);
122
123	timebar->title_label = gtk_label_new("Time Frame ");
124	gtk_widget_show(timebar->title_label);
125	gtk_container_add(GTK_CONTAINER(timebar->title_eventbox), timebar->title_label);
126
127	/* Start time entry */
128	timebar->start_timeentry = timeentry_new("Start: ");
129	gtk_widget_show(timebar->start_timeentry);
130
131	/* End time entry */
132	timebar->end_timeentry = timeentry_new("End: ");
133	gtk_widget_show(timebar->end_timeentry);
134
135	/* Interval time entry */
136	timebar->interval_timeentry = timeentry_new("Time Interval: ");
137	gtk_widget_show(timebar->interval_timeentry);
138
139	/* Current time entry */
140	timebar->current_timeentry = timeentry_new("Current Time: ");
141	gtk_widget_show(timebar->current_timeentry);
142
143	/* Pack all the widget in the timebar box */
144	GtkWidget *temp_widget;
145
146	gtk_box_pack_start (GTK_BOX(timebar), timebar->title_eventbox, FALSE, FALSE, 2);
147
148	gtk_box_pack_start (GTK_BOX(timebar), timebar->start_timeentry, FALSE, FALSE, 0);
149
150	temp_widget = gtk_vseparator_new();
151	gtk_widget_show(temp_widget);
152	gtk_box_pack_start (GTK_BOX(timebar), temp_widget, FALSE, FALSE, 2);
153
154	gtk_box_pack_start (GTK_BOX(timebar), timebar->end_timeentry, FALSE, FALSE, 0);
155
156	temp_widget = gtk_vseparator_new();
157	gtk_widget_show(temp_widget);
158	gtk_box_pack_start (GTK_BOX(timebar), temp_widget, FALSE, FALSE, 2);
159
160	gtk_box_pack_start (GTK_BOX(timebar), timebar->interval_timeentry, FALSE, FALSE, 0);
161
162	gtk_box_pack_end (GTK_BOX(timebar), timebar->current_timeentry, FALSE, FALSE, 0);
163	temp_widget = gtk_vseparator_new();
164	gtk_widget_show(temp_widget);
165	gtk_box_pack_end (GTK_BOX(timebar), temp_widget, FALSE, FALSE, 2);
166
167	/* Set an initial time */
168	timebar_set_minmax_time(timebar, &ltt_time_zero, &ltt_time_one);
169
170	/* Connect signals */
171	g_signal_connect ((gpointer) timebar->start_timeentry, "time-changed",
172	G_CALLBACK(on_start_time_value_changed),
173	timebar);
174	g_signal_connect ((gpointer) timebar->end_timeentry, "time-changed",
175	G_CALLBACK(on_end_time_value_changed),
176	timebar);
177	timebar->interval_handler_id =
178	g_signal_connect ((gpointer) timebar->interval_timeentry, "time-changed",
179	G_CALLBACK (on_interval_time_value_changed),
180	timebar);
181	g_signal_connect ((gpointer) timebar->current_timeentry, "time-changed",
182	G_CALLBACK(on_current_time_value_changed),
183	timebar);
184	}
185
186	GtkWidget *timebar_new(void)
187	{
188	return GTK_WIDGET(g_object_new (TIMEBAR_TYPE, NULL));
189	}
190
191	void timebar_set_current_time(Timebar timebar, const LttTime time)
192	{
193	if (time == NULL) {
194	return;
195	}
196
197	timeentry_set_time(TIMEENTRY(timebar->current_timeentry),
198	time->tv_sec,
199	time->tv_nsec);
200	}
201
202	void timebar_set_start_time(Timebar timebar, const LttTime time)
203	{
204	if (time == NULL) {
205	return;
206	}
207
208	timeentry_set_time(TIMEENTRY(timebar->start_timeentry),
209	time->tv_sec,
210	time->tv_nsec);
211
212	update_interval(timebar);
213	}
214
215	void timebar_set_end_time(Timebar timebar, const LttTime time)
216	{
217	if (time == NULL) {
218	return;
219	}
220
221	timeentry_set_time(TIMEENTRY(timebar->end_timeentry),
222	time->tv_sec,
223	time->tv_nsec);
224	update_interval(timebar);
225	}
226
227	void timebar_set_minmax_time(Timebar *timebar,
228	const LttTime *min_time,
229	const LttTime *max_time)
230	{
231	LttTime new_interval_length;
232	LttTime start_max_time;
233	LttTime end_min_time;
234
235	/* Need to set both min_time and max_time */
236	if (min_time == NULL \|\| max_time == NULL) {
237	return;
238	}
239	/* Do nothing if there is no change */
240	if (ltt_time_compare(timebar->min_time, *min_time) == 0 &&
241	ltt_time_compare(timebar->max_time, *max_time) == 0
242	) {
243	return;
244	}
451aaf27 FD	245	/* null-checked already */
	246	timebar->min_time = *min_time;
	247	timebar->max_time = *max_time;
4172f013 YB	248
	249	if (ltt_time_compare(timebar->min_time, timebar->max_time) == 0) {
	250
	251	/* If the min and max are equal set the same values, which will
	252	disable all the widgets of the timebar */
	253	new_interval_length.tv_sec = 0;
	254	new_interval_length.tv_nsec = 1;
	255
	256	start_max_time.tv_sec = timebar->max_time.tv_sec;
	257	start_max_time.tv_nsec = timebar->max_time.tv_nsec;
	258
	259	end_min_time.tv_sec = timebar->min_time.tv_sec;
	260	end_min_time.tv_nsec = timebar->min_time.tv_nsec;
	261
	262	} else {
	263	/* Special minmax (to keep a minimum interval of 1 nsec */
	264	/* start max time is max minus 1 nsec */
	265	if (timebar->max_time.tv_nsec == 0) {
	266	start_max_time.tv_sec = timebar->max_time.tv_sec - 1;
	267	start_max_time.tv_nsec = NANOSECONDS_PER_SECOND - 1;
	268	} else {
	269	start_max_time.tv_sec = timebar->max_time.tv_sec;
	270	start_max_time.tv_nsec = timebar->max_time.tv_nsec - 1;
	271	}
	272
	273	/* end min time is min plus 1 nsec */
	274	if (timebar->min_time.tv_nsec + 1 == NANOSECONDS_PER_SECOND) {
	275	end_min_time.tv_sec = timebar->min_time.tv_sec + 1;
	276	end_min_time.tv_nsec = 0;
	277	} else {
	278	end_min_time.tv_sec = timebar->min_time.tv_sec;
	279	end_min_time.tv_nsec = timebar->min_time.tv_nsec + 1;
	280	}
	281
	282	/* Compute max interval */
	283	new_interval_length = ltt_time_sub(timebar->max_time,
	284	timebar->min_time);
	285	}
	286
	287
	288	/* Update widgets */
	289	timeentry_set_minmax_time(TIMEENTRY(timebar->start_timeentry),
	290	timebar->min_time.tv_sec,
	291	timebar->min_time.tv_nsec,
	292	start_max_time.tv_sec,
	293	start_max_time.tv_nsec);
	294	timeentry_set_minmax_time(TIMEENTRY(timebar->end_timeentry),
	295	end_min_time.tv_sec,
	296	end_min_time.tv_nsec,
	297	timebar->max_time.tv_sec,
	298	timebar->max_time.tv_nsec);
	299	timeentry_set_minmax_time(TIMEENTRY(timebar->current_timeentry),
	300	timebar->min_time.tv_sec,
	301	timebar->min_time.tv_nsec,
	302	timebar->max_time.tv_sec,
	303	timebar->max_time.tv_nsec);
	304
	305
	306	timeentry_set_minmax_time(TIMEENTRY(timebar->interval_timeentry),
	307	0,
	308	1,
	309	new_interval_length.tv_sec,
	310	new_interval_length.tv_nsec);
	311	}
312
313	LttTime timebar_get_start_time(Timebar *timebar)
314	{
315	return timeentry_get_ltt_time(TIMEENTRY(timebar->start_timeentry));
316	}
317
318	LttTime timebar_get_end_time(Timebar *timebar)
319	{
320	return timeentry_get_ltt_time(TIMEENTRY(timebar->end_timeentry));
321	}
322
323	LttTime timebar_get_current_time(Timebar *timebar)
324	{
325	return timeentry_get_ltt_time(TIMEENTRY(timebar->current_timeentry));
326	}
327
328	static void update_interval(Timebar *timebar)
329	{
330	LttTime start_time = timeentry_get_ltt_time(TIMEENTRY(timebar->start_timeentry));
331	LttTime end_time = timeentry_get_ltt_time(TIMEENTRY(timebar->end_timeentry));
332	LttTime new_interval;
333
334	/* Compute max interval */
335	new_interval = ltt_time_sub(end_time,
336	start_time);
337
338	/* Don't trigger the signal when we update the interval */
339	g_signal_handler_block(timebar->interval_timeentry,
340	timebar->interval_handler_id);
341
342	timeentry_set_time(TIMEENTRY(timebar->interval_timeentry),
343	new_interval.tv_sec,
344	new_interval.tv_nsec);
345
346	g_signal_handler_unblock(timebar->interval_timeentry,
347	timebar->interval_handler_id);
348	}
349
350	static void on_start_time_value_changed(Timeentry *timeentry,
351	gpointer user_data)
352	{
353	Timebar timebar = (Timebar )user_data;
354
355	update_interval(timebar);
356
357	g_signal_emit(timebar,
358	timebar_signals[SIGNAL_START_TIME_CHANGED], 0);
359	}
360
361	static void on_end_time_value_changed(Timeentry *timeentry,
362	gpointer user_data)
363	{
364	Timebar timebar = (Timebar )user_data;
365
366	update_interval(timebar);
367
368	g_signal_emit(timebar,
369	timebar_signals[SIGNAL_END_TIME_CHANGED], 0);
370	}
371
372	static void on_interval_time_value_changed (Timeentry *timeentry,
373	gpointer user_data)
374	{
375	Timebar timebar = (Timebar )user_data;
376
377	LttTime new_interval = timeentry_get_ltt_time(TIMEENTRY(timebar->interval_timeentry));
378
379	LttTime start_time = timebar_get_start_time(timebar);
380
381	LttTime new_end_time;
382
383	gboolean need_interval_update = FALSE;
384
385	/* Lock the start and change the end */
386	new_end_time = ltt_time_add(start_time, new_interval);
387
388	/* We cannot push further the max end */
389	if (ltt_time_compare(new_end_time, timebar->max_time) > 0) {
390	/* Set the end to the max and pull on the start */
391	new_end_time = timebar->max_time;
392	LttTime new_start_time = ltt_time_sub(new_end_time, new_interval);
393
394	/* We cannot pull before the min start */
395	if (ltt_time_compare(new_start_time, timebar->min_time) < 0) {
396	/* Set the interval to the max */
397	new_start_time = timebar->min_time;
398	need_interval_update = TRUE;
399	}
400	timebar_set_start_time(timebar, &new_start_time);
401	}
402	timebar_set_end_time(timebar, &new_end_time);
403
404	if (need_interval_update) {
405	update_interval(timebar);
406	}
407	}
408
409	static void on_current_time_value_changed(Timeentry *timeentry,
410	gpointer user_data)
411	{
412	Timebar timebar = (Timebar )user_data;
413
414	g_signal_emit(timebar,
415	timebar_signals[SIGNAL_CURRENT_TIME_CHANGED], 0);
416	}
417
418