[sigrok-gtk.git] / gtkcellrenderersignal.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 <gtk/gtk.h>

#include "gtkcellrenderersignal.h"

enum
{
	PROP_0,
	PROP_DATA,
	PROP_PROBE,
	PROP_FOREGROUND,
	PROP_SCALE,
	PROP_OFFSET,
};

struct _GtkCellRendererSignalPrivate
{
	GArray *data;
	guint32 probe;
	GdkColor foreground;
	gdouble scale;
	gint offset;
};

static void gtk_cell_renderer_signal_finalize(GObject *object);
static void gtk_cell_renderer_signal_get_property(GObject *object,
				guint param_id, GValue *value,
				GParamSpec *pspec);
static void gtk_cell_renderer_signal_set_property(GObject *object,
				guint param_id, const GValue *value,
				GParamSpec *pspec);
static void gtk_cell_renderer_signal_get_size(GtkCellRenderer *cell,
				GtkWidget *widget,
				GdkRectangle *cell_area,
				gint *x_offset,
				gint *y_offset,
				gint *width,
				gint *height);
static void gtk_cell_renderer_signal_render(GtkCellRenderer *cell,
				GdkWindow *window,
				GtkWidget *widget,
				GdkRectangle *background_area,
				GdkRectangle *cell_area,
				GdkRectangle *expose_area,
				GtkCellRendererState flags);


G_DEFINE_TYPE(GtkCellRendererSignal, gtk_cell_renderer_signal, GTK_TYPE_CELL_RENDERER);

static void
gtk_cell_renderer_signal_class_init (GtkCellRendererSignalClass *klass)
{
	GObjectClass *object_class = G_OBJECT_CLASS (klass);
	GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass);

	object_class->finalize = gtk_cell_renderer_signal_finalize;
	object_class->get_property = gtk_cell_renderer_signal_get_property;
	object_class->set_property = gtk_cell_renderer_signal_set_property;

	cell_class->get_size = gtk_cell_renderer_signal_get_size;
	cell_class->render = gtk_cell_renderer_signal_render;

	g_object_class_install_property(object_class,
				PROP_DATA,
				g_param_spec_pointer("data",
						"Data",
						"Binary samples data",
						G_PARAM_READWRITE));

	g_object_class_install_property (object_class,
				PROP_PROBE,
				g_param_spec_int("probe",
						"Probe",
						"Bit in Data to display",
						-1, G_MAXINT, -1,
						G_PARAM_READWRITE));

	g_object_class_install_property (object_class,
				PROP_FOREGROUND,
				g_param_spec_string("foreground",
						"Foreground",
						"Foreground Colour",
						NULL,
						G_PARAM_WRITABLE));

	g_object_class_install_property (object_class,
				PROP_SCALE,
				g_param_spec_double("scale",
						"Scale",
						"Pixels per sample",
						0, 100, 1,
						G_PARAM_READWRITE));

	g_object_class_install_property (object_class,
				PROP_OFFSET,
				g_param_spec_int("offset",
						"Offset",
						"Offset...",
						0, G_MAXINT, 0,
						G_PARAM_READWRITE));

	g_type_class_add_private (object_class,
			sizeof (GtkCellRendererSignalPrivate));
}

static void gtk_cell_renderer_signal_init(GtkCellRendererSignal *cel)
{
	GtkCellRendererSignalPrivate *priv;

	cel->priv = G_TYPE_INSTANCE_GET_PRIVATE(cel,
				GTK_TYPE_CELL_RENDERER_SIGNAL,
				GtkCellRendererSignalPrivate);
	priv = cel->priv;

	priv->data = NULL;
	priv->probe = -1;
	priv->scale = 1;
	priv->offset = 0;
}

GtkCellRenderer *gtk_cell_renderer_signal_new(void)
{
	return g_object_new(GTK_TYPE_CELL_RENDERER_SIGNAL, NULL);
}

static void gtk_cell_renderer_signal_finalize(GObject *object)
{
	GtkCellRendererSignal *cel = GTK_CELL_RENDERER_SIGNAL(object);
	GtkCellRendererSignalPrivate *priv = cel->priv;
	/* Keep this around, because it'll be useful in future */
	(void)priv;
	G_OBJECT_CLASS(gtk_cell_renderer_signal_parent_class)->finalize(object);
}

static void
gtk_cell_renderer_signal_get_property(GObject *object,
				guint param_id,
				GValue *value,
				GParamSpec *pspec)
{
	GtkCellRendererSignal *cel = GTK_CELL_RENDERER_SIGNAL(object);
	GtkCellRendererSignalPrivate *priv = cel->priv;

	switch (param_id) {
	case PROP_DATA:
		g_value_set_pointer(value, priv->data);
		break;
	case PROP_PROBE:
		g_value_set_int(value, priv->probe);
		break;
	case PROP_SCALE:
		g_value_set_double(value, priv->scale);
		break;
	case PROP_OFFSET:
		g_value_set_int(value, priv->offset);
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
	}
}

static void
gtk_cell_renderer_signal_set_property(GObject *object,
				guint param_id,
				const GValue *value,
				GParamSpec *pspec)
{
	GtkCellRendererSignal *cel = GTK_CELL_RENDERER_SIGNAL(object);
	GtkCellRendererSignalPrivate *priv = cel->priv;

	switch (param_id) {
	case PROP_DATA:
		priv->data = g_value_get_pointer(value);
		break;
	case PROP_PROBE:
		priv->probe = g_value_get_int(value);
		break;
	case PROP_FOREGROUND:
		gdk_color_parse(g_value_get_string(value), &priv->foreground);
		break;
	case PROP_SCALE:
		priv->scale = g_value_get_double(value);
		break;
	case PROP_OFFSET:
		priv->offset = g_value_get_int(value);
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
	}
}

static void
gtk_cell_renderer_signal_get_size(GtkCellRenderer *cell,
				GtkWidget *widget,
				GdkRectangle *cell_area,
				gint *x_offset,
				gint *y_offset,
				gint *width,
				gint *height)
{
	(void)cell;
	(void)widget;
	(void)cell_area;

	/* FIXME: What about cell_area? */
	if (width) *width = 0;
	if (height) *height = 30;

	if (x_offset) *x_offset = 0;
	if (y_offset) *y_offset = 0;
}


static gboolean sample(GArray *data, gint probe, guint i)
{
	int unitsize = g_array_get_element_size(data);
	g_return_val_if_fail(i < data->len, FALSE);
	g_return_val_if_fail(probe < unitsize * 8, FALSE);

	return data->data[(i*unitsize) + probe/8] & (1 << (probe & 7));
}

static void
gtk_cell_renderer_signal_render(GtkCellRenderer *cell,
				GdkWindow *window,
				GtkWidget *widget,
				GdkRectangle *background_area,
				GdkRectangle *cell_area,
				GdkRectangle *expose_area,
				GtkCellRendererState flags)
{
	GtkCellRendererSignal *cel = GTK_CELL_RENDERER_SIGNAL(cell);
	GtkCellRendererSignalPrivate *priv= cel->priv;
	guint nsamples = priv->data->len;
	gint xpad, ypad;
	int x, y, w, h;
	guint si;
	gdouble o;

	(void)widget;
	(void)expose_area;
	(void)flags;

	gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
	x = cell_area->x + xpad;
	y = cell_area->y + ypad;
	w = cell_area->width - xpad * 2;
	h = cell_area->height - ypad * 2;

	cairo_t *cr = gdk_cairo_create(GDK_DRAWABLE(window));

	/* Set clipping region to background rectangle.
	 * This prevents us drawing over other cells.
	 */
	cairo_new_path(cr);
	gdk_cairo_rectangle(cr, background_area);
	cairo_clip(cr);

	cairo_set_line_join(cr, CAIRO_LINE_JOIN_ROUND);
	gdk_cairo_set_source_color(cr, &priv->foreground);
	/*cairo_set_line_width(cr, 1);*/
	cairo_new_path(cr);

	si = priv->offset / priv->scale;
	if (si >= nsamples)
		return;
	o = x - (priv->offset - si * priv->scale);

	guint32 oldsample = sample(priv->data, priv->probe, si++);
	cairo_move_to(cr, o, y +
		(oldsample ? 0 : h));
	o += priv->scale;
	
	while ((si < nsamples) && (o - priv->scale < x+w)) {
		guint32 cursample = sample(priv->data, priv->probe, si);
		if (cursample != oldsample) {
			cairo_line_to(cr, o - priv->scale/8, y +
				(oldsample ? 0 : h));
			cairo_line_to(cr, o + priv->scale/8, y +
				(cursample ? 0 : h));
			oldsample = cursample;
		}
		o += priv->scale;
		si++;
	}
	cairo_line_to(cr, o - priv->scale/8, y +
		(oldsample ? 0 : h));

	cairo_stroke(cr);
	cairo_destroy(cr);
}
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 <gtk/gtk.h>
	21
	22	#include "gtkcellrenderersignal.h"
	23
	24	enum
	25	{
	26	PROP_0,
	27	PROP_DATA,
	28	PROP_PROBE,
	29	PROP_FOREGROUND,
	30	PROP_SCALE,
	31	PROP_OFFSET,
	32	};
	33
	34	struct _GtkCellRendererSignalPrivate
	35	{
	36	GArray *data;
	37	guint32 probe;
	38	GdkColor foreground;
	39	gdouble scale;
	40	gint offset;
	41	};
	42
	43	static void gtk_cell_renderer_signal_finalize(GObject *object);
	44	static void gtk_cell_renderer_signal_get_property(GObject *object,
	45	guint param_id, GValue *value,
	46	GParamSpec *pspec);
	47	static void gtk_cell_renderer_signal_set_property(GObject *object,
	48	guint param_id, const GValue *value,
	49	GParamSpec *pspec);
	50	static void gtk_cell_renderer_signal_get_size(GtkCellRenderer *cell,
	51	GtkWidget *widget,
	52	GdkRectangle *cell_area,
	53	gint *x_offset,
	54	gint *y_offset,
	55	gint *width,
	56	gint *height);
	57	static void gtk_cell_renderer_signal_render(GtkCellRenderer *cell,
	58	GdkWindow *window,
	59	GtkWidget *widget,
	60	GdkRectangle *background_area,
	61	GdkRectangle *cell_area,
	62	GdkRectangle *expose_area,
	63	GtkCellRendererState flags);
	64
65
66	G_DEFINE_TYPE(GtkCellRendererSignal, gtk_cell_renderer_signal, GTK_TYPE_CELL_RENDERER);
67
68	static void
69	gtk_cell_renderer_signal_class_init (GtkCellRendererSignalClass *klass)
70	{
71	GObjectClass *object_class = G_OBJECT_CLASS (klass);
72	GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass);
73
74	object_class->finalize = gtk_cell_renderer_signal_finalize;
75	object_class->get_property = gtk_cell_renderer_signal_get_property;
76	object_class->set_property = gtk_cell_renderer_signal_set_property;
77
78	cell_class->get_size = gtk_cell_renderer_signal_get_size;
79	cell_class->render = gtk_cell_renderer_signal_render;
80
81	g_object_class_install_property(object_class,
82	PROP_DATA,
83	g_param_spec_pointer("data",
84	"Data",
85	"Binary samples data",
86	G_PARAM_READWRITE));
87
88	g_object_class_install_property (object_class,
89	PROP_PROBE,
90	g_param_spec_int("probe",
91	"Probe",
92	"Bit in Data to display",
93	-1, G_MAXINT, -1,
94	G_PARAM_READWRITE));
95
96	g_object_class_install_property (object_class,
97	PROP_FOREGROUND,
98	g_param_spec_string("foreground",
99	"Foreground",
100	"Foreground Colour",
101	NULL,
102	G_PARAM_WRITABLE));
103
104	g_object_class_install_property (object_class,
105	PROP_SCALE,
106	g_param_spec_double("scale",
107	"Scale",
108	"Pixels per sample",
109	0, 100, 1,
110	G_PARAM_READWRITE));
111
112	g_object_class_install_property (object_class,
113	PROP_OFFSET,
114	g_param_spec_int("offset",
115	"Offset",
116	"Offset...",
117	0, G_MAXINT, 0,
118	G_PARAM_READWRITE));
119
120	g_type_class_add_private (object_class,
121	sizeof (GtkCellRendererSignalPrivate));
122	}
123
124	static void gtk_cell_renderer_signal_init(GtkCellRendererSignal *cel)
125	{
126	GtkCellRendererSignalPrivate *priv;
127
128	cel->priv = G_TYPE_INSTANCE_GET_PRIVATE(cel,
129	GTK_TYPE_CELL_RENDERER_SIGNAL,
130	GtkCellRendererSignalPrivate);
131	priv = cel->priv;
132
133	priv->data = NULL;
134	priv->probe = -1;
135	priv->scale = 1;
136	priv->offset = 0;
137	}
138
139	GtkCellRenderer *gtk_cell_renderer_signal_new(void)
140	{
141	return g_object_new(GTK_TYPE_CELL_RENDERER_SIGNAL, NULL);
142	}
143
144	static void gtk_cell_renderer_signal_finalize(GObject *object)
145	{
146	GtkCellRendererSignal *cel = GTK_CELL_RENDERER_SIGNAL(object);
147	GtkCellRendererSignalPrivate *priv = cel->priv;
148	/* Keep this around, because it'll be useful in future */
149	(void)priv;
150	G_OBJECT_CLASS(gtk_cell_renderer_signal_parent_class)->finalize(object);
151	}
152
153	static void
154	gtk_cell_renderer_signal_get_property(GObject *object,
155	guint param_id,
156	GValue *value,
157	GParamSpec *pspec)
158	{
159	GtkCellRendererSignal *cel = GTK_CELL_RENDERER_SIGNAL(object);
160	GtkCellRendererSignalPrivate *priv = cel->priv;
161
162	switch (param_id) {
163	case PROP_DATA:
164	g_value_set_pointer(value, priv->data);
165	break;
166	case PROP_PROBE:
167	g_value_set_int(value, priv->probe);
168	break;
169	case PROP_SCALE:
170	g_value_set_double(value, priv->scale);
171	break;
172	case PROP_OFFSET:
173	g_value_set_int(value, priv->offset);
174	break;
175	default:
176	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
177	}
178	}
179
180	static void
181	gtk_cell_renderer_signal_set_property(GObject *object,
182	guint param_id,
183	const GValue *value,
184	GParamSpec *pspec)
185	{
186	GtkCellRendererSignal *cel = GTK_CELL_RENDERER_SIGNAL(object);
187	GtkCellRendererSignalPrivate *priv = cel->priv;
188
189	switch (param_id) {
190	case PROP_DATA:
191	priv->data = g_value_get_pointer(value);
192	break;
193	case PROP_PROBE:
194	priv->probe = g_value_get_int(value);
195	break;
196	case PROP_FOREGROUND:
197	gdk_color_parse(g_value_get_string(value), &priv->foreground);
198	break;
199	case PROP_SCALE:
200	priv->scale = g_value_get_double(value);
201	break;
202	case PROP_OFFSET:
203	priv->offset = g_value_get_int(value);
204	break;
205	default:
206	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
207	}
208	}
209
210	static void
211	gtk_cell_renderer_signal_get_size(GtkCellRenderer *cell,
212	GtkWidget *widget,
213	GdkRectangle *cell_area,
214	gint *x_offset,
215	gint *y_offset,
216	gint *width,
217	gint *height)
218	{
219	(void)cell;
220	(void)widget;
221	(void)cell_area;
222
223	/* FIXME: What about cell_area? */
224	if (width) *width = 0;
225	if (height) *height = 30;
226
227	if (x_offset) *x_offset = 0;
228	if (y_offset) *y_offset = 0;
229	}
230
231
232	static gboolean sample(GArray *data, gint probe, guint i)
233	{
234	int unitsize = g_array_get_element_size(data);
235	g_return_val_if_fail(i < data->len, FALSE);
236	g_return_val_if_fail(probe < unitsize * 8, FALSE);
237
238	return data->data[(i*unitsize) + probe/8] & (1 << (probe & 7));
239	}
240
241	static void
242	gtk_cell_renderer_signal_render(GtkCellRenderer *cell,
243	GdkWindow *window,
244	GtkWidget *widget,
245	GdkRectangle *background_area,
246	GdkRectangle *cell_area,
247	GdkRectangle *expose_area,
248	GtkCellRendererState flags)
249	{
250	GtkCellRendererSignal *cel = GTK_CELL_RENDERER_SIGNAL(cell);
251	GtkCellRendererSignalPrivate *priv= cel->priv;
252	guint nsamples = priv->data->len;
253	gint xpad, ypad;
254	int x, y, w, h;
255	guint si;
256	gdouble o;
257
258	(void)widget;
259	(void)expose_area;
260	(void)flags;
261
262	gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
263	x = cell_area->x + xpad;
264	y = cell_area->y + ypad;
265	w = cell_area->width - xpad * 2;
266	h = cell_area->height - ypad * 2;
267
268	cairo_t *cr = gdk_cairo_create(GDK_DRAWABLE(window));
269
270	/* Set clipping region to background rectangle.
271	* This prevents us drawing over other cells.
272	*/
273	cairo_new_path(cr);
274	gdk_cairo_rectangle(cr, background_area);
275	cairo_clip(cr);
276
277	cairo_set_line_join(cr, CAIRO_LINE_JOIN_ROUND);
278	gdk_cairo_set_source_color(cr, &priv->foreground);
279	/cairo_set_line_width(cr, 1);/
280	cairo_new_path(cr);
281
282	si = priv->offset / priv->scale;
283	if (si >= nsamples)
284	return;
285	o = x - (priv->offset - si * priv->scale);
286
287	guint32 oldsample = sample(priv->data, priv->probe, si++);
288	cairo_move_to(cr, o, y +
289	(oldsample ? 0 : h));
290	o += priv->scale;
291
292	while ((si < nsamples) && (o - priv->scale < x+w)) {
293	guint32 cursample = sample(priv->data, priv->probe, si);
294	if (cursample != oldsample) {
295	cairo_line_to(cr, o - priv->scale/8, y +
296	(oldsample ? 0 : h));
297	cairo_line_to(cr, o + priv->scale/8, y +
298	(cursample ? 0 : h));
299	oldsample = cursample;
300	}
301	o += priv->scale;
302	si++;
303	}
304	cairo_line_to(cr, o - priv->scale/8, y +
305	(oldsample ? 0 : h));
306
307	cairo_stroke(cr);
308	cairo_destroy(cr);
309	}