[sigrok-gtk.git] / sigview.c

/*
 * This file is part of the sigrok project.
 *
 * Copyright (C) 2011 Gareth McMullin <gareth@blacksphere.co.nz>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <sigrok.h>
#include <gtk/gtk.h>

#include <string.h>
#include <math.h>

#include "gtkcellrenderersignal.h"
#include "sigrok-gtk.h"

/* FIXME: No globals */
GtkListStore *siglist;

static void format_func(GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
		GtkTreeModel *siglist, GtkTreeIter *iter, gpointer user_data)
{
	int probe;
	char *colour;
	GArray *data;

	(void)tree_column;
	(void)user_data;

	/* TODO: In future we will get data here from tree model.
	 * PD data streams will be kept in the list.  The logic stream
	 * will be used if data is NULL.
	 */
	gtk_tree_model_get(siglist, iter, 1, &colour, 2, &probe, -1);

	/* Try get summary data from the list */
	data = g_object_get_data(G_OBJECT(siglist), "summarydata");
	if (!data)
		data = g_object_get_data(G_OBJECT(siglist), "sampledata");

	g_object_set(G_OBJECT(cell), "data", data, "probe", probe,
				"foreground", colour, NULL);
}

static gboolean do_scroll_event(GtkTreeView *tv, GdkEventScroll *e)
{
	gint x, y, cx;
	GtkTreeViewColumn *col;

	gtk_tree_view_widget_to_tree_coords(tv, e->x, e->y, &x, &y);
	if (!gtk_tree_view_get_path_at_pos(tv, x, y, NULL, &col, &cx, NULL))
		return FALSE;
	if (col != g_object_get_data(G_OBJECT(tv), "signalcol"))
		return FALSE;

	switch (e->direction) {
	case GDK_SCROLL_UP:
		sigview_zoom(GTK_WIDGET(tv), 1.2, cx);
		break;
	case GDK_SCROLL_DOWN:
		sigview_zoom(GTK_WIDGET(tv), 1/1.2, cx);
		break;
	default:
		/* Surpress warning about unswitch enum values */
		break;
	}
	
	return TRUE;
}

static gboolean do_motion_event(GtkWidget *tv, GdkEventMotion *e,
				GObject *cel)
{
	GObject *siglist;
	gint x;
	gint offset;
	GArray *data;
	guint nsamples;
	GtkTreeViewColumn *col;
	gint width;
	gdouble scale, *rscale;
	GtkAdjustment *adj;

	x = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(tv), "motion-x"));
	g_object_set_data(G_OBJECT(tv), "motion-x", GINT_TO_POINTER((gint)e->x));
	adj = g_object_get_data(G_OBJECT(tv), "hadj");

	siglist = G_OBJECT(gtk_tree_view_get_model(GTK_TREE_VIEW(tv)));
	data = g_object_get_data(siglist, "sampledata");
	rscale = g_object_get_data(siglist, "rscale");
	nsamples = (data->len / g_array_get_element_size(data)) - 1;
	col = g_object_get_data(G_OBJECT(tv), "signalcol");
	width = gtk_tree_view_column_get_width(col);

	g_object_get(cel, "offset", &offset, "scale", &scale, NULL);
	offset += x - e->x;
	if (offset < 0)
		offset = 0;
	if (offset > nsamples * *rscale - width)
		offset = nsamples * *rscale - width;

	gtk_adjustment_set_value(adj, offset);

	return TRUE;
}

static gboolean do_button_event(GtkTreeView *tv, GdkEventButton *e,
				GObject *cel)
{
	int h;
	gint x, y;
	GtkTreeViewColumn *col;

	if (e->button != 3)
		return FALSE;

	gtk_tree_view_widget_to_tree_coords(tv, e->x, e->y, &x, &y);

	switch (e->type) {
	case GDK_BUTTON_PRESS:
		if (!gtk_tree_view_get_path_at_pos(tv, x, y, NULL, &col, NULL, NULL))
			return FALSE;
		if (col != g_object_get_data(G_OBJECT(tv), "signalcol"))
			return FALSE;
		h = g_signal_connect(tv, "motion-notify-event", G_CALLBACK(do_motion_event), cel);
		g_object_set_data(G_OBJECT(tv), "motion-handler", GINT_TO_POINTER(h));
		g_object_set_data(G_OBJECT(tv), "motion-x", GINT_TO_POINTER((gint)e->x));
		break;
	case GDK_BUTTON_RELEASE:
		h = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(tv), "motion-handler"));
		if (!h)
			return TRUE;
		g_signal_handler_disconnect(GTK_WIDGET(tv), h);
		g_object_set_data(G_OBJECT(tv), "motion-handler", NULL);
		break;
	default:
		/* Surpress warning about unswitch enum values */
		break;
	}
	return TRUE;
}

static void col_resized(GtkWidget *col)
{
	sigview_zoom(col, 1, 0);
}

static void pan_changed(GtkAdjustment *adj, GtkWidget *sigview)
{
	GObject *cel = g_object_get_data(G_OBJECT(sigview), "signalcel");
	g_object_set(cel, "offset", (gint)gtk_adjustment_get_value(adj), NULL);
	gtk_widget_queue_draw(sigview);
}

GtkWidget *sigview_init(void)
{
	GtkWidget *sw, *tv;
	GtkTreeViewColumn *col;
	GtkCellRenderer *cel;

	sw = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
				GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC);
	tv = gtk_tree_view_new();
	gtk_container_add(GTK_CONTAINER(sw), tv);
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tv), FALSE);
	g_object_set(G_OBJECT(tv), "reorderable", TRUE, NULL);

	col = gtk_tree_view_column_new_with_attributes(NULL,
					gtk_cell_renderer_text_new(),
					"text", 0, "foreground", 1, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col);

	cel = gtk_cell_renderer_signal_new();
	g_object_set(G_OBJECT(cel), "ypad", 1, NULL);
	g_signal_connect(tv, "scroll-event", G_CALLBACK(do_scroll_event), cel);
	g_signal_connect(tv, "button-press-event", G_CALLBACK(do_button_event), cel);
	g_signal_connect(tv, "button-release-event", G_CALLBACK(do_button_event), cel);
	col = gtk_tree_view_column_new();
	g_object_set_data(G_OBJECT(tv), "signalcol", col);
	g_object_set_data(G_OBJECT(tv), "signalcel", cel);
	gtk_tree_view_column_pack_start(col, cel, TRUE);
	gtk_tree_view_column_set_cell_data_func(col, cel, format_func,
					NULL, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col);
	g_signal_connect_swapped(col, "notify::width",
					G_CALLBACK(col_resized), tv);

	siglist = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING,
					G_TYPE_INT);
	gtk_tree_view_set_model(GTK_TREE_VIEW(tv), GTK_TREE_MODEL(siglist));

	GtkObject *pan = gtk_adjustment_new(0, 0, 0, 1, 1, 1);
	g_object_set_data(G_OBJECT(tv), "hadj", pan);
	gtk_range_set_adjustment(GTK_RANGE(GTK_SCROLLED_WINDOW(sw)->hscrollbar),
				GTK_ADJUSTMENT(pan));
	g_signal_connect(pan, "value-changed", G_CALLBACK(pan_changed), tv);
	
	return sw;
}

static GArray *summarize(GArray *in, gdouble *scale)
{
	GArray *ret;
	int skip = 1 / (*scale * 4);
	guint64 i, j, k, l;
	unsigned unitsize = g_array_get_element_size(in);
	uint8_t s[unitsize];
	uint8_t smask[unitsize];

	g_return_val_if_fail(skip > 1, NULL);

	ret = g_array_sized_new(FALSE, FALSE, unitsize, in->len / skip);
	ret->len = in->len / skip;
	*scale *= skip;

	memset(s, 0, unitsize);
	for (i = 0, k = 0; i < (in->len/unitsize); i += skip, k++) {
		memset(smask, 0xFF, unitsize);
		for (j = i; j < i+skip; j++) {
			for (l = 0; l < unitsize; l++) {
				uint8_t ns = (in->data[(j*unitsize)+l] ^ s[l]) & smask[l];
				/* ns is now bits we need to toggle */
				s[l] ^= ns;
				smask[l] &= ~ns;
			}
		}
		memcpy(&ret->data[k*unitsize], s, unitsize);
	}
	return ret;
}

void sigview_zoom(GtkWidget *sigview, gdouble zoom, gint offset)
{
	GObject *siglist;
	GtkTreeViewColumn *col;
	GtkCellRendererSignal *cel;
	GtkAdjustment *adj;
	/* data and scale refer to summary */
	GArray *data;
	gdouble scale;
	/* rdata and rscale refer to complete data */
	GArray *rdata;
	gdouble *rscale;
	gint ofs;
	gint width;
	guint nsamples;

	/* This is so that sigview_zoom() may be called with pointer
	 * to the GtkTreeView or containing GtkScrolledWindow, as is the
	 * case when called from outside this module.
	 */
	if (GTK_IS_SCROLLED_WINDOW(sigview))
		sigview = gtk_bin_get_child(GTK_BIN(sigview));

	g_return_if_fail(GTK_IS_TREE_VIEW(sigview));

	col = g_object_get_data(G_OBJECT(sigview), "signalcol");
	adj = g_object_get_data(G_OBJECT(sigview), "hadj");
	width = gtk_tree_view_column_get_width(col);

	siglist = G_OBJECT(gtk_tree_view_get_model(GTK_TREE_VIEW(sigview)));
	rdata = g_object_get_data(siglist, "sampledata");
	rscale = g_object_get_data(siglist, "rscale");
	if (!rscale) {
		rscale = g_malloc(sizeof(rscale));
		*rscale = 1;
		g_object_set_data(siglist, "rscale", rscale);
	}
	data = g_object_get_data(siglist, "summarydata");
	if (!rdata)
		return;
	if (!data)
		data = rdata;
	nsamples = (rdata->len / g_array_get_element_size(rdata)) - 1;
	if ((fabs(*rscale - (double)width/nsamples) < 1e-12) && (zoom < 1))
		return;

	cel = g_object_get_data(G_OBJECT(sigview), "signalcel");
	g_object_get(cel, "scale", &scale, "offset", &ofs, NULL);

	ofs += offset;
		
	scale *= zoom;
	*rscale *= zoom;
	ofs *= zoom;

	ofs -= offset;

	if (ofs < 0)
		ofs = 0;

	if (*rscale < (double)width/nsamples) {
		*rscale = (double)width/nsamples;
		scale = *rscale;
		if (data && (data != rdata))
			g_array_free(data, TRUE);
		data = rdata;
	}

	if (ofs > nsamples * *rscale - width)
		ofs = nsamples * *rscale - width;

	gtk_adjustment_configure(adj, ofs, 0, nsamples * *rscale, 
			width/16, width/2, width);

	if (scale < 0.125) {
		g_object_set_data(siglist,
			"summarydata", summarize(data, &scale));
		if (data && (data != rdata))
			g_array_free(data, TRUE);
	} else if ((scale > 1) && (*rscale < 1)) {
		scale = *rscale;
		g_object_set_data(siglist,
			"summarydata", summarize(rdata, &scale));
		if (data && (data != rdata))
			g_array_free(data, TRUE);
	}

	g_object_set(cel, "scale", scale, "offset", ofs, NULL);
	gtk_widget_queue_draw(GTK_WIDGET(sigview));
}
Commit	Line	Data
3f63165c UH	1	/*
	2	* This file is part of the sigrok project.
	3	*
	4	* Copyright (C) 2011 Gareth McMullin <gareth@blacksphere.co.nz>
	5	*
	6	* This program is free software: you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation, either version 3 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include <sigrok.h>
	21	#include <gtk/gtk.h>
	22
	23	#include <string.h>
	24	#include <math.h>
	25
	26	#include "gtkcellrenderersignal.h"
	27	#include "sigrok-gtk.h"
	28
	29	/* FIXME: No globals */
	30	GtkListStore *siglist;
	31
	32	static void format_func(GtkTreeViewColumn tree_column, GtkCellRenderer cell,
	33	GtkTreeModel siglist, GtkTreeIter iter, gpointer user_data)
	34	{
	35	int probe;
	36	char *colour;
	37	GArray *data;
	38
	39	(void)tree_column;
	40	(void)user_data;
	41
	42	/* TODO: In future we will get data here from tree model.
	43	* PD data streams will be kept in the list. The logic stream
	44	* will be used if data is NULL.
	45	*/
	46	gtk_tree_model_get(siglist, iter, 1, &colour, 2, &probe, -1);
	47
	48	/* Try get summary data from the list */
	49	data = g_object_get_data(G_OBJECT(siglist), "summarydata");
	50	if (!data)
	51	data = g_object_get_data(G_OBJECT(siglist), "sampledata");
	52
	53	g_object_set(G_OBJECT(cell), "data", data, "probe", probe,
	54	"foreground", colour, NULL);
	55	}
	56
	57	static gboolean do_scroll_event(GtkTreeView tv, GdkEventScroll e)
	58	{
	59	gint x, y, cx;
	60	GtkTreeViewColumn *col;
	61
	62	gtk_tree_view_widget_to_tree_coords(tv, e->x, e->y, &x, &y);
	63	if (!gtk_tree_view_get_path_at_pos(tv, x, y, NULL, &col, &cx, NULL))
	64	return FALSE;
65	if (col != g_object_get_data(G_OBJECT(tv), "signalcol"))
66	return FALSE;
67
68	switch (e->direction) {
69	case GDK_SCROLL_UP:
70	sigview_zoom(GTK_WIDGET(tv), 1.2, cx);
71	break;
72	case GDK_SCROLL_DOWN:
73	sigview_zoom(GTK_WIDGET(tv), 1/1.2, cx);
74	break;
75	default:
76	/* Surpress warning about unswitch enum values */
77	break;
78	}
79
80	return TRUE;
81	}
82
83	static gboolean do_motion_event(GtkWidget tv, GdkEventMotion e,
84	GObject *cel)
85	{
86	GObject *siglist;
87	gint x;
88	gint offset;
89	GArray *data;
90	guint nsamples;
91	GtkTreeViewColumn *col;
92	gint width;
93	gdouble scale, *rscale;
94	GtkAdjustment *adj;
95
96	x = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(tv), "motion-x"));
97	g_object_set_data(G_OBJECT(tv), "motion-x", GINT_TO_POINTER((gint)e->x));
98	adj = g_object_get_data(G_OBJECT(tv), "hadj");
99
100	siglist = G_OBJECT(gtk_tree_view_get_model(GTK_TREE_VIEW(tv)));
101	data = g_object_get_data(siglist, "sampledata");
102	rscale = g_object_get_data(siglist, "rscale");
103	nsamples = (data->len / g_array_get_element_size(data)) - 1;
104	col = g_object_get_data(G_OBJECT(tv), "signalcol");
105	width = gtk_tree_view_column_get_width(col);
106
107	g_object_get(cel, "offset", &offset, "scale", &scale, NULL);
108	offset += x - e->x;
109	if (offset < 0)
110	offset = 0;
111	if (offset > nsamples * *rscale - width)
112	offset = nsamples * *rscale - width;
113
114	gtk_adjustment_set_value(adj, offset);
115
116	return TRUE;
117	}
118
119	static gboolean do_button_event(GtkTreeView tv, GdkEventButton e,
120	GObject *cel)
121	{
122	int h;
123	gint x, y;
124	GtkTreeViewColumn *col;
125
126	if (e->button != 3)
127	return FALSE;
128
129	gtk_tree_view_widget_to_tree_coords(tv, e->x, e->y, &x, &y);
130
131	switch (e->type) {
132	case GDK_BUTTON_PRESS:
133	if (!gtk_tree_view_get_path_at_pos(tv, x, y, NULL, &col, NULL, NULL))
134	return FALSE;
135	if (col != g_object_get_data(G_OBJECT(tv), "signalcol"))
136	return FALSE;
137	h = g_signal_connect(tv, "motion-notify-event", G_CALLBACK(do_motion_event), cel);
138	g_object_set_data(G_OBJECT(tv), "motion-handler", GINT_TO_POINTER(h));
139	g_object_set_data(G_OBJECT(tv), "motion-x", GINT_TO_POINTER((gint)e->x));
140	break;
141	case GDK_BUTTON_RELEASE:
142	h = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(tv), "motion-handler"));
143	if (!h)
144	return TRUE;
145	g_signal_handler_disconnect(GTK_WIDGET(tv), h);
146	g_object_set_data(G_OBJECT(tv), "motion-handler", NULL);
147	break;
148	default:
149	/* Surpress warning about unswitch enum values */
150	break;
151	}
152	return TRUE;
153	}
154
155	static void col_resized(GtkWidget *col)
156	{
157	sigview_zoom(col, 1, 0);
158	}
159
160	static void pan_changed(GtkAdjustment adj, GtkWidget sigview)
161	{
162	GObject *cel = g_object_get_data(G_OBJECT(sigview), "signalcel");
163	g_object_set(cel, "offset", (gint)gtk_adjustment_get_value(adj), NULL);
164	gtk_widget_queue_draw(sigview);
165	}
166
167	GtkWidget *sigview_init(void)
168	{
169	GtkWidget sw, tv;
170	GtkTreeViewColumn *col;
171	GtkCellRenderer *cel;
172
173	sw = gtk_scrolled_window_new(NULL, NULL);
174	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
175	GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC);
176	tv = gtk_tree_view_new();
177	gtk_container_add(GTK_CONTAINER(sw), tv);
178	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tv), FALSE);
179	g_object_set(G_OBJECT(tv), "reorderable", TRUE, NULL);
180
181	col = gtk_tree_view_column_new_with_attributes(NULL,
182	gtk_cell_renderer_text_new(),
183	"text", 0, "foreground", 1, NULL);
184	gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col);
185
186	cel = gtk_cell_renderer_signal_new();
187	g_object_set(G_OBJECT(cel), "ypad", 1, NULL);
188	g_signal_connect(tv, "scroll-event", G_CALLBACK(do_scroll_event), cel);
189	g_signal_connect(tv, "button-press-event", G_CALLBACK(do_button_event), cel);
190	g_signal_connect(tv, "button-release-event", G_CALLBACK(do_button_event), cel);
191	col = gtk_tree_view_column_new();
192	g_object_set_data(G_OBJECT(tv), "signalcol", col);
193	g_object_set_data(G_OBJECT(tv), "signalcel", cel);
194	gtk_tree_view_column_pack_start(col, cel, TRUE);
195	gtk_tree_view_column_set_cell_data_func(col, cel, format_func,
196	NULL, NULL);
197	gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col);
198	g_signal_connect_swapped(col, "notify::width",
199	G_CALLBACK(col_resized), tv);
200
201	siglist = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING,
202	G_TYPE_INT);
203	gtk_tree_view_set_model(GTK_TREE_VIEW(tv), GTK_TREE_MODEL(siglist));
204
205	GtkObject *pan = gtk_adjustment_new(0, 0, 0, 1, 1, 1);
206	g_object_set_data(G_OBJECT(tv), "hadj", pan);
207	gtk_range_set_adjustment(GTK_RANGE(GTK_SCROLLED_WINDOW(sw)->hscrollbar),
208	GTK_ADJUSTMENT(pan));
209	g_signal_connect(pan, "value-changed", G_CALLBACK(pan_changed), tv);
210
211	return sw;
212	}
213
214	static GArray summarize(GArray in, gdouble *scale)
215	{
216	GArray *ret;
217	int skip = 1 / (scale 4);
218	guint64 i, j, k, l;
219	unsigned unitsize = g_array_get_element_size(in);
220	uint8_t s[unitsize];
221	uint8_t smask[unitsize];
222
223	g_return_val_if_fail(skip > 1, NULL);
224
225	ret = g_array_sized_new(FALSE, FALSE, unitsize, in->len / skip);
226	ret->len = in->len / skip;
227	scale = skip;
228
229	memset(s, 0, unitsize);
230	for (i = 0, k = 0; i < (in->len/unitsize); i += skip, k++) {
231	memset(smask, 0xFF, unitsize);
232	for (j = i; j < i+skip; j++) {
233	for (l = 0; l < unitsize; l++) {
234	uint8_t ns = (in->data[(j*unitsize)+l] ^ s[l]) & smask[l];
235	/* ns is now bits we need to toggle */
236	s[l] ^= ns;
237	smask[l] &= ~ns;
238	}
239	}
240	memcpy(&ret->data[k*unitsize], s, unitsize);
241	}
242	return ret;
243	}
244
245	void sigview_zoom(GtkWidget *sigview, gdouble zoom, gint offset)
246	{
247	GObject *siglist;
248	GtkTreeViewColumn *col;
249	GtkCellRendererSignal *cel;
250	GtkAdjustment *adj;
251	/* data and scale refer to summary */
252	GArray *data;
253	gdouble scale;
254	/* rdata and rscale refer to complete data */
255	GArray *rdata;
256	gdouble *rscale;
257	gint ofs;
258	gint width;
259	guint nsamples;
260
261	/* This is so that sigview_zoom() may be called with pointer
262	* to the GtkTreeView or containing GtkScrolledWindow, as is the
263	* case when called from outside this module.
264	*/
265	if (GTK_IS_SCROLLED_WINDOW(sigview))
266	sigview = gtk_bin_get_child(GTK_BIN(sigview));
267
268	g_return_if_fail(GTK_IS_TREE_VIEW(sigview));
269
270	col = g_object_get_data(G_OBJECT(sigview), "signalcol");
271	adj = g_object_get_data(G_OBJECT(sigview), "hadj");
272	width = gtk_tree_view_column_get_width(col);
273
274	siglist = G_OBJECT(gtk_tree_view_get_model(GTK_TREE_VIEW(sigview)));
275	rdata = g_object_get_data(siglist, "sampledata");
276	rscale = g_object_get_data(siglist, "rscale");
277	if (!rscale) {
278	rscale = g_malloc(sizeof(rscale));
279	*rscale = 1;
280	g_object_set_data(siglist, "rscale", rscale);
281	}
282	data = g_object_get_data(siglist, "summarydata");
283	if (!rdata)
284	return;
285	if (!data)
286	data = rdata;
287	nsamples = (rdata->len / g_array_get_element_size(rdata)) - 1;
288	if ((fabs(*rscale - (double)width/nsamples) < 1e-12) && (zoom < 1))
289	return;
290
291	cel = g_object_get_data(G_OBJECT(sigview), "signalcel");
292	g_object_get(cel, "scale", &scale, "offset", &ofs, NULL);
293
294	ofs += offset;
295
296	scale *= zoom;
297	rscale = zoom;
298	ofs *= zoom;
299
300	ofs -= offset;
301
302	if (ofs < 0)
303	ofs = 0;
304
305	if (*rscale < (double)width/nsamples) {
306	*rscale = (double)width/nsamples;
307	scale = *rscale;
308	if (data && (data != rdata))
309	g_array_free(data, TRUE);
310	data = rdata;
311	}
312
313	if (ofs > nsamples * *rscale - width)
314	ofs = nsamples * *rscale - width;
315
316	gtk_adjustment_configure(adj, ofs, 0, nsamples * *rscale,
317	width/16, width/2, width);
318
319	if (scale < 0.125) {
320	g_object_set_data(siglist,
321	"summarydata", summarize(data, &scale));
322	if (data && (data != rdata))
323	g_array_free(data, TRUE);
324	} else if ((scale > 1) && (*rscale < 1)) {
325	scale = *rscale;
326	g_object_set_data(siglist,
327	"summarydata", summarize(rdata, &scale));
328	if (data && (data != rdata))
329	g_array_free(data, TRUE);
330	}
331
332	g_object_set(cel, "scale", scale, "offset", ofs, NULL);
333	gtk_widget_queue_draw(GTK_WIDGET(sigview));
334	}
335