[fio.git] / graph.c

/*
 * gfio - gui front end for fio - the flexible io tester
 *
 * Copyright (C) 2012 Stephen M. Cameron <stephenmcameron@gmail.com> 
 *
 * The license below covers all files distributed with fio unless otherwise
 * noted in the file itself.
 *
 *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
#include <string.h>
#include <malloc.h>
#include <math.h>
#include <assert.h>

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

#include "tickmarks.h"

struct xyvalue {
	double x, y;
};

struct graph_value {
	struct graph_value *next;
	void *value;
};

struct graph_label {
	char *label;
	struct graph_value *tail;
	struct graph_value *values;
	struct graph_label *next;
	double r, g, b;
	int value_count;
	struct graph *parent;
};

struct graph {
	char *title;
	char *xtitle;
	char *ytitle;
	unsigned int xdim, ydim;
	struct graph_label *labels;
	struct graph_label *tail;
	int per_label_limit;
	const char *font;
};

void graph_set_size(struct graph *g, unsigned int xdim, unsigned int ydim)
{
	g->xdim = xdim;
	g->ydim = ydim;
}

struct graph *graph_new(unsigned int xdim, unsigned int ydim, const char *font)
{
	struct graph *g;

	g = calloc(1, sizeof(*g));
	graph_set_size(g, xdim, ydim);
	g->per_label_limit = -1;
	g->font = font;
	if (!g->font)
		g->font = "Sans";
	return g;
}

static int count_labels(struct graph_label *labels)
{
	int count = 0;
	struct graph_label *i;

	for (i = labels; i; i = i->next)
		count++;
	return count;
}

static int count_values(struct graph_value *values)
{
	int count = 0;
	struct graph_value *i;

	for (i = values; i; i = i->next)
		count++;
	return count;
}

typedef double (*double_comparator)(double a, double b);

static double mindouble(double a, double b)
{
	return a < b ? a : b;
}

static double maxdouble(double a, double b)
{
	return a < b ? b : a;
}

static double find_double_values(struct graph_value *values, double_comparator cmp)
{
	struct graph_value *i;
	int first = 1;
	double answer, tmp;

	assert(values != NULL);
	answer = 0.0; /* shut the compiler up, might need to think harder though. */
	for (i = values; i; i = i->next) {
		tmp = *(double *) i->value; 
		if (first) {
			answer = tmp;
			first = 0;
		} else {
			answer = cmp(answer, tmp);
		}
	}
	return answer;
}

static double find_double_data(struct graph_label *labels, double_comparator cmp)
{
	struct graph_label *i;
	int first = 1;
	double answer, tmp;

	assert(labels != NULL);
	answer = 0.0; /* shut the compiler up, might need to think harder though. */
	for (i = labels; i; i = i->next) {
		tmp = find_double_values(i->values, cmp);
		if (first) {
			answer = tmp;
			first = 0;
		} else {
			answer = cmp(tmp, answer);
		}
	}
	return answer;
}

static double find_min_data(struct graph_label *labels)
{
	return find_double_data(labels, mindouble);
}

static double find_max_data(struct graph_label *labels)
{
	return find_double_data(labels, maxdouble);
}

static void draw_bars(struct graph *bg, cairo_t *cr, struct graph_label *lb,
			double label_offset, double bar_width,
			double mindata, double maxdata)
{
	struct graph_value *i;
	double x1, y1, x2, y2;
	int bar_num = 0;
	double domain, range, v;

	domain = (maxdata - mindata);
	range = (double) bg->ydim * 0.80; /* FIXME */
	cairo_stroke(cr);
	for (i = lb->values; i; i = i->next) {

		x1 = label_offset + (double) bar_num * bar_width + (bar_width * 0.05);
		x2 = x1 + bar_width * 0.90;
		y2 = bg->ydim * 0.90;
		v = *(double *) i->value;
		y1 = y2 - (((v - mindata) / domain) * range);
		cairo_move_to(cr, x1, y1);
		cairo_line_to(cr, x1, y2);
		cairo_line_to(cr, x2, y2);
		cairo_line_to(cr, x2, y1);
		cairo_close_path(cr);
		cairo_fill(cr);
		cairo_stroke(cr);
		bar_num++;	
	}
}

static void draw_aligned_text(struct graph *g, cairo_t *cr, double x, double y,
			       double fontsize, const char *text, int alignment)
{
#define CENTERED 0
#define LEFT_JUSTIFIED 1
#define RIGHT_JUSTIFIED 2

	double factor, direction;
	cairo_text_extents_t extents;

	switch(alignment) {
		case CENTERED:
			direction = -1.0;
			factor = 0.5;
			break;
		case RIGHT_JUSTIFIED:
			direction = -1.0;
			factor = 1.0;
			break;
		case LEFT_JUSTIFIED:
		default:
			direction = 1.0;
			factor = 1.0;
			break;
	}
	cairo_select_font_face (cr, g->font, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);

	cairo_set_font_size(cr, fontsize);
	cairo_text_extents(cr, text, &extents);
	x = x + direction * (factor * extents.width  + extents.x_bearing);
	y = y - (extents.height / 2 + extents.y_bearing);

	cairo_move_to(cr, x, y);
	cairo_show_text(cr, text);
}

static inline void draw_centered_text(struct graph *g, cairo_t *cr, double x, double y,
			       double fontsize, const char *text)
{
	draw_aligned_text(g, cr, x, y, fontsize, text, CENTERED);
}

static inline void draw_right_justified_text(struct graph *g, cairo_t *cr,
				double x, double y,
				double fontsize, const char *text)
{
	draw_aligned_text(g, cr, x, y, fontsize, text, RIGHT_JUSTIFIED);
}

static inline void draw_left_justified_text(struct graph *g, cairo_t *cr,
				double x, double y,
				double fontsize, const char *text)
{
	draw_aligned_text(g, cr, x, y, fontsize, text, LEFT_JUSTIFIED);
}

static void draw_vertical_centered_text(struct graph *g, cairo_t *cr, double x,
					double y, double fontsize,
					const char *text)
{
	double sx, sy;
	cairo_text_extents_t extents;

	cairo_select_font_face(cr, g->font, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);

	cairo_set_font_size(cr, fontsize);
	cairo_text_extents(cr, text, &extents);
	sx = x;
	sy = y;
	y = y + (extents.width / 2.0 + extents.x_bearing);
	x = x - (extents.height / 2.0 + extents.y_bearing);

	cairo_move_to(cr, x, y);
	cairo_save(cr);
	cairo_translate(cr, -sx, -sy);
	cairo_rotate(cr, -90.0 * M_PI / 180.0);
	cairo_translate(cr, sx, sy);
	cairo_show_text(cr, text);
	cairo_restore(cr);
}

static void graph_draw_common(struct graph *g, cairo_t *cr,
	double *x1, double *y1, double *x2, double *y2)
{
        cairo_set_source_rgb(cr, 0, 0, 0);
        cairo_set_line_width (cr, 0.8);

	*x1 = 0.15 * g->xdim;	
	*x2 = 0.95 * g->xdim;
	*y1 = 0.10 * g->ydim;	
	*y2 = 0.90 * g->ydim;

	cairo_move_to(cr, *x1, *y1);
	cairo_line_to(cr, *x1, *y2);
	cairo_line_to(cr, *x2, *y2);
	cairo_line_to(cr, *x2, *y1);
	cairo_line_to(cr, *x1, *y1);
	cairo_stroke(cr);

	draw_centered_text(g, cr, g->xdim / 2, g->ydim / 20, 20.0, g->title);
	draw_centered_text(g, cr, g->xdim / 2, g->ydim * 0.97, 14.0, g->xtitle);
	draw_vertical_centered_text(g, cr, g->xdim * 0.02, g->ydim / 2, 14.0, g->ytitle);
	cairo_stroke(cr);
}

static void graph_draw_x_ticks(struct graph *g, cairo_t *cr,
	double x1, double y1, double x2, double y2,
	double minx, double maxx, int nticks)
{
	struct tickmark *tm;
	double tx;
	int i;
	static double dash[] = { 1.0, 2.0 };

	nticks = calc_tickmarks(minx, maxx, nticks, &tm);

	for (i = 0; i < nticks; i++) {
		tx = (((tm[i].value) - minx) / (maxx - minx)) * (x2 - x1) + x1;
		if (tx < x1 || tx > x2)
			continue;

		/* Draw tick mark */
		cairo_set_line_width(cr, 0.8);
		cairo_move_to(cr, tx, y2);
		cairo_line_to(cr, tx, y2 + (y2 - y1) * 0.03);
		cairo_stroke(cr);

		/* draw grid lines */
		cairo_save(cr);
		cairo_set_dash(cr, dash, 2, 2.0);
		cairo_set_line_width(cr, 0.5);
		cairo_move_to(cr, tx, y1);
		cairo_line_to(cr, tx, y2);
		cairo_stroke(cr);
		cairo_restore(cr);

		/* draw tickmark label */
		draw_centered_text(g, cr, tx, y2 * 1.04, 12.0, tm[i].string);
		cairo_stroke(cr);
		
	}
}

static void graph_draw_y_ticks(struct graph *g, cairo_t *cr,
	double x1, double y1, double x2, double y2,
	double miny, double maxy, int nticks)
{
	struct tickmark *tm;
	double ty;
	int i;
	static double dash[] = { 2.0, 2.0 };

	nticks = calc_tickmarks(miny, maxy, nticks, &tm);

	for (i = 0; i < nticks; i++) {
		ty = y2 - (((tm[i].value) - miny) / (maxy - miny)) * (y2 - y1);
		if (ty < y1 || ty > y2)
			continue;
		/* draw tick mark */
		cairo_move_to(cr, x1, ty);
		cairo_line_to(cr, x1 - (x2 - x1) * 0.02, ty);
		cairo_stroke(cr);

		/* draw grid lines */
		cairo_save(cr);
		cairo_set_dash(cr, dash, 2, 2.0);
		cairo_set_line_width(cr, 0.5);
		cairo_move_to(cr, x1, ty);
		cairo_line_to(cr, x2, ty);
		cairo_stroke(cr);
		cairo_restore(cr);

		/* draw tickmark label */
		draw_right_justified_text(g, cr, x1 - (x2 - x1) * 0.025, ty, 12.0, tm[i].string);
		cairo_stroke(cr);
	}
}

void bar_graph_draw(struct graph *bg, cairo_t *cr)
{
	double x1, y1, x2, y2;
	double space_per_label, bar_width;
	double label_offset, mindata, maxdata;
	int i, nlabels;
	struct graph_label *lb;

	cairo_save(cr);
	graph_draw_common(bg, cr, &x1, &y1, &x2, &y2);

	nlabels = count_labels(bg->labels);
	space_per_label = (x2 - x1) / (double) nlabels; 

	mindata = find_min_data(bg->labels);
	maxdata = find_max_data(bg->labels);

	if (fabs(maxdata - mindata) < 1e-20) {
		draw_centered_text(bg, cr,
			x1 + (x2 - x1) / 2.0,
			y1 + (y2 - y1) / 2.0, 20.0, "No good data");
		return;
	}

	graph_draw_y_ticks(bg, cr, x1, y1, x2, y2, mindata, maxdata, 10);

	i = 0;
	for (lb = bg->labels; lb; lb = lb->next) {
		int nvalues;
		nvalues = count_values(lb->values);
		bar_width = (space_per_label - space_per_label * 0.2) / (double) nvalues;
		label_offset = bg->xdim * 0.1 + space_per_label * (double) i + space_per_label * 0.1;
		draw_bars(bg, cr, lb, label_offset, bar_width, mindata, maxdata);
		// draw_centered_text(cr, label_offset + (bar_width / 2.0 + bar_width * 0.1), bg->ydim * 0.93,
		draw_centered_text(bg, cr, x1 + space_per_label * (i + 0.5), bg->ydim * 0.93,
			12.0, lb->label); 
		i++;
	}
	cairo_stroke(cr);
	cairo_restore(cr);
}

typedef double (*xy_value_extractor)(struct graph_value *v);

static double getx(struct graph_value *v)
{
	struct xyvalue *xy = v->value;
	return xy->x;
}

static double gety(struct graph_value *v)
{
	struct xyvalue *xy = v->value;
	return xy->y;
}

static double find_xy_value(struct graph *g, xy_value_extractor getvalue, double_comparator cmp)
{
	double tmp, answer = 0.0;
	struct graph_label *i;
	struct graph_value *j;
	int first = 1;

	for (i = g->labels; i; i = i->next)
		for (j = i->values; j; j = j->next) {
			tmp = getvalue(j);
			if (first) {
				first = 0;
				answer = tmp;
			}
			answer = cmp(tmp, answer);	
		}
	return answer;
} 

void line_graph_draw(struct graph *g, cairo_t *cr)
{
	double x1, y1, x2, y2;
	double minx, miny, maxx, maxy;
	double tx, ty;
	struct graph_label *i;
	struct graph_value *j;
	int good_data = 1, first = 1;

	cairo_save(cr);
	graph_draw_common(g, cr, &x1, &y1, &x2, &y2);

	minx = find_xy_value(g, getx, mindouble);
	maxx = find_xy_value(g, getx, maxdouble);
	miny = find_xy_value(g, gety, mindouble);
	maxy = find_xy_value(g, gety, maxdouble);

	if (fabs(maxx - minx) < 1e-20 || fabs(maxy - miny) < 1e-20) {
		good_data = 0;
		minx = 0.0;
		miny = 0.0;
		maxx = 10.0;
		maxy = 100.0;
	}

	graph_draw_x_ticks(g, cr, x1, y1, x2, y2, minx, maxx, 10);
	graph_draw_y_ticks(g, cr, x1, y1, x2, y2, miny, maxy, 10);

	if (!good_data)
		goto skip_data;

	cairo_set_line_width(cr, 1.5);
	for (i = g->labels; i; i = i->next) {
		first = 1;
		if (i->r < 0) /* invisible data */
			continue;
		cairo_set_source_rgb(cr, i->r, i->g, i->b);
		for (j = i->values; j; j = j->next) {
			tx = ((getx(j) - minx) / (maxx - minx)) * (x2 - x1) + x1;
			ty = y2 - ((gety(j) - miny) / (maxy - miny)) * (y2 - y1);
			if (first) {
				cairo_move_to(cr, tx, ty);
				first = 0;
			} else {
				cairo_line_to(cr, tx, ty);
			}
		}
		cairo_stroke(cr);
	}

skip_data:
	cairo_restore(cr);

}

static void gfree(void *f)
{
	if (f)
		free(f);
}

static void setstring(char **str, const char *value)
{
	gfree(*str);
	*str = strdup(value);
}

void graph_title(struct graph *bg, const char *title)
{
	setstring(&bg->title, title);
}

void graph_x_title(struct graph *bg, const char *title)
{
	setstring(&bg->xtitle, title);
}

void graph_y_title(struct graph *bg, const char *title)
{
	setstring(&bg->ytitle, title);
}

static struct graph_label *graph_find_label(struct graph *bg,
				const char *label)
{
	struct graph_label *i;
	
	for (i = bg->labels; i; i = i->next)
		if (strcmp(label, i->label) == 0)
			return i;
	return NULL;
}

void graph_add_label(struct graph *bg, const char *label)
{
	struct graph_label *i;
	
	i = graph_find_label(bg, label);
	if (i)
		return; /* already present. */
	i = calloc(1, sizeof(*i));
	i->parent = bg;
	setstring(&i->label, label);
	i->next = NULL;
	if (!bg->tail)
		bg->labels = i;
	else
		bg->tail->next = i;
	bg->tail = i;
}

static void graph_label_add_value(struct graph_label *i, void *value)
{
	struct graph_value *x;

	x = malloc(sizeof(*x));
	x->value = value;
	x->next = NULL;
	if (!i->tail) {
		i->values = x;
	} else {
		i->tail->next = x;
	}
	i->tail = x;
	i->value_count++;

	if (i->parent->per_label_limit != -1 &&
		i->value_count > i->parent->per_label_limit) {
		x = i->values;
		i->values = i->values->next;
		free(x->value);
		free(x);
		i->value_count--;
	}
}

int graph_add_data(struct graph *bg, const char *label, const double value)
{
	struct graph_label *i;
	double *d;

	d = malloc(sizeof(*d));
	*d = value;

	i = graph_find_label(bg, label);
	if (!i)
		return -1;
	graph_label_add_value(i, d);
	return 0;
}

int graph_add_xy_data(struct graph *bg, const char *label,
		const double x, const double y)
{
	struct graph_label *i;
	struct xyvalue *xy;

	xy = malloc(sizeof(*xy));
	xy->x = x;
	xy->y = y;

	i = graph_find_label(bg, label);
	if (!i)
		return -1;
	graph_label_add_value(i, xy);
	return 0;
}

static void graph_free_values(struct graph_value *values)
{
	struct graph_value *i, *next;

	for (i = values; i; i = next) {
		next = i->next;
		gfree(i->value);
		gfree(i);
	}	
}

static void graph_free_labels(struct graph_label *labels)
{
	struct graph_label *i, *next;

	for (i = labels; i; i = next) {
		next = i->next;
		graph_free_values(i->values);
		gfree(i);
	}	
}

void graph_set_color(struct graph *gr, const char *label,
	double red, double green, double blue)
{
	struct graph_label *i;
	double r, g, b;

	if (red < 0.0) { /* invisible color */
		r = -1.0;
		g = -1.0;
		b = -1.0;
	} else {
		r = fabs(red);
		g = fabs(green);
		b = fabs(blue);

		if (r > 1.0)
			r = 1.0;
		if (g > 1.0)
			g = 1.0;
		if (b > 1.0)
			b =1.0;
	}

	for (i = gr->labels; i; i = i->next)
		if (strcmp(i->label, label) == 0) {
			i->r = r;	
			i->g = g;	
			i->b = b;	
			break;
		}
}

void graph_free(struct graph *bg)
{
	gfree(bg->title);
	gfree(bg->xtitle);
	gfree(bg->ytitle);
	graph_free_labels(bg->labels);
}

/* For each line in the line graph, up to per_label_limit segments may
 * be added.  After that, adding more data to the end of the line
 * causes data to drop off of the front of the line.
 */
void line_graph_set_data_count_limit(struct graph *g, int per_label_limit)
{
	g->per_label_limit = per_label_limit;
}
Commit	Line	Data
af58ef32 SC	1	/*
	2	* gfio - gui front end for fio - the flexible io tester
	3	*
	4	* Copyright (C) 2012 Stephen M. Cameron <stephenmcameron@gmail.com>
	5	*
	6	* The license below covers all files distributed with fio unless otherwise
	7	* noted in the file itself.
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	21	*
	22	*/
	23	#include <string.h>
	24	#include <malloc.h>
	25	#include <math.h>
	26	#include <assert.h>
	27
	28	#include <cairo.h>
	29	#include <gtk/gtk.h>
	30
	31	#include "tickmarks.h"
	32
	33	struct xyvalue {
	34	double x, y;
	35	};
	36
	37	struct graph_value {
	38	struct graph_value *next;
	39	void *value;
	40	};
	41
	42	struct graph_label {
	43	char *label;
	44	struct graph_value *tail;
	45	struct graph_value *values;
	46	struct graph_label *next;
	47	double r, g, b;
	48	int value_count;
	49	struct graph *parent;
	50	};
	51
	52	struct graph {
	53	char *title;
	54	char *xtitle;
	55	char *ytitle;
87d5f276	56	unsigned int xdim, ydim;
af58ef32 SC	57	struct graph_label *labels;
	58	struct graph_label *tail;
	59	int per_label_limit;
f3e8440f	60	const char *font;
af58ef32 SC	61	};
af58ef32 SC	62
3ea48b88 SC	63	void graph_set_size(struct graph *g, unsigned int xdim, unsigned int ydim)
	64	{
	65	g->xdim = xdim;
	66	g->ydim = ydim;
	67	}
	68
f3e8440f	69	struct graph graph_new(unsigned int xdim, unsigned int ydim, const char font)
af58ef32 SC	70	{
	71	struct graph *g;
	72
	73	g = calloc(1, sizeof(*g));
3ea48b88	74	graph_set_size(g, xdim, ydim);
af58ef32	75	g->per_label_limit = -1;
f3e8440f JA	76	g->font = font;
	77	if (!g->font)
	78	g->font = "Sans";
af58ef32 SC	79	return g;
	80	}
	81
	82	static int count_labels(struct graph_label *labels)
	83	{
	84	int count = 0;
	85	struct graph_label *i;
	86
	87	for (i = labels; i; i = i->next)
	88	count++;
	89	return count;
	90	}
	91
	92	static int count_values(struct graph_value *values)
	93	{
	94	int count = 0;
	95	struct graph_value *i;
	96
	97	for (i = values; i; i = i->next)
	98	count++;
	99	return count;
	100	}
	101
	102	typedef double (*double_comparator)(double a, double b);
	103
	104	static double mindouble(double a, double b)
	105	{
	106	return a < b ? a : b;
	107	}
	108
	109	static double maxdouble(double a, double b)
	110	{
	111	return a < b ? b : a;
	112	}
	113
	114	static double find_double_values(struct graph_value *values, double_comparator cmp)
	115	{
	116	struct graph_value *i;
	117	int first = 1;
	118	double answer, tmp;
	119
	120	assert(values != NULL);
	121	answer = 0.0; /* shut the compiler up, might need to think harder though. */
	122	for (i = values; i; i = i->next) {
	123	tmp = (double ) i->value;
	124	if (first) {
	125	answer = tmp;
	126	first = 0;
	127	} else {
	128	answer = cmp(answer, tmp);
	129	}
	130	}
	131	return answer;
	132	}
	133
	134	static double find_double_data(struct graph_label *labels, double_comparator cmp)
	135	{
	136	struct graph_label *i;
	137	int first = 1;
	138	double answer, tmp;
	139
	140	assert(labels != NULL);
	141	answer = 0.0; /* shut the compiler up, might need to think harder though. */
	142	for (i = labels; i; i = i->next) {
143	tmp = find_double_values(i->values, cmp);
144	if (first) {
145	answer = tmp;
146	first = 0;
147	} else {
148	answer = cmp(tmp, answer);
149	}
150	}
151	return answer;
152	}
153
154	static double find_min_data(struct graph_label *labels)
155	{
156	return find_double_data(labels, mindouble);
157	}
158
159	static double find_max_data(struct graph_label *labels)
160	{
161	return find_double_data(labels, maxdouble);
162	}
163
164	static void draw_bars(struct graph bg, cairo_t cr, struct graph_label *lb,
165	double label_offset, double bar_width,
166	double mindata, double maxdata)
167	{
168	struct graph_value *i;
169	double x1, y1, x2, y2;
170	int bar_num = 0;
171	double domain, range, v;
172
173	domain = (maxdata - mindata);
174	range = (double) bg->ydim * 0.80; /* FIXME */
175	cairo_stroke(cr);
176	for (i = lb->values; i; i = i->next) {
177
178	x1 = label_offset + (double) bar_num * bar_width + (bar_width * 0.05);
179	x2 = x1 + bar_width * 0.90;
180	y2 = bg->ydim * 0.90;
181	v = (double ) i->value;
182	y1 = y2 - (((v - mindata) / domain) * range);
183	cairo_move_to(cr, x1, y1);
184	cairo_line_to(cr, x1, y2);
185	cairo_line_to(cr, x2, y2);
186	cairo_line_to(cr, x2, y1);
187	cairo_close_path(cr);
188	cairo_fill(cr);
189	cairo_stroke(cr);
190	bar_num++;
191	}
192	}
193
10e54cdc SC	194	static void draw_aligned_text(struct graph g, cairo_t cr, double x, double y,
10e54cdc SC	195	double fontsize, const char *text, int alignment)
af58ef32	196	{
10e54cdc SC	197	#define CENTERED 0
	198	#define LEFT_JUSTIFIED 1
	199	#define RIGHT_JUSTIFIED 2
	200
	201	double factor, direction;
af58ef32 SC	202	cairo_text_extents_t extents;
af58ef32 SC	203
10e54cdc SC	204	switch(alignment) {
	205	case CENTERED:
	206	direction = -1.0;
	207	factor = 0.5;
	208	break;
	209	case RIGHT_JUSTIFIED:
	210	direction = -1.0;
	211	factor = 1.0;
	212	break;
	213	case LEFT_JUSTIFIED:
	214	default:
	215	direction = 1.0;
	216	factor = 1.0;
	217	break;
	218	}
f3e8440f	219	cairo_select_font_face (cr, g->font, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
af58ef32 SC	220
	221	cairo_set_font_size(cr, fontsize);
	222	cairo_text_extents(cr, text, &extents);
10e54cdc	223	x = x + direction * (factor * extents.width + extents.x_bearing);
af58ef32 SC	224	y = y - (extents.height / 2 + extents.y_bearing);
	225
	226	cairo_move_to(cr, x, y);
	227	cairo_show_text(cr, text);
	228	}
	229
10e54cdc SC	230	static inline void draw_centered_text(struct graph g, cairo_t cr, double x, double y,
	231	double fontsize, const char *text)
	232	{
	233	draw_aligned_text(g, cr, x, y, fontsize, text, CENTERED);
	234	}
	235
	236	static inline void draw_right_justified_text(struct graph g, cairo_t cr,
	237	double x, double y,
	238	double fontsize, const char *text)
	239	{
	240	draw_aligned_text(g, cr, x, y, fontsize, text, RIGHT_JUSTIFIED);
	241	}
	242
	243	static inline void draw_left_justified_text(struct graph g, cairo_t cr,
	244	double x, double y,
	245	double fontsize, const char *text)
	246	{
	247	draw_aligned_text(g, cr, x, y, fontsize, text, LEFT_JUSTIFIED);
	248	}
	249
f3e8440f JA	250	static void draw_vertical_centered_text(struct graph g, cairo_t cr, double x,
	251	double y, double fontsize,
	252	const char *text)
af58ef32 SC	253	{
	254	double sx, sy;
	255	cairo_text_extents_t extents;
	256
f3e8440f	257	cairo_select_font_face(cr, g->font, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
af58ef32 SC	258
	259	cairo_set_font_size(cr, fontsize);
	260	cairo_text_extents(cr, text, &extents);
	261	sx = x;
	262	sy = y;
	263	y = y + (extents.width / 2.0 + extents.x_bearing);
	264	x = x - (extents.height / 2.0 + extents.y_bearing);
	265
	266	cairo_move_to(cr, x, y);
	267	cairo_save(cr);
	268	cairo_translate(cr, -sx, -sy);
	269	cairo_rotate(cr, -90.0 * M_PI / 180.0);
	270	cairo_translate(cr, sx, sy);
	271	cairo_show_text(cr, text);
	272	cairo_restore(cr);
	273	}
	274
	275	static void graph_draw_common(struct graph g, cairo_t cr,
	276	double x1, double y1, double x2, double y2)
	277	{
	278	cairo_set_source_rgb(cr, 0, 0, 0);
f3e8440f	279	cairo_set_line_width (cr, 0.8);
af58ef32	280
6bf86008 SC	281	x1 = 0.15 g->xdim;
	282	x2 = 0.95 g->xdim;
	283	y1 = 0.10 g->ydim;
	284	y2 = 0.90 g->ydim;
af58ef32 SC	285
	286	cairo_move_to(cr, x1, y1);
	287	cairo_line_to(cr, x1, y2);
	288	cairo_line_to(cr, x2, y2);
	289	cairo_line_to(cr, x2, y1);
	290	cairo_line_to(cr, x1, y1);
	291	cairo_stroke(cr);
	292
f3e8440f JA	293	draw_centered_text(g, cr, g->xdim / 2, g->ydim / 20, 20.0, g->title);
	294	draw_centered_text(g, cr, g->xdim / 2, g->ydim * 0.97, 14.0, g->xtitle);
	295	draw_vertical_centered_text(g, cr, g->xdim * 0.02, g->ydim / 2, 14.0, g->ytitle);
af58ef32 SC	296	cairo_stroke(cr);
	297	}
	298
	299	static void graph_draw_x_ticks(struct graph g, cairo_t cr,
	300	double x1, double y1, double x2, double y2,
	301	double minx, double maxx, int nticks)
	302	{
	303	struct tickmark *tm;
	304	double tx;
	305	int i;
	306	static double dash[] = { 1.0, 2.0 };
	307
	308	nticks = calc_tickmarks(minx, maxx, nticks, &tm);
	309
	310	for (i = 0; i < nticks; i++) {
	311	tx = (((tm[i].value) - minx) / (maxx - minx)) * (x2 - x1) + x1;
	312	if (tx < x1 \|\| tx > x2)
	313	continue;
	314
	315	/* Draw tick mark */
f3e8440f	316	cairo_set_line_width(cr, 0.8);
af58ef32 SC	317	cairo_move_to(cr, tx, y2);
	318	cairo_line_to(cr, tx, y2 + (y2 - y1) * 0.03);
	319	cairo_stroke(cr);
	320
	321	/* draw grid lines */
	322	cairo_save(cr);
	323	cairo_set_dash(cr, dash, 2, 2.0);
	324	cairo_set_line_width(cr, 0.5);
	325	cairo_move_to(cr, tx, y1);
	326	cairo_line_to(cr, tx, y2);
	327	cairo_stroke(cr);
	328	cairo_restore(cr);
	329
	330	/* draw tickmark label */
f3e8440f	331	draw_centered_text(g, cr, tx, y2 * 1.04, 12.0, tm[i].string);
af58ef32 SC	332	cairo_stroke(cr);
	333
	334	}
	335	}
	336
	337	static void graph_draw_y_ticks(struct graph g, cairo_t cr,
	338	double x1, double y1, double x2, double y2,
	339	double miny, double maxy, int nticks)
	340	{
	341	struct tickmark *tm;
	342	double ty;
	343	int i;
	344	static double dash[] = { 2.0, 2.0 };
	345
	346	nticks = calc_tickmarks(miny, maxy, nticks, &tm);
	347
	348	for (i = 0; i < nticks; i++) {
	349	ty = y2 - (((tm[i].value) - miny) / (maxy - miny)) * (y2 - y1);
	350	if (ty < y1 \|\| ty > y2)
	351	continue;
	352	/* draw tick mark */
	353	cairo_move_to(cr, x1, ty);
	354	cairo_line_to(cr, x1 - (x2 - x1) * 0.02, ty);
	355	cairo_stroke(cr);
	356
	357	/* draw grid lines */
	358	cairo_save(cr);
	359	cairo_set_dash(cr, dash, 2, 2.0);
	360	cairo_set_line_width(cr, 0.5);
	361	cairo_move_to(cr, x1, ty);
	362	cairo_line_to(cr, x2, ty);
	363	cairo_stroke(cr);
	364	cairo_restore(cr);
	365
	366	/* draw tickmark label */
10e54cdc	367	draw_right_justified_text(g, cr, x1 - (x2 - x1) * 0.025, ty, 12.0, tm[i].string);
af58ef32 SC	368	cairo_stroke(cr);
	369	}
	370	}
	371
	372	void bar_graph_draw(struct graph bg, cairo_t cr)
	373	{
	374	double x1, y1, x2, y2;
	375	double space_per_label, bar_width;
	376	double label_offset, mindata, maxdata;
	377	int i, nlabels;
	378	struct graph_label *lb;
	379
	380	cairo_save(cr);
	381	graph_draw_common(bg, cr, &x1, &y1, &x2, &y2);
	382
	383	nlabels = count_labels(bg->labels);
	384	space_per_label = (x2 - x1) / (double) nlabels;
	385
	386	mindata = find_min_data(bg->labels);
	387	maxdata = find_max_data(bg->labels);
	388
	389	if (fabs(maxdata - mindata) < 1e-20) {
f3e8440f	390	draw_centered_text(bg, cr,
af58ef32 SC	391	x1 + (x2 - x1) / 2.0,
	392	y1 + (y2 - y1) / 2.0, 20.0, "No good data");
	393	return;
	394	}
	395
	396	graph_draw_y_ticks(bg, cr, x1, y1, x2, y2, mindata, maxdata, 10);
	397
	398	i = 0;
	399	for (lb = bg->labels; lb; lb = lb->next) {
	400	int nvalues;
	401	nvalues = count_values(lb->values);
	402	bar_width = (space_per_label - space_per_label * 0.2) / (double) nvalues;
	403	label_offset = bg->xdim * 0.1 + space_per_label * (double) i + space_per_label * 0.1;
	404	draw_bars(bg, cr, lb, label_offset, bar_width, mindata, maxdata);
	405	// draw_centered_text(cr, label_offset + (bar_width / 2.0 + bar_width * 0.1), bg->ydim * 0.93,
f3e8440f	406	draw_centered_text(bg, cr, x1 + space_per_label * (i + 0.5), bg->ydim * 0.93,
af58ef32 SC	407	12.0, lb->label);
	408	i++;
	409	}
	410	cairo_stroke(cr);
	411	cairo_restore(cr);
	412	}
	413
	414	typedef double (xy_value_extractor)(struct graph_value v);
	415
	416	static double getx(struct graph_value *v)
	417	{
	418	struct xyvalue *xy = v->value;
	419	return xy->x;
	420	}
	421
	422	static double gety(struct graph_value *v)
	423	{
	424	struct xyvalue *xy = v->value;
	425	return xy->y;
	426	}
	427
	428	static double find_xy_value(struct graph *g, xy_value_extractor getvalue, double_comparator cmp)
	429	{
10e54cdc	430	double tmp, answer = 0.0;
af58ef32 SC	431	struct graph_label *i;
af58ef32 SC	432	struct graph_value *j;
d582bf70	433	int first = 1;
af58ef32 SC	434
	435	for (i = g->labels; i; i = i->next)
	436	for (j = i->values; j; j = j->next) {
	437	tmp = getvalue(j);
d582bf70 SC	438	if (first) {
	439	first = 0;
	440	answer = tmp;
	441	}
af58ef32 SC	442	answer = cmp(tmp, answer);
	443	}
	444	return answer;
	445	}
	446
	447	void line_graph_draw(struct graph g, cairo_t cr)
	448	{
	449	double x1, y1, x2, y2;
	450	double minx, miny, maxx, maxy;
	451	double tx, ty;
	452	struct graph_label *i;
	453	struct graph_value *j;
9ce9cfbd	454	int good_data = 1, first = 1;
af58ef32 SC	455
	456	cairo_save(cr);
	457	graph_draw_common(g, cr, &x1, &y1, &x2, &y2);
	458
	459	minx = find_xy_value(g, getx, mindouble);
	460	maxx = find_xy_value(g, getx, maxdouble);
	461	miny = find_xy_value(g, gety, mindouble);
	462	maxy = find_xy_value(g, gety, maxdouble);
	463
	464	if (fabs(maxx - minx) < 1e-20 \|\| fabs(maxy - miny) < 1e-20) {
9ce9cfbd SC	465	good_data = 0;
	466	minx = 0.0;
	467	miny = 0.0;
	468	maxx = 10.0;
	469	maxy = 100.0;
af58ef32 SC	470	}
	471
	472	graph_draw_x_ticks(g, cr, x1, y1, x2, y2, minx, maxx, 10);
	473	graph_draw_y_ticks(g, cr, x1, y1, x2, y2, miny, maxy, 10);
	474
9ce9cfbd SC	475	if (!good_data)
	476	goto skip_data;
	477
f3e8440f	478	cairo_set_line_width(cr, 1.5);
af58ef32 SC	479	for (i = g->labels; i; i = i->next) {
af58ef32 SC	480	first = 1;
cae08727 SC	481	if (i->r < 0) /* invisible data */
cae08727 SC	482	continue;
af58ef32 SC	483	cairo_set_source_rgb(cr, i->r, i->g, i->b);
	484	for (j = i->values; j; j = j->next) {
	485	tx = ((getx(j) - minx) / (maxx - minx)) * (x2 - x1) + x1;
	486	ty = y2 - ((gety(j) - miny) / (maxy - miny)) * (y2 - y1);
	487	if (first) {
	488	cairo_move_to(cr, tx, ty);
	489	first = 0;
	490	} else {
	491	cairo_line_to(cr, tx, ty);
	492	}
	493	}
	494	cairo_stroke(cr);
	495	}
9ce9cfbd SC	496
9ce9cfbd SC	497	skip_data:
af58ef32	498	cairo_restore(cr);
9ce9cfbd	499
af58ef32 SC	500	}
	501
	502	static void gfree(void *f)
	503	{
	504	if (f)
	505	free(f);
	506	}
	507
	508	static void setstring(char *str, const char value)
	509	{
	510	gfree(*str);
	511	*str = strdup(value);
	512	}
	513
	514	void graph_title(struct graph bg, const char title)
	515	{
	516	setstring(&bg->title, title);
	517	}
	518
	519	void graph_x_title(struct graph bg, const char title)
	520	{
	521	setstring(&bg->xtitle, title);
	522	}
	523
	524	void graph_y_title(struct graph bg, const char title)
	525	{
	526	setstring(&bg->ytitle, title);
	527	}
	528
	529	static struct graph_label graph_find_label(struct graph bg,
	530	const char *label)
	531	{
	532	struct graph_label *i;
	533
	534	for (i = bg->labels; i; i = i->next)
	535	if (strcmp(label, i->label) == 0)
	536	return i;
	537	return NULL;
	538	}
	539
	540	void graph_add_label(struct graph bg, const char label)
	541	{
	542	struct graph_label *i;
	543
	544	i = graph_find_label(bg, label);
	545	if (i)
	546	return; /* already present. */
	547	i = calloc(1, sizeof(*i));
	548	i->parent = bg;
	549	setstring(&i->label, label);
	550	i->next = NULL;
	551	if (!bg->tail)
	552	bg->labels = i;
	553	else
	554	bg->tail->next = i;
	555	bg->tail = i;
	556	}
	557
	558	static void graph_label_add_value(struct graph_label i, void value)
	559	{
	560	struct graph_value *x;
	561
	562	x = malloc(sizeof(*x));
	563	x->value = value;
564	x->next = NULL;
565	if (!i->tail) {
566	i->values = x;
567	} else {
568	i->tail->next = x;
569	}
570	i->tail = x;
571	i->value_count++;
572
573	if (i->parent->per_label_limit != -1 &&
574	i->value_count > i->parent->per_label_limit) {
575	x = i->values;
576	i->values = i->values->next;
577	free(x->value);
578	free(x);
579	i->value_count--;
580	}
581	}
582
583	int graph_add_data(struct graph bg, const char label, const double value)
584	{
585	struct graph_label *i;
586	double *d;
587
588	d = malloc(sizeof(*d));
589	*d = value;
590
591	i = graph_find_label(bg, label);
592	if (!i)
593	return -1;
594	graph_label_add_value(i, d);
595	return 0;
596	}
597
598	int graph_add_xy_data(struct graph bg, const char label,
599	const double x, const double y)
600	{
601	struct graph_label *i;
602	struct xyvalue *xy;
603
604	xy = malloc(sizeof(*xy));
605	xy->x = x;
606	xy->y = y;
607
608	i = graph_find_label(bg, label);
609	if (!i)
610	return -1;
611	graph_label_add_value(i, xy);
612	return 0;
613	}
614
615	static void graph_free_values(struct graph_value *values)
616	{
617	struct graph_value i, next;
618
619	for (i = values; i; i = next) {
620	next = i->next;
621	gfree(i->value);
622	gfree(i);
623	}
624	}
625
626	static void graph_free_labels(struct graph_label *labels)
627	{
628	struct graph_label i, next;
629
630	for (i = labels; i; i = next) {
631	next = i->next;
632	graph_free_values(i->values);
633	gfree(i);
634	}
635	}
636
637	void graph_set_color(struct graph gr, const char label,
638	double red, double green, double blue)
639	{
640	struct graph_label *i;
641	double r, g, b;
642
cae08727 SC	643	if (red < 0.0) { /* invisible color */
	644	r = -1.0;
	645	g = -1.0;
	646	b = -1.0;
	647	} else {
	648	r = fabs(red);
	649	g = fabs(green);
	650	b = fabs(blue);
	651
	652	if (r > 1.0)
	653	r = 1.0;
	654	if (g > 1.0)
	655	g = 1.0;
	656	if (b > 1.0)
	657	b =1.0;
	658	}
af58ef32 SC	659
	660	for (i = gr->labels; i; i = i->next)
	661	if (strcmp(i->label, label) == 0) {
	662	i->r = r;
	663	i->g = g;
	664	i->b = b;
	665	break;
	666	}
	667	}
	668
	669	void graph_free(struct graph *bg)
	670	{
	671	gfree(bg->title);
	672	gfree(bg->xtitle);
	673	gfree(bg->ytitle);
	674	graph_free_labels(bg->labels);
	675	}
	676
	677	/* For each line in the line graph, up to per_label_limit segments may
	678	* be added. After that, adding more data to the end of the line
	679	* causes data to drop off of the front of the line.
	680	*/
	681	void line_graph_set_data_count_limit(struct graph *g, int per_label_limit)
	682	{
	683	g->per_label_limit = per_label_limit;
	684	}
	685